mptbase.c 170 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 *  linux/drivers/message/fusion/mptbase.c
 *      High performance SCSI + LAN / Fibre Channel device drivers.
 *      This is the Fusion MPT base driver which supports multiple
 *      (SCSI + LAN) specialized protocol drivers.
 *      For use with PCI chip/adapter(s):
 *          LSIFC9xx/LSI409xx Fibre Channel
 *      running LSI Logic Fusion MPT (Message Passing Technology) firmware.
 *
 *  Credits:
 *      There are lots of people not mentioned below that deserve credit
 *      and thanks but won't get it here - sorry in advance that you
 *      got overlooked.
 *
 *      This driver would not exist if not for Alan Cox's development
 *      of the linux i2o driver.
 *
 *      A special thanks to Noah Romer (LSI Logic) for tons of work
 *      and tough debugging on the LAN driver, especially early on;-)
 *      And to Roger Hickerson (LSI Logic) for tirelessly supporting
 *      this driver project.
 *
Pam Delaney's avatar
Pam Delaney committed
23 24 25 26 27 28
 *      A special thanks to Pamela Delaney (LSI Logic) for tons of work
 *      and countless enhancements while adding support for the 1030
 *      chip family.  Pam has been instrumental in the development of
 *      of the 2.xx.xx series fusion drivers, and her contributions are
 *      far too numerous to hope to list in one place.
 *
Linus Torvalds's avatar
Linus Torvalds committed
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
 *      All manner of help from Stephen Shirron (LSI Logic):
 *      low-level FC analysis, debug + various fixes in FCxx firmware,
 *      initial port to alpha platform, various driver code optimizations,
 *      being a faithful sounding board on all sorts of issues & ideas,
 *      etc.
 *
 *      A huge debt of gratitude is owed to David S. Miller (DaveM)
 *      for fixing much of the stupid and broken stuff in the early
 *      driver while porting to sparc64 platform.  THANK YOU!
 *
 *      Special thanks goes to the I2O LAN driver people at the
 *      University of Helsinki, who, unbeknownst to them, provided
 *      the inspiration and initial structure for this driver.
 *
 *      A really huge debt of gratitude is owed to Eddie C. Dost
 *      for gobs of hard work fixing and optimizing LAN code.
 *      THANK YOU!
 *
47
 *  Copyright (c) 1999-2004 LSI Logic Corporation
Linus Torvalds's avatar
Linus Torvalds committed
48
 *  Originally By: Steven J. Ralston
Pam Delaney's avatar
Pam Delaney committed
49
 *  (mailto:sjralston1@netscape.net)
50
 *  (mailto:mpt_linux_developer@lsil.com)
Linus Torvalds's avatar
Linus Torvalds committed
51
 *
52
 *  $Id: mptbase.c,v 1.126 2002/12/16 15:28:45 pdelaney Exp $
Linus Torvalds's avatar
Linus Torvalds committed
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
 */
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; version 2 of the License.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    NO WARRANTY
    THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
    CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
    LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
    solely responsible for determining the appropriateness of using and
    distributing the Program and assumes all risks associated with its
    exercise of rights under this Agreement, including but not limited to
    the risks and costs of program errors, damage to or loss of data,
    programs or equipment, and unavailability or interruption of operations.

    DISCLAIMER OF LIABILITY
    NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
    ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
    USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
    HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

#include <linux/config.h>
#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/pci.h>
#include <linux/kdev_t.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
Pam Delaney's avatar
Pam Delaney committed
103
#include <linux/interrupt.h>		/* needed for in_interrupt() proto */
Linus Torvalds's avatar
Linus Torvalds committed
104 105 106 107
#include <asm/io.h>
#ifdef CONFIG_MTRR
#include <asm/mtrr.h>
#endif
Pam Delaney's avatar
Pam Delaney committed
108 109 110
#ifdef __sparc__
#include <asm/irq.h>			/* needed for __irq_itoa() proto */
#endif
Linus Torvalds's avatar
Linus Torvalds committed
111 112 113 114 115 116 117 118 119 120

#include "mptbase.h"

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
#define my_NAME		"Fusion MPT base driver"
#define my_VERSION	MPT_LINUX_VERSION_COMMON
#define MYNAM		"mptbase"

MODULE_AUTHOR(MODULEAUTHOR);
MODULE_DESCRIPTION(my_NAME);
Linus Torvalds's avatar
Linus Torvalds committed
121 122
MODULE_LICENSE("GPL");

Linus Torvalds's avatar
Linus Torvalds committed
123 124 125
/*
 *  cmd line parameters
 */
Pam Delaney's avatar
Pam Delaney committed
126 127 128 129
#ifdef MFCNT
static int mfcounter = 0;
#define PRINT_MF_COUNT 20000
#endif
Linus Torvalds's avatar
Linus Torvalds committed
130 131 132 133 134

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *  Public data...
 */
Pam Delaney's avatar
Pam Delaney committed
135 136 137 138 139 140 141 142 143 144
int mpt_lan_index = -1;
int mpt_stm_index = -1;

struct proc_dir_entry *mpt_proc_root_dir;

DmpServices_t *DmpService;

void *mpt_v_ASCQ_TablePtr;
const char **mpt_ScsiOpcodesPtr;
int mpt_ASCQ_TableSz;
Linus Torvalds's avatar
Linus Torvalds committed
145 146


Linus Torvalds's avatar
Linus Torvalds committed
147 148
#define WHOINIT_UNKNOWN		0xAA

Linus Torvalds's avatar
Linus Torvalds committed
149 150 151 152
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *  Private data...
 */
153 154
					/* Adapter link list */
LIST_HEAD(ioc_list);
Linus Torvalds's avatar
Linus Torvalds committed
155 156 157
					/* Callback lookup table */
static MPT_CALLBACK		 MptCallbacks[MPT_MAX_PROTOCOL_DRIVERS];
					/* Protocol driver class lookup table */
Pam Delaney's avatar
Pam Delaney committed
158
static int			 MptDriverClass[MPT_MAX_PROTOCOL_DRIVERS];
Linus Torvalds's avatar
Linus Torvalds committed
159 160
					/* Event handler lookup table */
static MPT_EVHANDLER		 MptEvHandlers[MPT_MAX_PROTOCOL_DRIVERS];
Linus Torvalds's avatar
Linus Torvalds committed
161 162
					/* Reset handler lookup table */
static MPT_RESETHANDLER		 MptResetHandlers[MPT_MAX_PROTOCOL_DRIVERS];
James Bottomley's avatar
James Bottomley committed
163
static struct mpt_pci_driver 	*MptDeviceDriverHandlers[MPT_MAX_PROTOCOL_DRIVERS];
Linus Torvalds's avatar
Linus Torvalds committed
164 165 166

static int	FusionInitCalled = 0;
static int	mpt_base_index = -1;
Pam Delaney's avatar
Pam Delaney committed
167 168 169 170
static int	last_drv_idx = -1;
static int	isense_idx = -1;

static DECLARE_WAIT_QUEUE_HEAD(mpt_waitq);
Linus Torvalds's avatar
Linus Torvalds committed
171 172 173 174 175

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *  Forward protos...
 */
176
static irqreturn_t mpt_interrupt(int irq, void *bus_id, struct pt_regs *r);
Linus Torvalds's avatar
Linus Torvalds committed
177 178
static int	mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);

Pam Delaney's avatar
Pam Delaney committed
179 180
static int	mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag);
static void	mpt_detect_bound_ports(MPT_ADAPTER *this, struct pci_dev *pdev);
Linus Torvalds's avatar
Linus Torvalds committed
181
static void	mpt_adapter_disable(MPT_ADAPTER *ioc, int freeup);
Linus Torvalds's avatar
Linus Torvalds committed
182 183 184
static void	mpt_adapter_dispose(MPT_ADAPTER *ioc);

static void	MptDisplayIocCapabilities(MPT_ADAPTER *ioc);
Pam Delaney's avatar
Pam Delaney committed
185 186 187 188 189 190 191 192 193 194 195
static int	MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag);
//static u32	mpt_GetIocState(MPT_ADAPTER *ioc, int cooked);
static int	GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason);
static int	GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
static int	SendIocInit(MPT_ADAPTER *ioc, int sleepFlag);
static int	SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
static int	mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag);
static int	mpt_downloadboot(MPT_ADAPTER *ioc, int sleepFlag);
static int	mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
static int	KickStart(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
static int	SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag);
Linus Torvalds's avatar
Linus Torvalds committed
196
static int	PrimeIocFifos(MPT_ADAPTER *ioc);
Pam Delaney's avatar
Pam Delaney committed
197 198 199
static int	WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
static int	WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
static int	WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
Linus Torvalds's avatar
Linus Torvalds committed
200
static int	GetLanConfigPages(MPT_ADAPTER *ioc);
Pam Delaney's avatar
Pam Delaney committed
201 202 203 204
static int	GetFcPortPage0(MPT_ADAPTER *ioc, int portnum);
static int	GetIoUnitPage2(MPT_ADAPTER *ioc);
static int	mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum);
static int	mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum);
205
static void 	mpt_read_ioc_pg_1(MPT_ADAPTER *ioc);
206
static void 	mpt_read_ioc_pg_4(MPT_ADAPTER *ioc);
Pam Delaney's avatar
Pam Delaney committed
207
static void	mpt_timer_expired(unsigned long data);
Linus Torvalds's avatar
Linus Torvalds committed
208 209 210 211
static int	SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch);
static int	SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp);

#ifdef CONFIG_PROC_FS
Pam Delaney's avatar
Pam Delaney committed
212 213 214 215 216 217
static int	procmpt_summary_read(char *buf, char **start, off_t offset,
				int request, int *eof, void *data);
static int	procmpt_version_read(char *buf, char **start, off_t offset,
				int request, int *eof, void *data);
static int	procmpt_iocinfo_read(char *buf, char **start, off_t offset,
				int request, int *eof, void *data);
Linus Torvalds's avatar
Linus Torvalds committed
218
#endif
Pam Delaney's avatar
Pam Delaney committed
219
static void	mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc);
Linus Torvalds's avatar
Linus Torvalds committed
220

Pam Delaney's avatar
Pam Delaney committed
221
//int		mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag);
Linus Torvalds's avatar
Linus Torvalds committed
222
static int	ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *evReply, int *evHandlers);
223
static void	mpt_sp_ioc_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf);
Linus Torvalds's avatar
Linus Torvalds committed
224 225 226
static void	mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info);
static void	mpt_sp_log_info(MPT_ADAPTER *ioc, u32 log_info);

James Bottomley's avatar
James Bottomley committed
227 228 229 230 231 232
/* module entry point */
static int  __devinit mptbase_probe (struct pci_dev *, const struct pci_device_id *);
static void __devexit mptbase_remove(struct pci_dev *);
static void mptbase_shutdown(struct device * );
static int  __init    fusion_init  (void);
static void __exit    fusion_exit  (void);
Linus Torvalds's avatar
Linus Torvalds committed
233

James Bottomley's avatar
James Bottomley committed
234 235 236 237 238
/****************************************************************************
 * Supported hardware
 */

static struct pci_device_id mptbase_pci_table[] = {
239 240
	{ PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC909,
		PCI_ANY_ID, PCI_ANY_ID },
James Bottomley's avatar
James Bottomley committed
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
	{ PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC929,
		PCI_ANY_ID, PCI_ANY_ID },
	{ PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC919,
		PCI_ANY_ID, PCI_ANY_ID },
	{ PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC929X,
		PCI_ANY_ID, PCI_ANY_ID },
	{ PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC919X,
		PCI_ANY_ID, PCI_ANY_ID },
	{ PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C1030,
		PCI_ANY_ID, PCI_ANY_ID },
	{ PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_1030_53C1035,
		PCI_ANY_ID, PCI_ANY_ID },
	{0}	/* Terminating entry */
};
MODULE_DEVICE_TABLE(pci, mptbase_pci_table);

257 258
#define CHIPREG_READ32(addr) 		readl_relaxed(addr)
#define CHIPREG_READ32_dmasync(addr)	readl(addr)
259 260 261
#define CHIPREG_WRITE32(addr,val) 	writel(val, addr)
#define CHIPREG_PIO_WRITE32(addr,val)	outl(val, (unsigned long)addr)
#define CHIPREG_PIO_READ32(addr) 	inl((unsigned long)addr)
Linus Torvalds's avatar
Linus Torvalds committed
262 263

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Pam Delaney's avatar
Pam Delaney committed
264
/*
Linus Torvalds's avatar
Linus Torvalds committed
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
 *	mpt_interrupt - MPT adapter (IOC) specific interrupt handler.
 *	@irq: irq number (not used)
 *	@bus_id: bus identifier cookie == pointer to MPT_ADAPTER structure
 *	@r: pt_regs pointer (not used)
 *
 *	This routine is registered via the request_irq() kernel API call,
 *	and handles all interrupts generated from a specific MPT adapter
 *	(also referred to as a IO Controller or IOC).
 *	This routine must clear the interrupt from the adapter and does
 *	so by reading the reply FIFO.  Multiple replies may be processed
 *	per single call to this routine; up to MPT_MAX_REPLIES_PER_ISR
 *	which is currently set to 32 in mptbase.h.
 *
 *	This routine handles register-level access of the adapter but
 *	dispatches (calls) a protocol-specific callback routine to handle
 *	the protocol-specific details of the MPT request completion.
 */
282
static irqreturn_t
Linus Torvalds's avatar
Linus Torvalds committed
283 284 285 286 287 288
mpt_interrupt(int irq, void *bus_id, struct pt_regs *r)
{
	MPT_ADAPTER	*ioc;
	MPT_FRAME_HDR	*mf;
	MPT_FRAME_HDR	*mr;
	u32		 pa;
289
	int		 req_idx;
Linus Torvalds's avatar
Linus Torvalds committed
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
	int		 cb_idx;
	int		 type;
	int		 freeme;

	ioc = bus_id;

	/*
	 *  Drain the reply FIFO!
	 *
	 * NOTES: I've seen up to 10 replies processed in this loop, so far...
	 * Update: I've seen up to 9182 replies processed in this loop! ??
	 * Update: Limit ourselves to processing max of N replies
	 *	(bottom of loop).
	 */
	while (1) {

306
		if ((pa = CHIPREG_READ32_dmasync(&ioc->chip->ReplyFifo)) == 0xFFFFFFFF)
307
			return IRQ_HANDLED;
Linus Torvalds's avatar
Linus Torvalds committed
308 309 310 311 312 313 314 315

		cb_idx = 0;
		freeme = 0;

		/*
		 *  Check for non-TURBO reply!
		 */
		if (pa & MPI_ADDRESS_REPLY_A_BIT) {
Pam Delaney's avatar
Pam Delaney committed
316
			u32 reply_dma_low;
Linus Torvalds's avatar
Linus Torvalds committed
317 318 319 320 321 322 323
			u16 ioc_stat;

			/* non-TURBO reply!  Hmmm, something may be up...
			 *  Newest turbo reply mechanism; get address
			 *  via left shift 1 (get rid of MPI_ADDRESS_REPLY_A_BIT)!
			 */

Pam Delaney's avatar
Pam Delaney committed
324 325 326 327 328 329 330
			/* Map DMA address of reply header to cpu address.
			 * pa is 32 bits - but the dma address may be 32 or 64 bits
			 * get offset based only only the low addresses
			 */
			reply_dma_low = (pa = (pa << 1));
			mr = (MPT_FRAME_HDR *)((u8 *)ioc->reply_frames +
					 (reply_dma_low - ioc->reply_frames_low_dma));
Linus Torvalds's avatar
Linus Torvalds committed
331 332 333 334 335

			req_idx = le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx);
			cb_idx = mr->u.frame.hwhdr.msgctxu.fld.cb_idx;
			mf = MPT_INDEX_2_MFPTR(ioc, req_idx);

Pam Delaney's avatar
Pam Delaney committed
336
			dprintk((MYIOC_s_INFO_FMT "Got non-TURBO reply=%p\n",
Linus Torvalds's avatar
Linus Torvalds committed
337 338 339 340 341 342 343
					ioc->name, mr));
			DBG_DUMP_REPLY_FRAME(mr)

			/* NEW!  20010301 -sralston
			 *  Check/log IOC log info
			 */
			ioc_stat = le16_to_cpu(mr->u.reply.IOCStatus);
Pam Delaney's avatar
Pam Delaney committed
344
			if (ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) {
Linus Torvalds's avatar
Linus Torvalds committed
345 346 347 348 349 350
				u32	 log_info = le32_to_cpu(mr->u.reply.IOCLogInfo);
				if ((int)ioc->chip_type <= (int)FC929)
					mpt_fc_log_info(ioc, log_info);
				else
					mpt_sp_log_info(ioc, log_info);
			}
351 352 353 354 355 356
			if (ioc_stat & MPI_IOCSTATUS_MASK) {
				if ((int)ioc->chip_type <= (int)FC929)
						;
				else
					mpt_sp_ioc_info(ioc, (u32)ioc_stat, mf);
			}
Linus Torvalds's avatar
Linus Torvalds committed
357 358 359 360
		} else {
			/*
			 *  Process turbo (context) reply...
			 */
Pam Delaney's avatar
Pam Delaney committed
361
			dirqprintk((MYIOC_s_INFO_FMT "Got TURBO reply(=%08x)\n", ioc->name, pa));
Linus Torvalds's avatar
Linus Torvalds committed
362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
			type = (pa >> MPI_CONTEXT_REPLY_TYPE_SHIFT);
			if (type == MPI_CONTEXT_REPLY_TYPE_SCSI_TARGET) {
				cb_idx = mpt_stm_index;
				mf = NULL;
				mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
			} else if (type == MPI_CONTEXT_REPLY_TYPE_LAN) {
				cb_idx = mpt_lan_index;
				/*
				 * BUG FIX!  20001218 -sralston
				 *  Blind set of mf to NULL here was fatal
				 *  after lan_reply says "freeme"
				 *  Fix sort of combined with an optimization here;
				 *  added explicit check for case where lan_reply
				 *  was just returning 1 and doing nothing else.
				 *  For this case skip the callback, but set up
				 *  proper mf value first here:-)
				 */
				if ((pa & 0x58000000) == 0x58000000) {
					req_idx = pa & 0x0000FFFF;
					mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
					freeme = 1;
					/*
					 *  IMPORTANT!  Invalidate the callback!
					 */
					cb_idx = 0;
				} else {
					mf = NULL;
				}
				mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
			} else {
				req_idx = pa & 0x0000FFFF;
				cb_idx = (pa & 0x00FF0000) >> 16;
				mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
				mr = NULL;
			}
			pa = 0;					/* No reply flush! */
		}

400
#ifdef MPT_DEBUG_IRQ
Pam Delaney's avatar
Pam Delaney committed
401
		if ((int)ioc->chip_type > (int)FC929) {
402
			/* Verify mf, mr are reasonable.
Pam Delaney's avatar
Pam Delaney committed
403 404 405
			 */
			if ((mf) && ((mf >= MPT_INDEX_2_MFPTR(ioc, ioc->req_depth))
				|| (mf < ioc->req_frames)) ) {
406
				printk(MYIOC_s_WARN_FMT
Pam Delaney's avatar
Pam Delaney committed
407 408 409 410 411 412 413
					"mpt_interrupt: Invalid mf (%p) req_idx (%d)!\n", ioc->name, (void *)mf, req_idx);
				cb_idx = 0;
				pa = 0;
				freeme = 0;
			}
			if ((pa) && (mr) && ((mr >= MPT_INDEX_2_RFPTR(ioc, ioc->req_depth))
				|| (mr < ioc->reply_frames)) ) {
414
				printk(MYIOC_s_WARN_FMT
Pam Delaney's avatar
Pam Delaney committed
415 416 417 418 419 420
					"mpt_interrupt: Invalid rf (%p)!\n", ioc->name, (void *)mr);
				cb_idx = 0;
				pa = 0;
				freeme = 0;
			}
			if (cb_idx > (MPT_MAX_PROTOCOL_DRIVERS-1)) {
421
				printk(MYIOC_s_WARN_FMT
Pam Delaney's avatar
Pam Delaney committed
422 423 424 425 426 427
					"mpt_interrupt: Invalid cb_idx (%d)!\n", ioc->name, cb_idx);
				cb_idx = 0;
				pa = 0;
				freeme = 0;
			}
		}
428
#endif
Pam Delaney's avatar
Pam Delaney committed
429

Linus Torvalds's avatar
Linus Torvalds committed
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446
		/*  Check for (valid) IO callback!  */
		if (cb_idx) {
			/*  Do the callback!  */
			freeme = (*(MptCallbacks[cb_idx]))(ioc, mf, mr);
		}

		if (pa) {
			/*  Flush (non-TURBO) reply with a WRITE!  */
			CHIPREG_WRITE32(&ioc->chip->ReplyFifo, pa);
		}

		if (freeme) {
			unsigned long flags;

			/*  Put Request back on FreeQ!  */
			spin_lock_irqsave(&ioc->FreeQlock, flags);
			Q_ADD_TAIL(&ioc->FreeQ, &mf->u.frame.linkage, MPT_FRAME_HDR);
Pam Delaney's avatar
Pam Delaney committed
447 448 449
#ifdef MFCNT
			ioc->mfcnt--;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
450 451 452 453 454
			spin_unlock_irqrestore(&ioc->FreeQlock, flags);
		}

		mb();
	}	/* drain reply FIFO */
455 456

	return IRQ_HANDLED;
Linus Torvalds's avatar
Linus Torvalds committed
457 458 459 460 461 462 463 464 465 466 467
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	mpt_base_reply - MPT base driver's callback routine; all base driver
 *	"internal" request/reply processing is routed here.
 *	Currently used for EventNotification and EventAck handling.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *	@mf: Pointer to original MPT request frame
 *	@reply: Pointer to MPT reply frame (NULL if TurboReply)
 *
James Bottomley's avatar
James Bottomley committed
468
	*	Returns 1 indicating original alloc'd request frame ptr
Linus Torvalds's avatar
Linus Torvalds committed
469 470 471 472 473 474 475 476
 *	should be freed, or 0 if it shouldn't.
 */
static int
mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply)
{
	int freereq = 1;
	u8 func;

Pam Delaney's avatar
Pam Delaney committed
477
	dprintk((MYIOC_s_INFO_FMT "mpt_base_reply() called\n", ioc->name));
Linus Torvalds's avatar
Linus Torvalds committed
478 479 480

	if ((mf == NULL) ||
	    (mf >= MPT_INDEX_2_MFPTR(ioc, ioc->req_depth))) {
Pam Delaney's avatar
Pam Delaney committed
481 482
		printk(MYIOC_s_ERR_FMT "NULL or BAD request frame ptr! (=%p)\n",
				ioc->name, (void *)mf);
Linus Torvalds's avatar
Linus Torvalds committed
483 484 485 486
		return 1;
	}

	if (reply == NULL) {
Pam Delaney's avatar
Pam Delaney committed
487
		dprintk((MYIOC_s_ERR_FMT "Unexpected NULL Event (turbo?) reply!\n",
Linus Torvalds's avatar
Linus Torvalds committed
488 489 490 491 492 493 494 495 496 497
				ioc->name));
		return 1;
	}

	if (!(reply->u.hdr.MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY)) {
		dmfprintk((KERN_INFO MYNAM ": Original request frame (@%p) header\n", mf));
		DBG_DUMP_REQUEST_FRAME_HDR(mf)
	}

	func = reply->u.hdr.Function;
Pam Delaney's avatar
Pam Delaney committed
498
	dprintk((MYIOC_s_INFO_FMT "mpt_base_reply, Function=%02Xh\n",
Linus Torvalds's avatar
Linus Torvalds committed
499 500 501 502 503 504 505 506 507 508
			ioc->name, func));

	if (func == MPI_FUNCTION_EVENT_NOTIFICATION) {
		EventNotificationReply_t *pEvReply = (EventNotificationReply_t *) reply;
		int evHandlers = 0;
		int results;

		results = ProcessEventNotification(ioc, pEvReply, &evHandlers);
		if (results != evHandlers) {
			/* CHECKME! Any special handling needed here? */
Pam Delaney's avatar
Pam Delaney committed
509
			dprintk((MYIOC_s_WARN_FMT "Called %d event handlers, sum results = %d\n",
Linus Torvalds's avatar
Linus Torvalds committed
510 511 512 513
					ioc->name, evHandlers, results));
		}

		/*
Pam Delaney's avatar
Pam Delaney committed
514 515
		 *	Hmmm...  It seems that EventNotificationReply is an exception
		 *	to the rule of one reply per request.
Linus Torvalds's avatar
Linus Torvalds committed
516 517 518
		 */
		if (pEvReply->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY)
			freereq = 0;
Pam Delaney's avatar
Pam Delaney committed
519

Linus Torvalds's avatar
Linus Torvalds committed
520 521 522
#ifdef CONFIG_PROC_FS
//		LogEvent(ioc, pEvReply);
#endif
Pam Delaney's avatar
Pam Delaney committed
523

Linus Torvalds's avatar
Linus Torvalds committed
524
	} else if (func == MPI_FUNCTION_EVENT_ACK) {
Pam Delaney's avatar
Pam Delaney committed
525
		dprintk((MYIOC_s_INFO_FMT "mpt_base_reply, EventAck reply received\n",
Linus Torvalds's avatar
Linus Torvalds committed
526
				ioc->name));
527 528
	} else if (func == MPI_FUNCTION_CONFIG ||
		   func == MPI_FUNCTION_TOOLBOX) {
Pam Delaney's avatar
Pam Delaney committed
529 530 531
		CONFIGPARMS *pCfg;
		unsigned long flags;

532
		dcprintk((MYIOC_s_INFO_FMT "config_complete (mf=%p,mr=%p)\n",
Pam Delaney's avatar
Pam Delaney committed
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
				ioc->name, mf, reply));

		pCfg = * ((CONFIGPARMS **)((u8 *) mf + ioc->req_sz - sizeof(void *)));

		if (pCfg) {
			/* disable timer and remove from linked list */
			del_timer(&pCfg->timer);

			spin_lock_irqsave(&ioc->FreeQlock, flags);
			Q_DEL_ITEM(&pCfg->linkage);
			spin_unlock_irqrestore(&ioc->FreeQlock, flags);

			/*
			 *	If IOC Status is SUCCESS, save the header
			 *	and set the status code to GOOD.
			 */
			pCfg->status = MPT_CONFIG_ERROR;
			if (reply) {
				ConfigReply_t	*pReply = (ConfigReply_t *)reply;
				u16		 status;

				status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
555
				dcprintk((KERN_NOTICE "  IOCStatus=%04xh, IOCLogInfo=%08xh\n",
Pam Delaney's avatar
Pam Delaney committed
556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572
				     status, le32_to_cpu(pReply->IOCLogInfo)));

				pCfg->status = status;
				if (status == MPI_IOCSTATUS_SUCCESS) {
					pCfg->hdr->PageVersion = pReply->Header.PageVersion;
					pCfg->hdr->PageLength = pReply->Header.PageLength;
					pCfg->hdr->PageNumber = pReply->Header.PageNumber;
					pCfg->hdr->PageType = pReply->Header.PageType;
				}
			}

			/*
			 *	Wake up the original calling thread
			 */
			pCfg->wait_done = 1;
			wake_up(&mpt_waitq);
		}
Linus Torvalds's avatar
Linus Torvalds committed
573
	} else {
Pam Delaney's avatar
Pam Delaney committed
574
		printk(MYIOC_s_ERR_FMT "Unexpected msg function (=%02Xh) reply received!\n",
Linus Torvalds's avatar
Linus Torvalds committed
575 576 577 578
				ioc->name, func);
	}

	/*
Pam Delaney's avatar
Pam Delaney committed
579 580
	 *	Conditionally tell caller to free the original
	 *	EventNotification/EventAck/unexpected request frame!
Linus Torvalds's avatar
Linus Torvalds committed
581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
	 */
	return freereq;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_register - Register protocol-specific main callback handler.
 *	@cbfunc: callback function pointer
 *	@dclass: Protocol driver's class (%MPT_DRIVER_CLASS enum value)
 *
 *	This routine is called by a protocol-specific driver (SCSI host,
 *	LAN, SCSI target) to register it's reply callback routine.  Each
 *	protocol-specific driver must do this before it will be able to
 *	use any IOC resources, such as obtaining request frames.
 *
Pam Delaney's avatar
Pam Delaney committed
596 597 598
 *	NOTES: The SCSI protocol driver currently calls this routine thrice
 *	in order to register separate callbacks; one for "normal" SCSI IO;
 *	one for MptScsiTaskMgmt requests; one for Scan/DV requests.
Linus Torvalds's avatar
Linus Torvalds committed
599 600
 *
 *	Returns a positive integer valued "handle" in the
Pam Delaney's avatar
Pam Delaney committed
601
 *	range (and S.O.D. order) {N,...,7,6,5,...,1} if successful.
Linus Torvalds's avatar
Linus Torvalds committed
602 603 604 605 606 607 608 609
 *	Any non-positive return value (including zero!) should be considered
 *	an error by the caller.
 */
int
mpt_register(MPT_CALLBACK cbfunc, MPT_DRIVER_CLASS dclass)
{
	int i;

Pam Delaney's avatar
Pam Delaney committed
610 611
	last_drv_idx = -1;

Linus Torvalds's avatar
Linus Torvalds committed
612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
#ifndef MODULE
	/*
	 *  Handle possibility of the mptscsih_detect() routine getting
	 *  called *before* fusion_init!
	 */
	if (!FusionInitCalled) {
		dprintk((KERN_INFO MYNAM ": Hmmm, calling fusion_init from mpt_register!\n"));
		/*
		 *  NOTE! We'll get recursion here, as fusion_init()
		 *  calls mpt_register()!
		 */
		fusion_init();
		FusionInitCalled++;
	}
#endif

	/*
Pam Delaney's avatar
Pam Delaney committed
629
	 *  Search for empty callback slot in this order: {N,...,7,6,5,...,1}
Linus Torvalds's avatar
Linus Torvalds committed
630 631 632 633 634 635 636
	 *  (slot/handle 0 is reserved!)
	 */
	for (i = MPT_MAX_PROTOCOL_DRIVERS-1; i; i--) {
		if (MptCallbacks[i] == NULL) {
			MptCallbacks[i] = cbfunc;
			MptDriverClass[i] = dclass;
			MptEvHandlers[i] = NULL;
Pam Delaney's avatar
Pam Delaney committed
637
			last_drv_idx = i;
Linus Torvalds's avatar
Linus Torvalds committed
638 639 640 641
			break;
		}
	}

Pam Delaney's avatar
Pam Delaney committed
642
	return last_drv_idx;
Linus Torvalds's avatar
Linus Torvalds committed
643 644 645 646 647 648 649 650 651 652 653 654 655
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_deregister - Deregister a protocol drivers resources.
 *	@cb_idx: previously registered callback handle
 *
 *	Each protocol-specific driver should call this routine when it's
 *	module is unloaded.
 */
void
mpt_deregister(int cb_idx)
{
656
	if ((cb_idx >= 0) && (cb_idx < MPT_MAX_PROTOCOL_DRIVERS)) {
Linus Torvalds's avatar
Linus Torvalds committed
657 658 659
		MptCallbacks[cb_idx] = NULL;
		MptDriverClass[cb_idx] = MPTUNKNOWN_DRIVER;
		MptEvHandlers[cb_idx] = NULL;
Pam Delaney's avatar
Pam Delaney committed
660 661 662 663

		last_drv_idx++;
		if (isense_idx != -1 && isense_idx <= cb_idx)
			isense_idx++;
Linus Torvalds's avatar
Linus Torvalds committed
664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707
	}
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_event_register - Register protocol-specific event callback
 *	handler.
 *	@cb_idx: previously registered (via mpt_register) callback handle
 *	@ev_cbfunc: callback function
 *
 *	This routine can be called by one or more protocol-specific drivers
 *	if/when they choose to be notified of MPT events.
 *
 *	Returns 0 for success.
 */
int
mpt_event_register(int cb_idx, MPT_EVHANDLER ev_cbfunc)
{
	if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
		return -1;

	MptEvHandlers[cb_idx] = ev_cbfunc;
	return 0;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_event_deregister - Deregister protocol-specific event callback
 *	handler.
 *	@cb_idx: previously registered callback handle
 *
 *	Each protocol-specific driver should call this routine
 *	when it does not (or can no longer) handle events,
 *	or when it's module is unloaded.
 */
void
mpt_event_deregister(int cb_idx)
{
	if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
		return;

	MptEvHandlers[cb_idx] = NULL;
}

Linus Torvalds's avatar
Linus Torvalds committed
708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_reset_register - Register protocol-specific IOC reset handler.
 *	@cb_idx: previously registered (via mpt_register) callback handle
 *	@reset_func: reset function
 *
 *	This routine can be called by one or more protocol-specific drivers
 *	if/when they choose to be notified of IOC resets.
 *
 *	Returns 0 for success.
 */
int
mpt_reset_register(int cb_idx, MPT_RESETHANDLER reset_func)
{
	if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
		return -1;

	MptResetHandlers[cb_idx] = reset_func;
	return 0;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_reset_deregister - Deregister protocol-specific IOC reset handler.
 *	@cb_idx: previously registered callback handle
 *
 *	Each protocol-specific driver should call this routine
 *	when it does not (or can no longer) handle IOC reset handling,
 *	or when it's module is unloaded.
 */
void
mpt_reset_deregister(int cb_idx)
{
	if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
		return;

	MptResetHandlers[cb_idx] = NULL;
}

James Bottomley's avatar
James Bottomley committed
747 748 749 750 751 752 753
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_device_driver_register - Register device driver hooks
 */
int
mpt_device_driver_register(struct mpt_pci_driver * dd_cbfunc, int cb_idx)
{
754 755 756 757 758 759 760
	MPT_ADAPTER	*ioc;
	int 		error=0;

	if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS) {
		error= -EINVAL;
		return error;
	}
James Bottomley's avatar
James Bottomley committed
761 762

	MptDeviceDriverHandlers[cb_idx] = dd_cbfunc;
763 764

	/* call per pci device probe entry point */
765
	list_for_each_entry(ioc, &ioc_list, list) {
766 767 768 769 770 771 772 773 774
		if(dd_cbfunc->probe) {
			error = dd_cbfunc->probe(ioc->pcidev,
			  ioc->pcidev->driver->id_table);
			if(error != 0)
				return error;
  		}
	 }

	return error;
James Bottomley's avatar
James Bottomley committed
775 776 777 778 779 780 781 782 783
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_device_driver_deregister - DeRegister device driver hooks
 */
void
mpt_device_driver_deregister(int cb_idx)
{
784 785 786
	struct mpt_pci_driver *dd_cbfunc;
	MPT_ADAPTER	*ioc;

James Bottomley's avatar
James Bottomley committed
787 788 789
	if (cb_idx < 1 || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
		return;

790 791 792 793 794 795 796
	dd_cbfunc = MptDeviceDriverHandlers[cb_idx];

	list_for_each_entry(ioc, &ioc_list, list) {
		if (dd_cbfunc->remove)
			dd_cbfunc->remove(ioc->pcidev);
	}
	
James Bottomley's avatar
James Bottomley committed
797 798 799 800
	MptDeviceDriverHandlers[cb_idx] = NULL;
}


Linus Torvalds's avatar
Linus Torvalds committed
801 802 803 804 805 806 807
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_get_msg_frame - Obtain a MPT request frame from the pool (of 1024)
 *	allocated per MPT adapter.
 *	@handle: Handle of registered MPT protocol driver
 *	@iocid: IOC unique identifier (integer)
 *
Pam Delaney's avatar
Pam Delaney committed
808 809
 *	Returns pointer to a MPT request frame or %NULL if none are available
 *	or IOC is not active.
Linus Torvalds's avatar
Linus Torvalds committed
810 811
 */
MPT_FRAME_HDR*
812
mpt_get_msg_frame(int handle, MPT_ADAPTER *iocp)
Linus Torvalds's avatar
Linus Torvalds committed
813
{
814
	MPT_FRAME_HDR *mf;
Linus Torvalds's avatar
Linus Torvalds committed
815 816
	unsigned long flags;

Pam Delaney's avatar
Pam Delaney committed
817 818 819 820 821 822 823 824 825
#ifdef MFCNT
	if (!iocp->active)
		printk(KERN_WARNING "IOC Not Active! mpt_get_msg_frame returning NULL!\n");
#endif

	/* If interrupts are not attached, do not return a request frame */
	if (!iocp->active)
		return NULL;

Linus Torvalds's avatar
Linus Torvalds committed
826 827 828 829 830 831 832 833 834 835 836 837
	spin_lock_irqsave(&iocp->FreeQlock, flags);
	if (! Q_IS_EMPTY(&iocp->FreeQ)) {
		int req_offset;

		mf = iocp->FreeQ.head;
		Q_DEL_ITEM(&mf->u.frame.linkage);
		mf->u.frame.hwhdr.msgctxu.fld.cb_idx = handle;	/* byte */
		req_offset = (u8 *)mf - (u8 *)iocp->req_frames;
								/* u16! */
		mf->u.frame.hwhdr.msgctxu.fld.req_idx =
				cpu_to_le16(req_offset / iocp->req_sz);
		mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
Pam Delaney's avatar
Pam Delaney committed
838 839 840
#ifdef MFCNT
		iocp->mfcnt++;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
841
	}
842 843
	else
		mf = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
844
	spin_unlock_irqrestore(&iocp->FreeQlock, flags);
Pam Delaney's avatar
Pam Delaney committed
845 846 847 848 849 850 851 852 853

#ifdef MFCNT
	if (mf == NULL)
		printk(KERN_WARNING "IOC Active. No free Msg Frames! Count 0x%x Max 0x%x\n", iocp->mfcnt, iocp->req_depth);
	mfcounter++;
	if (mfcounter == PRINT_MF_COUNT)
		printk(KERN_INFO "MF Count 0x%x Max 0x%x \n", iocp->mfcnt, iocp->req_depth);
#endif

Linus Torvalds's avatar
Linus Torvalds committed
854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870
	dmfprintk((KERN_INFO MYNAM ": %s: mpt_get_msg_frame(%d,%d), got mf=%p\n",
			iocp->name, handle, iocid, mf));
	return mf;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_put_msg_frame - Send a protocol specific MPT request frame
 *	to a IOC.
 *	@handle: Handle of registered MPT protocol driver
 *	@iocid: IOC unique identifier (integer)
 *	@mf: Pointer to MPT request frame
 *
 *	This routine posts a MPT request frame to the request post FIFO of a
 *	specific MPT adapter.
 */
void
871
mpt_put_msg_frame(int handle, MPT_ADAPTER *iocp, MPT_FRAME_HDR *mf)
Linus Torvalds's avatar
Linus Torvalds committed
872
{
873 874
	u32 mf_dma_addr;
	int req_offset;
Linus Torvalds's avatar
Linus Torvalds committed
875

876 877 878
	/* ensure values are reset properly! */
	mf->u.frame.hwhdr.msgctxu.fld.cb_idx = handle;		/* byte */
	req_offset = (u8 *)mf - (u8 *)iocp->req_frames;
Linus Torvalds's avatar
Linus Torvalds committed
879
									/* u16! */
880 881
	mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_offset / iocp->req_sz);
	mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
Linus Torvalds's avatar
Linus Torvalds committed
882 883

#ifdef MPT_DEBUG_MSG_FRAME
884 885 886 887 888 889 890 891 892 893 894 895 896
	{
		u32	*m = mf->u.frame.hwhdr.__hdr;
		int	 ii, n;

		printk(KERN_INFO MYNAM ": %s: About to Put msg frame @ %p:\n" KERN_INFO " ",
				iocp->name, m);
		n = iocp->req_sz/4 - 1;
		while (m[n] == 0)
			n--;
		for (ii=0; ii<=n; ii++) {
			if (ii && ((ii%8)==0))
				printk("\n" KERN_INFO " ");
			printk(" %08x", le32_to_cpu(m[ii]));
Linus Torvalds's avatar
Linus Torvalds committed
897
		}
898
		printk("\n");
Linus Torvalds's avatar
Linus Torvalds committed
899
	}
900
#endif
901

902 903
	mf_dma_addr = iocp->req_frames_low_dma + req_offset;
	CHIPREG_WRITE32(&iocp->chip->RequestFifo, mf_dma_addr);
Linus Torvalds's avatar
Linus Torvalds committed
904 905 906 907 908 909 910 911 912 913 914 915 916
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_free_msg_frame - Place MPT request frame back on FreeQ.
 *	@handle: Handle of registered MPT protocol driver
 *	@iocid: IOC unique identifier (integer)
 *	@mf: Pointer to MPT request frame
 *
 *	This routine places a MPT request frame back on the MPT adapter's
 *	FreeQ.
 */
void
917
mpt_free_msg_frame(int handle, MPT_ADAPTER *iocp, MPT_FRAME_HDR *mf)
Linus Torvalds's avatar
Linus Torvalds committed
918 919 920
{
	unsigned long flags;

921 922 923
	/*  Put Request back on FreeQ!  */
	spin_lock_irqsave(&iocp->FreeQlock, flags);
	Q_ADD_TAIL(&iocp->FreeQ, &mf->u.frame.linkage, MPT_FRAME_HDR);
Pam Delaney's avatar
Pam Delaney committed
924
#ifdef MFCNT
925
	iocp->mfcnt--;
Pam Delaney's avatar
Pam Delaney committed
926
#endif
927
	spin_unlock_irqrestore(&iocp->FreeQlock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
928 929
}

Pam Delaney's avatar
Pam Delaney committed
930 931 932 933 934
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_add_sge - Place a simple SGE at address pAddr.
 *	@pAddr: virtual address for SGE
 *	@flagslength: SGE flags and data transfer length
935
 *	@dma_addr: Physical address
Pam Delaney's avatar
Pam Delaney committed
936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964
 *
 *	This routine places a MPT request frame back on the MPT adapter's
 *	FreeQ.
 */
void
mpt_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
{
	if (sizeof(dma_addr_t) == sizeof(u64)) {
		SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
		u32 tmp = dma_addr & 0xFFFFFFFF;

		pSge->FlagsLength = cpu_to_le32(flagslength);
		pSge->Address.Low = cpu_to_le32(tmp);
		tmp = (u32) ((u64)dma_addr >> 32);
		pSge->Address.High = cpu_to_le32(tmp);

	} else {
		SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
		pSge->FlagsLength = cpu_to_le32(flagslength);
		pSge->Address = cpu_to_le32(dma_addr);
	}
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_add_chain - Place a chain SGE at address pAddr.
 *	@pAddr: virtual address for SGE
 *	@next: nextChainOffset value (u32's)
 *	@length: length of next SGL segment
965
 *	@dma_addr: Physical address
Pam Delaney's avatar
Pam Delaney committed
966 967 968 969 970 971 972 973 974 975 976 977
 *
 *	This routine places a MPT request frame back on the MPT adapter's
 *	FreeQ.
 */
void
mpt_add_chain(char *pAddr, u8 next, u16 length, dma_addr_t dma_addr)
{
	if (sizeof(dma_addr_t) == sizeof(u64)) {
		SGEChain64_t *pChain = (SGEChain64_t *) pAddr;
		u32 tmp = dma_addr & 0xFFFFFFFF;

		pChain->Length = cpu_to_le16(length);
978
		pChain->Flags = MPI_SGE_FLAGS_CHAIN_ELEMENT | mpt_addr_size();
Pam Delaney's avatar
Pam Delaney committed
979 980 981 982 983 984 985 986 987 988 989 990 991 992 993

		pChain->NextChainOffset = next;

		pChain->Address.Low = cpu_to_le32(tmp);
		tmp = (u32) ((u64)dma_addr >> 32);
		pChain->Address.High = cpu_to_le32(tmp);
	} else {
		SGEChain32_t *pChain = (SGEChain32_t *) pAddr;
		pChain->Length = cpu_to_le16(length);
		pChain->Flags = MPI_SGE_FLAGS_CHAIN_ELEMENT | mpt_addr_size();
		pChain->NextChainOffset = next;
		pChain->Address = cpu_to_le32(dma_addr);
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
994 995 996 997 998 999 1000 1001
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_send_handshake_request - Send MPT request via doorbell
 *	handshake method.
 *	@handle: Handle of registered MPT protocol driver
 *	@iocid: IOC unique identifier (integer)
 *	@reqBytes: Size of the request in bytes
 *	@req: Pointer to MPT request frame
Pam Delaney's avatar
Pam Delaney committed
1002
 *	@sleepFlag: Use schedule if CAN_SLEEP else use udelay.
Linus Torvalds's avatar
Linus Torvalds committed
1003
 *
Pam Delaney's avatar
Pam Delaney committed
1004
 *	This routine is used exclusively to send MptScsiTaskMgmt
Linus Torvalds's avatar
Linus Torvalds committed
1005 1006 1007 1008 1009 1010 1011 1012
 *	requests since they are required to be sent via doorbell handshake.
 *
 *	NOTE: It is the callers responsibility to byte-swap fields in the
 *	request which are greater than 1 byte in size.
 *
 *	Returns 0 for success, non-zero for failure.
 */
int
1013
mpt_send_handshake_request(int handle, MPT_ADAPTER *iocp, int reqBytes, u32 *req, int sleepFlag)
Linus Torvalds's avatar
Linus Torvalds committed
1014 1015
{
	int		 r = 0;
1016 1017
	u8	*req_as_bytes;
	int	 ii;
Linus Torvalds's avatar
Linus Torvalds committed
1018

1019 1020 1021 1022
	/* State is known to be good upon entering
	 * this function so issue the bus reset
	 * request.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
1023

1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
	/*
	 * Emulate what mpt_put_msg_frame() does /wrt to sanity
	 * setting cb_idx/req_idx.  But ONLY if this request
	 * is in proper (pre-alloc'd) request buffer range...
	 */
	ii = MFPTR_2_MPT_INDEX(iocp,(MPT_FRAME_HDR*)req);
	if (reqBytes >= 12 && ii >= 0 && ii < iocp->req_depth) {
		MPT_FRAME_HDR *mf = (MPT_FRAME_HDR*)req;
		mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(ii);
		mf->u.frame.hwhdr.msgctxu.fld.cb_idx = handle;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1035

1036 1037 1038 1039 1040
	/* Make sure there are no doorbells */
	CHIPREG_WRITE32(&iocp->chip->IntStatus, 0);
	CHIPREG_WRITE32(&iocp->chip->Doorbell,
			((MPI_FUNCTION_HANDSHAKE<<MPI_DOORBELL_FUNCTION_SHIFT) |
			 ((reqBytes/4)<<MPI_DOORBELL_ADD_DWORDS_SHIFT)));
Linus Torvalds's avatar
Linus Torvalds committed
1041

1042 1043 1044 1045
	/* Wait for IOC doorbell int */
	ii = WaitForDoorbellInt(iocp, 5, sleepFlag);
	if (ii < 0)
		return ii;
Linus Torvalds's avatar
Linus Torvalds committed
1046

1047 1048 1049
	/* Read doorbell and check for active bit */
	if (!(CHIPREG_READ32(&iocp->chip->Doorbell) & MPI_DOORBELL_ACTIVE))
		return -5;
Pam Delaney's avatar
Pam Delaney committed
1050

1051 1052
	dhsprintk((KERN_INFO MYNAM ": %s: mpt_send_handshake_request start, WaitCnt=%d\n",
			iocp->name, ii));
Linus Torvalds's avatar
Linus Torvalds committed
1053

1054
	CHIPREG_WRITE32(&iocp->chip->IntStatus, 0);
Linus Torvalds's avatar
Linus Torvalds committed
1055

1056 1057 1058
	r = WaitForDoorbellAck(iocp, 5, sleepFlag);
	if (r < 0)
		return -2;
Linus Torvalds's avatar
Linus Torvalds committed
1059

1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
	/* Send request via doorbell handshake */
	req_as_bytes = (u8 *) req;
	for (ii = 0; ii < reqBytes/4; ii++) {
		u32 word;

		word = ((req_as_bytes[(ii*4) + 0] <<  0) |
			(req_as_bytes[(ii*4) + 1] <<  8) |
			(req_as_bytes[(ii*4) + 2] << 16) |
			(req_as_bytes[(ii*4) + 3] << 24));
		CHIPREG_WRITE32(&iocp->chip->Doorbell, word);
		r = WaitForDoorbellAck(iocp, 5, sleepFlag);
		if (r < 0) {
			r = -3;
			break;
Linus Torvalds's avatar
Linus Torvalds committed
1074 1075 1076
		}
	}

1077 1078
	if (r >= 0 && WaitForDoorbellInt(iocp, 10, sleepFlag) >= 0)
		r = 0;
1079
	else
1080
		r = -4;
Linus Torvalds's avatar
Linus Torvalds committed
1081

1082 1083 1084
	/* Make sure there are no doorbells */
	CHIPREG_WRITE32(&iocp->chip->IntStatus, 0);
	return r;
Linus Torvalds's avatar
Linus Torvalds committed
1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_verify_adapter - Given a unique IOC identifier, set pointer to
 *	the associated MPT adapter structure.
 *	@iocid: IOC unique identifier (integer)
 *	@iocpp: Pointer to pointer to IOC adapter
 *
 *	Returns iocid and sets iocpp.
 */
int
mpt_verify_adapter(int iocid, MPT_ADAPTER **iocpp)
{
1099
	MPT_ADAPTER *ioc;
Linus Torvalds's avatar
Linus Torvalds committed
1100

1101 1102 1103 1104 1105 1106 1107
	list_for_each_entry(ioc,&ioc_list,list) {
		if (ioc->id == iocid) {
			*iocpp =ioc;
			return iocid;
		} 
	}
	
Linus Torvalds's avatar
Linus Torvalds committed
1108
	*iocpp = NULL;
1109
	return -1;
Linus Torvalds's avatar
Linus Torvalds committed
1110 1111 1112
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Pam Delaney's avatar
Pam Delaney committed
1113
/*
James Bottomley's avatar
James Bottomley committed
1114
 *	mptbase_probe - Install a PCI intelligent MPT adapter.
Linus Torvalds's avatar
Linus Torvalds committed
1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
 *	@pdev: Pointer to pci_dev structure
 *
 *	This routine performs all the steps necessary to bring the IOC of
 *	a MPT adapter to a OPERATIONAL state.  This includes registering
 *	memory regions, registering the interrupt, and allocating request
 *	and reply memory pools.
 *
 *	This routine also pre-fetches the LAN MAC address of a Fibre Channel
 *	MPT adapter.
 *
 *	Returns 0 for success, non-zero for failure.
 *
 *	TODO: Add support for polled controllers
 */
James Bottomley's avatar
James Bottomley committed
1129 1130
static int __devinit
mptbase_probe(struct pci_dev *pdev, const struct pci_device_id *id)
Linus Torvalds's avatar
Linus Torvalds committed
1131 1132 1133 1134 1135 1136 1137
{
	MPT_ADAPTER	*ioc;
	u8		*mem;
	unsigned long	 mem_phys;
	unsigned long	 port;
	u32		 msize;
	u32		 psize;
Pam Delaney's avatar
Pam Delaney committed
1138
	int		 ii;
Linus Torvalds's avatar
Linus Torvalds committed
1139
	int		 r = -ENODEV;
Dave Jones's avatar
Dave Jones committed
1140
	u64		 mask = 0xffffffffffffffffULL;
1141 1142
	u8		 revision;
	u8		 pcixcmd;
1143 1144
	static int	 mpt_ids = 0;
	struct proc_dir_entry *dent, *ent;
Linus Torvalds's avatar
Linus Torvalds committed
1145

Pam Delaney's avatar
Pam Delaney committed
1146 1147
	if (pci_enable_device(pdev))
		return r;
1148
	
Pam Delaney's avatar
Pam Delaney committed
1149
	if (!pci_set_dma_mask(pdev, mask)) {
1150
		dprintk((KERN_INFO MYNAM
Pam Delaney's avatar
Pam Delaney committed
1151 1152 1153 1154 1155 1156
			": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n"));
	} else if (pci_set_dma_mask(pdev, (u64) 0xffffffff)) {
		printk(KERN_WARNING MYNAM ": 32 BIT PCI BUS DMA ADDRESSING NOT SUPPORTED\n");
		return r;
	}

James Bottomley's avatar
James Bottomley committed
1157 1158 1159 1160 1161 1162 1163
	if (!pci_set_consistent_dma_mask(pdev, mask))
		dprintk((KERN_INFO MYNAM
			": Using 64 bit consistent mask\n"));
	else
		dprintk((KERN_INFO MYNAM
			": Not using 64 bit consistent mask\n"));

Pam Delaney's avatar
Pam Delaney committed
1164
	ioc = kmalloc(sizeof(MPT_ADAPTER), GFP_ATOMIC);
Linus Torvalds's avatar
Linus Torvalds committed
1165 1166 1167 1168
	if (ioc == NULL) {
		printk(KERN_ERR MYNAM ": ERROR - Insufficient memory to add adapter!\n");
		return -ENOMEM;
	}
1169
	memset(ioc, 0, sizeof(MPT_ADAPTER));
Linus Torvalds's avatar
Linus Torvalds committed
1170
	ioc->alloc_total = sizeof(MPT_ADAPTER);
Pam Delaney's avatar
Pam Delaney committed
1171
	ioc->req_sz = MPT_DEFAULT_FRAME_SIZE;		/* avoid div by zero! */
1172
	ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
Linus Torvalds's avatar
Linus Torvalds committed
1173 1174

	ioc->pcidev = pdev;
1175

Pam Delaney's avatar
Pam Delaney committed
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
	ioc->diagPending = 0;
	spin_lock_init(&ioc->diagLock);

	/* Initialize the event logging.
	 */
	ioc->eventTypes = 0;	/* None */
	ioc->eventContext = 0;
	ioc->eventLogSize = 0;
	ioc->events = NULL;

#ifdef MFCNT
	ioc->mfcnt = 0;
#endif

	ioc->cached_fw = NULL;

	/* Initilize SCSI Config Data structure
	 */
	memset(&ioc->spi_data, 0, sizeof(ScsiCfgData));

	/* Initialize the running configQ head.
	 */
	Q_INIT(&ioc->configQ, Q_ITEM);
Linus Torvalds's avatar
Linus Torvalds committed
1199

Linus Torvalds's avatar
Linus Torvalds committed
1200
	/* Find lookup slot. */
1201 1202 1203
	INIT_LIST_HEAD(&ioc->list);
	ioc->id = mpt_ids++;
	
Linus Torvalds's avatar
Linus Torvalds committed
1204 1205
	mem_phys = msize = 0;
	port = psize = 0;
Pam Delaney's avatar
Pam Delaney committed
1206
	for (ii=0; ii < DEVICE_COUNT_RESOURCE; ii++) {
1207
		if (pci_resource_flags(pdev, ii) & PCI_BASE_ADDRESS_SPACE_IO) {
Linus Torvalds's avatar
Linus Torvalds committed
1208
			/* Get I/O space! */
1209 1210
			port = pci_resource_start(pdev, ii);
			psize = pci_resource_len(pdev,ii);
Linus Torvalds's avatar
Linus Torvalds committed
1211
		} else {
Linus Torvalds's avatar
Linus Torvalds committed
1212
			/* Get memmap */
1213 1214
			mem_phys = pci_resource_start(pdev, ii);
			msize = pci_resource_len(pdev,ii);
Linus Torvalds's avatar
Linus Torvalds committed
1215 1216 1217 1218 1219
			break;
		}
	}
	ioc->mem_size = msize;

Pam Delaney's avatar
Pam Delaney committed
1220
	if (ii == DEVICE_COUNT_RESOURCE) {
Linus Torvalds's avatar
Linus Torvalds committed
1221 1222 1223 1224 1225 1226 1227 1228 1229
		printk(KERN_ERR MYNAM ": ERROR - MPT adapter has no memory regions defined!\n");
		kfree(ioc);
		return -EINVAL;
	}

	dprintk((KERN_INFO MYNAM ": MPT adapter @ %lx, msize=%dd bytes\n", mem_phys, msize));
	dprintk((KERN_INFO MYNAM ": (port i/o @ %lx, psize=%dd bytes)\n", port, psize));

	mem = NULL;
1230 1231 1232 1233 1234 1235 1236
	/* Get logical ptr for PciMem0 space */
	/*mem = ioremap(mem_phys, msize);*/
	mem = ioremap(mem_phys, 0x100);
	if (mem == NULL) {
		printk(KERN_ERR MYNAM ": ERROR - Unable to map adapter memory!\n");
		kfree(ioc);
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
1237
	}
1238
	ioc->memmap = mem;
Linus Torvalds's avatar
Linus Torvalds committed
1239 1240
	dprintk((KERN_INFO MYNAM ": mem = %p, mem_phys = %lx\n", mem, mem_phys));

Pam Delaney's avatar
Pam Delaney committed
1241 1242
	dprintk((KERN_INFO MYNAM ": facts @ %p, pfacts[0] @ %p\n",
			&ioc->facts, &ioc->pfacts[0]));
1243 1244 1245

	ioc->mem_phys = mem_phys;
	ioc->chip = (SYSIF_REGS*)mem;
Linus Torvalds's avatar
Linus Torvalds committed
1246

Pam Delaney's avatar
Pam Delaney committed
1247 1248 1249 1250 1251 1252 1253
	/* Save Port IO values incase we need to do downloadboot */
	{
		u8 *pmem = (u8*)port;
		ioc->pio_mem_phys = port;
		ioc->pio_chip = (SYSIF_REGS*)pmem;
	}

Linus Torvalds's avatar
Linus Torvalds committed
1254
	ioc->chip_type = FCUNK;
1255 1256 1257 1258
	if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC909) {
		ioc->chip_type = FC909;
		ioc->prod_name = "LSIFC909";
	}
1259
	if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC929) {
Linus Torvalds's avatar
Linus Torvalds committed
1260 1261 1262 1263
		ioc->chip_type = FC929;
		ioc->prod_name = "LSIFC929";
	}
	else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC919) {
Linus Torvalds's avatar
Linus Torvalds committed
1264
		ioc->chip_type = FC919;
Linus Torvalds's avatar
Linus Torvalds committed
1265 1266
		ioc->prod_name = "LSIFC919";
	}
Pam Delaney's avatar
Pam Delaney committed
1267 1268
	else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC929X) {
		ioc->chip_type = FC929X;
1269 1270 1271
		pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
		if (revision < XL_929) {
			ioc->prod_name = "LSIFC929X";
1272
			/* 929X Chip Fix. Set Split transactions level
1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284
		 	* for PCIX. Set MOST bits to zero.
		 	*/
			pci_read_config_byte(pdev, 0x6a, &pcixcmd);
			pcixcmd &= 0x8F;
			pci_write_config_byte(pdev, 0x6a, pcixcmd);
		} else {
			ioc->prod_name = "LSIFC929XL";
			/* 929XL Chip Fix. Set MMRBC to 0x08.
		 	*/
			pci_read_config_byte(pdev, 0x6a, &pcixcmd);
			pcixcmd |= 0x08;
			pci_write_config_byte(pdev, 0x6a, pcixcmd);
1285
		}
Pam Delaney's avatar
Pam Delaney committed
1286 1287 1288 1289
	}
	else if (pdev->device == MPI_MANUFACTPAGE_DEVICEID_FC919X) {
		ioc->chip_type = FC919X;
		ioc->prod_name = "LSIFC919X";
1290 1291 1292 1293 1294 1295
		/* 919X Chip Fix. Set Split transactions level
		 * for PCIX. Set MOST bits to zero.
		 */
		pci_read_config_byte(pdev, 0x6a, &pcixcmd);
		pcixcmd &= 0x8F;
		pci_write_config_byte(pdev, 0x6a, pcixcmd);
Pam Delaney's avatar
Pam Delaney committed
1296 1297
	}
	else if (pdev->device == MPI_MANUFACTPAGE_DEVID_53C1030) {
Linus Torvalds's avatar
Linus Torvalds committed
1298 1299
		ioc->chip_type = C1030;
		ioc->prod_name = "LSI53C1030";
1300 1301 1302 1303 1304 1305 1306 1307
		/* 1030 Chip Fix. Disable Split transactions
		 * for PCIX. Set MOST bits to zero if Rev < C0( = 8).
		 */
		pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
		if (revision < C0_1030) {
			pci_read_config_byte(pdev, 0x6a, &pcixcmd);
			pcixcmd &= 0x8F;
			pci_write_config_byte(pdev, 0x6a, pcixcmd);
Pam Delaney's avatar
Pam Delaney committed
1308
		}
Linus Torvalds's avatar
Linus Torvalds committed
1309
	}
1310 1311 1312 1313
	else if (pdev->device == MPI_MANUFACTPAGE_DEVID_1030_53C1035) {
		ioc->chip_type = C1035;
		ioc->prod_name = "LSI53C1035";
	}
Linus Torvalds's avatar
Linus Torvalds committed
1314

Pam Delaney's avatar
Pam Delaney committed
1315
	sprintf(ioc->name, "ioc%d", ioc->id);
Linus Torvalds's avatar
Linus Torvalds committed
1316 1317 1318 1319

	Q_INIT(&ioc->FreeQ, MPT_FRAME_HDR);
	spin_lock_init(&ioc->FreeQlock);

Linus Torvalds's avatar
Linus Torvalds committed
1320
	/* Disable all! */
Linus Torvalds's avatar
Linus Torvalds committed
1321 1322
	CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
	ioc->active = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1323
	CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
Linus Torvalds's avatar
Linus Torvalds committed
1324

1325
	/* Set lookup ptr. */
1326
	list_add_tail(&ioc->list, &ioc_list);
1327

Linus Torvalds's avatar
Linus Torvalds committed
1328 1329 1330 1331 1332
	ioc->pci_irq = -1;
	if (pdev->irq) {
		r = request_irq(pdev->irq, mpt_interrupt, SA_SHIRQ, ioc->name, ioc);

		if (r < 0) {
Pam Delaney's avatar
Pam Delaney committed
1333 1334
#ifndef __sparc__
			printk(MYIOC_s_ERR_FMT "Unable to allocate interrupt %d!\n",
Linus Torvalds's avatar
Linus Torvalds committed
1335
					ioc->name, pdev->irq);
Pam Delaney's avatar
Pam Delaney committed
1336 1337 1338 1339
#else
			printk(MYIOC_s_ERR_FMT "Unable to allocate interrupt %s!\n",
					ioc->name, __irq_itoa(pdev->irq));
#endif
1340
			Q_DEL_ITEM(ioc);
1341
			list_del(&ioc->list);
Linus Torvalds's avatar
Linus Torvalds committed
1342 1343 1344 1345 1346 1347 1348 1349
			iounmap(mem);
			kfree(ioc);
			return -EBUSY;
		}

		ioc->pci_irq = pdev->irq;

		pci_set_master(pdev);			/* ?? */
James Bottomley's avatar
James Bottomley committed
1350
		pci_set_drvdata(pdev, ioc);
Linus Torvalds's avatar
Linus Torvalds committed
1351

Pam Delaney's avatar
Pam Delaney committed
1352
#ifndef __sparc__
Linus Torvalds's avatar
Linus Torvalds committed
1353
		dprintk((KERN_INFO MYNAM ": %s installed at interrupt %d\n", ioc->name, pdev->irq));
Pam Delaney's avatar
Pam Delaney committed
1354 1355 1356
#else
		dprintk((KERN_INFO MYNAM ": %s installed at interrupt %s\n", ioc->name, __irq_itoa(pdev->irq)));
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1357 1358 1359
	}

	/* NEW!  20010220 -sralston
1360
	 * Check for "bound ports" (929, 929X, 1030, 1035) to reduce redundant resets.
Linus Torvalds's avatar
Linus Torvalds committed
1361
	 */
1362
	if ((ioc->chip_type == FC929) || (ioc->chip_type == C1030)
1363
			|| (ioc->chip_type == C1035) || (ioc->chip_type == FC929X))
Pam Delaney's avatar
Pam Delaney committed
1364
		mpt_detect_bound_ports(ioc, pdev);
Linus Torvalds's avatar
Linus Torvalds committed
1365

1366 1367 1368 1369 1370
	if ((r = mpt_do_ioc_recovery(ioc,
	  MPT_HOSTEVENT_IOC_BRINGUP, CAN_SLEEP)) != 0) {
		printk(KERN_WARNING MYNAM
		  ": WARNING - %s did not initialize properly! (%d)\n",
		  ioc->name, r);
Linus Torvalds's avatar
Linus Torvalds committed
1371

1372
		Q_DEL_ITEM(ioc);
1373
		list_del(&ioc->list);
1374 1375 1376
		free_irq(ioc->pci_irq, ioc);
		iounmap(mem);
		kfree(ioc);
1377
		pci_set_drvdata(pdev, NULL);
James Bottomley's avatar
James Bottomley committed
1378
		return r;
1379
	}
James Bottomley's avatar
James Bottomley committed
1380 1381 1382 1383 1384 1385 1386 1387 1388

	/* call per device driver probe entry point */
	for(ii=0; ii<MPT_MAX_PROTOCOL_DRIVERS; ii++) {
		if(MptDeviceDriverHandlers[ii] &&
		  MptDeviceDriverHandlers[ii]->probe) {
			MptDeviceDriverHandlers[ii]->probe(pdev,id);
		}
	}

1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
	/*
	 *  Create "/proc/mpt/iocN" subdirectory entry for each MPT adapter.
	 */
	dent = proc_mkdir(ioc->name, mpt_proc_root_dir);
	if (dent) {
		ent = create_proc_entry("info", S_IFREG|S_IRUGO, dent);
		if (ent) {
			ent->read_proc = procmpt_iocinfo_read;
			ent->data = ioc;
		}
		ent = create_proc_entry("summary", S_IFREG|S_IRUGO, dent);
		if (ent) {
			ent->read_proc = procmpt_summary_read;
			ent->data = ioc;
		}
	}

James Bottomley's avatar
James Bottomley committed
1406
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1407 1408
}

James Bottomley's avatar
James Bottomley committed
1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	mptbase_remove - Remove a PCI intelligent MPT adapter.
 *	@pdev: Pointer to pci_dev structure
 *
 */

static void __devexit
mptbase_remove(struct pci_dev *pdev)
{
	MPT_ADAPTER 	*ioc = pci_get_drvdata(pdev);
1420
	char pname[32];
James Bottomley's avatar
James Bottomley committed
1421 1422
	int ii;

1423 1424 1425 1426 1427 1428 1429
	sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/summary", ioc->name);
	remove_proc_entry(pname, NULL);
	sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/info", ioc->name);
	remove_proc_entry(pname, NULL);
	sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s", ioc->name);
	remove_proc_entry(pname, NULL);
	
James Bottomley's avatar
James Bottomley committed
1430 1431 1432 1433 1434 1435 1436
	/* call per device driver remove entry point */
	for(ii=0; ii<MPT_MAX_PROTOCOL_DRIVERS; ii++) {
		if(MptDeviceDriverHandlers[ii] &&
		  MptDeviceDriverHandlers[ii]->remove) {
			MptDeviceDriverHandlers[ii]->remove(pdev);
		}
	}
1437
	
James Bottomley's avatar
James Bottomley committed
1438 1439 1440 1441
	/* Disable interrupts! */
	CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);

	ioc->active = 0;
1442
	synchronize_irq(pdev->irq);
James Bottomley's avatar
James Bottomley committed
1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601

	/* Clear any lingering interrupt */
	CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);

	CHIPREG_READ32(&ioc->chip->IntStatus);

	mpt_adapter_dispose(ioc);

	pci_set_drvdata(pdev, NULL);
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	mptbase_shutdown -
 *
 */
static void
mptbase_shutdown(struct device * dev)
{
	int ii;

	/* call per device driver shutdown entry point */
	for(ii=0; ii<MPT_MAX_PROTOCOL_DRIVERS; ii++) {
		if(MptDeviceDriverHandlers[ii] &&
		  MptDeviceDriverHandlers[ii]->shutdown) {
			MptDeviceDriverHandlers[ii]->shutdown(dev);
		}
	}

}


/**************************************************************************
 * Power Management
 */
#ifdef CONFIG_PM
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	mptbase_suspend - Fusion MPT base driver suspend routine.
 *
 *
 */
static int
mptbase_suspend(struct pci_dev *pdev, u32 state)
{
	u32 device_state;
	MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
	int ii;

	switch(state)
	{
		case 1: /* S1 */
			device_state=1; /* D1 */;
			break;
		case 3: /* S3 */
		case 4: /* S4 */
			device_state=3; /* D3 */;
			break;
		default:
			return -EAGAIN /*FIXME*/;
			break;
	}

	printk(MYIOC_s_INFO_FMT
	"pci-suspend: pdev=0x%p, slot=%s, Entering operating state [D%d]\n",
		ioc->name, pdev, pci_name(pdev), device_state);

	/* call per device driver suspend entry point */
	for(ii=0; ii<MPT_MAX_PROTOCOL_DRIVERS; ii++) {
		if(MptDeviceDriverHandlers[ii] &&
		  MptDeviceDriverHandlers[ii]->suspend) {
			MptDeviceDriverHandlers[ii]->suspend(pdev, state);
		}
	}

	pci_save_state(pdev, ioc->PciState);

	/* put ioc into READY_STATE */
	if(SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, CAN_SLEEP)) {
		printk(MYIOC_s_ERR_FMT
		"pci-suspend:  IOC msg unit reset failed!\n", ioc->name);
	}

	/* disable interrupts */
	CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
	ioc->active = 0;

	/* Clear any lingering interrupt */
	CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);

	pci_disable_device(pdev);
	pci_set_power_state(pdev, device_state);

	return 0;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	mptbase_resume - Fusion MPT base driver resume routine.
 *
 *
 */
static int
mptbase_resume(struct pci_dev *pdev)
{
	MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
	u32 device_state = pdev->current_state;
	int recovery_state;
	int ii;

	printk(MYIOC_s_INFO_FMT
	"pci-resume: pdev=0x%p, slot=%s, Previous operating state [D%d]\n",
		ioc->name, pdev, pci_name(pdev), device_state);

	pci_set_power_state(pdev, 0);
	pci_restore_state(pdev, ioc->PciState);
	pci_enable_device(pdev);

	/* enable interrupts */
	CHIPREG_WRITE32(&ioc->chip->IntMask, ~(MPI_HIM_RIM));
	ioc->active = 1;

	/* F/W not running */
	if(!CHIPREG_READ32(&ioc->chip->Doorbell)) {
		/* enable domain validation flags */
		for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
			ioc->spi_data.dvStatus[ii] |= MPT_SCSICFG_NEED_DV;
		}
	}

	printk(MYIOC_s_INFO_FMT
		"pci-resume: ioc-state=0x%x,doorbell=0x%x\n",
		ioc->name,
		(mpt_GetIocState(ioc, 1) >> MPI_IOC_STATE_SHIFT),
		CHIPREG_READ32(&ioc->chip->Doorbell));

	/* bring ioc to operational state */
	if ((recovery_state = mpt_do_ioc_recovery(ioc,
	    MPT_HOSTEVENT_IOC_RECOVER, CAN_SLEEP)) != 0) {
		printk(MYIOC_s_INFO_FMT
			"pci-resume: Cannot recover, error:[%x]\n",
			ioc->name, recovery_state);
	} else {
		printk(MYIOC_s_INFO_FMT
			"pci-resume: success\n", ioc->name);
	}

	/* call per device driver resume entry point */
	for(ii=0; ii<MPT_MAX_PROTOCOL_DRIVERS; ii++) {
		if(MptDeviceDriverHandlers[ii] &&
		  MptDeviceDriverHandlers[ii]->resume) {
			MptDeviceDriverHandlers[ii]->resume(pdev);
		}
	}

	return 0;
}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
1602
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Pam Delaney's avatar
Pam Delaney committed
1603
/*
Linus Torvalds's avatar
Linus Torvalds committed
1604 1605 1606
 *	mpt_do_ioc_recovery - Initialize or recover MPT adapter.
 *	@ioc: Pointer to MPT adapter structure
 *	@reason: Event word / reason
Pam Delaney's avatar
Pam Delaney committed
1607
 *	@sleepFlag: Use schedule if CAN_SLEEP else use udelay.
Linus Torvalds's avatar
Linus Torvalds committed
1608 1609 1610 1611 1612 1613 1614
 *
 *	This routine performs all the steps necessary to bring the IOC
 *	to a OPERATIONAL state.
 *
 *	This routine also pre-fetches the LAN MAC address of a Fibre Channel
 *	MPT adapter.
 *
Pam Delaney's avatar
Pam Delaney committed
1615 1616 1617 1618 1619 1620
 *	Returns:
 *		 0 for success
 *		-1 if failed to get board READY
 *		-2 if READY but IOCFacts Failed
 *		-3 if READY but PrimeIOCFifos Failed
 *		-4 if READY but IOCInit Failed
Linus Torvalds's avatar
Linus Torvalds committed
1621 1622
 */
static int
Pam Delaney's avatar
Pam Delaney committed
1623
mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag)
Linus Torvalds's avatar
Linus Torvalds committed
1624 1625 1626 1627 1628
{
	int	 hard_reset_done = 0;
	int	 alt_ioc_ready = 0;
	int	 hard;
	int	 r;
Pam Delaney's avatar
Pam Delaney committed
1629
	int	 ii;
Linus Torvalds's avatar
Linus Torvalds committed
1630
	int	 handlers;
1631 1632
	int	 ret = 0;
	int	 reset_alt_ioc_active = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1633 1634 1635 1636

	printk(KERN_INFO MYNAM ": Initiating %s %s\n",
			ioc->name, reason==MPT_HOSTEVENT_IOC_BRINGUP ? "bringup" : "recovery");

1637
	/* Disable reply interrupts (also blocks FreeQ) */
Linus Torvalds's avatar
Linus Torvalds committed
1638 1639 1640
	CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
	ioc->active = 0;

Pam Delaney's avatar
Pam Delaney committed
1641
	if (ioc->alt_ioc) {
1642 1643 1644 1645
		if (ioc->alt_ioc->active)
			reset_alt_ioc_active = 1;

		/* Disable alt-IOC's reply interrupts (and FreeQ) for a bit ... */
Pam Delaney's avatar
Pam Delaney committed
1646 1647 1648
		CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, 0xFFFFFFFF);
		ioc->alt_ioc->active = 0;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1649

Pam Delaney's avatar
Pam Delaney committed
1650 1651
	hard = 1;
	if (reason == MPT_HOSTEVENT_IOC_BRINGUP)
Linus Torvalds's avatar
Linus Torvalds committed
1652 1653
		hard = 0;

Pam Delaney's avatar
Pam Delaney committed
1654
	if ((hard_reset_done = MakeIocReady(ioc, hard, sleepFlag)) < 0) {
1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670
		if (hard_reset_done == -4) {
			printk(KERN_WARNING MYNAM ": %s Owned by PEER..skipping!\n",
					ioc->name);

			if (reset_alt_ioc_active && ioc->alt_ioc) {
				/* (re)Enable alt-IOC! (reply interrupt, FreeQ) */
				dprintk((KERN_INFO MYNAM ": alt-%s reply irq re-enabled\n",
						ioc->alt_ioc->name));
				CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, ~(MPI_HIM_RIM));
				ioc->alt_ioc->active = 1;
			}

		} else {
			printk(KERN_WARNING MYNAM ": %s NOT READY WARNING!\n",
					ioc->name);
		}
Linus Torvalds's avatar
Linus Torvalds committed
1671
		return -1;
Linus Torvalds's avatar
Linus Torvalds committed
1672 1673
	}

Pam Delaney's avatar
Pam Delaney committed
1674 1675 1676
	/* hard_reset_done = 0 if a soft reset was performed
	 * and 1 if a hard reset was performed.
	 */
1677
	if (hard_reset_done && reset_alt_ioc_active && ioc->alt_ioc) {
Pam Delaney's avatar
Pam Delaney committed
1678
		if ((r = MakeIocReady(ioc->alt_ioc, 0, sleepFlag)) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
1679 1680
			alt_ioc_ready = 1;
		else
Pam Delaney's avatar
Pam Delaney committed
1681 1682
			printk(KERN_WARNING MYNAM
					": alt-%s: (%d) Not ready WARNING!\n",
Linus Torvalds's avatar
Linus Torvalds committed
1683 1684 1685
					ioc->alt_ioc->name, r);
	}

1686 1687 1688 1689 1690 1691 1692 1693
	for (ii=0; ii<5; ii++) {
		/* Get IOC facts! Allow 1 retry */
		if ((r = GetIocFacts(ioc, sleepFlag, reason)) != 0) {
			dinitprintk((MYIOC_s_INFO_FMT 
			     "ii=%d IocFacts failed r=%x\n", ioc->name, ii, r));
		} else
			break;
	}
1694 1695

	if (r) {
1696
		dinitprintk((MYIOC_s_INFO_FMT "Retry IocFacts failed r=%x\n", ioc->name, r));
1697 1698
		ret = -2;
	} else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
Linus Torvalds's avatar
Linus Torvalds committed
1699
		MptDisplayIocCapabilities(ioc);
Linus Torvalds's avatar
Linus Torvalds committed
1700 1701
	}

Linus Torvalds's avatar
Linus Torvalds committed
1702
	if (alt_ioc_ready) {
1703
		if ((r = GetIocFacts(ioc->alt_ioc, sleepFlag, reason)) != 0) {
1704
			dinitprintk((MYIOC_s_INFO_FMT "Initial Alt IocFacts failed r=%x\n", ioc->name, r));
1705 1706 1707 1708 1709
			/* Retry - alt IOC was initialized once
			 */
			r = GetIocFacts(ioc->alt_ioc, sleepFlag, reason);
		}
		if (r) {
1710
			dinitprintk((MYIOC_s_INFO_FMT "Retry Alt IocFacts failed r=%x\n", ioc->name, r));
1711 1712 1713
			alt_ioc_ready = 0;
			reset_alt_ioc_active = 0;
		} else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
Pam Delaney's avatar
Pam Delaney committed
1714
			MptDisplayIocCapabilities(ioc->alt_ioc);
Linus Torvalds's avatar
Linus Torvalds committed
1715
		}
Linus Torvalds's avatar
Linus Torvalds committed
1716 1717
	}

1718
	/* Prime reply & request queues!
Pam Delaney's avatar
Pam Delaney committed
1719 1720
	 * (mucho alloc's) Must be done prior to
	 * init as upper addresses are needed for init.
1721
	 * If fails, continue with alt-ioc processing
Linus Torvalds's avatar
Linus Torvalds committed
1722
	 */
1723 1724
	if ((ret == 0) && ((r = PrimeIocFifos(ioc)) != 0))
		ret = -3;
Pam Delaney's avatar
Pam Delaney committed
1725

1726 1727 1728 1729 1730
	/* May need to check/upload firmware & data here!
	 * If fails, continue with alt-ioc processing
	 */
	if ((ret == 0) && ((r = SendIocInit(ioc, sleepFlag)) != 0))
		ret = -4;
Linus Torvalds's avatar
Linus Torvalds committed
1731 1732 1733 1734
// NEW!
	if (alt_ioc_ready && ((r = PrimeIocFifos(ioc->alt_ioc)) != 0)) {
		printk(KERN_WARNING MYNAM ": alt-%s: (%d) FIFO mgmt alloc WARNING!\n",
				ioc->alt_ioc->name, r);
Pam Delaney's avatar
Pam Delaney committed
1735
		alt_ioc_ready = 0;
1736
		reset_alt_ioc_active = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1737
	}
Linus Torvalds's avatar
Linus Torvalds committed
1738

Pam Delaney's avatar
Pam Delaney committed
1739 1740 1741
	if (alt_ioc_ready) {
		if ((r = SendIocInit(ioc->alt_ioc, sleepFlag)) != 0) {
			alt_ioc_ready = 0;
1742
			reset_alt_ioc_active = 0;
Pam Delaney's avatar
Pam Delaney committed
1743 1744 1745 1746 1747
			printk(KERN_WARNING MYNAM
				": alt-%s: (%d) init failure WARNING!\n",
					ioc->alt_ioc->name, r);
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
1748

Pam Delaney's avatar
Pam Delaney committed
1749 1750
	if (reason == MPT_HOSTEVENT_IOC_BRINGUP){
		if (ioc->upload_fw) {
1751
			ddlprintk((MYIOC_s_INFO_FMT
Pam Delaney's avatar
Pam Delaney committed
1752 1753
				"firmware upload required!\n", ioc->name));

1754 1755 1756 1757 1758 1759 1760 1761
			/* Controller is not operational, cannot do upload
			 */
			if (ret == 0) {
				r = mpt_do_upload(ioc, sleepFlag);
				if (r != 0)
					printk(KERN_WARNING MYNAM ": firmware upload failure!\n");
			}

Pam Delaney's avatar
Pam Delaney committed
1762 1763
			/* Handle the alt IOC too */
			if ((alt_ioc_ready) && (ioc->alt_ioc->upload_fw)){
1764 1765 1766
				ddlprintk((MYIOC_s_INFO_FMT
					"Alt-ioc firmware upload required!\n",
					ioc->name));
Pam Delaney's avatar
Pam Delaney committed
1767 1768 1769 1770
				r = mpt_do_upload(ioc->alt_ioc, sleepFlag);
				if (r != 0)
					printk(KERN_WARNING MYNAM ": firmware upload failure!\n");
			}
Linus Torvalds's avatar
Linus Torvalds committed
1771 1772 1773
		}
	}

1774 1775 1776 1777 1778
	if (ret == 0) {
		/* Enable! (reply interrupt) */
		CHIPREG_WRITE32(&ioc->chip->IntMask, ~(MPI_HIM_RIM));
		ioc->active = 1;
	}
Pam Delaney's avatar
Pam Delaney committed
1779

1780
	if (reset_alt_ioc_active && ioc->alt_ioc) {
Linus Torvalds's avatar
Linus Torvalds committed
1781 1782 1783 1784 1785 1786 1787
		/* (re)Enable alt-IOC! (reply interrupt) */
		dprintk((KERN_INFO MYNAM ": alt-%s reply irq re-enabled\n",
				ioc->alt_ioc->name));
		CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, ~(MPI_HIM_RIM));
		ioc->alt_ioc->active = 1;
	}

Linus Torvalds's avatar
Linus Torvalds committed
1788 1789 1790 1791
	/* NEW!  20010120 -sralston
	 *  Enable MPT base driver management of EventNotification
	 *  and EventAck handling.
	 */
1792
	if ((ret == 0) && (!ioc->facts.EventState))
Linus Torvalds's avatar
Linus Torvalds committed
1793
		(void) SendEventNotification(ioc, 1);	/* 1=Enable EventNotification */
Linus Torvalds's avatar
Linus Torvalds committed
1794

Pam Delaney's avatar
Pam Delaney committed
1795 1796
	if (ioc->alt_ioc && alt_ioc_ready && !ioc->alt_ioc->facts.EventState)
		(void) SendEventNotification(ioc->alt_ioc, 1);	/* 1=Enable EventNotification */
Linus Torvalds's avatar
Linus Torvalds committed
1797

Pam Delaney's avatar
Pam Delaney committed
1798 1799 1800 1801 1802 1803 1804 1805
	/* (Bugzilla:fibrebugs, #513)
	 * Bug fix (part 2)!  20010905 -sralston
	 *	Add additional "reason" check before call to GetLanConfigPages
	 *	(combined with GetIoUnitPage2 call).  This prevents a somewhat
	 *	recursive scenario; GetLanConfigPages times out, timer expired
	 *	routine calls HardResetHandler, which calls into here again,
	 *	and we try GetLanConfigPages again...
	 */
1806
	if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP)) {
Pam Delaney's avatar
Pam Delaney committed
1807 1808 1809 1810 1811 1812 1813 1814
		if ((int)ioc->chip_type <= (int)FC929) {
			/*
			 *  Pre-fetch FC port WWN and stuff...
			 *  (FCPortPage0_t stuff)
			 */
			for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
				(void) GetFcPortPage0(ioc, ii);
			}
Linus Torvalds's avatar
Linus Torvalds committed
1815

Pam Delaney's avatar
Pam Delaney committed
1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834
			if ((ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) &&
			    (ioc->lan_cnfg_page0.Header.PageLength == 0)) {
				/*
				 *  Pre-fetch the ports LAN MAC address!
				 *  (LANPage1_t stuff)
				 */
				(void) GetLanConfigPages(ioc);
#ifdef MPT_DEBUG
				{
					u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
					dprintk((MYIOC_s_INFO_FMT "LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
							ioc->name, a[5], a[4], a[3], a[2], a[1], a[0] ));
				}
#endif
			}
		} else {
			/* Get NVRAM and adapter maximums from SPP 0 and 2
			 */
			mpt_GetScsiPortSettings(ioc, 0);
Linus Torvalds's avatar
Linus Torvalds committed
1835

1836
			/* Get version and length of SDP 1
Pam Delaney's avatar
Pam Delaney committed
1837 1838
			 */
			mpt_readScsiDevicePageHeaders(ioc, 0);
Linus Torvalds's avatar
Linus Torvalds committed
1839

1840
			/* Find IM volumes
Pam Delaney's avatar
Pam Delaney committed
1841 1842 1843
			 */
			if (ioc->facts.MsgVersion >= 0x0102)
				mpt_findImVolumes(ioc);
1844 1845 1846 1847

			/* Check, and possibly reset, the coalescing value
			 */
			mpt_read_ioc_pg_1(ioc);
1848 1849

			mpt_read_ioc_pg_4(ioc);
Pam Delaney's avatar
Pam Delaney committed
1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863
		}

		GetIoUnitPage2(ioc);
	}

	/*
	 * Call each currently registered protocol IOC reset handler
	 * with post-reset indication.
	 * NOTE: If we're doing _IOC_BRINGUP, there can be no
	 * MptResetHandlers[] registered yet.
	 */
	if (hard_reset_done) {
		r = handlers = 0;
		for (ii=MPT_MAX_PROTOCOL_DRIVERS-1; ii; ii--) {
1864
			if ((ret == 0) && MptResetHandlers[ii]) {
Pam Delaney's avatar
Pam Delaney committed
1865 1866 1867 1868
				dprintk((MYIOC_s_INFO_FMT "Calling IOC post_reset handler #%d\n",
						ioc->name, ii));
				r += (*(MptResetHandlers[ii]))(ioc, MPT_IOC_POST_RESET);
				handlers++;
1869
			}
Pam Delaney's avatar
Pam Delaney committed
1870

1871 1872 1873 1874 1875
			if (alt_ioc_ready && MptResetHandlers[ii]) {
				dprintk((MYIOC_s_INFO_FMT "Calling alt-%s post_reset handler #%d\n",
						ioc->name, ioc->alt_ioc->name, ii));
				r += (*(MptResetHandlers[ii]))(ioc->alt_ioc, MPT_IOC_POST_RESET);
				handlers++;
Pam Delaney's avatar
Pam Delaney committed
1876 1877 1878 1879 1880
			}
		}
		/* FIXME?  Examine results here? */
	}

1881
	return ret;
Pam Delaney's avatar
Pam Delaney committed
1882 1883 1884 1885 1886 1887
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	mpt_detect_bound_ports - Search for PCI bus/dev_function
 *	which matches PCI bus/dev_function (+/-1) for newly discovered 929,
1888
 *	929X, 1030 or 1035.
Pam Delaney's avatar
Pam Delaney committed
1889 1890 1891 1892 1893 1894 1895 1896 1897 1898
 *	@ioc: Pointer to MPT adapter structure
 *	@pdev: Pointer to (struct pci_dev) structure
 *
 *	If match on PCI dev_function +/-1 is found, bind the two MPT adapters
 *	using alt_ioc pointer fields in their %MPT_ADAPTER structures.
 */
static void
mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev)
{
	unsigned int match_lo, match_hi;
1899
	MPT_ADAPTER *ioc_srch;
Pam Delaney's avatar
Pam Delaney committed
1900 1901 1902 1903 1904 1905

	match_lo = pdev->devfn-1;
	match_hi = pdev->devfn+1;
	dprintk((MYIOC_s_INFO_FMT "PCI bus/devfn=%x/%x, searching for devfn match on %x or %x\n",
			ioc->name, pdev->bus->number, pdev->devfn, match_lo, match_hi));

1906
	list_for_each_entry(ioc_srch, &ioc_list, list) {
Pam Delaney's avatar
Pam Delaney committed
1907 1908 1909 1910 1911 1912 1913 1914 1915
		struct pci_dev *_pcidev = ioc_srch->pcidev;

		if ((_pcidev->device == pdev->device) &&
		    (_pcidev->bus->number == pdev->bus->number) &&
		    (_pcidev->devfn == match_lo || _pcidev->devfn == match_hi) ) {
			/* Paranoia checks */
			if (ioc->alt_ioc != NULL) {
				printk(KERN_WARNING MYNAM ": Oops, already bound (%s <==> %s)!\n",
						ioc->name, ioc->alt_ioc->name);
Linus Torvalds's avatar
Linus Torvalds committed
1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934
				break;
			} else if (ioc_srch->alt_ioc != NULL) {
				printk(KERN_WARNING MYNAM ": Oops, already bound (%s <==> %s)!\n",
						ioc_srch->name, ioc_srch->alt_ioc->name);
				break;
			}
			dprintk((KERN_INFO MYNAM ": FOUND! binding %s <==> %s\n",
					ioc->name, ioc_srch->name));
			ioc_srch->alt_ioc = ioc;
			ioc->alt_ioc = ioc_srch;
			break;
		}
	}
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	mpt_adapter_disable - Disable misbehaving MPT adapter.
 *	@this: Pointer to MPT adapter structure
Linus Torvalds's avatar
Linus Torvalds committed
1935
 *	@free: Free up alloc'd reply, request, etc.
Linus Torvalds's avatar
Linus Torvalds committed
1936 1937
 */
static void
Linus Torvalds's avatar
Linus Torvalds committed
1938
mpt_adapter_disable(MPT_ADAPTER *this, int freeup)
Linus Torvalds's avatar
Linus Torvalds committed
1939 1940
{
	if (this != NULL) {
1941
		int sz=0;
1942
		int ret;
Linus Torvalds's avatar
Linus Torvalds committed
1943

1944 1945 1946
		if (this->cached_fw != NULL) {
			ddlprintk((KERN_INFO MYNAM ": Pushing FW onto adapter\n"));

1947
			if ((ret = mpt_downloadboot(this, NO_SLEEP)) < 0) {
1948
				printk(KERN_WARNING MYNAM
1949
					": firmware downloadboot failure (%d)!\n", ret);
1950 1951 1952
			}
		}

Linus Torvalds's avatar
Linus Torvalds committed
1953 1954
		/* Disable adapter interrupts! */
		CHIPREG_WRITE32(&this->chip->IntMask, 0xFFFFFFFF);
Linus Torvalds's avatar
Linus Torvalds committed
1955
		this->active = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1956 1957 1958
		/* Clear any lingering interrupt */
		CHIPREG_WRITE32(&this->chip->IntStatus, 0);

1959 1960 1961 1962
		if (freeup && this->fifo_pool != NULL) {
			pci_free_consistent(this->pcidev,
				this->fifo_pool_sz,
				this->fifo_pool, this->fifo_pool_dma);
Linus Torvalds's avatar
Linus Torvalds committed
1963 1964 1965 1966
			this->reply_frames = NULL;
			this->reply_alloc = NULL;
			this->req_frames = NULL;
			this->req_alloc = NULL;
1967 1968 1969
			this->chain_alloc = NULL;
			this->fifo_pool = NULL;
			this->alloc_total -= this->fifo_pool_sz;
Linus Torvalds's avatar
Linus Torvalds committed
1970
		}
Linus Torvalds's avatar
Linus Torvalds committed
1971
		if (freeup && this->sense_buf_pool != NULL) {
Pam Delaney's avatar
Pam Delaney committed
1972
			sz = (this->req_depth * MPT_SENSE_BUFFER_ALLOC);
Linus Torvalds's avatar
Linus Torvalds committed
1973 1974 1975 1976 1977
			pci_free_consistent(this->pcidev, sz,
					this->sense_buf_pool, this->sense_buf_pool_dma);
			this->sense_buf_pool = NULL;
			this->alloc_total -= sz;
		}
Pam Delaney's avatar
Pam Delaney committed
1978 1979 1980 1981 1982 1983 1984 1985 1986 1987

		if (freeup && this->events != NULL){
			sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
			kfree(this->events);
			this->events = NULL;
			this->alloc_total -= sz;
		}

		if (freeup && this->cached_fw != NULL) {

1988 1989 1990
			sz = this->facts.FWImageSize;
			pci_free_consistent(this->pcidev, sz,
				this->cached_fw, this->cached_fw_dma);
Pam Delaney's avatar
Pam Delaney committed
1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003
			this->cached_fw = NULL;
			this->alloc_total -= sz;
		}

		if (freeup && this->spi_data.nvram != NULL) {
			kfree(this->spi_data.nvram);
			this->spi_data.nvram = NULL;
		}

		if (freeup && this->spi_data.pIocPg3 != NULL) {
			kfree(this->spi_data.pIocPg3);
			this->spi_data.pIocPg3 = NULL;
		}
2004 2005 2006 2007 2008 2009 2010 2011 2012

		if (freeup && this->spi_data.pIocPg4 != NULL) {
			sz = this->spi_data.IocPg4Sz;
			pci_free_consistent(this->pcidev, sz,
				this->spi_data.pIocPg4,
				this->spi_data.IocPg4_dma);
			this->spi_data.pIocPg4 = NULL;
			this->alloc_total -= sz;
		}
Linus Torvalds's avatar
Linus Torvalds committed
2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032
	}
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	mpt_adapter_dispose - Free all resources associated with a MPT
 *	adapter.
 *	@this: Pointer to MPT adapter structure
 *
 *	This routine unregisters h/w resources and frees all alloc'd memory
 *	associated with a MPT adapter structure.
 */
static void
mpt_adapter_dispose(MPT_ADAPTER *this)
{
	if (this != NULL) {
		int sz_first, sz_last;

		sz_first = this->alloc_total;

Linus Torvalds's avatar
Linus Torvalds committed
2033
		mpt_adapter_disable(this, 1);
Linus Torvalds's avatar
Linus Torvalds committed
2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050

		if (this->pci_irq != -1) {
			free_irq(this->pci_irq, this);
			this->pci_irq = -1;
		}

		if (this->memmap != NULL)
			iounmap((u8 *) this->memmap);

#if defined(CONFIG_MTRR) && 0
		if (this->mtrr_reg > 0) {
			mtrr_del(this->mtrr_reg, 0, 0);
			dprintk((KERN_INFO MYNAM ": %s: MTRR region de-registered\n", this->name));
		}
#endif

		/*  Zap the adapter lookup ptr!  */
2051
		list_del(&this->list);
Linus Torvalds's avatar
Linus Torvalds committed
2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074

		sz_last = this->alloc_total;
		dprintk((KERN_INFO MYNAM ": %s: free'd %d of %d bytes\n",
				this->name, sz_first-sz_last+(int)sizeof(*this), sz_first));
		kfree(this);
	}
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	MptDisplayIocCapabilities - Disply IOC's capacilities.
 *	@ioc: Pointer to MPT adapter structure
 */
static void
MptDisplayIocCapabilities(MPT_ADAPTER *ioc)
{
	int i = 0;

	printk(KERN_INFO "%s: ", ioc->name);
	if (ioc->prod_name && strlen(ioc->prod_name) > 3)
		printk("%s: ", ioc->prod_name+3);
	printk("Capabilities={");

Linus Torvalds's avatar
Linus Torvalds committed
2075
	if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_INITIATOR) {
Linus Torvalds's avatar
Linus Torvalds committed
2076 2077 2078 2079
		printk("Initiator");
		i++;
	}

Linus Torvalds's avatar
Linus Torvalds committed
2080
	if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
Linus Torvalds's avatar
Linus Torvalds committed
2081 2082 2083 2084
		printk("%sTarget", i ? "," : "");
		i++;
	}

Linus Torvalds's avatar
Linus Torvalds committed
2085
	if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) {
Linus Torvalds's avatar
Linus Torvalds committed
2086 2087 2088 2089 2090 2091 2092 2093
		printk("%sLAN", i ? "," : "");
		i++;
	}

#if 0
	/*
	 *  This would probably evoke more questions than it's worth
	 */
Linus Torvalds's avatar
Linus Torvalds committed
2094
	if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
Linus Torvalds's avatar
Linus Torvalds committed
2095 2096 2097 2098 2099 2100 2101 2102
		printk("%sLogBusAddr", i ? "," : "");
		i++;
	}
#endif

	printk("}\n");
}

Linus Torvalds's avatar
Linus Torvalds committed
2103 2104 2105 2106
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	MakeIocReady - Get IOC to a READY state, using KickStart if needed.
 *	@ioc: Pointer to MPT_ADAPTER structure
Pam Delaney's avatar
Pam Delaney committed
2107 2108
 *	@force: Force hard KickStart of IOC
 *	@sleepFlag: Specifies whether the process can sleep
Linus Torvalds's avatar
Linus Torvalds committed
2109
 *
Pam Delaney's avatar
Pam Delaney committed
2110 2111
 *	Returns:
 *		 1 - DIAG reset and READY
2112 2113
 *		 0 - READY initially OR soft reset and READY
 *		-1 - Any failure on KickStart
Pam Delaney's avatar
Pam Delaney committed
2114 2115 2116
 *		-2 - Msg Unit Reset Failed
 *		-3 - IO Unit Reset Failed
 *		-4 - IOC owned by a PEER
Linus Torvalds's avatar
Linus Torvalds committed
2117 2118
 */
static int
Pam Delaney's avatar
Pam Delaney committed
2119
MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag)
Linus Torvalds's avatar
Linus Torvalds committed
2120 2121 2122
{
	u32	 ioc_state;
	int	 statefault = 0;
Pam Delaney's avatar
Pam Delaney committed
2123
	int	 cntdn;
Linus Torvalds's avatar
Linus Torvalds committed
2124 2125
	int	 hard_reset_done = 0;
	int	 r;
Pam Delaney's avatar
Pam Delaney committed
2126 2127
	int	 ii;
	int	 whoinit;
Linus Torvalds's avatar
Linus Torvalds committed
2128 2129

	/* Get current [raw] IOC state  */
Pam Delaney's avatar
Pam Delaney committed
2130
	ioc_state = mpt_GetIocState(ioc, 0);
Linus Torvalds's avatar
Linus Torvalds committed
2131 2132 2133 2134 2135 2136 2137 2138
	dhsprintk((KERN_INFO MYNAM "::MakeIocReady, %s [raw] state=%08x\n", ioc->name, ioc_state));

	/*
	 *	Check to see if IOC got left/stuck in doorbell handshake
	 *	grip of death.  If so, hard reset the IOC.
	 */
	if (ioc_state & MPI_DOORBELL_ACTIVE) {
		statefault = 1;
Pam Delaney's avatar
Pam Delaney committed
2139
		printk(MYIOC_s_WARN_FMT "Unexpected doorbell active!\n",
Linus Torvalds's avatar
Linus Torvalds committed
2140 2141 2142 2143
				ioc->name);
	}

	/* Is it already READY? */
2144 2145 2146 2147
	if (!statefault && (ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_READY) {
		if ((int)ioc->chip_type <= (int)FC929)
			return 0;
		else {
2148
			return 0;
2149 2150 2151
			/* Workaround from broken 1030 FW.
			 * Force a diagnostic reset if fails.
			 */
2152
/*			if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) == 0)
2153 2154
				return 0;
			else
2155
				statefault = 4; */
2156
		}
2157
	}
Linus Torvalds's avatar
Linus Torvalds committed
2158 2159 2160 2161 2162 2163

	/*
	 *	Check to see if IOC is in FAULT state.
	 */
	if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
		statefault = 2;
Pam Delaney's avatar
Pam Delaney committed
2164
		printk(MYIOC_s_WARN_FMT "IOC is in FAULT state!!!\n",
Linus Torvalds's avatar
Linus Torvalds committed
2165 2166 2167 2168 2169 2170 2171 2172 2173
				ioc->name);
		printk(KERN_WARNING "           FAULT code = %04xh\n",
				ioc_state & MPI_DOORBELL_DATA_MASK);
	}

	/*
	 *	Hmmm...  Did it get left operational?
	 */
	if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_OPERATIONAL) {
2174
		dinitprintk((MYIOC_s_WARN_FMT "IOC operational unexpected\n",
Linus Torvalds's avatar
Linus Torvalds committed
2175
				ioc->name));
Pam Delaney's avatar
Pam Delaney committed
2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194

		/* Check WhoInit.
		 * If PCI Peer, exit.
		 * Else, if no fault conditions are present, issue a MessageUnitReset
		 * Else, fall through to KickStart case
		 */
		whoinit = (ioc_state & MPI_DOORBELL_WHO_INIT_MASK) >> MPI_DOORBELL_WHO_INIT_SHIFT;
		dprintk((KERN_WARNING MYNAM
			": whoinit 0x%x\n statefault %d force %d\n",
			whoinit, statefault, force));
		if (whoinit == MPI_WHOINIT_PCI_PEER)
			return -4;
		else {
			if ((statefault == 0 ) && (force == 0)) {
				if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) == 0)
					return 0;
			}
			statefault = 3;
		}
Linus Torvalds's avatar
Linus Torvalds committed
2195 2196
	}

Pam Delaney's avatar
Pam Delaney committed
2197
	hard_reset_done = KickStart(ioc, statefault||force, sleepFlag);
Linus Torvalds's avatar
Linus Torvalds committed
2198 2199 2200 2201 2202 2203
	if (hard_reset_done < 0)
		return -1;

	/*
	 *  Loop here waiting for IOC to come READY.
	 */
Pam Delaney's avatar
Pam Delaney committed
2204
	ii = 0;
2205
	cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 15;	/* 15 seconds */
Pam Delaney's avatar
Pam Delaney committed
2206 2207

	while ((ioc_state = mpt_GetIocState(ioc, 1)) != MPI_IOC_STATE_READY) {
Linus Torvalds's avatar
Linus Torvalds committed
2208 2209 2210 2211 2212
		if (ioc_state == MPI_IOC_STATE_OPERATIONAL) {
			/*
			 *  BIOS or previous driver load left IOC in OP state.
			 *  Reset messaging FIFOs.
			 */
Pam Delaney's avatar
Pam Delaney committed
2213 2214
			if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) != 0) {
				printk(MYIOC_s_ERR_FMT "IOC msg unit reset failed!\n", ioc->name);
Linus Torvalds's avatar
Linus Torvalds committed
2215 2216 2217 2218 2219 2220 2221
				return -2;
			}
		} else if (ioc_state == MPI_IOC_STATE_RESET) {
			/*
			 *  Something is wrong.  Try to get IOC back
			 *  to a known state.
			 */
Pam Delaney's avatar
Pam Delaney committed
2222 2223
			if ((r = SendIocReset(ioc, MPI_FUNCTION_IO_UNIT_RESET, sleepFlag)) != 0) {
				printk(MYIOC_s_ERR_FMT "IO unit reset failed!\n", ioc->name);
Linus Torvalds's avatar
Linus Torvalds committed
2224 2225 2226 2227
				return -3;
			}
		}

Pam Delaney's avatar
Pam Delaney committed
2228
		ii++; cntdn--;
Linus Torvalds's avatar
Linus Torvalds committed
2229
		if (!cntdn) {
Pam Delaney's avatar
Pam Delaney committed
2230 2231
			printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
					ioc->name, (ii+5)/HZ);
Linus Torvalds's avatar
Linus Torvalds committed
2232 2233 2234
			return -ETIME;
		}

Pam Delaney's avatar
Pam Delaney committed
2235 2236 2237 2238 2239 2240 2241
		if (sleepFlag == CAN_SLEEP) {
			set_current_state(TASK_INTERRUPTIBLE);
			schedule_timeout(1);
		} else {
			mdelay (1);	/* 1 msec delay */
		}

Linus Torvalds's avatar
Linus Torvalds committed
2242 2243 2244
	}

	if (statefault < 3) {
Pam Delaney's avatar
Pam Delaney committed
2245
		printk(MYIOC_s_INFO_FMT "Recovered from %s\n",
Linus Torvalds's avatar
Linus Torvalds committed
2246 2247 2248 2249 2250 2251 2252
				ioc->name,
				statefault==1 ? "stuck handshake" : "IOC FAULT");
	}

	return hard_reset_done;
}

Linus Torvalds's avatar
Linus Torvalds committed
2253 2254
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
Pam Delaney's avatar
Pam Delaney committed
2255
 *	mpt_GetIocState - Get the current state of a MPT adapter.
Linus Torvalds's avatar
Linus Torvalds committed
2256 2257 2258 2259 2260 2261
 *	@ioc: Pointer to MPT_ADAPTER structure
 *	@cooked: Request raw or cooked IOC state
 *
 *	Returns all IOC Doorbell register bits if cooked==0, else just the
 *	Doorbell bits in MPI_IOC_STATE_MASK.
 */
Pam Delaney's avatar
Pam Delaney committed
2262 2263
u32
mpt_GetIocState(MPT_ADAPTER *ioc, int cooked)
Linus Torvalds's avatar
Linus Torvalds committed
2264 2265 2266 2267 2268
{
	u32 s, sc;

	/*  Get!  */
	s = CHIPREG_READ32(&ioc->chip->Doorbell);
Pam Delaney's avatar
Pam Delaney committed
2269
//	dprintk((MYIOC_s_INFO_FMT "raw state = %08x\n", ioc->name, s));
Linus Torvalds's avatar
Linus Torvalds committed
2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281
	sc = s & MPI_IOC_STATE_MASK;

	/*  Save!  */
	ioc->last_state = sc;

	return cooked ? sc : s;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	GetIocFacts - Send IOCFacts request to MPT adapter.
 *	@ioc: Pointer to MPT_ADAPTER structure
Pam Delaney's avatar
Pam Delaney committed
2282 2283
 *	@sleepFlag: Specifies whether the process can sleep
 *	@reason: If recovery, only update facts.
Linus Torvalds's avatar
Linus Torvalds committed
2284 2285 2286 2287
 *
 *	Returns 0 for success, non-zero for failure.
 */
static int
Pam Delaney's avatar
Pam Delaney committed
2288
GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason)
Linus Torvalds's avatar
Linus Torvalds committed
2289 2290 2291 2292 2293 2294 2295 2296
{
	IOCFacts_t		 get_facts;
	IOCFactsReply_t		*facts;
	int			 r;
	int			 req_sz;
	int			 reply_sz;
	u32			 status;

Linus Torvalds's avatar
Linus Torvalds committed
2297
	/* IOC *must* NOT be in RESET state! */
Linus Torvalds's avatar
Linus Torvalds committed
2298 2299 2300 2301 2302 2303 2304
	if (ioc->last_state == MPI_IOC_STATE_RESET) {
		printk(KERN_ERR MYNAM ": ERROR - Can't get IOCFacts, %s NOT READY! (%08x)\n",
				ioc->name,
				ioc->last_state );
		return -44;
	}

Linus Torvalds's avatar
Linus Torvalds committed
2305
	facts = &ioc->facts;
Linus Torvalds's avatar
Linus Torvalds committed
2306

Linus Torvalds's avatar
Linus Torvalds committed
2307
	/* Destination (reply area)... */
Linus Torvalds's avatar
Linus Torvalds committed
2308 2309 2310
	reply_sz = sizeof(*facts);
	memset(facts, 0, reply_sz);

Linus Torvalds's avatar
Linus Torvalds committed
2311
	/* Request area (get_facts on the stack right now!) */
Linus Torvalds's avatar
Linus Torvalds committed
2312 2313 2314 2315
	req_sz = sizeof(get_facts);
	memset(&get_facts, 0, req_sz);

	get_facts.Function = MPI_FUNCTION_IOC_FACTS;
Linus Torvalds's avatar
Linus Torvalds committed
2316
	/* Assert: All other get_facts fields are zero! */
Linus Torvalds's avatar
Linus Torvalds committed
2317

2318
	dinitprintk((MYIOC_s_INFO_FMT "Sending get IocFacts request\n", ioc->name));
Linus Torvalds's avatar
Linus Torvalds committed
2319 2320 2321 2322

	/* No non-zero fields in the get_facts request are greater than
	 * 1 byte in size, so we can just fire it off as is.
	 */
Pam Delaney's avatar
Pam Delaney committed
2323
	r = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_facts,
2324
			reply_sz, (u16*)facts, 5 /*seconds*/, sleepFlag);
Linus Torvalds's avatar
Linus Torvalds committed
2325 2326 2327 2328
	if (r != 0)
		return r;

	/*
Linus Torvalds's avatar
Linus Torvalds committed
2329 2330
	 * Now byte swap (GRRR) the necessary fields before any further
	 * inspection of reply contents.
Linus Torvalds's avatar
Linus Torvalds committed
2331
	 *
Linus Torvalds's avatar
Linus Torvalds committed
2332 2333
	 * But need to do some sanity checks on MsgLength (byte) field
	 * to make sure we don't zero IOC's req_sz!
Linus Torvalds's avatar
Linus Torvalds committed
2334 2335 2336
	 */
	/* Did we get a valid reply? */
	if (facts->MsgLength > offsetof(IOCFactsReply_t, RequestFrameSize)/sizeof(u32)) {
Pam Delaney's avatar
Pam Delaney committed
2337 2338 2339 2340 2341 2342 2343
		if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
			/*
			 * If not been here, done that, save off first WhoInit value
			 */
			if (ioc->FirstWhoInit == WHOINIT_UNKNOWN)
				ioc->FirstWhoInit = facts->WhoInit;
		}
Linus Torvalds's avatar
Linus Torvalds committed
2344

Linus Torvalds's avatar
Linus Torvalds committed
2345 2346
		facts->MsgVersion = le16_to_cpu(facts->MsgVersion);
		facts->MsgContext = le32_to_cpu(facts->MsgContext);
Pam Delaney's avatar
Pam Delaney committed
2347
		facts->IOCExceptions = le16_to_cpu(facts->IOCExceptions);
Linus Torvalds's avatar
Linus Torvalds committed
2348 2349 2350 2351 2352 2353 2354
		facts->IOCStatus = le16_to_cpu(facts->IOCStatus);
		facts->IOCLogInfo = le32_to_cpu(facts->IOCLogInfo);
		status = facts->IOCStatus & MPI_IOCSTATUS_MASK;
		/* CHECKME! IOCStatus, IOCLogInfo */

		facts->ReplyQueueDepth = le16_to_cpu(facts->ReplyQueueDepth);
		facts->RequestFrameSize = le16_to_cpu(facts->RequestFrameSize);
Pam Delaney's avatar
Pam Delaney committed
2355 2356

		/*
2357
		 * FC f/w version changed between 1.1 and 1.2
Pam Delaney's avatar
Pam Delaney committed
2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371
		 *	Old: u16{Major(4),Minor(4),SubMinor(8)}
		 *	New: u32{Major(8),Minor(8),Unit(8),Dev(8)}
		 */
		if (facts->MsgVersion < 0x0102) {
			/*
			 *	Handle old FC f/w style, convert to new...
			 */
			u16	 oldv = le16_to_cpu(facts->Reserved_0101_FWVersion);
			facts->FWVersion.Word =
					((oldv<<12) & 0xFF000000) |
					((oldv<<8)  & 0x000FFF00);
		} else
			facts->FWVersion.Word = le32_to_cpu(facts->FWVersion.Word);

Linus Torvalds's avatar
Linus Torvalds committed
2372 2373 2374 2375 2376 2377 2378 2379 2380 2381
		facts->ProductID = le16_to_cpu(facts->ProductID);
		facts->CurrentHostMfaHighAddr =
				le32_to_cpu(facts->CurrentHostMfaHighAddr);
		facts->GlobalCredits = le16_to_cpu(facts->GlobalCredits);
		facts->CurrentSenseBufferHighAddr =
				le32_to_cpu(facts->CurrentSenseBufferHighAddr);
		facts->CurReplyFrameSize =
				le16_to_cpu(facts->CurReplyFrameSize);

		/*
Linus Torvalds's avatar
Linus Torvalds committed
2382 2383 2384
		 * Handle NEW (!) IOCFactsReply fields in MPI-1.01.xx
		 * Older MPI-1.00.xx struct had 13 dwords, and enlarged
		 * to 14 in MPI-1.01.0x.
Linus Torvalds's avatar
Linus Torvalds committed
2385
		 */
Pam Delaney's avatar
Pam Delaney committed
2386 2387
		if (facts->MsgLength >= (offsetof(IOCFactsReply_t,FWImageSize) + 7)/4 &&
		    facts->MsgVersion > 0x0100) {
Linus Torvalds's avatar
Linus Torvalds committed
2388 2389 2390
			facts->FWImageSize = le32_to_cpu(facts->FWImageSize);
		}

Pam Delaney's avatar
Pam Delaney committed
2391
		if (!facts->RequestFrameSize) {
Linus Torvalds's avatar
Linus Torvalds committed
2392
			/*  Something is wrong!  */
Pam Delaney's avatar
Pam Delaney committed
2393
			printk(MYIOC_s_ERR_FMT "IOC reported invalid 0 request size!\n",
Linus Torvalds's avatar
Linus Torvalds committed
2394 2395 2396 2397
					ioc->name);
			return -55;
		}

Pam Delaney's avatar
Pam Delaney committed
2398 2399 2400 2401 2402
		if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
			/*
			 * Set values for this IOC's request & reply frame sizes,
			 * and request & reply queue depths...
			 */
2403 2404
			ioc->req_sz = min(MPT_DEFAULT_FRAME_SIZE, facts->RequestFrameSize * 4);
			ioc->req_depth = min_t(int, MPT_MAX_REQ_DEPTH, facts->GlobalCredits);
2405
			ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
2406
			ioc->reply_depth = min_t(int, MPT_DEFAULT_REPLY_DEPTH, facts->ReplyQueueDepth);
Pam Delaney's avatar
Pam Delaney committed
2407 2408

			dprintk((MYIOC_s_INFO_FMT "reply_sz=%3d, reply_depth=%4d\n",
Linus Torvalds's avatar
Linus Torvalds committed
2409
				ioc->name, ioc->reply_sz, ioc->reply_depth));
Pam Delaney's avatar
Pam Delaney committed
2410
			dprintk((MYIOC_s_INFO_FMT "req_sz  =%3d, req_depth  =%4d\n",
Linus Torvalds's avatar
Linus Torvalds committed
2411 2412
				ioc->name, ioc->req_sz, ioc->req_depth));

Pam Delaney's avatar
Pam Delaney committed
2413 2414 2415 2416
			/* Get port facts! */
			if ( (r = GetPortFacts(ioc, 0, sleepFlag)) != 0 )
				return r;
		}
Linus Torvalds's avatar
Linus Torvalds committed
2417
	} else {
2418
		printk(MYIOC_s_ERR_FMT 
2419
		     "Invalid IOC facts reply, msgLength=%d offsetof=%zd!\n",
2420 2421
		     ioc->name, facts->MsgLength, (offsetof(IOCFactsReply_t,
		     RequestFrameSize)/sizeof(u32)));
Linus Torvalds's avatar
Linus Torvalds committed
2422 2423 2424 2425 2426 2427 2428 2429 2430 2431
		return -66;
	}

	return 0;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	GetPortFacts - Send PortFacts request to MPT adapter.
 *	@ioc: Pointer to MPT_ADAPTER structure
Linus Torvalds's avatar
Linus Torvalds committed
2432
 *	@portnum: Port number
Pam Delaney's avatar
Pam Delaney committed
2433
 *	@sleepFlag: Specifies whether the process can sleep
Linus Torvalds's avatar
Linus Torvalds committed
2434 2435 2436 2437
 *
 *	Returns 0 for success, non-zero for failure.
 */
static int
Pam Delaney's avatar
Pam Delaney committed
2438
GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
Linus Torvalds's avatar
Linus Torvalds committed
2439 2440 2441
{
	PortFacts_t		 get_pfacts;
	PortFactsReply_t	*pfacts;
Pam Delaney's avatar
Pam Delaney committed
2442
	int			 ii;
Linus Torvalds's avatar
Linus Torvalds committed
2443 2444 2445
	int			 req_sz;
	int			 reply_sz;

Linus Torvalds's avatar
Linus Torvalds committed
2446
	/* IOC *must* NOT be in RESET state! */
Linus Torvalds's avatar
Linus Torvalds committed
2447 2448 2449 2450 2451 2452 2453
	if (ioc->last_state == MPI_IOC_STATE_RESET) {
		printk(KERN_ERR MYNAM ": ERROR - Can't get PortFacts, %s NOT READY! (%08x)\n",
				ioc->name,
				ioc->last_state );
		return -4;
	}

Linus Torvalds's avatar
Linus Torvalds committed
2454
	pfacts = &ioc->pfacts[portnum];
Linus Torvalds's avatar
Linus Torvalds committed
2455

Linus Torvalds's avatar
Linus Torvalds committed
2456
	/* Destination (reply area)...  */
Linus Torvalds's avatar
Linus Torvalds committed
2457 2458 2459
	reply_sz = sizeof(*pfacts);
	memset(pfacts, 0, reply_sz);

Linus Torvalds's avatar
Linus Torvalds committed
2460
	/* Request area (get_pfacts on the stack right now!) */
Linus Torvalds's avatar
Linus Torvalds committed
2461 2462 2463 2464
	req_sz = sizeof(get_pfacts);
	memset(&get_pfacts, 0, req_sz);

	get_pfacts.Function = MPI_FUNCTION_PORT_FACTS;
Linus Torvalds's avatar
Linus Torvalds committed
2465 2466
	get_pfacts.PortNumber = portnum;
	/* Assert: All other get_pfacts fields are zero! */
Linus Torvalds's avatar
Linus Torvalds committed
2467

Pam Delaney's avatar
Pam Delaney committed
2468
	dprintk((MYIOC_s_INFO_FMT "Sending get PortFacts(%d) request\n",
Linus Torvalds's avatar
Linus Torvalds committed
2469
			ioc->name, portnum));
Linus Torvalds's avatar
Linus Torvalds committed
2470 2471 2472 2473

	/* No non-zero fields in the get_pfacts request are greater than
	 * 1 byte in size, so we can just fire it off as is.
	 */
Pam Delaney's avatar
Pam Delaney committed
2474
	ii = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_pfacts,
2475
				reply_sz, (u16*)pfacts, 5 /*seconds*/, sleepFlag);
Pam Delaney's avatar
Pam Delaney committed
2476 2477
	if (ii != 0)
		return ii;
Linus Torvalds's avatar
Linus Torvalds committed
2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498

	/* Did we get a valid reply? */

	/* Now byte swap the necessary fields in the response. */
	pfacts->MsgContext = le32_to_cpu(pfacts->MsgContext);
	pfacts->IOCStatus = le16_to_cpu(pfacts->IOCStatus);
	pfacts->IOCLogInfo = le32_to_cpu(pfacts->IOCLogInfo);
	pfacts->MaxDevices = le16_to_cpu(pfacts->MaxDevices);
	pfacts->PortSCSIID = le16_to_cpu(pfacts->PortSCSIID);
	pfacts->ProtocolFlags = le16_to_cpu(pfacts->ProtocolFlags);
	pfacts->MaxPostedCmdBuffers = le16_to_cpu(pfacts->MaxPostedCmdBuffers);
	pfacts->MaxPersistentIDs = le16_to_cpu(pfacts->MaxPersistentIDs);
	pfacts->MaxLanBuckets = le16_to_cpu(pfacts->MaxLanBuckets);

	return 0;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	SendIocInit - Send IOCInit request to MPT adapter.
 *	@ioc: Pointer to MPT_ADAPTER structure
Pam Delaney's avatar
Pam Delaney committed
2499
 *	@sleepFlag: Specifies whether the process can sleep
Linus Torvalds's avatar
Linus Torvalds committed
2500 2501 2502 2503 2504 2505
 *
 *	Send IOCInit followed by PortEnable to bring IOC to OPERATIONAL state.
 *
 *	Returns 0 for success, non-zero for failure.
 */
static int
Pam Delaney's avatar
Pam Delaney committed
2506
SendIocInit(MPT_ADAPTER *ioc, int sleepFlag)
Linus Torvalds's avatar
Linus Torvalds committed
2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522
{
	IOCInit_t		 ioc_init;
	MPIDefaultReply_t	 init_reply;
	u32			 state;
	int			 r;
	int			 count;
	int			 cntdn;

	memset(&ioc_init, 0, sizeof(ioc_init));
	memset(&init_reply, 0, sizeof(init_reply));

	ioc_init.WhoInit = MPI_WHOINIT_HOST_DRIVER;
/*	ioc_init.ChainOffset = 0;			*/
	ioc_init.Function = MPI_FUNCTION_IOC_INIT;
/*	ioc_init.Flags = 0;				*/

Pam Delaney's avatar
Pam Delaney committed
2523 2524 2525 2526 2527 2528 2529 2530 2531
	/* If we are in a recovery mode and we uploaded the FW image,
	 * then this pointer is not NULL. Skip the upload a second time.
	 * Set this flag if cached_fw set for either IOC.
	 */
	ioc->upload_fw = 0;
	ioc_init.Flags = 0;
	if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT) {
		if ((ioc->cached_fw) || (ioc->alt_ioc && ioc->alt_ioc->cached_fw))
			ioc_init.Flags = MPI_IOCINIT_FLAGS_DISCARD_FW_IMAGE;
2532
		else
Pam Delaney's avatar
Pam Delaney committed
2533 2534
			ioc->upload_fw = 1;
	}
2535
	ddlprintk((MYIOC_s_INFO_FMT "flags %d, upload_fw %d \n",
2536
		   ioc->name, ioc_init.Flags, ioc->upload_fw));
Pam Delaney's avatar
Pam Delaney committed
2537 2538 2539 2540 2541 2542 2543

	if ((int)ioc->chip_type <= (int)FC929) {
		ioc_init.MaxDevices = MPT_MAX_FC_DEVICES;
	} else {
		ioc_init.MaxDevices = MPT_MAX_SCSI_DEVICES;
	}
	ioc_init.MaxBuses = MPT_MAX_BUS;
Linus Torvalds's avatar
Linus Torvalds committed
2544 2545 2546 2547

/*	ioc_init.MsgFlags = 0;				*/
/*	ioc_init.MsgContext = cpu_to_le32(0x00000000);	*/
	ioc_init.ReplyFrameSize = cpu_to_le16(ioc->reply_sz);	/* in BYTES */
2548 2549
		
	ioc->facts.RequestFrameSize = ioc_init.ReplyFrameSize;
Linus Torvalds's avatar
Linus Torvalds committed
2550

Pam Delaney's avatar
Pam Delaney committed
2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561
	if (sizeof(dma_addr_t) == sizeof(u64)) {
		/* Save the upper 32-bits of the request
		 * (reply) and sense buffers.
		 */
		ioc_init.HostMfaHighAddr = cpu_to_le32((u32)((u64)ioc->req_frames_dma >> 32));
		ioc_init.SenseBufferHighAddr = cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
	} else {
		/* Force 32-bit addressing */
		ioc_init.HostMfaHighAddr = cpu_to_le32(0);
		ioc_init.SenseBufferHighAddr = cpu_to_le32(0);
	}
2562 2563 2564
		
	ioc->facts.CurrentHostMfaHighAddr = ioc_init.HostMfaHighAddr;
	ioc->facts.CurrentSenseBufferHighAddr = ioc_init.SenseBufferHighAddr;
Pam Delaney's avatar
Pam Delaney committed
2565

2566
	dhsprintk((MYIOC_s_INFO_FMT "Sending IOCInit (req @ %p)\n",
Pam Delaney's avatar
Pam Delaney committed
2567
			ioc->name, &ioc_init));
Linus Torvalds's avatar
Linus Torvalds committed
2568

Pam Delaney's avatar
Pam Delaney committed
2569 2570
	r = mpt_handshake_req_reply_wait(ioc, sizeof(IOCInit_t), (u32*)&ioc_init,
				sizeof(MPIDefaultReply_t), (u16*)&init_reply, 10 /*seconds*/, sleepFlag);
Linus Torvalds's avatar
Linus Torvalds committed
2571 2572 2573 2574 2575 2576 2577
	if (r != 0)
		return r;

	/* No need to byte swap the multibyte fields in the reply
	 * since we don't even look at it's contents.
	 */

2578 2579 2580
	dhsprintk((MYIOC_s_INFO_FMT "Sending PortEnable (req @ %p)\n",
			ioc->name, &ioc_init));
	
Pam Delaney's avatar
Pam Delaney committed
2581
	if ((r = SendPortEnable(ioc, 0, sleepFlag)) != 0)
Linus Torvalds's avatar
Linus Torvalds committed
2582 2583 2584 2585 2586 2587 2588
		return r;

	/* YIKES!  SUPER IMPORTANT!!!
	 *  Poll IocState until _OPERATIONAL while IOC is doing
	 *  LoopInit and TargetDiscovery!
	 */
	count = 0;
2589
	cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 60;	/* 60 seconds */
Pam Delaney's avatar
Pam Delaney committed
2590
	state = mpt_GetIocState(ioc, 1);
Linus Torvalds's avatar
Linus Torvalds committed
2591
	while (state != MPI_IOC_STATE_OPERATIONAL && --cntdn) {
Pam Delaney's avatar
Pam Delaney committed
2592 2593 2594 2595 2596 2597
		if (sleepFlag == CAN_SLEEP) {
			set_current_state(TASK_INTERRUPTIBLE);
			schedule_timeout(1);
		} else {
			mdelay(1);
		}
Linus Torvalds's avatar
Linus Torvalds committed
2598 2599

		if (!cntdn) {
Pam Delaney's avatar
Pam Delaney committed
2600
			printk(MYIOC_s_ERR_FMT "Wait IOC_OP state timeout(%d)!\n",
Linus Torvalds's avatar
Linus Torvalds committed
2601 2602 2603 2604
					ioc->name, (count+5)/HZ);
			return -9;
		}

Pam Delaney's avatar
Pam Delaney committed
2605
		state = mpt_GetIocState(ioc, 1);
Linus Torvalds's avatar
Linus Torvalds committed
2606 2607
		count++;
	}
Pam Delaney's avatar
Pam Delaney committed
2608
	dhsprintk((MYIOC_s_INFO_FMT "INFO - Wait IOC_OPERATIONAL state (cnt=%d)\n",
Linus Torvalds's avatar
Linus Torvalds committed
2609 2610 2611 2612 2613 2614 2615 2616 2617 2618
			ioc->name, count));

	return r;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	SendPortEnable - Send PortEnable request to MPT adapter port.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *	@portnum: Port number to enable
Pam Delaney's avatar
Pam Delaney committed
2619
 *	@sleepFlag: Specifies whether the process can sleep
Linus Torvalds's avatar
Linus Torvalds committed
2620 2621 2622 2623 2624 2625
 *
 *	Send PortEnable to bring IOC to OPERATIONAL state.
 *
 *	Returns 0 for success, non-zero for failure.
 */
static int
Pam Delaney's avatar
Pam Delaney committed
2626
SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
Linus Torvalds's avatar
Linus Torvalds committed
2627 2628 2629
{
	PortEnable_t		 port_enable;
	MPIDefaultReply_t	 reply_buf;
Pam Delaney's avatar
Pam Delaney committed
2630
	int	 ii;
Linus Torvalds's avatar
Linus Torvalds committed
2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646
	int	 req_sz;
	int	 reply_sz;

	/*  Destination...  */
	reply_sz = sizeof(MPIDefaultReply_t);
	memset(&reply_buf, 0, reply_sz);

	req_sz = sizeof(PortEnable_t);
	memset(&port_enable, 0, req_sz);

	port_enable.Function = MPI_FUNCTION_PORT_ENABLE;
	port_enable.PortNumber = portnum;
/*	port_enable.ChainOffset = 0;		*/
/*	port_enable.MsgFlags = 0;		*/
/*	port_enable.MsgContext = 0;		*/

Pam Delaney's avatar
Pam Delaney committed
2647
	dprintk((MYIOC_s_INFO_FMT "Sending Port(%d)Enable (req @ %p)\n",
Linus Torvalds's avatar
Linus Torvalds committed
2648 2649
			ioc->name, portnum, &port_enable));

Pam Delaney's avatar
Pam Delaney committed
2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661
	/* RAID FW may take a long time to enable
	 */
	if ((int)ioc->chip_type <= (int)FC929) {
		ii = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&port_enable,
				reply_sz, (u16*)&reply_buf, 65 /*seconds*/, sleepFlag);
	} else {
		ii = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&port_enable,
				reply_sz, (u16*)&reply_buf, 300 /*seconds*/, sleepFlag);
	}

	if (ii != 0)
		return ii;
Linus Torvalds's avatar
Linus Torvalds committed
2662 2663 2664 2665 2666 2667 2668 2669

	/* We do not even look at the reply, so we need not
	 * swap the multi-byte fields.
	 */

	return 0;
}

Pam Delaney's avatar
Pam Delaney committed
2670 2671 2672 2673 2674
/*
 * Inputs: size - total FW bytes
 * Outputs: frags - number of fragments needed
 * Return NULL if failed.
 */
2675 2676
void
mpt_alloc_fw_memory(MPT_ADAPTER *ioc, int size)
Pam Delaney's avatar
Pam Delaney committed
2677
{
2678
	/* cached_fw
Pam Delaney's avatar
Pam Delaney committed
2679 2680
	 */

2681 2682
	if ( (ioc->cached_fw = pci_alloc_consistent(ioc->pcidev, size, &ioc->cached_fw_dma) ) )
		ioc->alloc_total += size;
Pam Delaney's avatar
Pam Delaney committed
2683 2684 2685 2686 2687 2688 2689
}

/*
 * If alt_img is NULL, delete from ioc structure.
 * Else, delete a secondary image in same format.
 */
void
2690
mpt_free_fw_memory(MPT_ADAPTER *ioc)
Pam Delaney's avatar
Pam Delaney committed
2691 2692 2693
{
	int sz;

2694 2695 2696 2697
	sz = ioc->facts.FWImageSize;
	pci_free_consistent(ioc->pcidev, sz,
			ioc->cached_fw, ioc->cached_fw_dma);
	ioc->cached_fw = NULL;
Pam Delaney's avatar
Pam Delaney committed
2698 2699 2700 2701 2702

	return;
}


Linus Torvalds's avatar
Linus Torvalds committed
2703 2704
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
Pam Delaney's avatar
Pam Delaney committed
2705
 *	mpt_do_upload - Construct and Send FWUpload request to MPT adapter port.
Linus Torvalds's avatar
Linus Torvalds committed
2706
 *	@ioc: Pointer to MPT_ADAPTER structure
Pam Delaney's avatar
Pam Delaney committed
2707
 *	@sleepFlag: Specifies whether the process can sleep
Linus Torvalds's avatar
Linus Torvalds committed
2708
 *
Pam Delaney's avatar
Pam Delaney committed
2709 2710
 *	Returns 0 for success, >0 for handshake failure
 *		<0 for fw upload failure.
Linus Torvalds's avatar
Linus Torvalds committed
2711
 *
Pam Delaney's avatar
Pam Delaney committed
2712 2713 2714 2715
 *	Remark: If bound IOC and a successful FWUpload was performed
 *	on the bound IOC, the second image is discarded
 *	and memory is free'd. Both channels must upload to prevent
 *	IOC from running in degraded mode.
Linus Torvalds's avatar
Linus Torvalds committed
2716 2717
 */
static int
Pam Delaney's avatar
Pam Delaney committed
2718
mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag)
Linus Torvalds's avatar
Linus Torvalds committed
2719
{
Pam Delaney's avatar
Pam Delaney committed
2720 2721 2722 2723
	u8			 request[ioc->req_sz];
	u8			 reply[sizeof(FWUploadReply_t)];
	FWUpload_t		*prequest;
	FWUploadReply_t		*preply;
2724
	FWUploadTCSGE_t		*ptcsge;
Pam Delaney's avatar
Pam Delaney committed
2725
	int			 sgeoffset;
2726
	u32			 flagsLength;
Pam Delaney's avatar
Pam Delaney committed
2727 2728 2729 2730 2731 2732 2733 2734
	int			 ii, sz, reply_sz;
	int			 cmdStatus, freeMem = 0;

	/* If the image size is 0 or if the pointer is
	 * not NULL (error), we are done.
	 */
	if (((sz = ioc->facts.FWImageSize) == 0) || ioc->cached_fw)
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
2735

2736 2737 2738 2739
	if ( sz & 0x01 )
		sz += 1;
	if ( sz & 0x02 )
		sz += 2;
Linus Torvalds's avatar
Linus Torvalds committed
2740

2741
	mpt_alloc_fw_memory(ioc, sz);
Pam Delaney's avatar
Pam Delaney committed
2742 2743 2744 2745 2746

	if (ioc->cached_fw == NULL) {
		/* Major Failure.
		 */
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
2747 2748
	}

2749 2750
	dinitprintk((KERN_WARNING MYNAM ": FW Image  @ %p[%p], sz=%d[%x] bytes\n",
		 ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
Linus Torvalds's avatar
Linus Torvalds committed
2751

Pam Delaney's avatar
Pam Delaney committed
2752 2753
	prequest = (FWUpload_t *)&request;
	preply = (FWUploadReply_t *)&reply;
Linus Torvalds's avatar
Linus Torvalds committed
2754

Pam Delaney's avatar
Pam Delaney committed
2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770
	/*  Destination...  */
	memset(prequest, 0, ioc->req_sz);

	reply_sz = sizeof(reply);
	memset(preply, 0, reply_sz);

	prequest->ImageType = MPI_FW_UPLOAD_ITYPE_FW_IOC_MEM;
	prequest->Function = MPI_FUNCTION_FW_UPLOAD;

	ptcsge = (FWUploadTCSGE_t *) &prequest->SGL;
	ptcsge->DetailsLength = 12;
	ptcsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
	ptcsge->ImageSize = cpu_to_le32(sz);

	sgeoffset = sizeof(FWUpload_t) - sizeof(SGE_MPI_UNION) + sizeof(FWUploadTCSGE_t);

2771 2772
	flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ | sz;
	mpt_add_sge(&request[sgeoffset], flagsLength, ioc->cached_fw_dma);
Pam Delaney's avatar
Pam Delaney committed
2773 2774

	sgeoffset += sizeof(u32) + sizeof(dma_addr_t);
2775 2776 2777
	dinitprintk((KERN_WARNING MYNAM "Sending FW Upload (req @ %p) sgeoffset=%d \n",
			prequest, sgeoffset));
	DBG_DUMP_FW_REQUEST_FRAME(prequest)
Pam Delaney's avatar
Pam Delaney committed
2778 2779 2780 2781

	ii = mpt_handshake_req_reply_wait(ioc, sgeoffset, (u32*)prequest,
				reply_sz, (u16*)preply, 65 /*seconds*/, sleepFlag);

2782 2783
	dinitprintk((KERN_WARNING MYNAM "FW Upload completed rc=%x \n", ii));

Pam Delaney's avatar
Pam Delaney committed
2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794
	cmdStatus = -EFAULT;
	if (ii == 0) {
		/* Handshake transfer was complete and successful.
		 * Check the Reply Frame.
		 */
		int status, transfer_sz;
		status = le16_to_cpu(preply->IOCStatus);
		if (status == MPI_IOCSTATUS_SUCCESS) {
			transfer_sz = le32_to_cpu(preply->ActualImageSize);
			if (transfer_sz == sz)
				cmdStatus = 0;
Linus Torvalds's avatar
Linus Torvalds committed
2795 2796
		}
	}
2797
	dinitprintk((MYIOC_s_INFO_FMT ": do_upload status %d \n",
Pam Delaney's avatar
Pam Delaney committed
2798
			ioc->name, cmdStatus));
Linus Torvalds's avatar
Linus Torvalds committed
2799

Pam Delaney's avatar
Pam Delaney committed
2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814
	/* Check to see if we have a copy of this image in
	 * host memory already.
	 */
	if (cmdStatus == 0) {
		ioc->upload_fw = 0;
		if (ioc->alt_ioc && ioc->alt_ioc->cached_fw)
			freeMem = 1;
	}

	/* We already have a copy of this image or
	 * we had some type of an error  - either the handshake
	 * failed (i != 0) or the command did not complete successfully.
	 */
	if (cmdStatus || freeMem) {

2815
		ddlprintk((MYIOC_s_INFO_FMT ": do_upload freeing %s image \n",
Pam Delaney's avatar
Pam Delaney committed
2816
			ioc->name, cmdStatus ? "incomplete" : "duplicate"));
2817
		mpt_free_fw_memory(ioc);
Pam Delaney's avatar
Pam Delaney committed
2818 2819 2820
	}

	return cmdStatus;
Linus Torvalds's avatar
Linus Torvalds committed
2821 2822 2823 2824
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
Pam Delaney's avatar
Pam Delaney committed
2825
 *	mpt_downloadboot - DownloadBoot code
Linus Torvalds's avatar
Linus Torvalds committed
2826
 *	@ioc: Pointer to MPT_ADAPTER structure
Pam Delaney's avatar
Pam Delaney committed
2827 2828
 *	@flag: Specify which part of IOC memory is to be uploaded.
 *	@sleepFlag: Specifies whether the process can sleep
Linus Torvalds's avatar
Linus Torvalds committed
2829
 *
Pam Delaney's avatar
Pam Delaney committed
2830
 *	FwDownloadBoot requires Programmed IO access.
Linus Torvalds's avatar
Linus Torvalds committed
2831
 *
Pam Delaney's avatar
Pam Delaney committed
2832 2833 2834 2835
 *	Returns 0 for success
 *		-1 FW Image size is 0
 *		-2 No valid cached_fw Pointer
 *		<0 for fw upload failure.
Linus Torvalds's avatar
Linus Torvalds committed
2836 2837
 */
static int
Pam Delaney's avatar
Pam Delaney committed
2838
mpt_downloadboot(MPT_ADAPTER *ioc, int sleepFlag)
Linus Torvalds's avatar
Linus Torvalds committed
2839
{
2840 2841 2842
	MpiFwHeader_t		*pFwHeader;
	MpiExtImageHeader_t	*pExtImage;
	u32			 fwSize;
Pam Delaney's avatar
Pam Delaney committed
2843
	u32			 diag0val;
Linus Torvalds's avatar
Linus Torvalds committed
2844
#ifdef MPT_DEBUG
Pam Delaney's avatar
Pam Delaney committed
2845 2846 2847
	u32			 diag1val = 0;
#endif
	int			 count = 0;
2848
	u32			*ptrFw;
Pam Delaney's avatar
Pam Delaney committed
2849 2850 2851
	u32			 diagRwData;
	u32			 nextImage;
	u32			 load_addr;
2852
	u32 			 ioc_state;
Pam Delaney's avatar
Pam Delaney committed
2853

2854
	ddlprintk((MYIOC_s_INFO_FMT "downloadboot: fw size 0x%x, ioc FW Ptr %p\n",
Pam Delaney's avatar
Pam Delaney committed
2855 2856 2857 2858
				ioc->name, ioc->facts.FWImageSize, ioc->cached_fw));

	/* Get dma_addr and data transfer size.
	 */
2859
	if ( ioc->facts.FWImageSize == 0 )
Pam Delaney's avatar
Pam Delaney committed
2860 2861 2862
		return -1;

	/* Get the DMA from ioc or ioc->alt_ioc */
2863
	if (ioc->cached_fw == NULL)
2864
		return -2;
Pam Delaney's avatar
Pam Delaney committed
2865

2866 2867 2868 2869 2870 2871
	CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
	CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
	CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
	CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
	CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
	CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
Pam Delaney's avatar
Pam Delaney committed
2872 2873

	diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
2874 2875
	diag0val |= (MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM);
	CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
Pam Delaney's avatar
Pam Delaney committed
2876

2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894
	/* wait 100 msec */
	if (sleepFlag == CAN_SLEEP) {
		set_current_state(TASK_INTERRUPTIBLE);
		schedule_timeout(100 * HZ / 1000);
	} else {
		mdelay (100);
	}

	CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);

	for (count = 0; count < 30; count ++) {
		diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
		if (!(diag0val & MPI_DIAG_RESET_ADAPTER)) {
			ddlprintk((MYIOC_s_INFO_FMT "RESET_ADAPTER cleared, count=%d\n",
				ioc->name, count));
			break;
		}
		/* wait 1 sec */
Pam Delaney's avatar
Pam Delaney committed
2895 2896
		if (sleepFlag == CAN_SLEEP) {
			set_current_state(TASK_INTERRUPTIBLE);
2897
			schedule_timeout(HZ);
Pam Delaney's avatar
Pam Delaney committed
2898
		} else {
2899
			mdelay (1000);
Pam Delaney's avatar
Pam Delaney committed
2900
		}
Linus Torvalds's avatar
Linus Torvalds committed
2901
	}
Linus Torvalds's avatar
Linus Torvalds committed
2902

2903 2904 2905 2906 2907
	if ( count == 30 ) {
		ddlprintk((MYIOC_s_INFO_FMT "downloadboot failed! Unable to RESET_ADAPTER diag0val=%x\n",
		ioc->name, diag0val));
		return -3;
	}
2908

2909 2910 2911 2912 2913 2914
	CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
	CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
	CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
	CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
	CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
	CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
Pam Delaney's avatar
Pam Delaney committed
2915

2916 2917 2918
	/* Set the DiagRwEn and Disable ARM bits */
	diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
	CHIPREG_WRITE32(&ioc->chip->Diagnostic, (diag0val | MPI_DIAG_RW_ENABLE | MPI_DIAG_DISABLE_ARM));
Pam Delaney's avatar
Pam Delaney committed
2919

2920 2921 2922
	pFwHeader = (MpiFwHeader_t *) ioc->cached_fw;
	fwSize = (pFwHeader->ImageSize + 3)/4;
	ptrFw = (u32 *) pFwHeader;
Pam Delaney's avatar
Pam Delaney committed
2923

2924 2925 2926
	/* Write the LoadStartAddress to the DiagRw Address Register
	 * using Programmed IO
	 */
2927
	CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->LoadStartAddress);
2928
	ddlprintk((MYIOC_s_INFO_FMT "LoadStart addr written 0x%x \n",
2929 2930 2931 2932 2933 2934
		ioc->name, pFwHeader->LoadStartAddress));

	ddlprintk((MYIOC_s_INFO_FMT "Write FW Image: 0x%x bytes @ %p\n",
				ioc->name, fwSize*4, ptrFw));
	while (fwSize--) {
		CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
Pam Delaney's avatar
Pam Delaney committed
2935 2936
	}

2937
	nextImage = pFwHeader->NextImageHeaderOffset;
Pam Delaney's avatar
Pam Delaney committed
2938
	while (nextImage) {
2939
		pExtImage = (MpiExtImageHeader_t *) ((char *)pFwHeader + nextImage);
Pam Delaney's avatar
Pam Delaney committed
2940

2941
		load_addr = pExtImage->LoadStartAddress;
Pam Delaney's avatar
Pam Delaney committed
2942

2943 2944
		fwSize = (pExtImage->ImageSize + 3) >> 2;
		ptrFw = (u32 *)pExtImage;
Pam Delaney's avatar
Pam Delaney committed
2945

2946 2947
		ddlprintk((MYIOC_s_INFO_FMT "Write Ext Image: 0x%x bytes @ %p load_addr=%x\n",
						ioc->name, fwSize*4, ptrFw, load_addr));
Pam Delaney's avatar
Pam Delaney committed
2948 2949
		CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, load_addr);

2950 2951
		while (fwSize--) {
			CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
Pam Delaney's avatar
Pam Delaney committed
2952
		}
2953
		nextImage = pExtImage->NextImageHeaderOffset;
Pam Delaney's avatar
Pam Delaney committed
2954 2955 2956
	}

	/* Write the IopResetVectorRegAddr */
2957 2958
	ddlprintk((MYIOC_s_INFO_FMT "Write IopResetVector Addr=%x! \n", ioc->name, 	pFwHeader->IopResetRegAddr));
	CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->IopResetRegAddr);
Pam Delaney's avatar
Pam Delaney committed
2959 2960

	/* Write the IopResetVectorValue */
2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971
	ddlprintk((MYIOC_s_INFO_FMT "Write IopResetVector Value=%x! \n", ioc->name, pFwHeader->IopResetVectorValue));
	CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, pFwHeader->IopResetVectorValue);

	/* clear the PREVENT_IOC_BOOT bit */
	diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
	ddlprintk((MYIOC_s_INFO_FMT "downloadboot diag0val=%x, turning off PREVENT_IOC_BOOT\n",
		ioc->name, diag0val));
	diag0val &= ~(MPI_DIAG_PREVENT_IOC_BOOT);
	ddlprintk((MYIOC_s_INFO_FMT "downloadboot now diag0val=%x\n",
		ioc->name, diag0val));
	CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
Pam Delaney's avatar
Pam Delaney committed
2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982

	/* Clear the internal flash bad bit - autoincrementing register,
	 * so must do two writes.
	 */
	CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
	diagRwData = CHIPREG_PIO_READ32(&ioc->pio_chip->DiagRwData);
	diagRwData |= 0x4000000;
	CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
	CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, diagRwData);

	diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
2983 2984 2985 2986 2987
	ddlprintk((MYIOC_s_INFO_FMT "downloadboot diag0val=%x, turning off DISABLE_ARM, RW_ENABLE, RESET_HISTORY\n",
		ioc->name, diag0val));
	diag0val &= ~(MPI_DIAG_DISABLE_ARM | MPI_DIAG_RW_ENABLE | MPI_DIAG_RESET_HISTORY);
	ddlprintk((MYIOC_s_INFO_FMT "downloadboot now diag0val=%x\n",
		ioc->name, diag0val));
Pam Delaney's avatar
Pam Delaney committed
2988 2989
	CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);

2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004
	/* wait 100 msec */
	if (sleepFlag == CAN_SLEEP) {
		ddlprintk((MYIOC_s_INFO_FMT "CAN_SLEEP 100 msec before reset the sequencer\n", ioc->name));
		set_current_state(TASK_INTERRUPTIBLE);
		schedule_timeout(100 * HZ / 1000);
	} else {
		ddlprintk((MYIOC_s_INFO_FMT "mdelay 100 msec before reset the sequencer\n", ioc->name));
		mdelay (100);
	}

	diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
	if ( diag0val & (MPI_DIAG_FLASH_BAD_SIG | MPI_DIAG_DISABLE_ARM) ) {
		ddlprintk((MYIOC_s_INFO_FMT "downloadboot failed, diag0val=%x FLASH_BAD_SIG | DISABLE_ARM on\n ",
			ioc->name, diag0val));
	}
Pam Delaney's avatar
Pam Delaney committed
3005 3006 3007
	/* Write 0xFF to reset the sequencer */
	CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);

3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038
	for (count=0; count<HZ*20; count++) {
		if ((ioc_state = mpt_GetIocState(ioc, 0)) & MPI_IOC_STATE_READY) {
			ddlprintk((MYIOC_s_INFO_FMT "downloadboot successful! (count=%d) IocState=%x\n",
					ioc->name, count, ioc_state));
/*			if ((r = GetIocFacts(ioc, sleepFlag, MPT_HOSTEVENT_IOC_BRINGUP)) != 0) {
				if ((r = GetIocFacts(ioc, sleepFlag, MPT_HOSTEVENT_IOC_BRINGUP)) != 0) {
					ddlprintk((MYIOC_s_INFO_FMT "GetIocFacts failed\n",
						ioc->name));
						return -EFAULT;
				}
			} */
			/* wait 2 sec */
/*			if (sleepFlag == CAN_SLEEP) {
				set_current_state(TASK_INTERRUPTIBLE);
				schedule_timeout(5000 * HZ / 1000);
			} else {
				mdelay (5000);
			} */

			return 0;
		}
		if (sleepFlag == CAN_SLEEP) {
			set_current_state(TASK_INTERRUPTIBLE);
			schedule_timeout(1);
		} else {
			mdelay (10);
		}
	}
	ddlprintk((MYIOC_s_INFO_FMT "downloadboot failed! IocState=%x\n",
		ioc->name, ioc_state));
	return -EFAULT;
Linus Torvalds's avatar
Linus Torvalds committed
3039
}
Pam Delaney's avatar
Pam Delaney committed
3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	KickStart - Perform hard reset of MPT adapter.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *	@force: Force hard reset
 *	@sleepFlag: Specifies whether the process can sleep
 *
 *	This routine places MPT adapter in diagnostic mode via the
 *	WriteSequence register, and then performs a hard reset of adapter
 *	via the Diagnostic register.
 *
 *	Inputs:   sleepflag - CAN_SLEEP (non-interrupt thread)
 *			or NO_SLEEP (interrupt thread, use mdelay)
 *		  force - 1 if doorbell active, board fault state
 *				board operational, IOC_RECOVERY or
 *				IOC_BRINGUP and there is an alt_ioc.
 *			  0 else
 *
 *	Returns:
 *		 1 - hard reset, READY	
 *		 0 - no reset due to History bit, READY	
 *		-1 - no reset due to History bit but not READY	
 *		     OR reset but failed to come READY
3064 3065
 *		-2 - no reset, could not enter DIAG mode
 *		-3 - reset but bad FW bit
Pam Delaney's avatar
Pam Delaney committed
3066 3067 3068 3069 3070 3071
 */
static int
KickStart(MPT_ADAPTER *ioc, int force, int sleepFlag)
{
	int hard_reset_done = 0;
	u32 ioc_state;
3072
	int cntdn, cnt = 0;
Pam Delaney's avatar
Pam Delaney committed
3073

3074
	dinitprintk((KERN_WARNING MYNAM ": KickStarting %s!\n", ioc->name));
3075 3076 3077 3078 3079 3080 3081
	if ((int)ioc->chip_type > (int)FC929) {
		/* Always issue a Msg Unit Reset first. This will clear some
		 * SCSI bus hang conditions.
		 */
		SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag);

		if (sleepFlag == CAN_SLEEP) {
3082
			set_current_state(TASK_INTERRUPTIBLE);
3083 3084 3085 3086 3087
			schedule_timeout(HZ);
		} else {
			mdelay (1000);
		}
	}
Pam Delaney's avatar
Pam Delaney committed
3088 3089 3090 3091 3092 3093 3094 3095

	hard_reset_done = mpt_diag_reset(ioc, force, sleepFlag);
	if (hard_reset_done < 0)
		return hard_reset_done;

	dprintk((MYIOC_s_INFO_FMT "Diagnostic reset successful!\n",
			ioc->name));

3096 3097
	cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 20;	/* 20 seconds */
	for (cnt=0; cnt<cntdn; cnt++) {
Pam Delaney's avatar
Pam Delaney committed
3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143
		if ((ioc_state = mpt_GetIocState(ioc, 1)) == MPI_IOC_STATE_READY) {
			dprintk((MYIOC_s_INFO_FMT "KickStart successful! (cnt=%d)\n",
					ioc->name, cnt));
			return hard_reset_done;
		}
		if (sleepFlag == CAN_SLEEP) {
			set_current_state(TASK_INTERRUPTIBLE);
			schedule_timeout(1);
		} else {
			mdelay (10);
		}
	}

	printk(MYIOC_s_ERR_FMT "Failed to come READY after reset!\n",
			ioc->name);
	return -1;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	mpt_diag_reset - Perform hard reset of the adapter.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *	@ignore: Set if to honor and clear to ignore
 *		the reset history bit
 *	@sleepflag: CAN_SLEEP if called in a non-interrupt thread,
 *		else set to NO_SLEEP (use mdelay instead)
 *
 *	This routine places the adapter in diagnostic mode via the
 *	WriteSequence register and then performs a hard reset of adapter
 *	via the Diagnostic register. Adapter should be in ready state
 *	upon successful completion.
 *
 *	Returns:  1  hard reset successful
 *		  0  no reset performed because reset history bit set
 *		 -2  enabling diagnostic mode failed
 *		 -3  diagnostic reset failed
 */
static int
mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag)
{
	u32 diag0val;
	u32 doorbell;
	int hard_reset_done = 0;
	int count = 0;
#ifdef MPT_DEBUG
	u32 diag1val = 0;
Linus Torvalds's avatar
Linus Torvalds committed
3144
#endif
Pam Delaney's avatar
Pam Delaney committed
3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166

	/* Clear any existing interrupts */
	CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);

	/* Use "Diagnostic reset" method! (only thing available!) */
	diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);

#ifdef MPT_DEBUG
	if (ioc->alt_ioc)
		diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
	dprintk((MYIOC_s_INFO_FMT "DbG1: diag0=%08x, diag1=%08x\n",
			ioc->name, diag0val, diag1val));
#endif

	/* Do the reset if we are told to ignore the reset history
	 * or if the reset history is 0
	 */
	if (ignore || !(diag0val & MPI_DIAG_RESET_HISTORY)) {
		while ((diag0val & MPI_DIAG_DRWE) == 0) {
			/* Write magic sequence to WriteSequence register
			 * Loop until in diagnostic mode
			 */
3167
			CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
Pam Delaney's avatar
Pam Delaney committed
3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202
			CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
			CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
			CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
			CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
			CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);

			/* wait 100 msec */
			if (sleepFlag == CAN_SLEEP) {
				set_current_state(TASK_INTERRUPTIBLE);
				schedule_timeout(100 * HZ / 1000);
			} else {
				mdelay (100);
			}

			count++;
			if (count > 20) {
				printk(MYIOC_s_ERR_FMT "Enable Diagnostic mode FAILED! (%02xh)\n",
						ioc->name, diag0val);
				return -2;

			}

			diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);

			dprintk((MYIOC_s_INFO_FMT "Wrote magic DiagWriteEn sequence (%x)\n",
					ioc->name, diag0val));
		}

#ifdef MPT_DEBUG
		if (ioc->alt_ioc)
			diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
		dprintk((MYIOC_s_INFO_FMT "DbG2: diag0=%08x, diag1=%08x\n",
				ioc->name, diag0val, diag1val));
#endif
		/* Write the PreventIocBoot bit */
3203
		if ((ioc->cached_fw) || (ioc->alt_ioc && ioc->alt_ioc->cached_fw)) {
Pam Delaney's avatar
Pam Delaney committed
3204 3205 3206 3207 3208 3209
			diag0val |= MPI_DIAG_PREVENT_IOC_BOOT;
			CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
		}

		/*
		 * Disable the ARM (Bug fix)
3210
		 *
Pam Delaney's avatar
Pam Delaney committed
3211 3212 3213 3214
		 */
		CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_DISABLE_ARM);
		mdelay (1);

Linus Torvalds's avatar
Linus Torvalds committed
3215 3216
		/*
		 * Now hit the reset bit in the Diagnostic register
Pam Delaney's avatar
Pam Delaney committed
3217
		 * (THE BIG HAMMER!) (Clears DRWE bit).
Linus Torvalds's avatar
Linus Torvalds committed
3218
		 */
Pam Delaney's avatar
Pam Delaney committed
3219
		CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
Linus Torvalds's avatar
Linus Torvalds committed
3220
		hard_reset_done = 1;
Pam Delaney's avatar
Pam Delaney committed
3221
		dprintk((MYIOC_s_INFO_FMT "Diagnostic reset performed\n",
Linus Torvalds's avatar
Linus Torvalds committed
3222
				ioc->name));
Linus Torvalds's avatar
Linus Torvalds committed
3223

Pam Delaney's avatar
Pam Delaney committed
3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248
		/*
		 * Call each currently registered protocol IOC reset handler
		 * with pre-reset indication.
		 * NOTE: If we're doing _IOC_BRINGUP, there can be no
		 * MptResetHandlers[] registered yet.
		 */
		{
			int	 ii;
			int	 r = 0;

			for (ii=MPT_MAX_PROTOCOL_DRIVERS-1; ii; ii--) {
				if (MptResetHandlers[ii]) {
					dprintk((MYIOC_s_INFO_FMT "Calling IOC pre_reset handler #%d\n",
							ioc->name, ii));
					r += (*(MptResetHandlers[ii]))(ioc, MPT_IOC_PRE_RESET);
					if (ioc->alt_ioc) {
						dprintk((MYIOC_s_INFO_FMT "Calling alt-%s pre_reset handler #%d\n",
								ioc->name, ioc->alt_ioc->name, ii));
						r += (*(MptResetHandlers[ii]))(ioc->alt_ioc, MPT_IOC_PRE_RESET);
					}
				}
			}
			/* FIXME?  Examine results here? */
		}

3249
		if ((ioc->cached_fw) || (ioc->alt_ioc && ioc->alt_ioc->cached_fw)) {
Pam Delaney's avatar
Pam Delaney committed
3250 3251 3252 3253 3254 3255 3256 3257 3258
			/* If the DownloadBoot operation fails, the
			 * IOC will be left unusable. This is a fatal error
			 * case.  _diag_reset will return < 0
			 */
			for (count = 0; count < 30; count ++) {
				diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
#ifdef MPT_DEBUG
				if (ioc->alt_ioc)
					diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3259
				dprintk((MYIOC_s_INFO_FMT
Pam Delaney's avatar
Pam Delaney committed
3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275
					"DbG2b: diag0=%08x, diag1=%08x\n",
					ioc->name, diag0val, diag1val));
#endif
				if (!(diag0val & MPI_DIAG_RESET_ADAPTER)) {
					break;
				}

				/* wait 1 sec */
				if (sleepFlag == CAN_SLEEP) {
					set_current_state(TASK_INTERRUPTIBLE);
					schedule_timeout(HZ);
				} else {
					mdelay (1000);
				}
			}
			if ((count = mpt_downloadboot(ioc, sleepFlag)) < 0) {
3276
				printk(KERN_WARNING MYNAM
Pam Delaney's avatar
Pam Delaney committed
3277 3278 3279 3280 3281 3282
					": firmware downloadboot failure (%d)!\n", count);
			}

		} else {
			/* Wait for FW to reload and for board
			 * to go to the READY state.
3283
			 * Maximum wait is 60 seconds.
Pam Delaney's avatar
Pam Delaney committed
3284 3285 3286
			 * If fail, no error will check again
			 * with calling program.
			 */
3287
			for (count = 0; count < 60; count ++) {
Pam Delaney's avatar
Pam Delaney committed
3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312
				doorbell = CHIPREG_READ32(&ioc->chip->Doorbell);
				doorbell &= MPI_IOC_STATE_MASK;

				if (doorbell == MPI_IOC_STATE_READY) {
					break;
				}

				/* wait 1 sec */
				if (sleepFlag == CAN_SLEEP) {
					set_current_state(TASK_INTERRUPTIBLE);
					schedule_timeout(HZ);
				} else {
					mdelay (1000);
				}
			}
		}
	}

	diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
#ifdef MPT_DEBUG
	if (ioc->alt_ioc)
		diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
	dprintk((MYIOC_s_INFO_FMT "DbG3: diag0=%08x, diag1=%08x\n",
		ioc->name, diag0val, diag1val));
#endif
Linus Torvalds's avatar
Linus Torvalds committed
3313

Pam Delaney's avatar
Pam Delaney committed
3314 3315 3316 3317 3318 3319 3320 3321 3322
	/* Clear RESET_HISTORY bit!  Place board in the
	 * diagnostic mode to update the diag register.
	 */
	diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
	count = 0;
	while ((diag0val & MPI_DIAG_DRWE) == 0) {
		/* Write magic sequence to WriteSequence register
		 * Loop until in diagnostic mode
		 */
3323
		CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
Linus Torvalds's avatar
Linus Torvalds committed
3324 3325 3326 3327 3328
		CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
		CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
		CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
		CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
		CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
Linus Torvalds's avatar
Linus Torvalds committed
3329

Pam Delaney's avatar
Pam Delaney committed
3330 3331 3332 3333 3334 3335 3336
		/* wait 100 msec */
		if (sleepFlag == CAN_SLEEP) {
			set_current_state(TASK_INTERRUPTIBLE);
			schedule_timeout(100 * HZ / 1000);
		} else {
			mdelay (100);
		}
Linus Torvalds's avatar
Linus Torvalds committed
3337

Pam Delaney's avatar
Pam Delaney committed
3338 3339 3340 3341 3342 3343 3344 3345 3346 3347
		count++;
		if (count > 20) {
			printk(MYIOC_s_ERR_FMT "Enable Diagnostic mode FAILED! (%02xh)\n",
					ioc->name, diag0val);
			break;
		}
		diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
	}
	diag0val &= ~MPI_DIAG_RESET_HISTORY;
	CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
Linus Torvalds's avatar
Linus Torvalds committed
3348 3349
	diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
	if (diag0val & MPI_DIAG_RESET_HISTORY) {
Pam Delaney's avatar
Pam Delaney committed
3350
		printk(MYIOC_s_WARN_FMT "ResetHistory bit failed to clear!\n",
Linus Torvalds's avatar
Linus Torvalds committed
3351 3352 3353
				ioc->name);
	}

Pam Delaney's avatar
Pam Delaney committed
3354 3355 3356 3357 3358 3359
	/* Disable Diagnostic Mode
	 */
	CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFFFFFFFF);

	/* Check FW reload status flags.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
3360
	diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
Pam Delaney's avatar
Pam Delaney committed
3361 3362 3363 3364 3365 3366
	if (diag0val & (MPI_DIAG_FLASH_BAD_SIG | MPI_DIAG_RESET_ADAPTER | MPI_DIAG_DISABLE_ARM)) {
		printk(MYIOC_s_ERR_FMT "Diagnostic reset FAILED! (%02xh)\n",
				ioc->name, diag0val);
		return -3;
	}

Linus Torvalds's avatar
Linus Torvalds committed
3367 3368 3369
#ifdef MPT_DEBUG
	if (ioc->alt_ioc)
		diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
Pam Delaney's avatar
Pam Delaney committed
3370
	dprintk((MYIOC_s_INFO_FMT "DbG4: diag0=%08x, diag1=%08x\n",
Linus Torvalds's avatar
Linus Torvalds committed
3371 3372 3373 3374 3375
			ioc->name, diag0val, diag1val));
#endif

	/*
	 * Reset flag that says we've enabled event notification
Linus Torvalds's avatar
Linus Torvalds committed
3376
	 */
Linus Torvalds's avatar
Linus Torvalds committed
3377
	ioc->facts.EventState = 0;
Linus Torvalds's avatar
Linus Torvalds committed
3378

Pam Delaney's avatar
Pam Delaney committed
3379 3380
	if (ioc->alt_ioc)
		ioc->alt_ioc->facts.EventState = 0;
Linus Torvalds's avatar
Linus Torvalds committed
3381

Linus Torvalds's avatar
Linus Torvalds committed
3382
	return hard_reset_done;
Linus Torvalds's avatar
Linus Torvalds committed
3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	SendIocReset - Send IOCReset request to MPT adapter.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *	@reset_type: reset type, expected values are
 *	%MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET or %MPI_FUNCTION_IO_UNIT_RESET
 *
 *	Send IOCReset request to the MPT adapter.
 *
 *	Returns 0 for success, non-zero for failure.
 */
static int
Pam Delaney's avatar
Pam Delaney committed
3397
SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag)
Linus Torvalds's avatar
Linus Torvalds committed
3398 3399
{
	int r;
Pam Delaney's avatar
Pam Delaney committed
3400 3401
	u32 state;
	int cntdn, count;
Linus Torvalds's avatar
Linus Torvalds committed
3402

3403
	drsprintk((KERN_WARNING MYNAM ": %s: Sending IOC reset(0x%02x)!\n",
Linus Torvalds's avatar
Linus Torvalds committed
3404
			ioc->name, reset_type));
Linus Torvalds's avatar
Linus Torvalds committed
3405
	CHIPREG_WRITE32(&ioc->chip->Doorbell, reset_type<<MPI_DOORBELL_FUNCTION_SHIFT);
3406
	if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
Linus Torvalds's avatar
Linus Torvalds committed
3407 3408
		return r;

3409
	/* FW ACK'd request, wait for READY state
Pam Delaney's avatar
Pam Delaney committed
3410 3411
	 */
	count = 0;
3412
	cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 15;	/* 15 seconds */
Pam Delaney's avatar
Pam Delaney committed
3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433

	while ((state = mpt_GetIocState(ioc, 1)) != MPI_IOC_STATE_READY) {
		cntdn--;
		count++;
		if (!cntdn) {
			if (sleepFlag != CAN_SLEEP)
				count *= 10;

			printk(KERN_ERR MYNAM ": %s: ERROR - Wait IOC_READY state timeout(%d)!\n",
					ioc->name, (count+5)/HZ);
			return -ETIME;
		}

		if (sleepFlag == CAN_SLEEP) {
			set_current_state(TASK_INTERRUPTIBLE);
			schedule_timeout(1);
		} else {
			mdelay (1);	/* 1 msec delay */
		}
	}

Linus Torvalds's avatar
Linus Torvalds committed
3434 3435 3436 3437
	/* TODO!
	 *  Cleanup all event stuff for this IOC; re-issue EventNotification
	 *  request if needed.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
3438 3439
	if (ioc->facts.Function)
		ioc->facts.EventState = 0;
Linus Torvalds's avatar
Linus Torvalds committed
3440 3441 3442 3443 3444 3445 3446 3447 3448 3449

	return 0;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	PrimeIocFifos - Initialize IOC request and reply FIFOs.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *
 *	This routine allocates memory for the MPT reply and request frame
Pam Delaney's avatar
Pam Delaney committed
3450 3451
 *	pools (if necessary), and primes the IOC reply FIFO with
 *	reply frames.
Linus Torvalds's avatar
Linus Torvalds committed
3452 3453 3454 3455 3456 3457 3458 3459
 *
 *	Returns 0 for success, non-zero for failure.
 */
static int
PrimeIocFifos(MPT_ADAPTER *ioc)
{
	MPT_FRAME_HDR *mf;
	unsigned long b;
Pam Delaney's avatar
Pam Delaney committed
3460
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
3461
	dma_addr_t aligned_mem_dma;
3462
	u8 *aligned_mem;
Linus Torvalds's avatar
Linus Torvalds committed
3463
	int i, sz;
3464 3465
	int chain_buffer_sz, reply_buffer_sz, request_buffer_sz;
	int scale, num_sge, num_chain;
Linus Torvalds's avatar
Linus Torvalds committed
3466

3467 3468 3469
	/* request buffer size,  rounding UP to nearest 4-kB boundary */
	request_buffer_sz = (ioc->req_sz * ioc->req_depth) + 128;
	request_buffer_sz = ((request_buffer_sz + 0x1000UL - 1UL) / 0x1000) * 0x1000;
Linus Torvalds's avatar
Linus Torvalds committed
3470

3471 3472
	/* reply buffer size */
	reply_buffer_sz = (ioc->reply_sz * ioc->reply_depth) + 128;
Linus Torvalds's avatar
Linus Torvalds committed
3473

3474 3475 3476 3477 3478 3479 3480 3481
	/* chain buffer size, copied from from mptscsih_initChainBuffers()
	 *
	 * Calculate the number of chain buffers needed(plus 1) per I/O
	 * then multiply the the maximum number of simultaneous cmds
	 *
	 * num_sge = num sge in request frame + last chain buffer
	 * scale = num sge per chain buffer if no chain element
	 */
Linus Torvalds's avatar
Linus Torvalds committed
3482

3483 3484 3485 3486 3487
	scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
	if (sizeof(dma_addr_t) == sizeof(u64))
		num_sge =  scale + (ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
	else
		num_sge =  1 + scale + (ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
Linus Torvalds's avatar
Linus Torvalds committed
3488

3489 3490 3491 3492
	num_chain = 1;
	while (MPT_SCSI_SG_DEPTH - num_sge > 0) {
		num_chain++;
		num_sge += (scale - 1);
Pam Delaney's avatar
Pam Delaney committed
3493
	}
3494
	num_chain++;
Pam Delaney's avatar
Pam Delaney committed
3495

3496 3497 3498 3499
	if ((int)ioc->chip_type > (int) FC929)
		num_chain *= MPT_SCSI_CAN_QUEUE;
	else
		num_chain *= MPT_FC_CAN_QUEUE;
Pam Delaney's avatar
Pam Delaney committed
3500

3501
	chain_buffer_sz = num_chain * ioc->req_sz;
Linus Torvalds's avatar
Linus Torvalds committed
3502

3503
	if(ioc->fifo_pool == NULL) {
Linus Torvalds's avatar
Linus Torvalds committed
3504

3505 3506
		ioc->fifo_pool_sz = request_buffer_sz +
			reply_buffer_sz + chain_buffer_sz;
Linus Torvalds's avatar
Linus Torvalds committed
3507

3508 3509
		ioc->fifo_pool = pci_alloc_consistent(ioc->pcidev,
		ioc->fifo_pool_sz, &ioc->fifo_pool_dma);
Linus Torvalds's avatar
Linus Torvalds committed
3510

3511
		if( ioc->fifo_pool == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
3512 3513
			goto out_fail;

3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529
		ioc->alloc_total += ioc->fifo_pool_sz;
		memset(ioc->fifo_pool, 0, ioc->fifo_pool_sz);

		/* reply fifo pointers */
		ioc->reply_alloc = ioc->fifo_pool;
		ioc->reply_alloc_dma = ioc->fifo_pool_dma;
		/* request fifo pointers */
		ioc->req_alloc = ioc->reply_alloc+reply_buffer_sz;
		ioc->req_alloc_dma = ioc->reply_alloc_dma+reply_buffer_sz;
		/* chain buffer pointers */
		ioc->chain_alloc = ioc->req_alloc+request_buffer_sz;
		ioc->chain_alloc_dma = ioc->req_alloc_dma+request_buffer_sz;
		ioc->chain_alloc_sz = chain_buffer_sz;

		/*  Prime reply FIFO...  */
		dprintk((KERN_INFO MYNAM ": %s.reply_alloc  @ %p[%p], sz=%d bytes\n",
3530 3531
			ioc->name, ioc->reply_alloc, 
			(void *)(ulong)ioc->reply_alloc_dma, reply_buffer_sz));
3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542

		b = (unsigned long) ioc->reply_alloc;
		b = (b + (0x80UL - 1UL)) & ~(0x80UL - 1UL); /* round up to 128-byte boundary */
		aligned_mem = (u8 *) b;
		ioc->reply_frames = (MPT_FRAME_HDR *) aligned_mem;
		ioc->reply_frames_dma =
			(ioc->reply_alloc_dma + (aligned_mem - ioc->reply_alloc));

		ioc->reply_frames_low_dma = (u32) (ioc->reply_frames_dma & 0xFFFFFFFF);
	
		/*  Request FIFO - WE manage this!  */
Pam Delaney's avatar
Pam Delaney committed
3543
		dprintk((KERN_INFO MYNAM ": %s.req_alloc    @ %p[%p], sz=%d bytes\n",
3544 3545
			ioc->name, ioc->req_alloc,
			(void *)(ulong)ioc->req_alloc_dma, request_buffer_sz));
Linus Torvalds's avatar
Linus Torvalds committed
3546

3547
		b = (unsigned long) ioc->req_alloc;
Linus Torvalds's avatar
Linus Torvalds committed
3548 3549 3550 3551
		b = (b + (0x80UL - 1UL)) & ~(0x80UL - 1UL); /* round up to 128-byte boundary */
		aligned_mem = (u8 *) b;
		ioc->req_frames = (MPT_FRAME_HDR *) aligned_mem;
		ioc->req_frames_dma =
3552
			(ioc->req_alloc_dma + (aligned_mem - ioc->req_alloc));
Linus Torvalds's avatar
Linus Torvalds committed
3553

Pam Delaney's avatar
Pam Delaney committed
3554
		ioc->req_frames_low_dma = (u32) (ioc->req_frames_dma & 0xFFFFFFFF);
Linus Torvalds's avatar
Linus Torvalds committed
3555 3556 3557 3558 3559 3560 3561

#if defined(CONFIG_MTRR) && 0
		/*
		 *  Enable Write Combining MTRR for IOC's memory region.
		 *  (at least as much as we can; "size and base must be
		 *  multiples of 4 kiB"
		 */
3562 3563
		ioc->mtrr_reg = mtrr_add(ioc->fifo_pool,
					 ioc->fifo_pool_sz,
Linus Torvalds's avatar
Linus Torvalds committed
3564
					 MTRR_TYPE_WRCOMB, 1);
Pam Delaney's avatar
Pam Delaney committed
3565
		dprintk((MYIOC_s_INFO_FMT "MTRR region registered (base:size=%08x:%x)\n",
3566
				ioc->name, ioc->fifo_pool, ioc->fifo_pool_sz));
Linus Torvalds's avatar
Linus Torvalds committed
3567
#endif
3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580

	} /* ioc->fifo_pool == NULL */
	
	/* Post Reply frames to FIFO
	 */
	aligned_mem_dma = ioc->reply_frames_dma;
	dprintk((KERN_INFO MYNAM ": %s.reply_frames @ %p[%p]\n",
		 	ioc->name, ioc->reply_frames, (void *)(ulong)aligned_mem_dma));

	for (i = 0; i < ioc->reply_depth; i++) {
		/*  Write each address to the IOC!  */
		CHIPREG_WRITE32(&ioc->chip->ReplyFifo, aligned_mem_dma);
		aligned_mem_dma += ioc->reply_sz;
Pam Delaney's avatar
Pam Delaney committed
3581 3582
	}

3583

Pam Delaney's avatar
Pam Delaney committed
3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594
	/* Initialize Request frames linked list
	 */
	aligned_mem_dma = ioc->req_frames_dma;
	aligned_mem = (u8 *) ioc->req_frames;
	dprintk((KERN_INFO MYNAM ": %s.req_frames   @ %p[%p]\n",
		 	ioc->name, aligned_mem, (void *)(ulong)aligned_mem_dma));

	spin_lock_irqsave(&ioc->FreeQlock, flags);
	Q_INIT(&ioc->FreeQ, MPT_FRAME_HDR);
	for (i = 0; i < ioc->req_depth; i++) {
		mf = (MPT_FRAME_HDR *) aligned_mem;
Linus Torvalds's avatar
Linus Torvalds committed
3595

Pam Delaney's avatar
Pam Delaney committed
3596 3597 3598
		/*  Queue REQUESTs *internally*!  */
		Q_ADD_TAIL(&ioc->FreeQ.head, &mf->u.frame.linkage, MPT_FRAME_HDR);
		aligned_mem += ioc->req_sz;
Linus Torvalds's avatar
Linus Torvalds committed
3599
	}
Pam Delaney's avatar
Pam Delaney committed
3600 3601
	spin_unlock_irqrestore(&ioc->FreeQlock, flags);

Linus Torvalds's avatar
Linus Torvalds committed
3602 3603

	if (ioc->sense_buf_pool == NULL) {
Pam Delaney's avatar
Pam Delaney committed
3604
		sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
Linus Torvalds's avatar
Linus Torvalds committed
3605 3606 3607 3608 3609
		ioc->sense_buf_pool =
				pci_alloc_consistent(ioc->pcidev, sz, &ioc->sense_buf_pool_dma);
		if (ioc->sense_buf_pool == NULL)
			goto out_fail;

Pam Delaney's avatar
Pam Delaney committed
3610
		ioc->sense_buf_low_dma = (u32) (ioc->sense_buf_pool_dma & 0xFFFFFFFF);
Linus Torvalds's avatar
Linus Torvalds committed
3611 3612 3613 3614 3615 3616
		ioc->alloc_total += sz;
	}

	return 0;

out_fail:
3617
	if (ioc->fifo_pool != NULL) {
Linus Torvalds's avatar
Linus Torvalds committed
3618
		pci_free_consistent(ioc->pcidev,
3619 3620
				ioc->fifo_pool_sz,
				ioc->fifo_pool, ioc->fifo_pool_dma);
Linus Torvalds's avatar
Linus Torvalds committed
3621 3622
		ioc->reply_frames = NULL;
		ioc->reply_alloc = NULL;
3623 3624 3625 3626 3627
		ioc->req_frames = NULL;
		ioc->req_alloc = NULL;
		ioc->chain_alloc = NULL;
		ioc->fifo_pool = NULL;
		ioc->alloc_total -= ioc->fifo_pool_sz;
Linus Torvalds's avatar
Linus Torvalds committed
3628 3629 3630
#if defined(CONFIG_MTRR) && 0
		if (ioc->mtrr_reg > 0) {
			mtrr_del(ioc->mtrr_reg, 0, 0);
Pam Delaney's avatar
Pam Delaney committed
3631
			dprintk((MYIOC_s_INFO_FMT "MTRR region de-registered\n",
Linus Torvalds's avatar
Linus Torvalds committed
3632 3633 3634 3635 3636
					ioc->name));
		}
#endif
	}
	if (ioc->sense_buf_pool != NULL) {
Pam Delaney's avatar
Pam Delaney committed
3637
		sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
Linus Torvalds's avatar
Linus Torvalds committed
3638 3639 3640 3641 3642 3643 3644 3645 3646
		pci_free_consistent(ioc->pcidev,
				sz,
				ioc->sense_buf_pool, ioc->sense_buf_pool_dma);
		ioc->sense_buf_pool = NULL;
	}
	return -1;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Pam Delaney's avatar
Pam Delaney committed
3647
/**
3648 3649
 *	mpt_handshake_req_reply_wait - Send MPT request to and receive reply
 *	from IOC via doorbell handshake method.
Linus Torvalds's avatar
Linus Torvalds committed
3650 3651 3652 3653 3654
 *	@ioc: Pointer to MPT_ADAPTER structure
 *	@reqBytes: Size of the request in bytes
 *	@req: Pointer to MPT request frame
 *	@replyBytes: Expected size of the reply in bytes
 *	@u16reply: Pointer to area where reply should be written
Linus Torvalds's avatar
Linus Torvalds committed
3655
 *	@maxwait: Max wait time for a reply (in seconds)
Pam Delaney's avatar
Pam Delaney committed
3656
 *	@sleepFlag: Specifies whether the process can sleep
Linus Torvalds's avatar
Linus Torvalds committed
3657 3658 3659 3660 3661 3662 3663 3664
 *
 *	NOTES: It is the callers responsibility to byte-swap fields in the
 *	request which are greater than 1 byte in size.  It is also the
 *	callers responsibility to byte-swap response fields which are
 *	greater than 1 byte in size.
 *
 *	Returns 0 for success, non-zero for failure.
 */
Pam Delaney's avatar
Pam Delaney committed
3665 3666 3667
int
mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes, u32 *req,
				int replyBytes, u16 *u16reply, int maxwait, int sleepFlag)
Linus Torvalds's avatar
Linus Torvalds committed
3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692
{
	MPIDefaultReply_t *mptReply;
	int failcnt = 0;
	int t;

	/*
	 * Get ready to cache a handshake reply
	 */
	ioc->hs_reply_idx = 0;
	mptReply = (MPIDefaultReply_t *) ioc->hs_reply;
	mptReply->MsgLength = 0;

	/*
	 * Make sure there are no doorbells (WRITE 0 to IntStatus reg),
	 * then tell IOC that we want to handshake a request of N words.
	 * (WRITE u32val to Doorbell reg).
	 */
	CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
	CHIPREG_WRITE32(&ioc->chip->Doorbell,
			((MPI_FUNCTION_HANDSHAKE<<MPI_DOORBELL_FUNCTION_SHIFT) |
			 ((reqBytes/4)<<MPI_DOORBELL_ADD_DWORDS_SHIFT)));

	/*
	 * Wait for IOC's doorbell handshake int
	 */
Pam Delaney's avatar
Pam Delaney committed
3693
	if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
Linus Torvalds's avatar
Linus Torvalds committed
3694 3695
		failcnt++;

Pam Delaney's avatar
Pam Delaney committed
3696
	dhsprintk((MYIOC_s_INFO_FMT "HandShake request start, WaitCnt=%d%s\n",
Linus Torvalds's avatar
Linus Torvalds committed
3697 3698
			ioc->name, t, failcnt ? " - MISSING DOORBELL HANDSHAKE!" : ""));

Pam Delaney's avatar
Pam Delaney committed
3699 3700 3701 3702
	/* Read doorbell and check for active bit */
	if (!(CHIPREG_READ32(&ioc->chip->Doorbell) & MPI_DOORBELL_ACTIVE))
			return -1;

Linus Torvalds's avatar
Linus Torvalds committed
3703 3704 3705 3706 3707 3708
	/*
	 * Clear doorbell int (WRITE 0 to IntStatus reg),
	 * then wait for IOC to ACKnowledge that it's ready for
	 * our handshake request.
	 */
	CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
3709
	if (!failcnt && (t = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
Linus Torvalds's avatar
Linus Torvalds committed
3710 3711 3712
		failcnt++;

	if (!failcnt) {
Pam Delaney's avatar
Pam Delaney committed
3713
		int	 ii;
Linus Torvalds's avatar
Linus Torvalds committed
3714 3715 3716 3717 3718 3719
		u8	*req_as_bytes = (u8 *) req;

		/*
		 * Stuff request words via doorbell handshake,
		 * with ACK from IOC for each.
		 */
Pam Delaney's avatar
Pam Delaney committed
3720 3721 3722 3723 3724
		for (ii = 0; !failcnt && ii < reqBytes/4; ii++) {
			u32 word = ((req_as_bytes[(ii*4) + 0] <<  0) |
				    (req_as_bytes[(ii*4) + 1] <<  8) |
				    (req_as_bytes[(ii*4) + 2] << 16) |
				    (req_as_bytes[(ii*4) + 3] << 24));
Linus Torvalds's avatar
Linus Torvalds committed
3725 3726

			CHIPREG_WRITE32(&ioc->chip->Doorbell, word);
3727
			if ((t = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
Linus Torvalds's avatar
Linus Torvalds committed
3728 3729 3730 3731 3732 3733
				failcnt++;
		}

		dmfprintk((KERN_INFO MYNAM ": Handshake request frame (@%p) header\n", req));
		DBG_DUMP_REQUEST_FRAME_HDR(req)

Pam Delaney's avatar
Pam Delaney committed
3734
		dhsprintk((MYIOC_s_INFO_FMT "HandShake request post done, WaitCnt=%d%s\n",
Linus Torvalds's avatar
Linus Torvalds committed
3735 3736 3737 3738 3739
				ioc->name, t, failcnt ? " - MISSING DOORBELL ACK!" : ""));

		/*
		 * Wait for completion of doorbell handshake reply from the IOC
		 */
Pam Delaney's avatar
Pam Delaney committed
3740
		if (!failcnt && (t = WaitForDoorbellReply(ioc, maxwait, sleepFlag)) < 0)
Linus Torvalds's avatar
Linus Torvalds committed
3741
			failcnt++;
3742 3743 3744
		
		dhsprintk((MYIOC_s_INFO_FMT "HandShake reply count=%d%s\n",
				ioc->name, t, failcnt ? " - MISSING DOORBELL REPLY!" : ""));
Linus Torvalds's avatar
Linus Torvalds committed
3745 3746 3747 3748

		/*
		 * Copy out the cached reply...
		 */
3749
		for (ii=0; ii < min(replyBytes/2,mptReply->MsgLength*2); ii++)
Pam Delaney's avatar
Pam Delaney committed
3750
			u16reply[ii] = ioc->hs_reply[ii];
Linus Torvalds's avatar
Linus Torvalds committed
3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762
	} else {
		return -99;
	}

	return -failcnt;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	WaitForDoorbellAck - Wait for IOC to clear the IOP_DOORBELL_STATUS bit
 *	in it's IntStatus register.
 *	@ioc: Pointer to MPT_ADAPTER structure
Linus Torvalds's avatar
Linus Torvalds committed
3763
 *	@howlong: How long to wait (in seconds)
Pam Delaney's avatar
Pam Delaney committed
3764
 *	@sleepFlag: Specifies whether the process can sleep
Linus Torvalds's avatar
Linus Torvalds committed
3765
 *
Linus Torvalds's avatar
Linus Torvalds committed
3766
 *	This routine waits (up to ~2 seconds max) for IOC doorbell
Linus Torvalds's avatar
Linus Torvalds committed
3767 3768 3769 3770 3771
 *	handshake ACKnowledge.
 *
 *	Returns a negative value on failure, else wait loop count.
 */
static int
Pam Delaney's avatar
Pam Delaney committed
3772
WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
Linus Torvalds's avatar
Linus Torvalds committed
3773
{
3774
	int cntdn;
Linus Torvalds's avatar
Linus Torvalds committed
3775
	int count = 0;
3776
	u32 intstat=0;
Linus Torvalds's avatar
Linus Torvalds committed
3777

3778 3779
	cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * howlong;

Pam Delaney's avatar
Pam Delaney committed
3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796
	if (sleepFlag == CAN_SLEEP) {
		while (--cntdn) {
			intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
			if (! (intstat & MPI_HIS_IOP_DOORBELL_STATUS))
				break;
			set_current_state(TASK_INTERRUPTIBLE);
			schedule_timeout(1);
			count++;
		}
	} else {
		while (--cntdn) {
			intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
			if (! (intstat & MPI_HIS_IOP_DOORBELL_STATUS))
				break;
			mdelay (1);
			count++;
		}
Linus Torvalds's avatar
Linus Torvalds committed
3797 3798 3799
	}

	if (cntdn) {
3800
		dprintk((MYIOC_s_INFO_FMT "WaitForDoorbell ACK (count=%d)\n",
Linus Torvalds's avatar
Linus Torvalds committed
3801 3802 3803 3804
				ioc->name, count));
		return count;
	}

3805 3806
	printk(MYIOC_s_ERR_FMT "Doorbell ACK timeout (count=%d), IntStatus=%x!\n",
			ioc->name, count, intstat);
Linus Torvalds's avatar
Linus Torvalds committed
3807 3808 3809 3810 3811 3812 3813 3814
	return -1;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	WaitForDoorbellInt - Wait for IOC to set the HIS_DOORBELL_INTERRUPT bit
 *	in it's IntStatus register.
 *	@ioc: Pointer to MPT_ADAPTER structure
Linus Torvalds's avatar
Linus Torvalds committed
3815
 *	@howlong: How long to wait (in seconds)
Pam Delaney's avatar
Pam Delaney committed
3816
 *	@sleepFlag: Specifies whether the process can sleep
Linus Torvalds's avatar
Linus Torvalds committed
3817
 *
Linus Torvalds's avatar
Linus Torvalds committed
3818
 *	This routine waits (up to ~2 seconds max) for IOC doorbell interrupt.
Linus Torvalds's avatar
Linus Torvalds committed
3819 3820 3821 3822
 *
 *	Returns a negative value on failure, else wait loop count.
 */
static int
Pam Delaney's avatar
Pam Delaney committed
3823
WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
Linus Torvalds's avatar
Linus Torvalds committed
3824
{
3825
	int cntdn;
Linus Torvalds's avatar
Linus Torvalds committed
3826
	int count = 0;
3827
	u32 intstat=0;
Linus Torvalds's avatar
Linus Torvalds committed
3828

3829
	cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * howlong;
Pam Delaney's avatar
Pam Delaney committed
3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846
	if (sleepFlag == CAN_SLEEP) {
		while (--cntdn) {
			intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
			if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
				break;
			set_current_state(TASK_INTERRUPTIBLE);
			schedule_timeout(1);
			count++;
		}
	} else {
		while (--cntdn) {
			intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
			if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
				break;
			mdelay(1);
			count++;
		}
Linus Torvalds's avatar
Linus Torvalds committed
3847 3848 3849
	}

	if (cntdn) {
3850 3851
		dprintk((MYIOC_s_INFO_FMT "WaitForDoorbell INT (cnt=%d) howlong=%d\n",
				ioc->name, count, howlong));
Linus Torvalds's avatar
Linus Torvalds committed
3852 3853 3854
		return count;
	}

3855 3856
	printk(MYIOC_s_ERR_FMT "Doorbell INT timeout (count=%d), IntStatus=%x!\n",
			ioc->name, count, intstat);
Linus Torvalds's avatar
Linus Torvalds committed
3857 3858 3859 3860 3861 3862 3863
	return -1;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	WaitForDoorbellReply - Wait for and capture a IOC handshake reply.
 *	@ioc: Pointer to MPT_ADAPTER structure
Linus Torvalds's avatar
Linus Torvalds committed
3864
 *	@howlong: How long to wait (in seconds)
Pam Delaney's avatar
Pam Delaney committed
3865
 *	@sleepFlag: Specifies whether the process can sleep
Linus Torvalds's avatar
Linus Torvalds committed
3866 3867 3868 3869 3870 3871 3872 3873
 *
 *	This routine polls the IOC for a handshake reply, 16 bits at a time.
 *	Reply is cached to IOC private area large enough to hold a maximum
 *	of 128 bytes of reply data.
 *
 *	Returns a negative value on failure, else size of reply in WORDS.
 */
static int
Pam Delaney's avatar
Pam Delaney committed
3874
WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
Linus Torvalds's avatar
Linus Torvalds committed
3875 3876 3877 3878 3879
{
	int u16cnt = 0;
	int failcnt = 0;
	int t;
	u16 *hs_reply = ioc->hs_reply;
Pam Delaney's avatar
Pam Delaney committed
3880
	volatile MPIDefaultReply_t *mptReply = (MPIDefaultReply_t *) ioc->hs_reply;
Linus Torvalds's avatar
Linus Torvalds committed
3881 3882 3883 3884 3885 3886 3887
	u16 hword;

	hs_reply[0] = hs_reply[1] = hs_reply[7] = 0;

	/*
	 * Get first two u16's so we can look at IOC's intended reply MsgLength
	 */
Linus Torvalds's avatar
Linus Torvalds committed
3888
	u16cnt=0;
Pam Delaney's avatar
Pam Delaney committed
3889
	if ((t = WaitForDoorbellInt(ioc, howlong, sleepFlag)) < 0) {
Linus Torvalds's avatar
Linus Torvalds committed
3890 3891 3892
		failcnt++;
	} else {
		hs_reply[u16cnt++] = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
Linus Torvalds's avatar
Linus Torvalds committed
3893
		CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
3894
		if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
Linus Torvalds's avatar
Linus Torvalds committed
3895 3896 3897 3898 3899
			failcnt++;
		else {
			hs_reply[u16cnt++] = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
			CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
		}
Linus Torvalds's avatar
Linus Torvalds committed
3900 3901
	}

3902 3903
	dhsprintk((MYIOC_s_INFO_FMT "WaitCnt=%d First handshake reply word=%08x%s\n",
			ioc->name, t, le32_to_cpu(*(u32 *)hs_reply), 
Linus Torvalds's avatar
Linus Torvalds committed
3904 3905 3906 3907 3908 3909 3910
			failcnt ? " - MISSING DOORBELL HANDSHAKE!" : ""));

	/*
	 * If no error (and IOC said MsgLength is > 0), piece together
	 * reply 16 bits at a time.
	 */
	for (u16cnt=2; !failcnt && u16cnt < (2 * mptReply->MsgLength); u16cnt++) {
3911
		if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
Linus Torvalds's avatar
Linus Torvalds committed
3912 3913 3914 3915 3916 3917 3918 3919
			failcnt++;
		hword = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
		/* don't overflow our IOC hs_reply[] buffer! */
		if (u16cnt < sizeof(ioc->hs_reply) / sizeof(ioc->hs_reply[0]))
			hs_reply[u16cnt] = hword;
		CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
	}

3920
	if (!failcnt && (t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
Linus Torvalds's avatar
Linus Torvalds committed
3921 3922 3923 3924
		failcnt++;
	CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);

	if (failcnt) {
Pam Delaney's avatar
Pam Delaney committed
3925
		printk(MYIOC_s_ERR_FMT "Handshake reply failure!\n",
Linus Torvalds's avatar
Linus Torvalds committed
3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937
				ioc->name);
		return -failcnt;
	}
#if 0
	else if (u16cnt != (2 * mptReply->MsgLength)) {
		return -101;
	}
	else if ((mptReply->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
		return -102;
	}
#endif

Pam Delaney's avatar
Pam Delaney committed
3938
	dmfprintk((MYIOC_s_INFO_FMT "Got Handshake reply:\n", ioc->name));
Linus Torvalds's avatar
Linus Torvalds committed
3939 3940
	DBG_DUMP_REPLY_FRAME(mptReply)

3941 3942
	dhsprintk((MYIOC_s_INFO_FMT "WaitForDoorbell REPLY WaitCnt=%d (sz=%d)\n",
			ioc->name, t, u16cnt/2));
Linus Torvalds's avatar
Linus Torvalds committed
3943 3944 3945 3946 3947 3948 3949 3950
	return u16cnt/2;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	GetLanConfigPages - Fetch LANConfig pages.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *
Pam Delaney's avatar
Pam Delaney committed
3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995
 *	Return: 0 for success
 *	-ENOMEM if no memory available
 *		-EPERM if not allowed due to ISR context
 *		-EAGAIN if no msg frames currently available
 *		-EFAULT for non-successful reply or no reply (timeout)
 */
static int
GetLanConfigPages(MPT_ADAPTER *ioc)
{
	ConfigPageHeader_t	 hdr;
	CONFIGPARMS		 cfg;
	LANPage0_t		*ppage0_alloc;
	dma_addr_t		 page0_dma;
	LANPage1_t		*ppage1_alloc;
	dma_addr_t		 page1_dma;
	int			 rc = 0;
	int			 data_sz;
	int			 copy_sz;

	/* Get LAN Page 0 header */
	hdr.PageVersion = 0;
	hdr.PageLength = 0;
	hdr.PageNumber = 0;
	hdr.PageType = MPI_CONFIG_PAGETYPE_LAN;
	cfg.hdr = &hdr;
	cfg.physAddr = -1;
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
	cfg.dir = 0;
	cfg.pageAddr = 0;
	cfg.timeout = 0;

	if ((rc = mpt_config(ioc, &cfg)) != 0)
		return rc;

	if (hdr.PageLength > 0) {
		data_sz = hdr.PageLength * 4;
		ppage0_alloc = (LANPage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page0_dma);
		rc = -ENOMEM;
		if (ppage0_alloc) {
			memset((u8 *)ppage0_alloc, 0, data_sz);
			cfg.physAddr = page0_dma;
			cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;

			if ((rc = mpt_config(ioc, &cfg)) == 0) {
				/* save the data */
3996
				copy_sz = min_t(int, sizeof(LANPage0_t), data_sz);
Pam Delaney's avatar
Pam Delaney committed
3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040
				memcpy(&ioc->lan_cnfg_page0, ppage0_alloc, copy_sz);

			}

			pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage0_alloc, page0_dma);

			/* FIXME!
			 *	Normalize endianness of structure data,
			 *	by byte-swapping all > 1 byte fields!
			 */

		}

		if (rc)
			return rc;
	}

	/* Get LAN Page 1 header */
	hdr.PageVersion = 0;
	hdr.PageLength = 0;
	hdr.PageNumber = 1;
	hdr.PageType = MPI_CONFIG_PAGETYPE_LAN;
	cfg.hdr = &hdr;
	cfg.physAddr = -1;
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
	cfg.dir = 0;
	cfg.pageAddr = 0;

	if ((rc = mpt_config(ioc, &cfg)) != 0)
		return rc;

	if (hdr.PageLength == 0)
		return 0;

	data_sz = hdr.PageLength * 4;
	rc = -ENOMEM;
	ppage1_alloc = (LANPage1_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page1_dma);
	if (ppage1_alloc) {
		memset((u8 *)ppage1_alloc, 0, data_sz);
		cfg.physAddr = page1_dma;
		cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;

		if ((rc = mpt_config(ioc, &cfg)) == 0) {
			/* save the data */
4041
			copy_sz = min_t(int, sizeof(LANPage1_t), data_sz);
Pam Delaney's avatar
Pam Delaney committed
4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109
			memcpy(&ioc->lan_cnfg_page1, ppage1_alloc, copy_sz);
		}

		pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage1_alloc, page1_dma);

		/* FIXME!
		 *	Normalize endianness of structure data,
		 *	by byte-swapping all > 1 byte fields!
		 */

	}

	return rc;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	GetFcPortPage0 - Fetch FCPort config Page0.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *	@portnum: IOC Port number
 *
 *	Return: 0 for success
 *	-ENOMEM if no memory available
 *		-EPERM if not allowed due to ISR context
 *		-EAGAIN if no msg frames currently available
 *		-EFAULT for non-successful reply or no reply (timeout)
 */
static int
GetFcPortPage0(MPT_ADAPTER *ioc, int portnum)
{
	ConfigPageHeader_t	 hdr;
	CONFIGPARMS		 cfg;
	FCPortPage0_t		*ppage0_alloc;
	FCPortPage0_t		*pp0dest;
	dma_addr_t		 page0_dma;
	int			 data_sz;
	int			 copy_sz;
	int			 rc;

	/* Get FCPort Page 0 header */
	hdr.PageVersion = 0;
	hdr.PageLength = 0;
	hdr.PageNumber = 0;
	hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT;
	cfg.hdr = &hdr;
	cfg.physAddr = -1;
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
	cfg.dir = 0;
	cfg.pageAddr = portnum;
	cfg.timeout = 0;

	if ((rc = mpt_config(ioc, &cfg)) != 0)
		return rc;

	if (hdr.PageLength == 0)
		return 0;

	data_sz = hdr.PageLength * 4;
	rc = -ENOMEM;
	ppage0_alloc = (FCPortPage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page0_dma);
	if (ppage0_alloc) {
		memset((u8 *)ppage0_alloc, 0, data_sz);
		cfg.physAddr = page0_dma;
		cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;

		if ((rc = mpt_config(ioc, &cfg)) == 0) {
			/* save the data */
			pp0dest = &ioc->fc_port_page0[portnum];
4110
			copy_sz = min_t(int, sizeof(FCPortPage0_t), data_sz);
Pam Delaney's avatar
Pam Delaney committed
4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222
			memcpy(pp0dest, ppage0_alloc, copy_sz);

			/*
			 *	Normalize endianness of structure data,
			 *	by byte-swapping all > 1 byte fields!
			 */
			pp0dest->Flags = le32_to_cpu(pp0dest->Flags);
			pp0dest->PortIdentifier = le32_to_cpu(pp0dest->PortIdentifier);
			pp0dest->WWNN.Low = le32_to_cpu(pp0dest->WWNN.Low);
			pp0dest->WWNN.High = le32_to_cpu(pp0dest->WWNN.High);
			pp0dest->WWPN.Low = le32_to_cpu(pp0dest->WWPN.Low);
			pp0dest->WWPN.High = le32_to_cpu(pp0dest->WWPN.High);
			pp0dest->SupportedServiceClass = le32_to_cpu(pp0dest->SupportedServiceClass);
			pp0dest->SupportedSpeeds = le32_to_cpu(pp0dest->SupportedSpeeds);
			pp0dest->CurrentSpeed = le32_to_cpu(pp0dest->CurrentSpeed);
			pp0dest->MaxFrameSize = le32_to_cpu(pp0dest->MaxFrameSize);
			pp0dest->FabricWWNN.Low = le32_to_cpu(pp0dest->FabricWWNN.Low);
			pp0dest->FabricWWNN.High = le32_to_cpu(pp0dest->FabricWWNN.High);
			pp0dest->FabricWWPN.Low = le32_to_cpu(pp0dest->FabricWWPN.Low);
			pp0dest->FabricWWPN.High = le32_to_cpu(pp0dest->FabricWWPN.High);
			pp0dest->DiscoveredPortsCount = le32_to_cpu(pp0dest->DiscoveredPortsCount);
			pp0dest->MaxInitiators = le32_to_cpu(pp0dest->MaxInitiators);

		}

		pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage0_alloc, page0_dma);
	}

	return rc;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	GetIoUnitPage2 - Retrieve BIOS version and boot order information.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *
 *	Returns: 0 for success
 *	-ENOMEM if no memory available
 *		-EPERM if not allowed due to ISR context
 *		-EAGAIN if no msg frames currently available
 *		-EFAULT for non-successful reply or no reply (timeout)
 */
static int
GetIoUnitPage2(MPT_ADAPTER *ioc)
{
	ConfigPageHeader_t	 hdr;
	CONFIGPARMS		 cfg;
	IOUnitPage2_t		*ppage_alloc;
	dma_addr_t		 page_dma;
	int			 data_sz;
	int			 rc;

	/* Get the page header */
	hdr.PageVersion = 0;
	hdr.PageLength = 0;
	hdr.PageNumber = 2;
	hdr.PageType = MPI_CONFIG_PAGETYPE_IO_UNIT;
	cfg.hdr = &hdr;
	cfg.physAddr = -1;
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
	cfg.dir = 0;
	cfg.pageAddr = 0;
	cfg.timeout = 0;

	if ((rc = mpt_config(ioc, &cfg)) != 0)
		return rc;

	if (hdr.PageLength == 0)
		return 0;

	/* Read the config page */
	data_sz = hdr.PageLength * 4;
	rc = -ENOMEM;
	ppage_alloc = (IOUnitPage2_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
	if (ppage_alloc) {
		memset((u8 *)ppage_alloc, 0, data_sz);
		cfg.physAddr = page_dma;
		cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;

		/* If Good, save data */
		if ((rc = mpt_config(ioc, &cfg)) == 0)
			ioc->biosVersion = le32_to_cpu(ppage_alloc->BiosVersion);

		pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage_alloc, page_dma);
	}

	return rc;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*	mpt_GetScsiPortSettings - read SCSI Port Page 0 and 2
 *	@ioc: Pointer to a Adapter Strucutre
 *	@portnum: IOC port number
 *
 *	Return: -EFAULT if read of config page header fails
 *			or if no nvram
 *	If read of SCSI Port Page 0 fails,
 *		NVRAM = MPT_HOST_NVRAM_INVALID  (0xFFFFFFFF)
 *		Adapter settings: async, narrow
 *		Return 1
 *	If read of SCSI Port Page 2 fails,
 *		Adapter settings valid
 *		NVRAM = MPT_HOST_NVRAM_INVALID  (0xFFFFFFFF)
 *		Return 1
 *	Else
 *		Both valid
 *		Return 0
 *	CHECK - what type of locking mechanisms should be used????
 */
static int
mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum)
{
4223
	u8			*pbuf;
Pam Delaney's avatar
Pam Delaney committed
4224 4225 4226 4227 4228 4229
	dma_addr_t		 buf_dma;
	CONFIGPARMS		 cfg;
	ConfigPageHeader_t	 header;
	int			 ii;
	int			 data, rc = 0;

4230
	/* Allocate memory
Pam Delaney's avatar
Pam Delaney committed
4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284
	 */
	if (!ioc->spi_data.nvram) {
		int	 sz;
		u8	*mem;
		sz = MPT_MAX_SCSI_DEVICES * sizeof(int);
		mem = kmalloc(sz, GFP_ATOMIC);
		if (mem == NULL)
			return -EFAULT;

		ioc->spi_data.nvram = (int *) mem;

		dprintk((MYIOC_s_INFO_FMT "SCSI device NVRAM settings @ %p, sz=%d\n",
			ioc->name, ioc->spi_data.nvram, sz));
	}

	/* Invalidate NVRAM information
	 */
	for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
		ioc->spi_data.nvram[ii] = MPT_HOST_NVRAM_INVALID;
	}

	/* Read SPP0 header, allocate memory, then read page.
	 */
	header.PageVersion = 0;
	header.PageLength = 0;
	header.PageNumber = 0;
	header.PageType = MPI_CONFIG_PAGETYPE_SCSI_PORT;
	cfg.hdr = &header;
	cfg.physAddr = -1;
	cfg.pageAddr = portnum;
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
	cfg.dir = 0;
	cfg.timeout = 0;	/* use default */
	if (mpt_config(ioc, &cfg) != 0)
		 return -EFAULT;

	if (header.PageLength > 0) {
		pbuf = pci_alloc_consistent(ioc->pcidev, header.PageLength * 4, &buf_dma);
		if (pbuf) {
			cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
			cfg.physAddr = buf_dma;
			if (mpt_config(ioc, &cfg) != 0) {
				ioc->spi_data.maxBusWidth = MPT_NARROW;
				ioc->spi_data.maxSyncOffset = 0;
				ioc->spi_data.minSyncFactor = MPT_ASYNC;
				ioc->spi_data.busType = MPT_HOST_BUS_UNKNOWN;
				rc = 1;
			} else {
				/* Save the Port Page 0 data
				 */
				SCSIPortPage0_t  *pPP0 = (SCSIPortPage0_t  *) pbuf;
				pPP0->Capabilities = le32_to_cpu(pPP0->Capabilities);
				pPP0->PhysicalInterface = le32_to_cpu(pPP0->PhysicalInterface);

4285 4286 4287
				if ( (pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_QAS) == 0 )
					ioc->spi_data.noQas |= MPT_TARGET_NO_NEGO_QAS;

Pam Delaney's avatar
Pam Delaney committed
4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347
				ioc->spi_data.maxBusWidth = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_WIDE ? 1 : 0;
				data = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_MAX_SYNC_OFFSET_MASK;
				if (data) {
					ioc->spi_data.maxSyncOffset = (u8) (data >> 16);
					data = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_MIN_SYNC_PERIOD_MASK;
					ioc->spi_data.minSyncFactor = (u8) (data >> 8);
				} else {
					ioc->spi_data.maxSyncOffset = 0;
					ioc->spi_data.minSyncFactor = MPT_ASYNC;
				}

				ioc->spi_data.busType = pPP0->PhysicalInterface & MPI_SCSIPORTPAGE0_PHY_SIGNAL_TYPE_MASK;

				/* Update the minSyncFactor based on bus type.
				 */
				if ((ioc->spi_data.busType == MPI_SCSIPORTPAGE0_PHY_SIGNAL_HVD) ||
					(ioc->spi_data.busType == MPI_SCSIPORTPAGE0_PHY_SIGNAL_SE))  {

					if (ioc->spi_data.minSyncFactor < MPT_ULTRA)
						ioc->spi_data.minSyncFactor = MPT_ULTRA;
				}
			}
			if (pbuf) {
				pci_free_consistent(ioc->pcidev, header.PageLength * 4, pbuf, buf_dma);
			}
		}
	}

	/* SCSI Port Page 2 - Read the header then the page.
	 */
	header.PageVersion = 0;
	header.PageLength = 0;
	header.PageNumber = 2;
	header.PageType = MPI_CONFIG_PAGETYPE_SCSI_PORT;
	cfg.hdr = &header;
	cfg.physAddr = -1;
	cfg.pageAddr = portnum;
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
	cfg.dir = 0;
	if (mpt_config(ioc, &cfg) != 0)
		return -EFAULT;

	if (header.PageLength > 0) {
		/* Allocate memory and read SCSI Port Page 2
		 */
		pbuf = pci_alloc_consistent(ioc->pcidev, header.PageLength * 4, &buf_dma);
		if (pbuf) {
			cfg.action = MPI_CONFIG_ACTION_PAGE_READ_NVRAM;
			cfg.physAddr = buf_dma;
			if (mpt_config(ioc, &cfg) != 0) {
				/* Nvram data is left with INVALID mark
				 */
				rc = 1;
			} else {
				SCSIPortPage2_t *pPP2 = (SCSIPortPage2_t  *) pbuf;
				MpiDeviceInfo_t	*pdevice = NULL;

				/* Save the Port Page 2 data
				 * (reformat into a 32bit quantity)
				 */
4348 4349
				data = le32_to_cpu(pPP2->PortFlags) & MPI_SCSIPORTPAGE2_PORT_FLAGS_DV_MASK;
				ioc->spi_data.PortFlags = data;
Pam Delaney's avatar
Pam Delaney committed
4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411
				for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
					pdevice = &pPP2->DeviceSettings[ii];
					data = (le16_to_cpu(pdevice->DeviceFlags) << 16) |
						(pdevice->SyncFactor << 8) | pdevice->Timeout;
					ioc->spi_data.nvram[ii] = data;
				}
			}

			pci_free_consistent(ioc->pcidev, header.PageLength * 4, pbuf, buf_dma);
		}
	}

	/* Update Adapter limits with those from NVRAM
	 * Comment: Don't need to do this. Target performance
	 * parameters will never exceed the adapters limits.
	 */

	return rc;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*	mpt_readScsiDevicePageHeaders - save version and length of SDP1
 *	@ioc: Pointer to a Adapter Strucutre
 *	@portnum: IOC port number
 *
 *	Return: -EFAULT if read of config page header fails
 *		or 0 if success.
 */
static int
mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum)
{
	CONFIGPARMS		 cfg;
	ConfigPageHeader_t	 header;

	/* Read the SCSI Device Page 1 header
	 */
	header.PageVersion = 0;
	header.PageLength = 0;
	header.PageNumber = 1;
	header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
	cfg.hdr = &header;
	cfg.physAddr = -1;
	cfg.pageAddr = portnum;
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
	cfg.dir = 0;
	cfg.timeout = 0;
	if (mpt_config(ioc, &cfg) != 0)
		 return -EFAULT;

	ioc->spi_data.sdp1version = cfg.hdr->PageVersion;
	ioc->spi_data.sdp1length = cfg.hdr->PageLength;

	header.PageVersion = 0;
	header.PageLength = 0;
	header.PageNumber = 0;
	header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
	if (mpt_config(ioc, &cfg) != 0)
		 return -EFAULT;

	ioc->spi_data.sdp0version = cfg.hdr->PageVersion;
	ioc->spi_data.sdp0length = cfg.hdr->PageLength;

4412 4413 4414 4415 4416
	dcprintk((MYIOC_s_INFO_FMT "Headers: 0: version %d length %d\n",
			ioc->name, ioc->spi_data.sdp0version, ioc->spi_data.sdp0length));

	dcprintk((MYIOC_s_INFO_FMT "Headers: 1: version %d length %d\n",
			ioc->name, ioc->spi_data.sdp1version, ioc->spi_data.sdp1length));
Pam Delaney's avatar
Pam Delaney committed
4417 4418 4419 4420 4421
	return 0;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
4422
 *	mpt_findImVolumes - Identify IDs of hidden disks and RAID Volumes
Pam Delaney's avatar
Pam Delaney committed
4423 4424 4425 4426 4427 4428 4429
 *	@ioc: Pointer to a Adapter Strucutre
 *	@portnum: IOC port number
 *
 *	Return:
 *	0 on success
 *	-EFAULT if read of config page header fails or data pointer not NULL
 *	-ENOMEM if pci_alloc failed
Linus Torvalds's avatar
Linus Torvalds committed
4430
 */
4431
int
Pam Delaney's avatar
Pam Delaney committed
4432
mpt_findImVolumes(MPT_ADAPTER *ioc)
Linus Torvalds's avatar
Linus Torvalds committed
4433
{
4434 4435 4436
	IOCPage2_t		*pIoc2;
	u8			*mem;
	ConfigPageIoc2RaidVol_t	*pIocRv;
Pam Delaney's avatar
Pam Delaney committed
4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467
	dma_addr_t		 ioc2_dma;
	CONFIGPARMS		 cfg;
	ConfigPageHeader_t	 header;
	int			 jj;
	int			 rc = 0;
	int			 iocpage2sz;
	u8			 nVols, nPhys;
	u8			 vid, vbus, vioc;

	/* Read IOCP2 header then the page.
	 */
	header.PageVersion = 0;
	header.PageLength = 0;
	header.PageNumber = 2;
	header.PageType = MPI_CONFIG_PAGETYPE_IOC;
	cfg.hdr = &header;
	cfg.physAddr = -1;
	cfg.pageAddr = 0;
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
	cfg.dir = 0;
	cfg.timeout = 0;
	if (mpt_config(ioc, &cfg) != 0)
		 return -EFAULT;

	if (header.PageLength == 0)
		return -EFAULT;

	iocpage2sz = header.PageLength * 4;
	pIoc2 = pci_alloc_consistent(ioc->pcidev, iocpage2sz, &ioc2_dma);
	if (!pIoc2)
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
4468

Pam Delaney's avatar
Pam Delaney committed
4469 4470 4471 4472
	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
	cfg.physAddr = ioc2_dma;
	if (mpt_config(ioc, &cfg) != 0)
		goto done_and_free;
Linus Torvalds's avatar
Linus Torvalds committed
4473

4474 4475 4476 4477 4478 4479 4480 4481 4482 4483
	if ( (mem = (u8 *)ioc->spi_data.pIocPg2) == NULL ) {
		mem = kmalloc(iocpage2sz, GFP_ATOMIC);
		if (mem) {
			ioc->spi_data.pIocPg2 = (IOCPage2_t *) mem;
		} else {
			goto done_and_free;
		}
	}
	memcpy(mem, (u8 *)pIoc2, iocpage2sz);

Pam Delaney's avatar
Pam Delaney committed
4484 4485 4486
	/* Identify RAID Volume Id's */
	nVols = pIoc2->NumActiveVolumes;
	if ( nVols == 0) {
4487
		/* No RAID Volume.
Pam Delaney's avatar
Pam Delaney committed
4488
		 */
4489
		goto done_and_free;
Pam Delaney's avatar
Pam Delaney committed
4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509
	} else {
		/* At least 1 RAID Volume
		 */
		pIocRv = pIoc2->RaidVolume;
		ioc->spi_data.isRaid = 0;
		for (jj = 0; jj < nVols; jj++, pIocRv++) {
			vid = pIocRv->VolumeID;
			vbus = pIocRv->VolumeBus;
			vioc = pIocRv->VolumeIOC;

			/* find the match
			 */
			if (vbus == 0) {
				ioc->spi_data.isRaid |= (1 << vid);
			} else {
				/* Error! Always bus 0
				 */
			}
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
4510

Pam Delaney's avatar
Pam Delaney committed
4511 4512 4513
	/* Identify Hidden Physical Disk Id's */
	nPhys = pIoc2->NumActivePhysDisks;
	if (nPhys == 0) {
4514
		/* No physical disks.
Pam Delaney's avatar
Pam Delaney committed
4515 4516
		 */
	} else {
4517
		mpt_read_ioc_pg_3(ioc);
Pam Delaney's avatar
Pam Delaney committed
4518
	}
Linus Torvalds's avatar
Linus Torvalds committed
4519

Pam Delaney's avatar
Pam Delaney committed
4520
done_and_free:
4521
	pci_free_consistent(ioc->pcidev, iocpage2sz, pIoc2, ioc2_dma);
Linus Torvalds's avatar
Linus Torvalds committed
4522

4523 4524 4525 4526 4527 4528
	return rc;
}

int
mpt_read_ioc_pg_3(MPT_ADAPTER *ioc)
{
4529
	IOCPage3_t		*pIoc3;
4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581
	u8			*mem;
	CONFIGPARMS		 cfg;
	ConfigPageHeader_t	 header;
	dma_addr_t		 ioc3_dma;
	int			 iocpage3sz = 0;

	/* Free the old page
	 */
	if (ioc->spi_data.pIocPg3) {
		kfree(ioc->spi_data.pIocPg3);
		ioc->spi_data.pIocPg3 = NULL;
	}

	/* There is at least one physical disk.
	 * Read and save IOC Page 3
	 */
	header.PageVersion = 0;
	header.PageLength = 0;
	header.PageNumber = 3;
	header.PageType = MPI_CONFIG_PAGETYPE_IOC;
	cfg.hdr = &header;
	cfg.physAddr = -1;
	cfg.pageAddr = 0;
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
	cfg.dir = 0;
	cfg.timeout = 0;
	if (mpt_config(ioc, &cfg) != 0)
		return 0;

	if (header.PageLength == 0)
		return 0;

	/* Read Header good, alloc memory
	 */
	iocpage3sz = header.PageLength * 4;
	pIoc3 = pci_alloc_consistent(ioc->pcidev, iocpage3sz, &ioc3_dma);
	if (!pIoc3)
		return 0;

	/* Read the Page and save the data
	 * into malloc'd memory.
	 */
	cfg.physAddr = ioc3_dma;
	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
	if (mpt_config(ioc, &cfg) == 0) {
		mem = kmalloc(iocpage3sz, GFP_ATOMIC);
		if (mem) {
			memcpy(mem, (u8 *)pIoc3, iocpage3sz);
			ioc->spi_data.pIocPg3 = (IOCPage3_t *) mem;
		}
	}

4582
	pci_free_consistent(ioc->pcidev, iocpage3sz, pIoc3, ioc3_dma);
Pam Delaney's avatar
Pam Delaney committed
4583

4584
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
4585 4586
}

4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637
static void
mpt_read_ioc_pg_4(MPT_ADAPTER *ioc)
{
	IOCPage4_t		*pIoc4;
	CONFIGPARMS		 cfg;
	ConfigPageHeader_t	 header;
	dma_addr_t		 ioc4_dma;
	int			 iocpage4sz;

	/* Read and save IOC Page 4
	 */
	header.PageVersion = 0;
	header.PageLength = 0;
	header.PageNumber = 4;
	header.PageType = MPI_CONFIG_PAGETYPE_IOC;
	cfg.hdr = &header;
	cfg.physAddr = -1;
	cfg.pageAddr = 0;
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
	cfg.dir = 0;
	cfg.timeout = 0;
	if (mpt_config(ioc, &cfg) != 0)
		return;

	if (header.PageLength == 0)
		return;

	if ( (pIoc4 = ioc->spi_data.pIocPg4) == NULL ) {
		iocpage4sz = (header.PageLength + 4) * 4; /* Allow 4 additional SEP's */
		pIoc4 = pci_alloc_consistent(ioc->pcidev, iocpage4sz, &ioc4_dma);
		if (!pIoc4)
			return;
	} else {
		ioc4_dma = ioc->spi_data.IocPg4_dma;
		iocpage4sz = ioc->spi_data.IocPg4Sz;
	}

	/* Read the Page into dma memory.
	 */
	cfg.physAddr = ioc4_dma;
	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
	if (mpt_config(ioc, &cfg) == 0) {
		ioc->spi_data.pIocPg4 = (IOCPage4_t *) pIoc4;
		ioc->spi_data.IocPg4_dma = ioc4_dma;
		ioc->spi_data.IocPg4Sz = iocpage4sz;
	} else {
		pci_free_consistent(ioc->pcidev, iocpage4sz, pIoc4, ioc4_dma);
		ioc->spi_data.pIocPg4 = NULL;
	}
}

4638 4639 4640
static void
mpt_read_ioc_pg_1(MPT_ADAPTER *ioc)
{
4641
	IOCPage1_t		*pIoc1;
4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716
	CONFIGPARMS		 cfg;
	ConfigPageHeader_t	 header;
	dma_addr_t		 ioc1_dma;
	int			 iocpage1sz = 0;
	u32			 tmp;

	/* Check the Coalescing Timeout in IOC Page 1
	 */
	header.PageVersion = 0;
	header.PageLength = 0;
	header.PageNumber = 1;
	header.PageType = MPI_CONFIG_PAGETYPE_IOC;
	cfg.hdr = &header;
	cfg.physAddr = -1;
	cfg.pageAddr = 0;
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
	cfg.dir = 0;
	cfg.timeout = 0;
	if (mpt_config(ioc, &cfg) != 0)
		return;

	if (header.PageLength == 0)
		return;

	/* Read Header good, alloc memory
	 */
	iocpage1sz = header.PageLength * 4;
	pIoc1 = pci_alloc_consistent(ioc->pcidev, iocpage1sz, &ioc1_dma);
	if (!pIoc1)
		return;

	/* Read the Page and check coalescing timeout
	 */
	cfg.physAddr = ioc1_dma;
	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
	if (mpt_config(ioc, &cfg) == 0) {
		
		tmp = le32_to_cpu(pIoc1->Flags) & MPI_IOCPAGE1_REPLY_COALESCING;
		if (tmp == MPI_IOCPAGE1_REPLY_COALESCING) {
			tmp = le32_to_cpu(pIoc1->CoalescingTimeout);

			dprintk((MYIOC_s_INFO_FMT "Coalescing Enabled Timeout = %d\n",
					ioc->name, tmp));

			if (tmp > MPT_COALESCING_TIMEOUT) {
				pIoc1->CoalescingTimeout = cpu_to_le32(MPT_COALESCING_TIMEOUT);

				/* Write NVRAM and current
				 */
				cfg.dir = 1;
				cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
				if (mpt_config(ioc, &cfg) == 0) {
					dprintk((MYIOC_s_INFO_FMT "Reset Current Coalescing Timeout to = %d\n",
							ioc->name, MPT_COALESCING_TIMEOUT));

					cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM;
					if (mpt_config(ioc, &cfg) == 0) {
						dprintk((MYIOC_s_INFO_FMT "Reset NVRAM Coalescing Timeout to = %d\n",
								ioc->name, MPT_COALESCING_TIMEOUT));
					} else {
						dprintk((MYIOC_s_INFO_FMT "Reset NVRAM Coalescing Timeout Failed\n",
									ioc->name));
					}

				} else {
					dprintk((MYIOC_s_WARN_FMT "Reset of Current Coalescing Timeout Failed!\n",
								ioc->name));
				}
			}

		} else {
			dprintk((MYIOC_s_WARN_FMT "Coalescing Disabled\n", ioc->name));
		}
	}

4717
	pci_free_consistent(ioc->pcidev, iocpage1sz, pIoc1, ioc1_dma);
4718 4719 4720

	return;
}
Pam Delaney's avatar
Pam Delaney committed
4721

Linus Torvalds's avatar
Linus Torvalds committed
4722
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Pam Delaney's avatar
Pam Delaney committed
4723
/*
Linus Torvalds's avatar
Linus Torvalds committed
4724 4725 4726 4727 4728 4729 4730 4731 4732 4733
 *	SendEventNotification - Send EventNotification (on or off) request
 *	to MPT adapter.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *	@EvSwitch: Event switch flags
 */
static int
SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch)
{
	EventNotification_t	*evnp;

4734
	evnp = (EventNotification_t *) mpt_get_msg_frame(mpt_base_index, ioc);
Linus Torvalds's avatar
Linus Torvalds committed
4735
	if (evnp == NULL) {
Pam Delaney's avatar
Pam Delaney committed
4736
		dprintk((MYIOC_s_WARN_FMT "Unable to allocate event request frame!\n",
Linus Torvalds's avatar
Linus Torvalds committed
4737 4738 4739 4740 4741
				ioc->name));
		return 0;
	}
	memset(evnp, 0, sizeof(*evnp));

Pam Delaney's avatar
Pam Delaney committed
4742
	dprintk((MYIOC_s_INFO_FMT "Sending EventNotification(%d)\n", ioc->name, EvSwitch));
Linus Torvalds's avatar
Linus Torvalds committed
4743 4744 4745 4746 4747 4748

	evnp->Function = MPI_FUNCTION_EVENT_NOTIFICATION;
	evnp->ChainOffset = 0;
	evnp->MsgFlags = 0;
	evnp->Switch = EvSwitch;

4749
	mpt_put_msg_frame(mpt_base_index, ioc, (MPT_FRAME_HDR *)evnp);
Linus Torvalds's avatar
Linus Torvalds committed
4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764

	return 0;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	SendEventAck - Send EventAck request to MPT adapter.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *	@evnp: Pointer to original EventNotification request
 */
static int
SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp)
{
	EventAck_t	*pAck;

4765
	if ((pAck = (EventAck_t *) mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
Pam Delaney's avatar
Pam Delaney committed
4766
		printk(MYIOC_s_WARN_FMT "Unable to allocate event ACK request frame!\n",
Linus Torvalds's avatar
Linus Torvalds committed
4767 4768 4769 4770 4771
				ioc->name);
		return -1;
	}
	memset(pAck, 0, sizeof(*pAck));

Pam Delaney's avatar
Pam Delaney committed
4772
	dprintk((MYIOC_s_INFO_FMT "Sending EventAck\n", ioc->name));
Linus Torvalds's avatar
Linus Torvalds committed
4773 4774 4775 4776 4777 4778 4779

	pAck->Function     = MPI_FUNCTION_EVENT_ACK;
	pAck->ChainOffset  = 0;
	pAck->MsgFlags     = 0;
	pAck->Event        = evnp->Event;
	pAck->EventContext = evnp->EventContext;

4780
	mpt_put_msg_frame(mpt_base_index, ioc, (MPT_FRAME_HDR *)pAck);
Linus Torvalds's avatar
Linus Torvalds committed
4781 4782 4783 4784

	return 0;
}

Pam Delaney's avatar
Pam Delaney committed
4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_config - Generic function to issue config message
 *	@ioc - Pointer to an adapter structure
 *	@cfg - Pointer to a configuration structure. Struct contains
 *		action, page address, direction, physical address
 *		and pointer to a configuration page header
 *		Page header is updated.
 *
 *	Returns 0 for success
 *	-EPERM if not allowed due to ISR context
 *	-EAGAIN if no msg frames currently available
 *	-EFAULT for non-successful reply or no reply (timeout)
 */
int
mpt_config(MPT_ADAPTER *ioc, CONFIGPARMS *pCfg)
{
	Config_t	*pReq;
	MPT_FRAME_HDR	*mf;
	unsigned long	 flags;
	int		 ii, rc;
4806
	u32		 flagsLength;
Pam Delaney's avatar
Pam Delaney committed
4807 4808 4809 4810 4811 4812 4813 4814 4815
	int		 in_isr;

	/* (Bugzilla:fibrebugs, #513)
	 * Bug fix (part 1)!  20010905 -sralston
	 *	Prevent calling wait_event() (below), if caller happens
	 *	to be in ISR context, because that is fatal!
	 */
	in_isr = in_interrupt();
	if (in_isr) {
4816
		dcprintk((MYIOC_s_WARN_FMT "Config request not allowed in ISR context!\n",
Pam Delaney's avatar
Pam Delaney committed
4817 4818 4819 4820 4821 4822
				ioc->name));
		return -EPERM;
	}

	/* Get and Populate a free Frame
	 */
4823
	if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
4824
		dcprintk((MYIOC_s_WARN_FMT "mpt_config: no msg frames!\n",
Pam Delaney's avatar
Pam Delaney committed
4825 4826 4827 4828 4829 4830 4831 4832
				ioc->name));
		return -EAGAIN;
	}
	pReq = (Config_t *)mf;
	pReq->Action = pCfg->action;
	pReq->Reserved = 0;
	pReq->ChainOffset = 0;
	pReq->Function = MPI_FUNCTION_CONFIG;
4833 4834
	pReq->ExtPageLength = 0;
	pReq->ExtPageType = 0;
Pam Delaney's avatar
Pam Delaney committed
4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855
	pReq->MsgFlags = 0;
	for (ii=0; ii < 8; ii++)
		pReq->Reserved2[ii] = 0;

	pReq->Header.PageVersion = pCfg->hdr->PageVersion;
	pReq->Header.PageLength = pCfg->hdr->PageLength;
	pReq->Header.PageNumber = pCfg->hdr->PageNumber;
	pReq->Header.PageType = (pCfg->hdr->PageType & MPI_CONFIG_PAGETYPE_MASK);
	pReq->PageAddress = cpu_to_le32(pCfg->pageAddr);

	/* Add a SGE to the config request.
	 */
	if (pCfg->dir)
		flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
	else
		flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;

	flagsLength |= pCfg->hdr->PageLength * 4;

	mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, pCfg->physAddr);

4856
	dcprintk((MYIOC_s_INFO_FMT "Sending Config request type %d, page %d and action %d\n",
Pam Delaney's avatar
Pam Delaney committed
4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881
		ioc->name, pReq->Header.PageType, pReq->Header.PageNumber, pReq->Action));

	/* Append pCfg pointer to end of mf
	 */
	*((void **) (((u8 *) mf) + (ioc->req_sz - sizeof(void *)))) =  (void *) pCfg;

	/* Initalize the timer
	 */
	init_timer(&pCfg->timer);
	pCfg->timer.data = (unsigned long) ioc;
	pCfg->timer.function = mpt_timer_expired;
	pCfg->wait_done = 0;

	/* Set the timer; ensure 10 second minimum */
	if (pCfg->timeout < 10)
		pCfg->timer.expires = jiffies + HZ*10;
	else
		pCfg->timer.expires = jiffies + HZ*pCfg->timeout;

	/* Add to end of Q, set timer and then issue this command */
	spin_lock_irqsave(&ioc->FreeQlock, flags);
	Q_ADD_TAIL(&ioc->configQ.head, &pCfg->linkage, Q_ITEM);
	spin_unlock_irqrestore(&ioc->FreeQlock, flags);

	add_timer(&pCfg->timer);
4882
	mpt_put_msg_frame(mpt_base_index, ioc, mf);
Pam Delaney's avatar
Pam Delaney committed
4883 4884 4885 4886 4887 4888 4889 4890 4891
	wait_event(mpt_waitq, pCfg->wait_done);

	/* mf has been freed - do not access */

	rc = pCfg->status;

	return rc;
}

4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_toolbox - Generic function to issue toolbox message
 *	@ioc - Pointer to an adapter structure
 *	@cfg - Pointer to a toolbox structure. Struct contains
 *		action, page address, direction, physical address
 *		and pointer to a configuration page header
 *		Page header is updated.
 *
 *	Returns 0 for success
 *	-EPERM if not allowed due to ISR context
 *	-EAGAIN if no msg frames currently available
 *	-EFAULT for non-successful reply or no reply (timeout)
 */
int
mpt_toolbox(MPT_ADAPTER *ioc, CONFIGPARMS *pCfg)
{
	ToolboxIstwiReadWriteRequest_t	*pReq;
4910
	struct pci_dev	*pdev;
4911 4912 4913
	MPT_FRAME_HDR	*mf;
	unsigned long	 flags;
	int		 rc;
4914
	u32		 flagsLength;
4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930
	int		 in_isr;

	/* (Bugzilla:fibrebugs, #513)
	 * Bug fix (part 1)!  20010905 -sralston
	 *	Prevent calling wait_event() (below), if caller happens
	 *	to be in ISR context, because that is fatal!
	 */
	in_isr = in_interrupt();
	if (in_isr) {
		dcprintk((MYIOC_s_WARN_FMT "toobox request not allowed in ISR context!\n",
				ioc->name));
		return -EPERM;
	}

	/* Get and Populate a free Frame
	 */
4931
	if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949
		dcprintk((MYIOC_s_WARN_FMT "mpt_toolbox: no msg frames!\n",
				ioc->name));
		return -EAGAIN;
	}
	pReq = (ToolboxIstwiReadWriteRequest_t	*)mf;
	pReq->Tool = pCfg->action;
	pReq->Reserved = 0;
	pReq->ChainOffset = 0;
	pReq->Function = MPI_FUNCTION_TOOLBOX;
	pReq->Reserved1 = 0;
	pReq->Reserved2 = 0;
	pReq->MsgFlags = 0;
	pReq->Flags = pCfg->dir;
	pReq->BusNum = 0;
	pReq->Reserved3 = 0;
	pReq->NumAddressBytes = 0x01;
	pReq->Reserved4 = 0;
	pReq->DataLength = 0x04;
4950 4951 4952 4953 4954
	pdev = (struct pci_dev *) ioc->pcidev;
	if (pdev->devfn & 1)
		pReq->DeviceAddr = 0xB2;
	else
		pReq->DeviceAddr = 0xB0;
4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992
	pReq->Addr1 = 0;
	pReq->Addr2 = 0;
	pReq->Addr3 = 0;
	pReq->Reserved5 = 0;

	/* Add a SGE to the config request.
	 */

	flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ | 4;

	mpt_add_sge((char *)&pReq->SGL, flagsLength, pCfg->physAddr);

	dcprintk((MYIOC_s_INFO_FMT "Sending Toolbox request, Tool=%x\n",
		ioc->name, pReq->Tool));

	/* Append pCfg pointer to end of mf
	 */
	*((void **) (((u8 *) mf) + (ioc->req_sz - sizeof(void *)))) =  (void *) pCfg;

	/* Initalize the timer
	 */
	init_timer(&pCfg->timer);
	pCfg->timer.data = (unsigned long) ioc;
	pCfg->timer.function = mpt_timer_expired;
	pCfg->wait_done = 0;

	/* Set the timer; ensure 10 second minimum */
	if (pCfg->timeout < 10)
		pCfg->timer.expires = jiffies + HZ*10;
	else
		pCfg->timer.expires = jiffies + HZ*pCfg->timeout;

	/* Add to end of Q, set timer and then issue this command */
	spin_lock_irqsave(&ioc->FreeQlock, flags);
	Q_ADD_TAIL(&ioc->configQ.head, &pCfg->linkage, Q_ITEM);
	spin_unlock_irqrestore(&ioc->FreeQlock, flags);

	add_timer(&pCfg->timer);
4993
	mpt_put_msg_frame(mpt_base_index, ioc, mf);
4994 4995 4996 4997 4998 4999 5000 5001 5002
	wait_event(mpt_waitq, pCfg->wait_done);

	/* mf has been freed - do not access */

	rc = pCfg->status;

	return rc;
}

Linus Torvalds's avatar
Linus Torvalds committed
5003 5004
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
Pam Delaney's avatar
Pam Delaney committed
5005 5006 5007 5008 5009 5010 5011 5012 5013
 *	mpt_timer_expired - Call back for timer process.
 *	Used only internal config functionality.
 *	@data: Pointer to MPT_SCSI_HOST recast as an unsigned long
 */
static void
mpt_timer_expired(unsigned long data)
{
	MPT_ADAPTER *ioc = (MPT_ADAPTER *) data;

5014
	dcprintk((MYIOC_s_WARN_FMT "mpt_timer_expired! \n", ioc->name));
Pam Delaney's avatar
Pam Delaney committed
5015 5016 5017 5018 5019 5020 5021 5022 5023

	/* Perform a FW reload */
	if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0)
		printk(MYIOC_s_WARN_FMT "Firmware Reload FAILED!\n", ioc->name);

	/* No more processing.
	 * Hard reset clean-up will wake up
	 * process and free all resources.
	 */
5024
	dcprintk((MYIOC_s_WARN_FMT "mpt_timer_expired complete!\n", ioc->name));
Pam Delaney's avatar
Pam Delaney committed
5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035

	return;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	mpt_ioc_reset - Base cleanup for hard reset
 *	@ioc: Pointer to the adapter structure
 *	@reset_phase: Indicates pre- or post-reset functionality
 *
 *	Remark: Free's resources with internally generated commands.
Linus Torvalds's avatar
Linus Torvalds committed
5036
 */
Pam Delaney's avatar
Pam Delaney committed
5037 5038 5039 5040 5041 5042 5043 5044
static int
mpt_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
{
	CONFIGPARMS *pCfg;
	unsigned long flags;

	dprintk((KERN_WARNING MYNAM
			": IOC %s_reset routed to MPT base driver!\n",
5045 5046
			reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
			reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
Pam Delaney's avatar
Pam Delaney committed
5047

5048 5049 5050
	if (reset_phase == MPT_IOC_SETUP_RESET) {
		;
	} else if (reset_phase == MPT_IOC_PRE_RESET) {
Pam Delaney's avatar
Pam Delaney committed
5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067
		/* If the internal config Q is not empty -
		 * delete timer. MF resources will be freed when
		 * the FIFO's are primed.
		 */
		spin_lock_irqsave(&ioc->FreeQlock, flags);
		if (! Q_IS_EMPTY(&ioc->configQ)){
			pCfg = (CONFIGPARMS *)ioc->configQ.head;
			do {
				del_timer(&pCfg->timer);
				pCfg = (CONFIGPARMS *) (pCfg->linkage.forw);
			} while (pCfg != (CONFIGPARMS *)&ioc->configQ);
		}
		spin_unlock_irqrestore(&ioc->FreeQlock, flags);

	} else {
		CONFIGPARMS *pNext;

5068
		/* Search the configQ for internal commands.
Pam Delaney's avatar
Pam Delaney committed
5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081
		 * Flush the Q, and wake up all suspended threads.
		 */
		spin_lock_irqsave(&ioc->FreeQlock, flags);
		if (! Q_IS_EMPTY(&ioc->configQ)){
			pCfg = (CONFIGPARMS *)ioc->configQ.head;
			do {
				pNext = (CONFIGPARMS *) pCfg->linkage.forw;

				Q_DEL_ITEM(&pCfg->linkage);

				pCfg->status = MPT_CONFIG_ERROR;
				pCfg->wait_done = 1;
				wake_up(&mpt_waitq);
Linus Torvalds's avatar
Linus Torvalds committed
5082

Pam Delaney's avatar
Pam Delaney committed
5083 5084 5085 5086 5087 5088 5089
				pCfg = pNext;
			} while (pCfg != (CONFIGPARMS *)&ioc->configQ);
		}
		spin_unlock_irqrestore(&ioc->FreeQlock, flags);
	}

	return 1;		/* currently means nothing really */
Linus Torvalds's avatar
Linus Torvalds committed
5090 5091
}

Pam Delaney's avatar
Pam Delaney committed
5092 5093 5094 5095 5096 5097

#ifdef CONFIG_PROC_FS		/* { */
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	procfs (%MPT_PROCFS_MPTBASEDIR/...) support stuff...
 */
Linus Torvalds's avatar
Linus Torvalds committed
5098 5099 5100 5101 5102 5103 5104 5105 5106
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	procmpt_create - Create %MPT_PROCFS_MPTBASEDIR entries.
 *
 *	Returns 0 for success, non-zero for failure.
 */
static int
procmpt_create(void)
{
Pam Delaney's avatar
Pam Delaney committed
5107
	struct proc_dir_entry	*ent;
Linus Torvalds's avatar
Linus Torvalds committed
5108

Pam Delaney's avatar
Pam Delaney committed
5109 5110
	mpt_proc_root_dir = proc_mkdir(MPT_PROCFS_MPTBASEDIR, NULL);
	if (mpt_proc_root_dir == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
5111 5112
		return -ENOTDIR;

5113 5114 5115
	ent = create_proc_entry("summary", S_IFREG|S_IRUGO, mpt_proc_root_dir);
	if (ent)
		ent->read_proc = procmpt_summary_read;
Linus Torvalds's avatar
Linus Torvalds committed
5116

5117 5118 5119
	ent = create_proc_entry("version", S_IFREG|S_IRUGO, mpt_proc_root_dir);
	if (ent)
		ent->read_proc = procmpt_version_read;
Linus Torvalds's avatar
Linus Torvalds committed
5120 5121 5122 5123 5124 5125 5126 5127 5128 5129

	return 0;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	procmpt_destroy - Tear down %MPT_PROCFS_MPTBASEDIR entries.
 *
 *	Returns 0 for success, non-zero for failure.
 */
5130
static void
Linus Torvalds's avatar
Linus Torvalds committed
5131 5132
procmpt_destroy(void)
{
5133 5134 5135
	remove_proc_entry("version", mpt_proc_root_dir);
	remove_proc_entry("summary", mpt_proc_root_dir);
	remove_proc_entry(MPT_PROCFS_MPTBASEDIR, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
5136 5137 5138
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Pam Delaney's avatar
Pam Delaney committed
5139 5140
/*
 *	procmpt_summary_read - Handle read request from /proc/mpt/summary
Linus Torvalds's avatar
Linus Torvalds committed
5141
 *	or from /proc/mpt/iocN/summary.
Pam Delaney's avatar
Pam Delaney committed
5142
 *	@buf: Pointer to area to write information
Linus Torvalds's avatar
Linus Torvalds committed
5143
 *	@start: Pointer to start pointer
Pam Delaney's avatar
Pam Delaney committed
5144 5145
 *	@offset: Offset to start writing
 *	@request:
Linus Torvalds's avatar
Linus Torvalds committed
5146
 *	@eof: Pointer to EOF integer
Pam Delaney's avatar
Pam Delaney committed
5147
 *	@data: Pointer
Linus Torvalds's avatar
Linus Torvalds committed
5148
 *
Pam Delaney's avatar
Pam Delaney committed
5149
 *	Returns number of characters written to process performing the read.
Linus Torvalds's avatar
Linus Torvalds committed
5150 5151
 */
static int
Pam Delaney's avatar
Pam Delaney committed
5152
procmpt_summary_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
5153 5154
{
	MPT_ADAPTER *ioc;
Pam Delaney's avatar
Pam Delaney committed
5155
	char *out = buf;
Linus Torvalds's avatar
Linus Torvalds committed
5156 5157
	int len;

5158
	if (data) {
Andrew Morton's avatar
Andrew Morton committed
5159
		int more = 0;
Linus Torvalds's avatar
Linus Torvalds committed
5160

Andrew Morton's avatar
Andrew Morton committed
5161
		ioc = data;
Linus Torvalds's avatar
Linus Torvalds committed
5162
		mpt_print_ioc_summary(ioc, out, &more, 0, 1);
Linus Torvalds's avatar
Linus Torvalds committed
5163 5164

		out += more;
5165 5166 5167
	} else {
		list_for_each_entry(ioc, &ioc_list, list) {
			int	more = 0;
Linus Torvalds's avatar
Linus Torvalds committed
5168

5169 5170 5171 5172 5173 5174
			mpt_print_ioc_summary(ioc, out, &more, 0, 1);

			out += more;
			if ((out-buf) >= request)
				break;
		}
Linus Torvalds's avatar
Linus Torvalds committed
5175
	}
5176

Pam Delaney's avatar
Pam Delaney committed
5177
	len = out - buf;
Linus Torvalds's avatar
Linus Torvalds committed
5178

Pam Delaney's avatar
Pam Delaney committed
5179
	MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
Linus Torvalds's avatar
Linus Torvalds committed
5180 5181 5182
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Pam Delaney's avatar
Pam Delaney committed
5183 5184 5185
/*
 *	procmpt_version_read - Handle read request from /proc/mpt/version.
 *	@buf: Pointer to area to write information
Linus Torvalds's avatar
Linus Torvalds committed
5186
 *	@start: Pointer to start pointer
Pam Delaney's avatar
Pam Delaney committed
5187 5188
 *	@offset: Offset to start writing
 *	@request:
Linus Torvalds's avatar
Linus Torvalds committed
5189
 *	@eof: Pointer to EOF integer
Pam Delaney's avatar
Pam Delaney committed
5190
 *	@data: Pointer
Linus Torvalds's avatar
Linus Torvalds committed
5191
 *
Pam Delaney's avatar
Pam Delaney committed
5192
 *	Returns number of characters written to process performing the read.
Linus Torvalds's avatar
Linus Torvalds committed
5193 5194
 */
static int
Pam Delaney's avatar
Pam Delaney committed
5195
procmpt_version_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
5196
{
Pam Delaney's avatar
Pam Delaney committed
5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234
	int	 ii;
	int	 scsi, lan, ctl, targ, dmp;
	char	*drvname;
	int	 len;

	len = sprintf(buf, "%s-%s\n", "mptlinux", MPT_LINUX_VERSION_COMMON);
	len += sprintf(buf+len, "  Fusion MPT base driver\n");

	scsi = lan = ctl = targ = dmp = 0;
	for (ii=MPT_MAX_PROTOCOL_DRIVERS-1; ii; ii--) {
		drvname = NULL;
		if (MptCallbacks[ii]) {
			switch (MptDriverClass[ii]) {
			case MPTSCSIH_DRIVER:
				if (!scsi++) drvname = "SCSI host";
				break;
			case MPTLAN_DRIVER:
				if (!lan++) drvname = "LAN";
				break;
			case MPTSTM_DRIVER:
				if (!targ++) drvname = "SCSI target";
				break;
			case MPTCTL_DRIVER:
				if (!ctl++) drvname = "ioctl";
				break;
			case MPTDMP_DRIVER:
				if (!dmp++) drvname = "DMP";
				break;
			}

			if (drvname)
				len += sprintf(buf+len, "  Fusion MPT %s driver\n", drvname);
			/*
			 *	Handle isense special case, because it
			 *	doesn't do a formal mpt_register call.
			 */
			if (isense_idx == ii)
				len += sprintf(buf+len, "  Fusion MPT isense driver\n");
5235
		}
Pam Delaney's avatar
Pam Delaney committed
5236
	}
Linus Torvalds's avatar
Linus Torvalds committed
5237

Pam Delaney's avatar
Pam Delaney committed
5238 5239
	MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
}
Linus Torvalds's avatar
Linus Torvalds committed
5240

Pam Delaney's avatar
Pam Delaney committed
5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	procmpt_iocinfo_read - Handle read request from /proc/mpt/iocN/info.
 *	@buf: Pointer to area to write information
 *	@start: Pointer to start pointer
 *	@offset: Offset to start writing
 *	@request:
 *	@eof: Pointer to EOF integer
 *	@data: Pointer
 *
 *	Returns number of characters written to process performing the read.
 */
static int
procmpt_iocinfo_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
{
	MPT_ADAPTER	*ioc = data;
	int		 len;
	char		 expVer[32];
	int		 sz;
	int		 p;

	mpt_get_fw_exp_ver(expVer, ioc);
Linus Torvalds's avatar
Linus Torvalds committed
5263

Pam Delaney's avatar
Pam Delaney committed
5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283
	len = sprintf(buf, "%s:", ioc->name);
	if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)
		len += sprintf(buf+len, "  (f/w download boot flag set)");
//	if (ioc->facts.IOCExceptions & MPI_IOCFACTS_EXCEPT_CONFIG_CHECKSUM_FAIL)
//		len += sprintf(buf+len, "  CONFIG_CHECKSUM_FAIL!");

	len += sprintf(buf+len, "\n  ProductID = 0x%04x (%s)\n",
			ioc->facts.ProductID,
			ioc->prod_name);
	len += sprintf(buf+len, "  FWVersion = 0x%08x%s", ioc->facts.FWVersion.Word, expVer);
	if (ioc->facts.FWImageSize)
		len += sprintf(buf+len, " (fw_size=%d)", ioc->facts.FWImageSize);
	len += sprintf(buf+len, "\n  MsgVersion = 0x%04x\n", ioc->facts.MsgVersion);
	len += sprintf(buf+len, "  FirstWhoInit = 0x%02x\n", ioc->FirstWhoInit);
	len += sprintf(buf+len, "  EventState = 0x%02x\n", ioc->facts.EventState);

	len += sprintf(buf+len, "  CurrentHostMfaHighAddr = 0x%08x\n",
			ioc->facts.CurrentHostMfaHighAddr);
	len += sprintf(buf+len, "  CurrentSenseBufferHighAddr = 0x%08x\n",
			ioc->facts.CurrentSenseBufferHighAddr);
Linus Torvalds's avatar
Linus Torvalds committed
5284

Pam Delaney's avatar
Pam Delaney committed
5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329
	len += sprintf(buf+len, "  MaxChainDepth = 0x%02x frames\n", ioc->facts.MaxChainDepth);
	len += sprintf(buf+len, "  MinBlockSize = 0x%02x bytes\n", 4*ioc->facts.BlockSize);

	len += sprintf(buf+len, "  RequestFrames @ 0x%p (Dma @ 0x%p)\n",
					(void *)ioc->req_alloc, (void *)(ulong)ioc->req_alloc_dma);
	/*
	 *  Rounding UP to nearest 4-kB boundary here...
	 */
	sz = (ioc->req_sz * ioc->req_depth) + 128;
	sz = ((sz + 0x1000UL - 1UL) / 0x1000) * 0x1000;
	len += sprintf(buf+len, "    {CurReqSz=%d} x {CurReqDepth=%d} = %d bytes ^= 0x%x\n",
					ioc->req_sz, ioc->req_depth, ioc->req_sz*ioc->req_depth, sz);
	len += sprintf(buf+len, "    {MaxReqSz=%d}   {MaxReqDepth=%d}\n",
					4*ioc->facts.RequestFrameSize,
					ioc->facts.GlobalCredits);

	len += sprintf(buf+len, "  ReplyFrames   @ 0x%p (Dma @ 0x%p)\n",
					(void *)ioc->reply_alloc, (void *)(ulong)ioc->reply_alloc_dma);
	sz = (ioc->reply_sz * ioc->reply_depth) + 128;
	len += sprintf(buf+len, "    {CurRepSz=%d} x {CurRepDepth=%d} = %d bytes ^= 0x%x\n",
					ioc->reply_sz, ioc->reply_depth, ioc->reply_sz*ioc->reply_depth, sz);
	len += sprintf(buf+len, "    {MaxRepSz=%d}   {MaxRepDepth=%d}\n",
					ioc->facts.CurReplyFrameSize,
					ioc->facts.ReplyQueueDepth);

	len += sprintf(buf+len, "  MaxDevices = %d\n",
			(ioc->facts.MaxDevices==0) ? 255 : ioc->facts.MaxDevices);
	len += sprintf(buf+len, "  MaxBuses = %d\n", ioc->facts.MaxBuses);

	/* per-port info */
	for (p=0; p < ioc->facts.NumberOfPorts; p++) {
		len += sprintf(buf+len, "  PortNumber = %d (of %d)\n",
				p+1,
				ioc->facts.NumberOfPorts);
		if ((int)ioc->chip_type <= (int)FC929) {
			if (ioc->pfacts[p].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) {
				u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
				len += sprintf(buf+len, "    LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
						a[5], a[4], a[3], a[2], a[1], a[0]);
			}
			len += sprintf(buf+len, "    WWN = %08X%08X:%08X%08X\n",
					ioc->fc_port_page0[p].WWNN.High,
					ioc->fc_port_page0[p].WWNN.Low,
					ioc->fc_port_page0[p].WWPN.High,
					ioc->fc_port_page0[p].WWPN.Low);
Linus Torvalds's avatar
Linus Torvalds committed
5330 5331 5332
		}
	}

Pam Delaney's avatar
Pam Delaney committed
5333
	MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
Linus Torvalds's avatar
Linus Torvalds committed
5334
}
Pam Delaney's avatar
Pam Delaney committed
5335

Linus Torvalds's avatar
Linus Torvalds committed
5336 5337 5338 5339 5340 5341
#endif		/* CONFIG_PROC_FS } */

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
static void
mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc)
{
Pam Delaney's avatar
Pam Delaney committed
5342 5343
	buf[0] ='\0';
	if ((ioc->facts.FWVersion.Word >> 24) == 0x0E) {
Linus Torvalds's avatar
Linus Torvalds committed
5344
		sprintf(buf, " (Exp %02d%02d)",
Pam Delaney's avatar
Pam Delaney committed
5345 5346
			(ioc->facts.FWVersion.Word >> 16) & 0x00FF,	/* Month */
			(ioc->facts.FWVersion.Word >> 8) & 0x1F);	/* Day */
Linus Torvalds's avatar
Linus Torvalds committed
5347

Pam Delaney's avatar
Pam Delaney committed
5348 5349 5350
		/* insider hack! */
		if ((ioc->facts.FWVersion.Word >> 8) & 0x80)
			strcat(buf, " [MDBG]");
Linus Torvalds's avatar
Linus Torvalds committed
5351 5352 5353 5354 5355 5356 5357 5358 5359 5360
	}
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_print_ioc_summary - Write ASCII summary of IOC to a buffer.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *	@buffer: Pointer to buffer where IOC summary info should be written
 *	@size: Pointer to number of bytes we wrote (set by this routine)
 *	@len: Offset at which to start writing in buffer
Linus Torvalds's avatar
Linus Torvalds committed
5361
 *	@showlan: Display LAN stuff?
Linus Torvalds's avatar
Linus Torvalds committed
5362
 *
Pam Delaney's avatar
Pam Delaney committed
5363 5364
 *	This routine writes (english readable) ASCII text, which represents
 *	a summary of IOC information, to a buffer.
Linus Torvalds's avatar
Linus Torvalds committed
5365 5366
 */
void
Linus Torvalds's avatar
Linus Torvalds committed
5367
mpt_print_ioc_summary(MPT_ADAPTER *ioc, char *buffer, int *size, int len, int showlan)
Linus Torvalds's avatar
Linus Torvalds committed
5368 5369 5370 5371 5372 5373 5374 5375 5376
{
	char expVer[32];
	int y;

	mpt_get_fw_exp_ver(expVer, ioc);

	/*
	 *  Shorter summary of attached ioc's...
	 */
Pam Delaney's avatar
Pam Delaney committed
5377
	y = sprintf(buffer+len, "%s: %s, %s%08xh%s, Ports=%d, MaxQ=%d",
Linus Torvalds's avatar
Linus Torvalds committed
5378 5379 5380
			ioc->name,
			ioc->prod_name,
			MPT_FW_REV_MAGIC_ID_STRING,	/* "FwRev=" or somesuch */
Pam Delaney's avatar
Pam Delaney committed
5381
			ioc->facts.FWVersion.Word,
Linus Torvalds's avatar
Linus Torvalds committed
5382
			expVer,
Linus Torvalds's avatar
Linus Torvalds committed
5383
			ioc->facts.NumberOfPorts,
Linus Torvalds's avatar
Linus Torvalds committed
5384 5385
			ioc->req_depth);

Linus Torvalds's avatar
Linus Torvalds committed
5386
	if (showlan && (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN)) {
Linus Torvalds's avatar
Linus Torvalds committed
5387 5388 5389 5390 5391
		u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
		y += sprintf(buffer+len+y, ", LanAddr=%02X:%02X:%02X:%02X:%02X:%02X",
			a[5], a[4], a[3], a[2], a[1], a[0]);
	}

Pam Delaney's avatar
Pam Delaney committed
5392 5393 5394 5395 5396
#ifndef __sparc__
	y += sprintf(buffer+len+y, ", IRQ=%d", ioc->pci_irq);
#else
	y += sprintf(buffer+len+y, ", IRQ=%s", __irq_itoa(ioc->pci_irq));
#endif
Linus Torvalds's avatar
Linus Torvalds committed
5397

Linus Torvalds's avatar
Linus Torvalds committed
5398 5399 5400 5401 5402 5403 5404 5405
	if (!ioc->active)
		y += sprintf(buffer+len+y, " (disabled)");

	y += sprintf(buffer+len+y, "\n");

	*size = y;
}

Pam Delaney's avatar
Pam Delaney committed
5406 5407 5408 5409
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	Reset Handling
 */
Linus Torvalds's avatar
Linus Torvalds committed
5410 5411
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
Pam Delaney's avatar
Pam Delaney committed
5412 5413 5414
 *	mpt_HardResetHandler - Generic reset handler, issue SCSI Task
 *	Management call based on input arg values.  If TaskMgmt fails,
 *	return associated SCSI request.
Linus Torvalds's avatar
Linus Torvalds committed
5415
 *	@ioc: Pointer to MPT_ADAPTER structure
Pam Delaney's avatar
Pam Delaney committed
5416 5417 5418 5419 5420 5421 5422
 *	@sleepFlag: Indicates if sleep or schedule must be called.
 *
 *	Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
 *	or a non-interrupt thread.  In the former, must not call schedule().
 *
 *	Remark: A return of -1 is a FATAL error case, as it means a
 *	FW reload/initialization failed.
Linus Torvalds's avatar
Linus Torvalds committed
5423
 *
Pam Delaney's avatar
Pam Delaney committed
5424
 *	Returns 0 for SUCCESS or -1 if FAILED.
Linus Torvalds's avatar
Linus Torvalds committed
5425
 */
Pam Delaney's avatar
Pam Delaney committed
5426 5427
int
mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag)
Linus Torvalds's avatar
Linus Torvalds committed
5428
{
Pam Delaney's avatar
Pam Delaney committed
5429 5430
	int		 rc;
	unsigned long	 flags;
Linus Torvalds's avatar
Linus Torvalds committed
5431

5432
	dtmprintk((MYIOC_s_INFO_FMT "HardResetHandler Entered!\n", ioc->name));
Pam Delaney's avatar
Pam Delaney committed
5433 5434 5435 5436
#ifdef MFCNT
	printk(MYIOC_s_INFO_FMT "HardResetHandler Entered!\n", ioc->name);
	printk("MF count 0x%x !\n", ioc->mfcnt);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
5437

Pam Delaney's avatar
Pam Delaney committed
5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448
	/* Reset the adapter. Prevent more than 1 call to
	 * mpt_do_ioc_recovery at any instant in time.
	 */
	spin_lock_irqsave(&ioc->diagLock, flags);
	if ((ioc->diagPending) || (ioc->alt_ioc && ioc->alt_ioc->diagPending)){
		spin_unlock_irqrestore(&ioc->diagLock, flags);
		return 0;
	} else {
		ioc->diagPending = 1;
	}
	spin_unlock_irqrestore(&ioc->diagLock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
5449

Pam Delaney's avatar
Pam Delaney committed
5450
	/* FIXME: If do_ioc_recovery fails, repeat....
Linus Torvalds's avatar
Linus Torvalds committed
5451 5452
	 */

5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475
	/* The SCSI driver needs to adjust timeouts on all current
	 * commands prior to the diagnostic reset being issued.
	 * Prevents timeouts occuring during a diagnostic reset...very bad.
	 * For all other protocol drivers, this is a no-op.
	 */
	{
		int	 ii;
		int	 r = 0;

		for (ii=MPT_MAX_PROTOCOL_DRIVERS-1; ii; ii--) {
			if (MptResetHandlers[ii]) {
				dtmprintk((MYIOC_s_INFO_FMT "Calling IOC reset_setup handler #%d\n",
						ioc->name, ii));
				r += (*(MptResetHandlers[ii]))(ioc, MPT_IOC_SETUP_RESET);
				if (ioc->alt_ioc) {
					dtmprintk((MYIOC_s_INFO_FMT "Calling alt-%s setup reset handler #%d\n",
							ioc->name, ioc->alt_ioc->name, ii));
					r += (*(MptResetHandlers[ii]))(ioc->alt_ioc, MPT_IOC_SETUP_RESET);
				}
			}
		}
	}

Pam Delaney's avatar
Pam Delaney committed
5476 5477 5478 5479
	if ((rc = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_RECOVER, sleepFlag)) != 0) {
		printk(KERN_WARNING MYNAM ": WARNING - (%d) Cannot recover %s\n",
			rc, ioc->name);
	}
5480 5481 5482
	ioc->reload_fw = 0;
	if (ioc->alt_ioc)
		ioc->alt_ioc->reload_fw = 0;
Linus Torvalds's avatar
Linus Torvalds committed
5483

Pam Delaney's avatar
Pam Delaney committed
5484 5485 5486 5487 5488 5489
	spin_lock_irqsave(&ioc->diagLock, flags);
	ioc->diagPending = 0;
	if (ioc->alt_ioc)
		ioc->alt_ioc->diagPending = 0;
	spin_unlock_irqrestore(&ioc->diagLock, flags);

5490
	dtmprintk((MYIOC_s_INFO_FMT "HardResetHandler rc = %d!\n", ioc->name, rc));
Pam Delaney's avatar
Pam Delaney committed
5491 5492

	return rc;
Linus Torvalds's avatar
Linus Torvalds committed
5493 5494 5495 5496 5497 5498
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
static char *
EventDescriptionStr(u8 event, u32 evData0)
{
5499
	char *ds;
Linus Torvalds's avatar
Linus Torvalds committed
5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520

	switch(event) {
	case MPI_EVENT_NONE:
		ds = "None";
		break;
	case MPI_EVENT_LOG_DATA:
		ds = "Log Data";
		break;
	case MPI_EVENT_STATE_CHANGE:
		ds = "State Change";
		break;
	case MPI_EVENT_UNIT_ATTENTION:
		ds = "Unit Attention";
		break;
	case MPI_EVENT_IOC_BUS_RESET:
		ds = "IOC Bus Reset";
		break;
	case MPI_EVENT_EXT_BUS_RESET:
		ds = "External Bus Reset";
		break;
	case MPI_EVENT_RESCAN:
Pam Delaney's avatar
Pam Delaney committed
5521
		ds = "Bus Rescan Event";
Linus Torvalds's avatar
Linus Torvalds committed
5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548
		/* Ok, do we need to do anything here? As far as
		   I can tell, this is when a new device gets added
		   to the loop. */
		break;
	case MPI_EVENT_LINK_STATUS_CHANGE:
		if (evData0 == MPI_EVENT_LINK_STATUS_FAILURE)
			ds = "Link Status(FAILURE) Change";
		else
			ds = "Link Status(ACTIVE) Change";
		break;
	case MPI_EVENT_LOOP_STATE_CHANGE:
		if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LIP)
			ds = "Loop State(LIP) Change";
		else if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LPE)
			ds = "Loop State(LPE) Change";			/* ??? */
		else
			ds = "Loop State(LPB) Change";			/* ??? */
		break;
	case MPI_EVENT_LOGOUT:
		ds = "Logout";
		break;
	case MPI_EVENT_EVENT_CHANGE:
		if (evData0)
			ds = "Events(ON) Change";
		else
			ds = "Events(OFF) Change";
		break;
Pam Delaney's avatar
Pam Delaney committed
5549 5550 5551
	case MPI_EVENT_INTEGRATED_RAID:
		ds = "Integrated Raid";
		break;
Linus Torvalds's avatar
Linus Torvalds committed
5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562
	/*
	 *  MPT base "custom" events may be added here...
	 */
	default:
		ds = "Unknown";
		break;
	}
	return ds;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Pam Delaney's avatar
Pam Delaney committed
5563
/*
Linus Torvalds's avatar
Linus Torvalds committed
5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577
 *	ProcessEventNotification - Route a received EventNotificationReply to
 *	all currently regeistered event handlers.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *	@pEventReply: Pointer to EventNotification reply frame
 *	@evHandlers: Pointer to integer, number of event handlers
 *
 *	Returns sum of event handlers return values.
 */
static int
ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *pEventReply, int *evHandlers)
{
	u16 evDataLen;
	u32 evData0 = 0;
//	u32 evCtx;
Pam Delaney's avatar
Pam Delaney committed
5578
	int ii;
Linus Torvalds's avatar
Linus Torvalds committed
5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594
	int r = 0;
	int handlers = 0;
	char *evStr;
	u8 event;

	/*
	 *  Do platform normalization of values
	 */
	event = le32_to_cpu(pEventReply->Event) & 0xFF;
//	evCtx = le32_to_cpu(pEventReply->EventContext);
	evDataLen = le16_to_cpu(pEventReply->EventDataLength);
	if (evDataLen) {
		evData0 = le32_to_cpu(pEventReply->Data[0]);
	}

	evStr = EventDescriptionStr(event, evData0);
Pam Delaney's avatar
Pam Delaney committed
5595
	dprintk((MYIOC_s_INFO_FMT "MPT event (%s=%02Xh) detected!\n",
Linus Torvalds's avatar
Linus Torvalds committed
5596 5597 5598 5599 5600 5601
			ioc->name,
			evStr,
			event));

#if defined(MPT_DEBUG) || defined(MPT_DEBUG_EVENTS)
	printk(KERN_INFO MYNAM ": Event data:\n" KERN_INFO);
Pam Delaney's avatar
Pam Delaney committed
5602 5603
	for (ii = 0; ii < evDataLen; ii++)
		printk(" %08x", le32_to_cpu(pEventReply->Data[ii]));
Linus Torvalds's avatar
Linus Torvalds committed
5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620
	printk("\n");
#endif

	/*
	 *  Do general / base driver event processing
	 */
	switch(event) {
	case MPI_EVENT_NONE:			/* 00 */
	case MPI_EVENT_LOG_DATA:		/* 01 */
	case MPI_EVENT_STATE_CHANGE:		/* 02 */
	case MPI_EVENT_UNIT_ATTENTION:		/* 03 */
	case MPI_EVENT_IOC_BUS_RESET:		/* 04 */
	case MPI_EVENT_EXT_BUS_RESET:		/* 05 */
	case MPI_EVENT_RESCAN:			/* 06 */
	case MPI_EVENT_LINK_STATUS_CHANGE:	/* 07 */
	case MPI_EVENT_LOOP_STATE_CHANGE:	/* 08 */
	case MPI_EVENT_LOGOUT:			/* 09 */
Pam Delaney's avatar
Pam Delaney committed
5621 5622
	case MPI_EVENT_INTEGRATED_RAID:		/* 0B */
	case MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE:	/* 0C */
Linus Torvalds's avatar
Linus Torvalds committed
5623 5624 5625 5626 5627 5628 5629 5630 5631
	default:
		break;
	case MPI_EVENT_EVENT_CHANGE:		/* 0A */
		if (evDataLen) {
			u8 evState = evData0 & 0xFF;

			/* CHECKME! What if evState unexpectedly says OFF (0)? */

			/* Update EventState field in cached IocFacts */
Linus Torvalds's avatar
Linus Torvalds committed
5632 5633
			if (ioc->facts.Function) {
				ioc->facts.EventState = evState;
Linus Torvalds's avatar
Linus Torvalds committed
5634 5635 5636 5637 5638
			}
		}
		break;
	}

Pam Delaney's avatar
Pam Delaney committed
5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661
	/*
	 * Should this event be logged? Events are written sequentially.
	 * When buffer is full, start again at the top.
	 */
	if (ioc->events && (ioc->eventTypes & ( 1 << event))) {
		int idx;

		idx = ioc->eventContext % ioc->eventLogSize;

		ioc->events[idx].event = event;
		ioc->events[idx].eventContext = ioc->eventContext;

		for (ii = 0; ii < 2; ii++) {
			if (ii < evDataLen)
				ioc->events[idx].data[ii] = le32_to_cpu(pEventReply->Data[ii]);
			else
				ioc->events[idx].data[ii] =  0;
		}

		ioc->eventContext++;
	}


Linus Torvalds's avatar
Linus Torvalds committed
5662 5663 5664
	/*
	 *  Call each currently registered protocol event handler.
	 */
Pam Delaney's avatar
Pam Delaney committed
5665 5666 5667 5668 5669
	for (ii=MPT_MAX_PROTOCOL_DRIVERS-1; ii; ii--) {
		if (MptEvHandlers[ii]) {
			dprintk((MYIOC_s_INFO_FMT "Routing Event to event handler #%d\n",
					ioc->name, ii));
			r += (*(MptEvHandlers[ii]))(ioc, pEventReply);
Linus Torvalds's avatar
Linus Torvalds committed
5670 5671 5672 5673 5674 5675 5676 5677 5678
			handlers++;
		}
	}
	/* FIXME?  Examine results here? */

	/*
	 *  If needed, send (a single) EventAck.
	 */
	if (pEventReply->AckRequired == MPI_EVENT_NOTIFICATION_ACK_REQUIRED) {
Pam Delaney's avatar
Pam Delaney committed
5679 5680 5681
		if ((ii = SendEventAck(ioc, pEventReply)) != 0) {
			printk(MYIOC_s_WARN_FMT "SendEventAck returned %d\n",
					ioc->name, ii);
Linus Torvalds's avatar
Linus Torvalds committed
5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704
		}
	}

	*evHandlers = handlers;
	return r;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	mpt_fc_log_info - Log information returned from Fibre Channel IOC.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *	@log_info: U32 LogInfo reply word from the IOC
 *
 *	Refer to lsi/fc_log.h.
 */
static void
mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info)
{
	static char *subcl_str[8] = {
		"FCP Initiator", "FCP Target", "LAN", "MPI Message Layer",
		"FC Link", "Context Manager", "Invalid Field Offset", "State Change Info"
	};
	u8 subcl = (log_info >> 24) & 0x7;
5705
//	u32 SubCl = log_info & 0x27000000;
Linus Torvalds's avatar
Linus Torvalds committed
5706

Pam Delaney's avatar
Pam Delaney committed
5707
	printk(MYIOC_s_INFO_FMT "LogInfo(0x%08x): SubCl={%s}",
Linus Torvalds's avatar
Linus Torvalds committed
5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722
			ioc->name, log_info, subcl_str[subcl]);
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	mpt_sp_log_info - Log information returned from SCSI Parallel IOC.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *	@mr: Pointer to MPT reply frame
 *	@log_info: U32 LogInfo word from the IOC
 *
 *	Refer to lsi/sp_log.h.
 */
static void
mpt_sp_log_info(MPT_ADAPTER *ioc, u32 log_info)
{
5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759
	u32 info = log_info & 0x00FF0000;
	char *desc = "unknown";

	switch (info) {
	case 0x00010000:
		desc = "bug! MID not found";
		if (ioc->reload_fw == 0)
			ioc->reload_fw++;
		break;

	case 0x00020000:
		desc = "Parity Error";
		break;

	case 0x00030000:
		desc = "ASYNC Outbound Overrun";
		break;

	case 0x00040000:
		desc = "SYNC Offset Error";
		break;

	case 0x00050000:
		desc = "BM Change";
		break;

	case 0x00060000:
		desc = "Msg In Overflow";
		break;

	case 0x00070000:
		desc = "DMA Error";
		break;

	case 0x00080000:
		desc = "Outbound DMA Overrun";
		break;
5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776
	
	case 0x00090000:
		desc = "Task Management";
		break;

	case 0x000A0000:
		desc = "Device Problem";
		break;

	case 0x000B0000:
		desc = "Invalid Phase Change";
		break;

	case 0x000C0000:
		desc = "Untagged Table Size";
		break;
	
5777 5778 5779
	}

	printk(MYIOC_s_INFO_FMT "LogInfo(0x%08x): F/W: %s\n", ioc->name, log_info, desc);
Linus Torvalds's avatar
Linus Torvalds committed
5780 5781
}

5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	mpt_sp_ioc_info - IOC information returned from SCSI Parallel IOC.
 *	@ioc: Pointer to MPT_ADAPTER structure
 *	@ioc_status: U32 IOCStatus word from IOC
 *	@mf: Pointer to MPT request frame
 *
 *	Refer to lsi/mpi.h.
 */
static void
mpt_sp_ioc_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf)
{
	u32 status = ioc_status & MPI_IOCSTATUS_MASK;
	char *desc = "";

	switch (status) {
	case MPI_IOCSTATUS_INVALID_FUNCTION: /* 0x0001 */
		desc = "Invalid Function";
		break;

	case MPI_IOCSTATUS_BUSY: /* 0x0002 */
		desc = "Busy";
		break;

	case MPI_IOCSTATUS_INVALID_SGL: /* 0x0003 */
		desc = "Invalid SGL";
		break;

	case MPI_IOCSTATUS_INTERNAL_ERROR: /* 0x0004 */
		desc = "Internal Error";
		break;

	case MPI_IOCSTATUS_RESERVED: /* 0x0005 */
		desc = "Reserved";
		break;

	case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
		desc = "Insufficient Resources";
		break;

	case MPI_IOCSTATUS_INVALID_FIELD: /* 0x0007 */
		desc = "Invalid Field";
		break;

	case MPI_IOCSTATUS_INVALID_STATE: /* 0x0008 */
		desc = "Invalid State";
		break;

	case MPI_IOCSTATUS_CONFIG_INVALID_ACTION: /* 0x0020 */
	case MPI_IOCSTATUS_CONFIG_INVALID_TYPE:   /* 0x0021 */
	case MPI_IOCSTATUS_CONFIG_INVALID_PAGE:   /* 0x0022 */
	case MPI_IOCSTATUS_CONFIG_INVALID_DATA:   /* 0x0023 */
	case MPI_IOCSTATUS_CONFIG_NO_DEFAULTS:    /* 0x0024 */
	case MPI_IOCSTATUS_CONFIG_CANT_COMMIT:    /* 0x0025 */
		/* No message for Config IOCStatus values */
		break;

	case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
		/* No message for recovered error
		desc = "SCSI Recovered Error";
		*/
		break;

	case MPI_IOCSTATUS_SCSI_INVALID_BUS: /* 0x0041 */
		desc = "SCSI Invalid Bus";
		break;

	case MPI_IOCSTATUS_SCSI_INVALID_TARGETID: /* 0x0042 */
		desc = "SCSI Invalid TargetID";
		break;

	case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
	  {
		SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf;
		U8 cdb = pScsiReq->CDB[0];
		if (cdb != 0x12) { /* Inquiry is issued for device scanning */
			desc = "SCSI Device Not There";
		}
		break;
	  }

	case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: /* 0x0044 */
		desc = "SCSI Data Overrun";
		break;

	case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
		/* This error is checked in scsi_io_done(). Skip. 
		desc = "SCSI Data Underrun";
		*/
		break;

	case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
		desc = "SCSI I/O Data Error";
		break;

	case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
		desc = "SCSI Protocol Error";
		break;

	case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
		desc = "SCSI Task Terminated";
		break;

	case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */
		desc = "SCSI Residual Mismatch";
		break;

	case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED: /* 0x004A */
		desc = "SCSI Task Management Failed";
		break;

	case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
		desc = "SCSI IOC Terminated";
		break;

	case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
		desc = "SCSI Ext Terminated";
		break;

	default:
		desc = "Others";
		break;
	}
	if (desc != "")
		printk(MYIOC_s_INFO_FMT "IOCStatus(0x%04x): %s\n", ioc->name, status, desc);
}

Linus Torvalds's avatar
Linus Torvalds committed
5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_register_ascqops_strings - Register SCSI ASC/ASCQ and SCSI
 *	OpCode strings from the (optional) isense module.
 *	@ascqTable: Pointer to ASCQ_Table_t structure
 *	@ascqtbl_sz: Number of entries in ASCQ_Table
 *	@opsTable: Pointer to array of SCSI OpCode strings (char pointers)
 *
 *	Specialized driver registration routine for the isense driver.
 */
int
Pam Delaney's avatar
Pam Delaney committed
5920
mpt_register_ascqops_strings(void *ascqTable, int ascqtbl_sz, const char **opsTable)
Linus Torvalds's avatar
Linus Torvalds committed
5921 5922 5923 5924 5925 5926 5927 5928
{
	int r = 0;

	if (ascqTable && ascqtbl_sz && opsTable) {
		mpt_v_ASCQ_TablePtr = ascqTable;
		mpt_ASCQ_TableSz = ascqtbl_sz;
		mpt_ScsiOpcodesPtr = opsTable;
		printk(KERN_INFO MYNAM ": English readable SCSI-3 strings enabled:-)\n");
Pam Delaney's avatar
Pam Delaney committed
5929
		isense_idx = last_drv_idx;
Linus Torvalds's avatar
Linus Torvalds committed
5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948
		r = 1;
	}
	return r;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mpt_deregister_ascqops_strings - Deregister SCSI ASC/ASCQ and SCSI
 *	OpCode strings from the isense driver.
 *
 *	Specialized driver deregistration routine for the isense driver.
 */
void
mpt_deregister_ascqops_strings(void)
{
	mpt_v_ASCQ_TablePtr = NULL;
	mpt_ASCQ_TableSz = 0;
	mpt_ScsiOpcodesPtr = NULL;
	printk(KERN_INFO MYNAM ": English readable SCSI-3 strings disabled)-:\n");
Pam Delaney's avatar
Pam Delaney committed
5949
	isense_idx = -1;
Linus Torvalds's avatar
Linus Torvalds committed
5950 5951 5952 5953
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

5954
EXPORT_SYMBOL(ioc_list);
Pam Delaney's avatar
Pam Delaney committed
5955 5956
EXPORT_SYMBOL(mpt_proc_root_dir);
EXPORT_SYMBOL(DmpService);
Linus Torvalds's avatar
Linus Torvalds committed
5957 5958 5959 5960
EXPORT_SYMBOL(mpt_register);
EXPORT_SYMBOL(mpt_deregister);
EXPORT_SYMBOL(mpt_event_register);
EXPORT_SYMBOL(mpt_event_deregister);
Linus Torvalds's avatar
Linus Torvalds committed
5961 5962
EXPORT_SYMBOL(mpt_reset_register);
EXPORT_SYMBOL(mpt_reset_deregister);
James Bottomley's avatar
James Bottomley committed
5963 5964
EXPORT_SYMBOL(mpt_device_driver_register);
EXPORT_SYMBOL(mpt_device_driver_deregister);
Linus Torvalds's avatar
Linus Torvalds committed
5965 5966 5967
EXPORT_SYMBOL(mpt_get_msg_frame);
EXPORT_SYMBOL(mpt_put_msg_frame);
EXPORT_SYMBOL(mpt_free_msg_frame);
Pam Delaney's avatar
Pam Delaney committed
5968 5969
EXPORT_SYMBOL(mpt_add_sge);
EXPORT_SYMBOL(mpt_add_chain);
Linus Torvalds's avatar
Linus Torvalds committed
5970
EXPORT_SYMBOL(mpt_send_handshake_request);
Pam Delaney's avatar
Pam Delaney committed
5971
EXPORT_SYMBOL(mpt_handshake_req_reply_wait);
Linus Torvalds's avatar
Linus Torvalds committed
5972
EXPORT_SYMBOL(mpt_verify_adapter);
Pam Delaney's avatar
Pam Delaney committed
5973
EXPORT_SYMBOL(mpt_GetIocState);
Linus Torvalds's avatar
Linus Torvalds committed
5974 5975 5976
EXPORT_SYMBOL(mpt_print_ioc_summary);
EXPORT_SYMBOL(mpt_lan_index);
EXPORT_SYMBOL(mpt_stm_index);
Pam Delaney's avatar
Pam Delaney committed
5977 5978
EXPORT_SYMBOL(mpt_HardResetHandler);
EXPORT_SYMBOL(mpt_config);
5979 5980
EXPORT_SYMBOL(mpt_toolbox);
EXPORT_SYMBOL(mpt_findImVolumes);
5981
EXPORT_SYMBOL(mpt_read_ioc_pg_3);
Pam Delaney's avatar
Pam Delaney committed
5982 5983
EXPORT_SYMBOL(mpt_alloc_fw_memory);
EXPORT_SYMBOL(mpt_free_fw_memory);
Linus Torvalds's avatar
Linus Torvalds committed
5984 5985 5986 5987 5988 5989 5990

EXPORT_SYMBOL(mpt_register_ascqops_strings);
EXPORT_SYMBOL(mpt_deregister_ascqops_strings);
EXPORT_SYMBOL(mpt_v_ASCQ_TablePtr);
EXPORT_SYMBOL(mpt_ASCQ_TableSz);
EXPORT_SYMBOL(mpt_ScsiOpcodesPtr);

James Bottomley's avatar
James Bottomley committed
5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005

static struct pci_driver mptbase_driver = {
	.name		= "mptbase",
	.id_table	= mptbase_pci_table,
	.probe		= mptbase_probe,
	.remove		= __devexit_p(mptbase_remove),
	.driver         = {
		.shutdown = mptbase_shutdown,
        },
#ifdef CONFIG_PM
	.suspend	= mptbase_suspend,
	.resume		= mptbase_resume,
#endif
};

Linus Torvalds's avatar
Linus Torvalds committed
6006
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Pam Delaney's avatar
Pam Delaney committed
6007
/*
Linus Torvalds's avatar
Linus Torvalds committed
6008 6009 6010 6011
 *	fusion_init - Fusion MPT base driver initialization routine.
 *
 *	Returns 0 for success, non-zero for failure.
 */
James Bottomley's avatar
James Bottomley committed
6012
static int __init
Pam Delaney's avatar
Pam Delaney committed
6013
fusion_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
6014 6015
{
	int i;
James Bottomley's avatar
James Bottomley committed
6016
	int r;
Linus Torvalds's avatar
Linus Torvalds committed
6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029

	if (FusionInitCalled++) {
		dprintk((KERN_INFO MYNAM ": INFO - Driver late-init entry point called\n"));
		return 0;
	}

	show_mptmod_ver(my_NAME, my_VERSION);
	printk(KERN_INFO COPYRIGHT "\n");

	for (i = 0; i < MPT_MAX_PROTOCOL_DRIVERS; i++) {
		MptCallbacks[i] = NULL;
		MptDriverClass[i] = MPTUNKNOWN_DRIVER;
		MptEvHandlers[i] = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
6030
		MptResetHandlers[i] = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
6031 6032
	}

Pam Delaney's avatar
Pam Delaney committed
6033 6034
	DmpService = NULL;

Linus Torvalds's avatar
Linus Torvalds committed
6035 6036 6037 6038 6039 6040
	/* NEW!  20010120 -sralston
	 *  Register ourselves (mptbase) in order to facilitate
	 *  EventNotification handling.
	 */
	mpt_base_index = mpt_register(mpt_base_reply, MPTBASE_DRIVER);

Pam Delaney's avatar
Pam Delaney committed
6041 6042 6043 6044 6045 6046 6047 6048
	/* Register for hard reset handling callbacks.
	 */
	if (mpt_reset_register(mpt_base_index, mpt_ioc_reset) == 0) {
		dprintk((KERN_INFO MYNAM ": Register for IOC reset notification\n"));
	} else {
		/* FIXME! */
	}

James Bottomley's avatar
James Bottomley committed
6049 6050 6051
#ifdef CONFIG_PROC_FS
	(void) procmpt_create();
#endif
6052 6053 6054
	r = pci_module_init(&mptbase_driver);
	if(r)
		return(r);
James Bottomley's avatar
James Bottomley committed
6055 6056

	return r;
Linus Torvalds's avatar
Linus Torvalds committed
6057 6058 6059
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Pam Delaney's avatar
Pam Delaney committed
6060
/*
Linus Torvalds's avatar
Linus Torvalds committed
6061 6062 6063 6064 6065
 *	fusion_exit - Perform driver unload cleanup.
 *
 *	This routine frees all resources associated with each MPT adapter
 *	and removes all %MPT_PROCFS_MPTBASEDIR entries.
 */
James Bottomley's avatar
James Bottomley committed
6066
static void __exit
Pam Delaney's avatar
Pam Delaney committed
6067
fusion_exit(void)
Linus Torvalds's avatar
Linus Torvalds committed
6068 6069
{

6070
	dexitprintk((KERN_INFO MYNAM ": fusion_exit() called!\n"));
Linus Torvalds's avatar
Linus Torvalds committed
6071

6072
	pci_unregister_driver(&mptbase_driver);
Pam Delaney's avatar
Pam Delaney committed
6073
	mpt_reset_deregister(mpt_base_index);
6074 6075 6076 6077

#ifdef CONFIG_PROC_FS
	procmpt_destroy();
#endif
Linus Torvalds's avatar
Linus Torvalds committed
6078 6079 6080 6081 6082
}


module_init(fusion_init);
module_exit(fusion_exit);