1 /*
2  *  linux/drivers/message/fusion/mptscsih.c
3  *      For use with LSI PCI chip/adapter(s)
4  *      running LSI Fusion MPT (Message Passing Technology) firmware.
5  *
6  *  Copyright (c) 1999-2008 LSI Corporation
7  *  (mailto:DL-MPTFusionLinux@lsi.com)
8  *
9  */
10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11 /*
12     This program is free software; you can redistribute it and/or modify
13     it under the terms of the GNU General Public License as published by
14     the Free Software Foundation; version 2 of the License.
15 
16     This program is distributed in the hope that it will be useful,
17     but WITHOUT ANY WARRANTY; without even the implied warranty of
18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19     GNU General Public License for more details.
20 
21     NO WARRANTY
22     THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
23     CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
24     LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
25     MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
26     solely responsible for determining the appropriateness of using and
27     distributing the Program and assumes all risks associated with its
28     exercise of rights under this Agreement, including but not limited to
29     the risks and costs of program errors, damage to or loss of data,
30     programs or equipment, and unavailability or interruption of operations.
31 
32     DISCLAIMER OF LIABILITY
33     NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
34     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35     DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
36     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
37     TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
38     USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
39     HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
40 
41     You should have received a copy of the GNU General Public License
42     along with this program; if not, write to the Free Software
43     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
44 */
45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
46 
47 #include <linux/module.h>
48 #include <linux/kernel.h>
49 #include <linux/slab.h>
50 #include <linux/init.h>
51 #include <linux/errno.h>
52 #include <linux/kdev_t.h>
53 #include <linux/blkdev.h>
54 #include <linux/delay.h>	/* for mdelay */
55 #include <linux/interrupt.h>
56 #include <linux/reboot.h>	/* notifier code */
57 #include <linux/workqueue.h>
58 
59 #include <scsi/scsi.h>
60 #include <scsi/scsi_cmnd.h>
61 #include <scsi/scsi_device.h>
62 #include <scsi/scsi_host.h>
63 #include <scsi/scsi_tcq.h>
64 #include <scsi/scsi_dbg.h>
65 
66 #include "mptbase.h"
67 #include "mptscsih.h"
68 #include "lsi/mpi_log_sas.h"
69 
70 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
71 #define my_NAME		"Fusion MPT SCSI Host driver"
72 #define my_VERSION	MPT_LINUX_VERSION_COMMON
73 #define MYNAM		"mptscsih"
74 
75 MODULE_AUTHOR(MODULEAUTHOR);
76 MODULE_DESCRIPTION(my_NAME);
77 MODULE_LICENSE("GPL");
78 MODULE_VERSION(my_VERSION);
79 
80 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
81 /*
82  *  Other private/forward protos...
83  */
84 struct scsi_cmnd	*mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i);
85 static struct scsi_cmnd * mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i);
86 static void	mptscsih_set_scsi_lookup(MPT_ADAPTER *ioc, int i, struct scsi_cmnd *scmd);
87 static int	SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *scmd);
88 int		mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
89 static void	mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq);
90 int		mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
91 
92 static int	mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt,
93 				 SCSIIORequest_t *pReq, int req_idx);
94 static void	mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx);
95 static void	mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply);
96 
97 int	mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id,
98 		u64 lun, int ctx2abort, ulong timeout);
99 
100 int		mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset);
101 int		mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
102 
103 void
104 mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code);
105 static int	mptscsih_get_completion_code(MPT_ADAPTER *ioc,
106 		MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);
107 int		mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
108 static int	mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *iocmd);
109 static void	mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice);
110 
111 static int
112 mptscsih_taskmgmt_reply(MPT_ADAPTER *ioc, u8 type,
113 				SCSITaskMgmtReply_t *pScsiTmReply);
114 void 		mptscsih_remove(struct pci_dev *);
115 void 		mptscsih_shutdown(struct pci_dev *);
116 #ifdef CONFIG_PM
117 int 		mptscsih_suspend(struct pci_dev *pdev, pm_message_t state);
118 int 		mptscsih_resume(struct pci_dev *pdev);
119 #endif
120 
121 
122 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
123 /*
124  *	mptscsih_getFreeChainBuffer - Function to get a free chain
125  *	from the MPT_SCSI_HOST FreeChainQ.
126  *	@ioc: Pointer to MPT_ADAPTER structure
127  *	@req_idx: Index of the SCSI IO request frame. (output)
128  *
129  *	return SUCCESS or FAILED
130  */
131 static inline int
132 mptscsih_getFreeChainBuffer(MPT_ADAPTER *ioc, int *retIndex)
133 {
134 	MPT_FRAME_HDR *chainBuf;
135 	unsigned long flags;
136 	int rc;
137 	int chain_idx;
138 
139 	dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "getFreeChainBuffer called\n",
140 	    ioc->name));
141 	spin_lock_irqsave(&ioc->FreeQlock, flags);
142 	if (!list_empty(&ioc->FreeChainQ)) {
143 		int offset;
144 
145 		chainBuf = list_entry(ioc->FreeChainQ.next, MPT_FRAME_HDR,
146 				u.frame.linkage.list);
147 		list_del(&chainBuf->u.frame.linkage.list);
148 		offset = (u8 *)chainBuf - (u8 *)ioc->ChainBuffer;
149 		chain_idx = offset / ioc->req_sz;
150 		rc = SUCCESS;
151 		dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT
152 		    "getFreeChainBuffer chainBuf=%p ChainBuffer=%p offset=%d chain_idx=%d\n",
153 		    ioc->name, chainBuf, ioc->ChainBuffer, offset, chain_idx));
154 	} else {
155 		rc = FAILED;
156 		chain_idx = MPT_HOST_NO_CHAIN;
157 		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "getFreeChainBuffer failed\n",
158 		    ioc->name));
159 	}
160 	spin_unlock_irqrestore(&ioc->FreeQlock, flags);
161 
162 	*retIndex = chain_idx;
163 	return rc;
164 } /* mptscsih_getFreeChainBuffer() */
165 
166 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
167 /*
168  *	mptscsih_AddSGE - Add a SGE (plus chain buffers) to the
169  *	SCSIIORequest_t Message Frame.
170  *	@ioc: Pointer to MPT_ADAPTER structure
171  *	@SCpnt: Pointer to scsi_cmnd structure
172  *	@pReq: Pointer to SCSIIORequest_t structure
173  *
174  *	Returns ...
175  */
176 static int
177 mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt,
178 		SCSIIORequest_t *pReq, int req_idx)
179 {
180 	char 	*psge;
181 	char	*chainSge;
182 	struct scatterlist *sg;
183 	int	 frm_sz;
184 	int	 sges_left, sg_done;
185 	int	 chain_idx = MPT_HOST_NO_CHAIN;
186 	int	 sgeOffset;
187 	int	 numSgeSlots, numSgeThisFrame;
188 	u32	 sgflags, sgdir, thisxfer = 0;
189 	int	 chain_dma_off = 0;
190 	int	 newIndex;
191 	int	 ii;
192 	dma_addr_t v2;
193 	u32	RequestNB;
194 
195 	sgdir = le32_to_cpu(pReq->Control) & MPI_SCSIIO_CONTROL_DATADIRECTION_MASK;
196 	if (sgdir == MPI_SCSIIO_CONTROL_WRITE)  {
197 		sgdir = MPT_TRANSFER_HOST_TO_IOC;
198 	} else {
199 		sgdir = MPT_TRANSFER_IOC_TO_HOST;
200 	}
201 
202 	psge = (char *) &pReq->SGL;
203 	frm_sz = ioc->req_sz;
204 
205 	/* Map the data portion, if any.
206 	 * sges_left  = 0 if no data transfer.
207 	 */
208 	sges_left = scsi_dma_map(SCpnt);
209 	if (sges_left < 0)
210 		return FAILED;
211 
212 	/* Handle the SG case.
213 	 */
214 	sg = scsi_sglist(SCpnt);
215 	sg_done  = 0;
216 	sgeOffset = sizeof(SCSIIORequest_t) - sizeof(SGE_IO_UNION);
217 	chainSge = NULL;
218 
219 	/* Prior to entering this loop - the following must be set
220 	 * current MF:  sgeOffset (bytes)
221 	 *              chainSge (Null if original MF is not a chain buffer)
222 	 *              sg_done (num SGE done for this MF)
223 	 */
224 
225 nextSGEset:
226 	numSgeSlots = ((frm_sz - sgeOffset) / ioc->SGE_size);
227 	numSgeThisFrame = (sges_left < numSgeSlots) ? sges_left : numSgeSlots;
228 
229 	sgflags = MPT_SGE_FLAGS_SIMPLE_ELEMENT | sgdir;
230 
231 	/* Get first (num - 1) SG elements
232 	 * Skip any SG entries with a length of 0
233 	 * NOTE: at finish, sg and psge pointed to NEXT data/location positions
234 	 */
235 	for (ii=0; ii < (numSgeThisFrame-1); ii++) {
236 		thisxfer = sg_dma_len(sg);
237 		if (thisxfer == 0) {
238 			/* Get next SG element from the OS */
239 			sg = sg_next(sg);
240 			sg_done++;
241 			continue;
242 		}
243 
244 		v2 = sg_dma_address(sg);
245 		ioc->add_sge(psge, sgflags | thisxfer, v2);
246 
247 		/* Get next SG element from the OS */
248 		sg = sg_next(sg);
249 		psge += ioc->SGE_size;
250 		sgeOffset += ioc->SGE_size;
251 		sg_done++;
252 	}
253 
254 	if (numSgeThisFrame == sges_left) {
255 		/* Add last element, end of buffer and end of list flags.
256 		 */
257 		sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT |
258 				MPT_SGE_FLAGS_END_OF_BUFFER |
259 				MPT_SGE_FLAGS_END_OF_LIST;
260 
261 		/* Add last SGE and set termination flags.
262 		 * Note: Last SGE may have a length of 0 - which should be ok.
263 		 */
264 		thisxfer = sg_dma_len(sg);
265 
266 		v2 = sg_dma_address(sg);
267 		ioc->add_sge(psge, sgflags | thisxfer, v2);
268 		sgeOffset += ioc->SGE_size;
269 		sg_done++;
270 
271 		if (chainSge) {
272 			/* The current buffer is a chain buffer,
273 			 * but there is not another one.
274 			 * Update the chain element
275 			 * Offset and Length fields.
276 			 */
277 			ioc->add_chain((char *)chainSge, 0, sgeOffset,
278 				ioc->ChainBufferDMA + chain_dma_off);
279 		} else {
280 			/* The current buffer is the original MF
281 			 * and there is no Chain buffer.
282 			 */
283 			pReq->ChainOffset = 0;
284 			RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor)  + 1) & 0x03;
285 			dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT
286 			    "Single Buffer RequestNB=%x, sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset));
287 			ioc->RequestNB[req_idx] = RequestNB;
288 		}
289 	} else {
290 		/* At least one chain buffer is needed.
291 		 * Complete the first MF
292 		 *  - last SGE element, set the LastElement bit
293 		 *  - set ChainOffset (words) for orig MF
294 		 *             (OR finish previous MF chain buffer)
295 		 *  - update MFStructPtr ChainIndex
296 		 *  - Populate chain element
297 		 * Also
298 		 * Loop until done.
299 		 */
300 
301 		dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SG: Chain Required! sg done %d\n",
302 				ioc->name, sg_done));
303 
304 		/* Set LAST_ELEMENT flag for last non-chain element
305 		 * in the buffer. Since psge points at the NEXT
306 		 * SGE element, go back one SGE element, update the flags
307 		 * and reset the pointer. (Note: sgflags & thisxfer are already
308 		 * set properly).
309 		 */
310 		if (sg_done) {
311 			u32 *ptmp = (u32 *) (psge - ioc->SGE_size);
312 			sgflags = le32_to_cpu(*ptmp);
313 			sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT;
314 			*ptmp = cpu_to_le32(sgflags);
315 		}
316 
317 		if (chainSge) {
318 			/* The current buffer is a chain buffer.
319 			 * chainSge points to the previous Chain Element.
320 			 * Update its chain element Offset and Length (must
321 			 * include chain element size) fields.
322 			 * Old chain element is now complete.
323 			 */
324 			u8 nextChain = (u8) (sgeOffset >> 2);
325 			sgeOffset += ioc->SGE_size;
326 			ioc->add_chain((char *)chainSge, nextChain, sgeOffset,
327 					 ioc->ChainBufferDMA + chain_dma_off);
328 		} else {
329 			/* The original MF buffer requires a chain buffer -
330 			 * set the offset.
331 			 * Last element in this MF is a chain element.
332 			 */
333 			pReq->ChainOffset = (u8) (sgeOffset >> 2);
334 			RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor)  + 1) & 0x03;
335 			dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Chain Buffer Needed, RequestNB=%x sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset));
336 			ioc->RequestNB[req_idx] = RequestNB;
337 		}
338 
339 		sges_left -= sg_done;
340 
341 
342 		/* NOTE: psge points to the beginning of the chain element
343 		 * in current buffer. Get a chain buffer.
344 		 */
345 		if ((mptscsih_getFreeChainBuffer(ioc, &newIndex)) == FAILED) {
346 			dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
347 			    "getFreeChainBuffer FAILED SCSI cmd=%02x (%p)\n",
348  			    ioc->name, pReq->CDB[0], SCpnt));
349 			return FAILED;
350 		}
351 
352 		/* Update the tracking arrays.
353 		 * If chainSge == NULL, update ReqToChain, else ChainToChain
354 		 */
355 		if (chainSge) {
356 			ioc->ChainToChain[chain_idx] = newIndex;
357 		} else {
358 			ioc->ReqToChain[req_idx] = newIndex;
359 		}
360 		chain_idx = newIndex;
361 		chain_dma_off = ioc->req_sz * chain_idx;
362 
363 		/* Populate the chainSGE for the current buffer.
364 		 * - Set chain buffer pointer to psge and fill
365 		 *   out the Address and Flags fields.
366 		 */
367 		chainSge = (char *) psge;
368 		dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "  Current buff @ %p (index 0x%x)",
369 		    ioc->name, psge, req_idx));
370 
371 		/* Start the SGE for the next buffer
372 		 */
373 		psge = (char *) (ioc->ChainBuffer + chain_dma_off);
374 		sgeOffset = 0;
375 		sg_done = 0;
376 
377 		dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "  Chain buff @ %p (index 0x%x)\n",
378 		    ioc->name, psge, chain_idx));
379 
380 		/* Start the SGE for the next buffer
381 		 */
382 
383 		goto nextSGEset;
384 	}
385 
386 	return SUCCESS;
387 } /* mptscsih_AddSGE() */
388 
389 static void
390 mptscsih_issue_sep_command(MPT_ADAPTER *ioc, VirtTarget *vtarget,
391     U32 SlotStatus)
392 {
393 	MPT_FRAME_HDR *mf;
394 	SEPRequest_t 	 *SEPMsg;
395 
396 	if (ioc->bus_type != SAS)
397 		return;
398 
399 	/* Not supported for hidden raid components
400 	 */
401 	if (vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
402 		return;
403 
404 	if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
405 		dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: no msg frames!!\n",
406 		    ioc->name,__func__));
407 		return;
408 	}
409 
410 	SEPMsg = (SEPRequest_t *)mf;
411 	SEPMsg->Function = MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
412 	SEPMsg->Bus = vtarget->channel;
413 	SEPMsg->TargetID = vtarget->id;
414 	SEPMsg->Action = MPI_SEP_REQ_ACTION_WRITE_STATUS;
415 	SEPMsg->SlotStatus = SlotStatus;
416 	devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
417 	    "Sending SEP cmd=%x channel=%d id=%d\n",
418 	    ioc->name, SlotStatus, SEPMsg->Bus, SEPMsg->TargetID));
419 	mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
420 }
421 
422 #ifdef CONFIG_FUSION_LOGGING
423 /**
424  *	mptscsih_info_scsiio - debug print info on reply frame
425  *	@ioc: Pointer to MPT_ADAPTER structure
426  *	@sc: original scsi cmnd pointer
427  *	@pScsiReply: Pointer to MPT reply frame
428  *
429  *	MPT_DEBUG_REPLY needs to be enabled to obtain this info
430  *
431  *	Refer to lsi/mpi.h.
432  **/
433 static void
434 mptscsih_info_scsiio(MPT_ADAPTER *ioc, struct scsi_cmnd *sc, SCSIIOReply_t * pScsiReply)
435 {
436 	char	*desc = NULL;
437 	char	*desc1 = NULL;
438 	u16	ioc_status;
439 	u8	skey, asc, ascq;
440 
441 	ioc_status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK;
442 
443 	switch (ioc_status) {
444 
445 	case MPI_IOCSTATUS_SUCCESS:
446 		desc = "success";
447 		break;
448 	case MPI_IOCSTATUS_SCSI_INVALID_BUS:
449 		desc = "invalid bus";
450 		break;
451 	case MPI_IOCSTATUS_SCSI_INVALID_TARGETID:
452 		desc = "invalid target_id";
453 		break;
454 	case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
455 		desc = "device not there";
456 		break;
457 	case MPI_IOCSTATUS_SCSI_DATA_OVERRUN:
458 		desc = "data overrun";
459 		break;
460 	case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN:
461 		desc = "data underrun";
462 		break;
463 	case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR:
464 		desc = "I/O data error";
465 		break;
466 	case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR:
467 		desc = "protocol error";
468 		break;
469 	case MPI_IOCSTATUS_SCSI_TASK_TERMINATED:
470 		desc = "task terminated";
471 		break;
472 	case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
473 		desc = "residual mismatch";
474 		break;
475 	case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
476 		desc = "task management failed";
477 		break;
478 	case MPI_IOCSTATUS_SCSI_IOC_TERMINATED:
479 		desc = "IOC terminated";
480 		break;
481 	case MPI_IOCSTATUS_SCSI_EXT_TERMINATED:
482 		desc = "ext terminated";
483 		break;
484 	default:
485 		desc = "";
486 		break;
487 	}
488 
489 	switch (pScsiReply->SCSIStatus)
490 	{
491 
492 	case MPI_SCSI_STATUS_SUCCESS:
493 		desc1 = "success";
494 		break;
495 	case MPI_SCSI_STATUS_CHECK_CONDITION:
496 		desc1 = "check condition";
497 		break;
498 	case MPI_SCSI_STATUS_CONDITION_MET:
499 		desc1 = "condition met";
500 		break;
501 	case MPI_SCSI_STATUS_BUSY:
502 		desc1 = "busy";
503 		break;
504 	case MPI_SCSI_STATUS_INTERMEDIATE:
505 		desc1 = "intermediate";
506 		break;
507 	case MPI_SCSI_STATUS_INTERMEDIATE_CONDMET:
508 		desc1 = "intermediate condmet";
509 		break;
510 	case MPI_SCSI_STATUS_RESERVATION_CONFLICT:
511 		desc1 = "reservation conflict";
512 		break;
513 	case MPI_SCSI_STATUS_COMMAND_TERMINATED:
514 		desc1 = "command terminated";
515 		break;
516 	case MPI_SCSI_STATUS_TASK_SET_FULL:
517 		desc1 = "task set full";
518 		break;
519 	case MPI_SCSI_STATUS_ACA_ACTIVE:
520 		desc1 = "aca active";
521 		break;
522 	case MPI_SCSI_STATUS_FCPEXT_DEVICE_LOGGED_OUT:
523 		desc1 = "fcpext device logged out";
524 		break;
525 	case MPI_SCSI_STATUS_FCPEXT_NO_LINK:
526 		desc1 = "fcpext no link";
527 		break;
528 	case MPI_SCSI_STATUS_FCPEXT_UNASSIGNED:
529 		desc1 = "fcpext unassigned";
530 		break;
531 	default:
532 		desc1 = "";
533 		break;
534 	}
535 
536 	scsi_print_command(sc);
537 	printk(MYIOC_s_DEBUG_FMT "\tfw_channel = %d, fw_id = %d, lun = %llu\n",
538 	    ioc->name, pScsiReply->Bus, pScsiReply->TargetID, sc->device->lun);
539 	printk(MYIOC_s_DEBUG_FMT "\trequest_len = %d, underflow = %d, "
540 	    "resid = %d\n", ioc->name, scsi_bufflen(sc), sc->underflow,
541 	    scsi_get_resid(sc));
542 	printk(MYIOC_s_DEBUG_FMT "\ttag = %d, transfer_count = %d, "
543 	    "sc->result = %08X\n", ioc->name, le16_to_cpu(pScsiReply->TaskTag),
544 	    le32_to_cpu(pScsiReply->TransferCount), sc->result);
545 
546 	printk(MYIOC_s_DEBUG_FMT "\tiocstatus = %s (0x%04x), "
547 	    "scsi_status = %s (0x%02x), scsi_state = (0x%02x)\n",
548 	    ioc->name, desc, ioc_status, desc1, pScsiReply->SCSIStatus,
549 	    pScsiReply->SCSIState);
550 
551 	if (pScsiReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID) {
552 		skey = sc->sense_buffer[2] & 0x0F;
553 		asc = sc->sense_buffer[12];
554 		ascq = sc->sense_buffer[13];
555 
556 		printk(MYIOC_s_DEBUG_FMT "\t[sense_key,asc,ascq]: "
557 		    "[0x%02x,0x%02x,0x%02x]\n", ioc->name, skey, asc, ascq);
558 	}
559 
560 	/*
561 	 *  Look for + dump FCP ResponseInfo[]!
562 	 */
563 	if (pScsiReply->SCSIState & MPI_SCSI_STATE_RESPONSE_INFO_VALID &&
564 	    pScsiReply->ResponseInfo)
565 		printk(MYIOC_s_DEBUG_FMT "response_info = %08xh\n",
566 		    ioc->name, le32_to_cpu(pScsiReply->ResponseInfo));
567 }
568 #endif
569 
570 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
571 /*
572  *	mptscsih_io_done - Main SCSI IO callback routine registered to
573  *	Fusion MPT (base) driver
574  *	@ioc: Pointer to MPT_ADAPTER structure
575  *	@mf: Pointer to original MPT request frame
576  *	@r: Pointer to MPT reply frame (NULL if TurboReply)
577  *
578  *	This routine is called from mpt.c::mpt_interrupt() at the completion
579  *	of any SCSI IO request.
580  *	This routine is registered with the Fusion MPT (base) driver at driver
581  *	load/init time via the mpt_register() API call.
582  *
583  *	Returns 1 indicating alloc'd request frame ptr should be freed.
584  */
585 int
586 mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
587 {
588 	struct scsi_cmnd	*sc;
589 	MPT_SCSI_HOST	*hd;
590 	SCSIIORequest_t	*pScsiReq;
591 	SCSIIOReply_t	*pScsiReply;
592 	u16		 req_idx, req_idx_MR;
593 	VirtDevice	 *vdevice;
594 	VirtTarget	 *vtarget;
595 
596 	hd = shost_priv(ioc->sh);
597 	req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
598 	req_idx_MR = (mr != NULL) ?
599 	    le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx) : req_idx;
600 
601 	/* Special case, where already freed message frame is received from
602 	 * Firmware. It happens with Resetting IOC.
603 	 * Return immediately. Do not care
604 	 */
605 	if ((req_idx != req_idx_MR) ||
606 	    (le32_to_cpu(mf->u.frame.linkage.arg1) == 0xdeadbeaf))
607 		return 0;
608 
609 	sc = mptscsih_getclear_scsi_lookup(ioc, req_idx);
610 	if (sc == NULL) {
611 		MPIHeader_t *hdr = (MPIHeader_t *)mf;
612 
613 		/* Remark: writeSDP1 will use the ScsiDoneCtx
614 		 * If a SCSI I/O cmd, device disabled by OS and
615 		 * completion done. Cannot touch sc struct. Just free mem.
616 		 */
617 		if (hdr->Function == MPI_FUNCTION_SCSI_IO_REQUEST)
618 			printk(MYIOC_s_ERR_FMT "NULL ScsiCmd ptr!\n",
619 			ioc->name);
620 
621 		mptscsih_freeChainBuffers(ioc, req_idx);
622 		return 1;
623 	}
624 
625 	if ((unsigned char *)mf != sc->host_scribble) {
626 		mptscsih_freeChainBuffers(ioc, req_idx);
627 		return 1;
628 	}
629 
630 	if (ioc->bus_type == SAS) {
631 		VirtDevice *vdevice = sc->device->hostdata;
632 
633 		if (!vdevice || !vdevice->vtarget ||
634 		    vdevice->vtarget->deleted) {
635 			sc->result = DID_NO_CONNECT << 16;
636 			goto out;
637 		}
638 	}
639 
640 	sc->host_scribble = NULL;
641 	sc->result = DID_OK << 16;		/* Set default reply as OK */
642 	pScsiReq = (SCSIIORequest_t *) mf;
643 	pScsiReply = (SCSIIOReply_t *) mr;
644 
645 	if((ioc->facts.MsgVersion >= MPI_VERSION_01_05) && pScsiReply){
646 		dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT
647 			"ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d,task-tag=%d)\n",
648 			ioc->name, mf, mr, sc, req_idx, pScsiReply->TaskTag));
649 	}else{
650 		dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT
651 			"ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d)\n",
652 			ioc->name, mf, mr, sc, req_idx));
653 	}
654 
655 	if (pScsiReply == NULL) {
656 		/* special context reply handling */
657 		;
658 	} else {
659 		u32	 xfer_cnt;
660 		u16	 status;
661 		u8	 scsi_state, scsi_status;
662 		u32	 log_info;
663 
664 		status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK;
665 
666 		scsi_state = pScsiReply->SCSIState;
667 		scsi_status = pScsiReply->SCSIStatus;
668 		xfer_cnt = le32_to_cpu(pScsiReply->TransferCount);
669 		scsi_set_resid(sc, scsi_bufflen(sc) - xfer_cnt);
670 		log_info = le32_to_cpu(pScsiReply->IOCLogInfo);
671 
672 		/*
673 		 *  if we get a data underrun indication, yet no data was
674 		 *  transferred and the SCSI status indicates that the
675 		 *  command was never started, change the data underrun
676 		 *  to success
677 		 */
678 		if (status == MPI_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 &&
679 		    (scsi_status == MPI_SCSI_STATUS_BUSY ||
680 		     scsi_status == MPI_SCSI_STATUS_RESERVATION_CONFLICT ||
681 		     scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)) {
682 			status = MPI_IOCSTATUS_SUCCESS;
683 		}
684 
685 		if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)
686 			mptscsih_copy_sense_data(sc, hd, mf, pScsiReply);
687 
688 		/*
689 		 *  Look for + dump FCP ResponseInfo[]!
690 		 */
691 		if (scsi_state & MPI_SCSI_STATE_RESPONSE_INFO_VALID &&
692 		    pScsiReply->ResponseInfo) {
693 			printk(MYIOC_s_NOTE_FMT "[%d:%d:%d:%llu] "
694 			"FCP_ResponseInfo=%08xh\n", ioc->name,
695 			sc->device->host->host_no, sc->device->channel,
696 			sc->device->id, sc->device->lun,
697 			le32_to_cpu(pScsiReply->ResponseInfo));
698 		}
699 
700 		switch(status) {
701 		case MPI_IOCSTATUS_BUSY:			/* 0x0002 */
702 		case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES:	/* 0x0006 */
703 			/* CHECKME!
704 			 * Maybe: DRIVER_BUSY | SUGGEST_RETRY | DID_SOFT_ERROR (retry)
705 			 * But not: DID_BUS_BUSY lest one risk
706 			 * killing interrupt handler:-(
707 			 */
708 			sc->result = SAM_STAT_BUSY;
709 			break;
710 
711 		case MPI_IOCSTATUS_SCSI_INVALID_BUS:		/* 0x0041 */
712 		case MPI_IOCSTATUS_SCSI_INVALID_TARGETID:	/* 0x0042 */
713 			sc->result = DID_BAD_TARGET << 16;
714 			break;
715 
716 		case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE:	/* 0x0043 */
717 			/* Spoof to SCSI Selection Timeout! */
718 			if (ioc->bus_type != FC)
719 				sc->result = DID_NO_CONNECT << 16;
720 			/* else fibre, just stall until rescan event */
721 			else
722 				sc->result = DID_REQUEUE << 16;
723 
724 			if (hd->sel_timeout[pScsiReq->TargetID] < 0xFFFF)
725 				hd->sel_timeout[pScsiReq->TargetID]++;
726 
727 			vdevice = sc->device->hostdata;
728 			if (!vdevice)
729 				break;
730 			vtarget = vdevice->vtarget;
731 			if (vtarget->tflags & MPT_TARGET_FLAGS_LED_ON) {
732 				mptscsih_issue_sep_command(ioc, vtarget,
733 				    MPI_SEP_REQ_SLOTSTATUS_UNCONFIGURED);
734 				vtarget->tflags &= ~MPT_TARGET_FLAGS_LED_ON;
735 			}
736 			break;
737 
738 		case MPI_IOCSTATUS_SCSI_IOC_TERMINATED:		/* 0x004B */
739 			if ( ioc->bus_type == SAS ) {
740 				u16 ioc_status =
741 				    le16_to_cpu(pScsiReply->IOCStatus);
742 				if ((ioc_status &
743 					MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
744 					&&
745 					((log_info & SAS_LOGINFO_MASK) ==
746 					SAS_LOGINFO_NEXUS_LOSS)) {
747 						VirtDevice *vdevice =
748 						sc->device->hostdata;
749 
750 					    /* flag the device as being in
751 					     * device removal delay so we can
752 					     * notify the midlayer to hold off
753 					     * on timeout eh */
754 						if (vdevice && vdevice->
755 							vtarget &&
756 							vdevice->vtarget->
757 							raidVolume)
758 							printk(KERN_INFO
759 							"Skipping Raid Volume"
760 							"for inDMD\n");
761 						else if (vdevice &&
762 							vdevice->vtarget)
763 							vdevice->vtarget->
764 								inDMD = 1;
765 
766 					    sc->result =
767 						    (DID_TRANSPORT_DISRUPTED
768 						    << 16);
769 					    break;
770 				}
771 			} else if (ioc->bus_type == FC) {
772 				/*
773 				 * The FC IOC may kill a request for variety of
774 				 * reasons, some of which may be recovered by a
775 				 * retry, some which are unlikely to be
776 				 * recovered. Return DID_ERROR instead of
777 				 * DID_RESET to permit retry of the command,
778 				 * just not an infinite number of them
779 				 */
780 				sc->result = DID_ERROR << 16;
781 				break;
782 			}
783 
784 			/*
785 			 * Allow non-SAS & non-NEXUS_LOSS to drop into below code
786 			 */
787 			fallthrough;
788 
789 		case MPI_IOCSTATUS_SCSI_TASK_TERMINATED:	/* 0x0048 */
790 			/* Linux handles an unsolicited DID_RESET better
791 			 * than an unsolicited DID_ABORT.
792 			 */
793 			sc->result = DID_RESET << 16;
794 			break;
795 
796 		case MPI_IOCSTATUS_SCSI_EXT_TERMINATED:		/* 0x004C */
797 			if (ioc->bus_type == FC)
798 				sc->result = DID_ERROR << 16;
799 			else
800 				sc->result = DID_RESET << 16;
801 			break;
802 
803 		case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:	/* 0x0049 */
804 			scsi_set_resid(sc, scsi_bufflen(sc) - xfer_cnt);
805 			if((xfer_cnt==0)||(sc->underflow > xfer_cnt))
806 				sc->result=DID_SOFT_ERROR << 16;
807 			else /* Sufficient data transfer occurred */
808 				sc->result = (DID_OK << 16) | scsi_status;
809 			dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
810 			    "RESIDUAL_MISMATCH: result=%x on channel=%d id=%d\n",
811 			    ioc->name, sc->result, sc->device->channel, sc->device->id));
812 			break;
813 
814 		case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN:		/* 0x0045 */
815 			/*
816 			 *  Do upfront check for valid SenseData and give it
817 			 *  precedence!
818 			 */
819 			sc->result = (DID_OK << 16) | scsi_status;
820 			if (!(scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
821 
822 				/*
823 				 * For an Errata on LSI53C1030
824 				 * When the length of request data
825 				 * and transfer data are different
826 				 * with result of command (READ or VERIFY),
827 				 * DID_SOFT_ERROR is set.
828 				 */
829 				if (ioc->bus_type == SPI) {
830 					if ((pScsiReq->CDB[0] == READ_6  && ((pScsiReq->CDB[1] & 0x02) == 0)) ||
831 					    pScsiReq->CDB[0] == READ_10 ||
832 					    pScsiReq->CDB[0] == READ_12 ||
833 						(pScsiReq->CDB[0] == READ_16 &&
834 						((pScsiReq->CDB[1] & 0x02) == 0)) ||
835 					    pScsiReq->CDB[0] == VERIFY  ||
836 					    pScsiReq->CDB[0] == VERIFY_16) {
837 						if (scsi_bufflen(sc) !=
838 							xfer_cnt) {
839 							sc->result =
840 							DID_SOFT_ERROR << 16;
841 						    printk(KERN_WARNING "Errata"
842 						    "on LSI53C1030 occurred."
843 						    "sc->req_bufflen=0x%02x,"
844 						    "xfer_cnt=0x%02x\n",
845 						    scsi_bufflen(sc),
846 						    xfer_cnt);
847 						}
848 					}
849 				}
850 
851 				if (xfer_cnt < sc->underflow) {
852 					if (scsi_status == SAM_STAT_BUSY)
853 						sc->result = SAM_STAT_BUSY;
854 					else
855 						sc->result = DID_SOFT_ERROR << 16;
856 				}
857 				if (scsi_state & (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)) {
858 					/* What to do?
859 				 	*/
860 					sc->result = DID_SOFT_ERROR << 16;
861 				}
862 				else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
863 					/*  Not real sure here either...  */
864 					sc->result = DID_RESET << 16;
865 				}
866 			}
867 
868 
869 			dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
870 			    "  sc->underflow={report ERR if < %02xh bytes xfer'd}\n",
871 			    ioc->name, sc->underflow));
872 			dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
873 			    "  ActBytesXferd=%02xh\n", ioc->name, xfer_cnt));
874 
875 			/* Report Queue Full
876 			 */
877 			if (scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)
878 				mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
879 
880 			break;
881 
882 		case MPI_IOCSTATUS_SCSI_DATA_OVERRUN:		/* 0x0044 */
883 			scsi_set_resid(sc, 0);
884 			fallthrough;
885 		case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR:	/* 0x0040 */
886 		case MPI_IOCSTATUS_SUCCESS:			/* 0x0000 */
887 			sc->result = (DID_OK << 16) | scsi_status;
888 			if (scsi_state == 0) {
889 				;
890 			} else if (scsi_state &
891 			    MPI_SCSI_STATE_AUTOSENSE_VALID) {
892 
893 				/*
894 				 * For potential trouble on LSI53C1030.
895 				 * (date:2007.xx.)
896 				 * It is checked whether the length of
897 				 * request data is equal to
898 				 * the length of transfer and residual.
899 				 * MEDIUM_ERROR is set by incorrect data.
900 				 */
901 				if ((ioc->bus_type == SPI) &&
902 					(sc->sense_buffer[2] & 0x20)) {
903 					u32	 difftransfer;
904 					difftransfer =
905 					sc->sense_buffer[3] << 24 |
906 					sc->sense_buffer[4] << 16 |
907 					sc->sense_buffer[5] << 8 |
908 					sc->sense_buffer[6];
909 					if (((sc->sense_buffer[3] & 0x80) ==
910 						0x80) && (scsi_bufflen(sc)
911 						!= xfer_cnt)) {
912 						sc->sense_buffer[2] =
913 						    MEDIUM_ERROR;
914 						sc->sense_buffer[12] = 0xff;
915 						sc->sense_buffer[13] = 0xff;
916 						printk(KERN_WARNING"Errata"
917 						"on LSI53C1030 occurred."
918 						"sc->req_bufflen=0x%02x,"
919 						"xfer_cnt=0x%02x\n" ,
920 						scsi_bufflen(sc),
921 						xfer_cnt);
922 					}
923 					if (((sc->sense_buffer[3] & 0x80)
924 						!= 0x80) &&
925 						(scsi_bufflen(sc) !=
926 						xfer_cnt + difftransfer)) {
927 						sc->sense_buffer[2] =
928 							MEDIUM_ERROR;
929 						sc->sense_buffer[12] = 0xff;
930 						sc->sense_buffer[13] = 0xff;
931 						printk(KERN_WARNING
932 						"Errata on LSI53C1030 occurred"
933 						"sc->req_bufflen=0x%02x,"
934 						" xfer_cnt=0x%02x,"
935 						"difftransfer=0x%02x\n",
936 						scsi_bufflen(sc),
937 						xfer_cnt,
938 						difftransfer);
939 					}
940 				}
941 
942 				/*
943 				 * If running against circa 200003dd 909 MPT f/w,
944 				 * may get this (AUTOSENSE_VALID) for actual TASK_SET_FULL
945 				 * (QUEUE_FULL) returned from device! --> get 0x0000?128
946 				 * and with SenseBytes set to 0.
947 				 */
948 				if (pScsiReply->SCSIStatus == MPI_SCSI_STATUS_TASK_SET_FULL)
949 					mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
950 
951 			}
952 			else if (scsi_state &
953 			         (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)
954 			   ) {
955 				/*
956 				 * What to do?
957 				 */
958 				sc->result = DID_SOFT_ERROR << 16;
959 			}
960 			else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
961 				/*  Not real sure here either...  */
962 				sc->result = DID_RESET << 16;
963 			}
964 			else if (scsi_state & MPI_SCSI_STATE_QUEUE_TAG_REJECTED) {
965 				/* Device Inq. data indicates that it supports
966 				 * QTags, but rejects QTag messages.
967 				 * This command completed OK.
968 				 *
969 				 * Not real sure here either so do nothing...  */
970 			}
971 
972 			if (sc->result == MPI_SCSI_STATUS_TASK_SET_FULL)
973 				mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
974 
975 			/* Add handling of:
976 			 * Reservation Conflict, Busy,
977 			 * Command Terminated, CHECK
978 			 */
979 			break;
980 
981 		case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR:		/* 0x0047 */
982 			sc->result = DID_SOFT_ERROR << 16;
983 			break;
984 
985 		case MPI_IOCSTATUS_INVALID_FUNCTION:		/* 0x0001 */
986 		case MPI_IOCSTATUS_INVALID_SGL:			/* 0x0003 */
987 		case MPI_IOCSTATUS_INTERNAL_ERROR:		/* 0x0004 */
988 		case MPI_IOCSTATUS_RESERVED:			/* 0x0005 */
989 		case MPI_IOCSTATUS_INVALID_FIELD:		/* 0x0007 */
990 		case MPI_IOCSTATUS_INVALID_STATE:		/* 0x0008 */
991 		case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR:		/* 0x0046 */
992 		case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED:	/* 0x004A */
993 		default:
994 			/*
995 			 * What to do?
996 			 */
997 			sc->result = DID_SOFT_ERROR << 16;
998 			break;
999 
1000 		}	/* switch(status) */
1001 
1002 #ifdef CONFIG_FUSION_LOGGING
1003 		if (sc->result && (ioc->debug_level & MPT_DEBUG_REPLY))
1004 			mptscsih_info_scsiio(ioc, sc, pScsiReply);
1005 #endif
1006 
1007 	} /* end of address reply case */
1008 out:
1009 	/* Unmap the DMA buffers, if any. */
1010 	scsi_dma_unmap(sc);
1011 
1012 	scsi_done(sc);			/* Issue the command callback */
1013 
1014 	/* Free Chain buffers */
1015 	mptscsih_freeChainBuffers(ioc, req_idx);
1016 	return 1;
1017 }
1018 
1019 /*
1020  *	mptscsih_flush_running_cmds - For each command found, search
1021  *		Scsi_Host instance taskQ and reply to OS.
1022  *		Called only if recovering from a FW reload.
1023  *	@hd: Pointer to a SCSI HOST structure
1024  *
1025  *	Returns: None.
1026  *
1027  *	Must be called while new I/Os are being queued.
1028  */
1029 void
1030 mptscsih_flush_running_cmds(MPT_SCSI_HOST *hd)
1031 {
1032 	MPT_ADAPTER *ioc = hd->ioc;
1033 	struct scsi_cmnd *sc;
1034 	SCSIIORequest_t	*mf = NULL;
1035 	int		 ii;
1036 	int		 channel, id;
1037 
1038 	for (ii= 0; ii < ioc->req_depth; ii++) {
1039 		sc = mptscsih_getclear_scsi_lookup(ioc, ii);
1040 		if (!sc)
1041 			continue;
1042 		mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(ioc, ii);
1043 		if (!mf)
1044 			continue;
1045 		channel = mf->Bus;
1046 		id = mf->TargetID;
1047 		mptscsih_freeChainBuffers(ioc, ii);
1048 		mpt_free_msg_frame(ioc, (MPT_FRAME_HDR *)mf);
1049 		if ((unsigned char *)mf != sc->host_scribble)
1050 			continue;
1051 		scsi_dma_unmap(sc);
1052 		sc->result = DID_RESET << 16;
1053 		sc->host_scribble = NULL;
1054 		dtmprintk(ioc, sdev_printk(KERN_INFO, sc->device, MYIOC_s_FMT
1055 		    "completing cmds: fw_channel %d, fw_id %d, sc=%p, mf = %p, "
1056 		    "idx=%x\n", ioc->name, channel, id, sc, mf, ii));
1057 		scsi_done(sc);
1058 	}
1059 }
1060 EXPORT_SYMBOL(mptscsih_flush_running_cmds);
1061 
1062 /*
1063  *	mptscsih_search_running_cmds - Delete any commands associated
1064  *		with the specified target and lun. Function called only
1065  *		when a lun is disable by mid-layer.
1066  *		Do NOT access the referenced scsi_cmnd structure or
1067  *		members. Will cause either a paging or NULL ptr error.
1068  *		(BUT, BUT, BUT, the code does reference it! - mdr)
1069  *      @hd: Pointer to a SCSI HOST structure
1070  *	@vdevice: per device private data
1071  *
1072  *	Returns: None.
1073  *
1074  *	Called from slave_destroy.
1075  */
1076 static void
1077 mptscsih_search_running_cmds(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
1078 {
1079 	SCSIIORequest_t	*mf = NULL;
1080 	int		 ii;
1081 	struct scsi_cmnd *sc;
1082 	struct scsi_lun  lun;
1083 	MPT_ADAPTER *ioc = hd->ioc;
1084 	unsigned long	flags;
1085 
1086 	spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
1087 	for (ii = 0; ii < ioc->req_depth; ii++) {
1088 		if ((sc = ioc->ScsiLookup[ii]) != NULL) {
1089 
1090 			mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(ioc, ii);
1091 			if (mf == NULL)
1092 				continue;
1093 			/* If the device is a hidden raid component, then its
1094 			 * expected that the mf->function will be RAID_SCSI_IO
1095 			 */
1096 			if (vdevice->vtarget->tflags &
1097 			    MPT_TARGET_FLAGS_RAID_COMPONENT && mf->Function !=
1098 			    MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)
1099 				continue;
1100 
1101 			int_to_scsilun(vdevice->lun, &lun);
1102 			if ((mf->Bus != vdevice->vtarget->channel) ||
1103 			    (mf->TargetID != vdevice->vtarget->id) ||
1104 			    memcmp(lun.scsi_lun, mf->LUN, 8))
1105 				continue;
1106 
1107 			if ((unsigned char *)mf != sc->host_scribble)
1108 				continue;
1109 			ioc->ScsiLookup[ii] = NULL;
1110 			spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1111 			mptscsih_freeChainBuffers(ioc, ii);
1112 			mpt_free_msg_frame(ioc, (MPT_FRAME_HDR *)mf);
1113 			scsi_dma_unmap(sc);
1114 			sc->host_scribble = NULL;
1115 			sc->result = DID_NO_CONNECT << 16;
1116 			dtmprintk(ioc, sdev_printk(KERN_INFO, sc->device,
1117 			   MYIOC_s_FMT "completing cmds: fw_channel %d, "
1118 			   "fw_id %d, sc=%p, mf = %p, idx=%x\n", ioc->name,
1119 			   vdevice->vtarget->channel, vdevice->vtarget->id,
1120 			   sc, mf, ii));
1121 			scsi_done(sc);
1122 			spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
1123 		}
1124 	}
1125 	spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1126 	return;
1127 }
1128 
1129 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1130 
1131 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1132 /*
1133  *	mptscsih_report_queue_full - Report QUEUE_FULL status returned
1134  *	from a SCSI target device.
1135  *	@sc: Pointer to scsi_cmnd structure
1136  *	@pScsiReply: Pointer to SCSIIOReply_t
1137  *	@pScsiReq: Pointer to original SCSI request
1138  *
1139  *	This routine periodically reports QUEUE_FULL status returned from a
1140  *	SCSI target device.  It reports this to the console via kernel
1141  *	printk() API call, not more than once every 10 seconds.
1142  */
1143 static void
1144 mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq)
1145 {
1146 	long time = jiffies;
1147 	MPT_SCSI_HOST		*hd;
1148 	MPT_ADAPTER	*ioc;
1149 
1150 	if (sc->device == NULL)
1151 		return;
1152 	if (sc->device->host == NULL)
1153 		return;
1154 	if ((hd = shost_priv(sc->device->host)) == NULL)
1155 		return;
1156 	ioc = hd->ioc;
1157 	if (time - hd->last_queue_full > 10 * HZ) {
1158 		dprintk(ioc, printk(MYIOC_s_WARN_FMT "Device (%d:%d:%llu) reported QUEUE_FULL!\n",
1159 				ioc->name, 0, sc->device->id, sc->device->lun));
1160 		hd->last_queue_full = time;
1161 	}
1162 }
1163 
1164 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1165 /*
1166  *	mptscsih_remove - Removed scsi devices
1167  *	@pdev: Pointer to pci_dev structure
1168  *
1169  *
1170  */
1171 void
1172 mptscsih_remove(struct pci_dev *pdev)
1173 {
1174 	MPT_ADAPTER 		*ioc = pci_get_drvdata(pdev);
1175 	struct Scsi_Host 	*host = ioc->sh;
1176 	MPT_SCSI_HOST		*hd;
1177 	int sz1;
1178 
1179 	if (host == NULL)
1180 		hd = NULL;
1181 	else
1182 		hd = shost_priv(host);
1183 
1184 	mptscsih_shutdown(pdev);
1185 
1186 	sz1=0;
1187 
1188 	if (ioc->ScsiLookup != NULL) {
1189 		sz1 = ioc->req_depth * sizeof(void *);
1190 		kfree(ioc->ScsiLookup);
1191 		ioc->ScsiLookup = NULL;
1192 	}
1193 
1194 	dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1195 	    "Free'd ScsiLookup (%d) memory\n",
1196 	    ioc->name, sz1));
1197 
1198 	if (hd)
1199 		kfree(hd->info_kbuf);
1200 
1201 	/* NULL the Scsi_Host pointer
1202 	 */
1203 	ioc->sh = NULL;
1204 
1205 	if (host)
1206 		scsi_host_put(host);
1207 	mpt_detach(pdev);
1208 
1209 }
1210 
1211 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1212 /*
1213  *	mptscsih_shutdown - reboot notifier
1214  *
1215  */
1216 void
1217 mptscsih_shutdown(struct pci_dev *pdev)
1218 {
1219 }
1220 
1221 #ifdef CONFIG_PM
1222 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1223 /*
1224  *	mptscsih_suspend - Fusion MPT scsi driver suspend routine.
1225  *
1226  *
1227  */
1228 int
1229 mptscsih_suspend(struct pci_dev *pdev, pm_message_t state)
1230 {
1231 	MPT_ADAPTER 		*ioc = pci_get_drvdata(pdev);
1232 
1233 	scsi_block_requests(ioc->sh);
1234 	mptscsih_shutdown(pdev);
1235 	return mpt_suspend(pdev,state);
1236 }
1237 
1238 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1239 /*
1240  *	mptscsih_resume - Fusion MPT scsi driver resume routine.
1241  *
1242  *
1243  */
1244 int
1245 mptscsih_resume(struct pci_dev *pdev)
1246 {
1247 	MPT_ADAPTER 		*ioc = pci_get_drvdata(pdev);
1248 	int rc;
1249 
1250 	rc = mpt_resume(pdev);
1251 	scsi_unblock_requests(ioc->sh);
1252 	return rc;
1253 }
1254 
1255 #endif
1256 
1257 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1258 /**
1259  *	mptscsih_info - Return information about MPT adapter
1260  *	@SChost: Pointer to Scsi_Host structure
1261  *
1262  *	(linux scsi_host_template.info routine)
1263  *
1264  *	Returns pointer to buffer where information was written.
1265  */
1266 const char *
1267 mptscsih_info(struct Scsi_Host *SChost)
1268 {
1269 	MPT_SCSI_HOST *h;
1270 	int size = 0;
1271 
1272 	h = shost_priv(SChost);
1273 
1274 	if (h->info_kbuf == NULL)
1275 		if ((h->info_kbuf = kmalloc(0x1000 /* 4Kb */, GFP_KERNEL)) == NULL)
1276 			return h->info_kbuf;
1277 	h->info_kbuf[0] = '\0';
1278 
1279 	mpt_print_ioc_summary(h->ioc, h->info_kbuf, &size, 0, 0);
1280 	h->info_kbuf[size-1] = '\0';
1281 
1282 	return h->info_kbuf;
1283 }
1284 
1285 int mptscsih_show_info(struct seq_file *m, struct Scsi_Host *host)
1286 {
1287 	MPT_SCSI_HOST	*hd = shost_priv(host);
1288 	MPT_ADAPTER	*ioc = hd->ioc;
1289 
1290 	seq_printf(m, "%s: %s, ", ioc->name, ioc->prod_name);
1291 	seq_printf(m, "%s%08xh, ", MPT_FW_REV_MAGIC_ID_STRING, ioc->facts.FWVersion.Word);
1292 	seq_printf(m, "Ports=%d, ", ioc->facts.NumberOfPorts);
1293 	seq_printf(m, "MaxQ=%d\n", ioc->req_depth);
1294 
1295 	return 0;
1296 }
1297 
1298 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1299 #define ADD_INDEX_LOG(req_ent)	do { } while(0)
1300 
1301 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1302 /**
1303  *	mptscsih_qcmd - Primary Fusion MPT SCSI initiator IO start routine.
1304  *	@SCpnt: Pointer to scsi_cmnd structure
1305  *
1306  *	(linux scsi_host_template.queuecommand routine)
1307  *	This is the primary SCSI IO start routine.  Create a MPI SCSIIORequest
1308  *	from a linux scsi_cmnd request and send it to the IOC.
1309  *
1310  *	Returns 0. (rtn value discarded by linux scsi mid-layer)
1311  */
1312 int
1313 mptscsih_qcmd(struct scsi_cmnd *SCpnt)
1314 {
1315 	MPT_SCSI_HOST		*hd;
1316 	MPT_FRAME_HDR		*mf;
1317 	SCSIIORequest_t		*pScsiReq;
1318 	VirtDevice		*vdevice = SCpnt->device->hostdata;
1319 	u32	 datalen;
1320 	u32	 scsictl;
1321 	u32	 scsidir;
1322 	u32	 cmd_len;
1323 	int	 my_idx;
1324 	int	 ii;
1325 	MPT_ADAPTER *ioc;
1326 
1327 	hd = shost_priv(SCpnt->device->host);
1328 	ioc = hd->ioc;
1329 
1330 	dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "qcmd: SCpnt=%p\n",
1331 		ioc->name, SCpnt));
1332 
1333 	if (ioc->taskmgmt_quiesce_io)
1334 		return SCSI_MLQUEUE_HOST_BUSY;
1335 
1336 	/*
1337 	 *  Put together a MPT SCSI request...
1338 	 */
1339 	if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
1340 		dprintk(ioc, printk(MYIOC_s_WARN_FMT "QueueCmd, no msg frames!!\n",
1341 				ioc->name));
1342 		return SCSI_MLQUEUE_HOST_BUSY;
1343 	}
1344 
1345 	pScsiReq = (SCSIIORequest_t *) mf;
1346 
1347 	my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1348 
1349 	ADD_INDEX_LOG(my_idx);
1350 
1351 	/*    TUR's being issued with scsictl=0x02000000 (DATA_IN)!
1352 	 *    Seems we may receive a buffer (datalen>0) even when there
1353 	 *    will be no data transfer!  GRRRRR...
1354 	 */
1355 	if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
1356 		datalen = scsi_bufflen(SCpnt);
1357 		scsidir = MPI_SCSIIO_CONTROL_READ;	/* DATA IN  (host<--ioc<--dev) */
1358 	} else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) {
1359 		datalen = scsi_bufflen(SCpnt);
1360 		scsidir = MPI_SCSIIO_CONTROL_WRITE;	/* DATA OUT (host-->ioc-->dev) */
1361 	} else {
1362 		datalen = 0;
1363 		scsidir = MPI_SCSIIO_CONTROL_NODATATRANSFER;
1364 	}
1365 
1366 	/* Default to untagged. Once a target structure has been allocated,
1367 	 * use the Inquiry data to determine if device supports tagged.
1368 	 */
1369 	if ((vdevice->vtarget->tflags & MPT_TARGET_FLAGS_Q_YES) &&
1370 	    SCpnt->device->tagged_supported)
1371 		scsictl = scsidir | MPI_SCSIIO_CONTROL_SIMPLEQ;
1372 	else
1373 		scsictl = scsidir | MPI_SCSIIO_CONTROL_UNTAGGED;
1374 
1375 
1376 	/* Use the above information to set up the message frame
1377 	 */
1378 	pScsiReq->TargetID = (u8) vdevice->vtarget->id;
1379 	pScsiReq->Bus = vdevice->vtarget->channel;
1380 	pScsiReq->ChainOffset = 0;
1381 	if (vdevice->vtarget->tflags &  MPT_TARGET_FLAGS_RAID_COMPONENT)
1382 		pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
1383 	else
1384 		pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
1385 	pScsiReq->CDBLength = SCpnt->cmd_len;
1386 	pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1387 	pScsiReq->Reserved = 0;
1388 	pScsiReq->MsgFlags = mpt_msg_flags(ioc);
1389 	int_to_scsilun(SCpnt->device->lun, (struct scsi_lun *)pScsiReq->LUN);
1390 	pScsiReq->Control = cpu_to_le32(scsictl);
1391 
1392 	/*
1393 	 *  Write SCSI CDB into the message
1394 	 */
1395 	cmd_len = SCpnt->cmd_len;
1396 	for (ii=0; ii < cmd_len; ii++)
1397 		pScsiReq->CDB[ii] = SCpnt->cmnd[ii];
1398 
1399 	for (ii=cmd_len; ii < 16; ii++)
1400 		pScsiReq->CDB[ii] = 0;
1401 
1402 	/* DataLength */
1403 	pScsiReq->DataLength = cpu_to_le32(datalen);
1404 
1405 	/* SenseBuffer low address */
1406 	pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma
1407 					   + (my_idx * MPT_SENSE_BUFFER_ALLOC));
1408 
1409 	/* Now add the SG list
1410 	 * Always have a SGE even if null length.
1411 	 */
1412 	if (datalen == 0) {
1413 		/* Add a NULL SGE */
1414 		ioc->add_sge((char *)&pScsiReq->SGL,
1415 			MPT_SGE_FLAGS_SSIMPLE_READ | 0,
1416 			(dma_addr_t) -1);
1417 	} else {
1418 		/* Add a 32 or 64 bit SGE */
1419 		if (mptscsih_AddSGE(ioc, SCpnt, pScsiReq, my_idx) != SUCCESS)
1420 			goto fail;
1421 	}
1422 
1423 	SCpnt->host_scribble = (unsigned char *)mf;
1424 	mptscsih_set_scsi_lookup(ioc, my_idx, SCpnt);
1425 
1426 	mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
1427 	dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Issued SCSI cmd (%p) mf=%p idx=%d\n",
1428 			ioc->name, SCpnt, mf, my_idx));
1429 	DBG_DUMP_REQUEST_FRAME(ioc, (u32 *)mf);
1430 	return 0;
1431 
1432  fail:
1433 	mptscsih_freeChainBuffers(ioc, my_idx);
1434 	mpt_free_msg_frame(ioc, mf);
1435 	return SCSI_MLQUEUE_HOST_BUSY;
1436 }
1437 
1438 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1439 /*
1440  *	mptscsih_freeChainBuffers - Function to free chain buffers associated
1441  *	with a SCSI IO request
1442  *	@hd: Pointer to the MPT_SCSI_HOST instance
1443  *	@req_idx: Index of the SCSI IO request frame.
1444  *
1445  *	Called if SG chain buffer allocation fails and mptscsih callbacks.
1446  *	No return.
1447  */
1448 static void
1449 mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx)
1450 {
1451 	MPT_FRAME_HDR *chain;
1452 	unsigned long flags;
1453 	int chain_idx;
1454 	int next;
1455 
1456 	/* Get the first chain index and reset
1457 	 * tracker state.
1458 	 */
1459 	chain_idx = ioc->ReqToChain[req_idx];
1460 	ioc->ReqToChain[req_idx] = MPT_HOST_NO_CHAIN;
1461 
1462 	while (chain_idx != MPT_HOST_NO_CHAIN) {
1463 
1464 		/* Save the next chain buffer index */
1465 		next = ioc->ChainToChain[chain_idx];
1466 
1467 		/* Free this chain buffer and reset
1468 		 * tracker
1469 		 */
1470 		ioc->ChainToChain[chain_idx] = MPT_HOST_NO_CHAIN;
1471 
1472 		chain = (MPT_FRAME_HDR *) (ioc->ChainBuffer
1473 					+ (chain_idx * ioc->req_sz));
1474 
1475 		spin_lock_irqsave(&ioc->FreeQlock, flags);
1476 		list_add_tail(&chain->u.frame.linkage.list, &ioc->FreeChainQ);
1477 		spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1478 
1479 		dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "FreeChainBuffers (index %d)\n",
1480 				ioc->name, chain_idx));
1481 
1482 		/* handle next */
1483 		chain_idx = next;
1484 	}
1485 	return;
1486 }
1487 
1488 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1489 /*
1490  *	Reset Handling
1491  */
1492 
1493 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1494 /**
1495  *	mptscsih_IssueTaskMgmt - Generic send Task Management function.
1496  *	@hd: Pointer to MPT_SCSI_HOST structure
1497  *	@type: Task Management type
1498  *	@channel: channel number for task management
1499  *	@id: Logical Target ID for reset (if appropriate)
1500  *	@lun: Logical Unit for reset (if appropriate)
1501  *	@ctx2abort: Context for the task to be aborted (if appropriate)
1502  *	@timeout: timeout for task management control
1503  *
1504  *	Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
1505  *	or a non-interrupt thread.  In the former, must not call schedule().
1506  *
1507  *	Not all fields are meaningfull for all task types.
1508  *
1509  *	Returns 0 for SUCCESS, or FAILED.
1510  *
1511  **/
1512 int
1513 mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, u64 lun,
1514 	int ctx2abort, ulong timeout)
1515 {
1516 	MPT_FRAME_HDR	*mf;
1517 	SCSITaskMgmt_t	*pScsiTm;
1518 	int		 ii;
1519 	int		 retval;
1520 	MPT_ADAPTER 	*ioc = hd->ioc;
1521 	u8		 issue_hard_reset;
1522 	u32		 ioc_raw_state;
1523 	unsigned long	 time_count;
1524 
1525 	issue_hard_reset = 0;
1526 	ioc_raw_state = mpt_GetIocState(ioc, 0);
1527 
1528 	if ((ioc_raw_state & MPI_IOC_STATE_MASK) != MPI_IOC_STATE_OPERATIONAL) {
1529 		printk(MYIOC_s_WARN_FMT
1530 			"TaskMgmt type=%x: IOC Not operational (0x%x)!\n",
1531 			ioc->name, type, ioc_raw_state);
1532 		printk(MYIOC_s_WARN_FMT "Issuing HardReset from %s!!\n",
1533 		    ioc->name, __func__);
1534 		if (mpt_HardResetHandler(ioc, CAN_SLEEP) < 0)
1535 			printk(MYIOC_s_WARN_FMT "TaskMgmt HardReset "
1536 			    "FAILED!!\n", ioc->name);
1537 		return 0;
1538 	}
1539 
1540 	/* DOORBELL ACTIVE check is not required if
1541 	*  MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q is supported.
1542 	*/
1543 
1544 	if (!((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q)
1545 		 && (ioc->facts.MsgVersion >= MPI_VERSION_01_05)) &&
1546 		(ioc_raw_state & MPI_DOORBELL_ACTIVE)) {
1547 		printk(MYIOC_s_WARN_FMT
1548 			"TaskMgmt type=%x: ioc_state: "
1549 			"DOORBELL_ACTIVE (0x%x)!\n",
1550 			ioc->name, type, ioc_raw_state);
1551 		return FAILED;
1552 	}
1553 
1554 	mutex_lock(&ioc->taskmgmt_cmds.mutex);
1555 	if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
1556 		mf = NULL;
1557 		retval = FAILED;
1558 		goto out;
1559 	}
1560 
1561 	/* Return Fail to calling function if no message frames available.
1562 	 */
1563 	if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) {
1564 		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1565 			"TaskMgmt no msg frames!!\n", ioc->name));
1566 		retval = FAILED;
1567 		mpt_clear_taskmgmt_in_progress_flag(ioc);
1568 		goto out;
1569 	}
1570 	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
1571 			ioc->name, mf));
1572 
1573 	/* Format the Request
1574 	 */
1575 	pScsiTm = (SCSITaskMgmt_t *) mf;
1576 	pScsiTm->TargetID = id;
1577 	pScsiTm->Bus = channel;
1578 	pScsiTm->ChainOffset = 0;
1579 	pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
1580 
1581 	pScsiTm->Reserved = 0;
1582 	pScsiTm->TaskType = type;
1583 	pScsiTm->Reserved1 = 0;
1584 	pScsiTm->MsgFlags = (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS)
1585                     ? MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION : 0;
1586 
1587 	int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
1588 
1589 	for (ii=0; ii < 7; ii++)
1590 		pScsiTm->Reserved2[ii] = 0;
1591 
1592 	pScsiTm->TaskMsgContext = ctx2abort;
1593 
1594 	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt: ctx2abort (0x%08x) "
1595 		"task_type = 0x%02X, timeout = %ld\n", ioc->name, ctx2abort,
1596 		type, timeout));
1597 
1598 	DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)pScsiTm);
1599 
1600 	INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
1601 	time_count = jiffies;
1602 	if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
1603 	    (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
1604 		mpt_put_msg_frame_hi_pri(ioc->TaskCtx, ioc, mf);
1605 	else {
1606 		retval = mpt_send_handshake_request(ioc->TaskCtx, ioc,
1607 			sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
1608 		if (retval) {
1609 			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1610 				"TaskMgmt handshake FAILED!(mf=%p, rc=%d) \n",
1611 				ioc->name, mf, retval));
1612 			mpt_free_msg_frame(ioc, mf);
1613 			mpt_clear_taskmgmt_in_progress_flag(ioc);
1614 			goto out;
1615 		}
1616 	}
1617 
1618 	wait_for_completion_timeout(&ioc->taskmgmt_cmds.done,
1619 		timeout*HZ);
1620 	if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
1621 		retval = FAILED;
1622 		dtmprintk(ioc, printk(MYIOC_s_ERR_FMT
1623 		    "TaskMgmt TIMED OUT!(mf=%p)\n", ioc->name, mf));
1624 		mpt_clear_taskmgmt_in_progress_flag(ioc);
1625 		if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
1626 			goto out;
1627 		issue_hard_reset = 1;
1628 		goto out;
1629 	}
1630 
1631 	retval = mptscsih_taskmgmt_reply(ioc, type,
1632 	    (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply);
1633 
1634 	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1635 	    "TaskMgmt completed (%d seconds)\n",
1636 	    ioc->name, jiffies_to_msecs(jiffies - time_count)/1000));
1637 
1638  out:
1639 
1640 	CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
1641 	if (issue_hard_reset) {
1642 		printk(MYIOC_s_WARN_FMT
1643 		       "Issuing Reset from %s!! doorbell=0x%08x\n",
1644 		       ioc->name, __func__, mpt_GetIocState(ioc, 0));
1645 		retval = (ioc->bus_type == SAS) ?
1646 			mpt_HardResetHandler(ioc, CAN_SLEEP) :
1647 			mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
1648 		mpt_free_msg_frame(ioc, mf);
1649 	}
1650 
1651 	retval = (retval == 0) ? 0 : FAILED;
1652 	mutex_unlock(&ioc->taskmgmt_cmds.mutex);
1653 	return retval;
1654 }
1655 EXPORT_SYMBOL(mptscsih_IssueTaskMgmt);
1656 
1657 static int
1658 mptscsih_get_tm_timeout(MPT_ADAPTER *ioc)
1659 {
1660 	switch (ioc->bus_type) {
1661 	case FC:
1662 		return 40;
1663 	case SAS:
1664 		return 30;
1665 	case SPI:
1666 	default:
1667 		return 10;
1668 	}
1669 }
1670 
1671 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1672 /**
1673  *	mptscsih_abort - Abort linux scsi_cmnd routine, new_eh variant
1674  *	@SCpnt: Pointer to scsi_cmnd structure, IO to be aborted
1675  *
1676  *	(linux scsi_host_template.eh_abort_handler routine)
1677  *
1678  *	Returns SUCCESS or FAILED.
1679  **/
1680 int
1681 mptscsih_abort(struct scsi_cmnd * SCpnt)
1682 {
1683 	MPT_SCSI_HOST	*hd;
1684 	MPT_FRAME_HDR	*mf;
1685 	u32		 ctx2abort;
1686 	int		 scpnt_idx;
1687 	int		 retval;
1688 	VirtDevice	 *vdevice;
1689 	MPT_ADAPTER	*ioc;
1690 
1691 	/* If we can't locate our host adapter structure, return FAILED status.
1692 	 */
1693 	if ((hd = shost_priv(SCpnt->device->host)) == NULL) {
1694 		SCpnt->result = DID_RESET << 16;
1695 		scsi_done(SCpnt);
1696 		printk(KERN_ERR MYNAM ": task abort: "
1697 		    "can't locate host! (sc=%p)\n", SCpnt);
1698 		return FAILED;
1699 	}
1700 
1701 	ioc = hd->ioc;
1702 	printk(MYIOC_s_INFO_FMT "attempting task abort! (sc=%p)\n",
1703 	       ioc->name, SCpnt);
1704 	scsi_print_command(SCpnt);
1705 
1706 	vdevice = SCpnt->device->hostdata;
1707 	if (!vdevice || !vdevice->vtarget) {
1708 		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1709 		    "task abort: device has been deleted (sc=%p)\n",
1710 		    ioc->name, SCpnt));
1711 		SCpnt->result = DID_NO_CONNECT << 16;
1712 		scsi_done(SCpnt);
1713 		retval = SUCCESS;
1714 		goto out;
1715 	}
1716 
1717 	/* Task aborts are not supported for hidden raid components.
1718 	 */
1719 	if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
1720 		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1721 		    "task abort: hidden raid component (sc=%p)\n",
1722 		    ioc->name, SCpnt));
1723 		SCpnt->result = DID_RESET << 16;
1724 		retval = FAILED;
1725 		goto out;
1726 	}
1727 
1728 	/* Task aborts are not supported for volumes.
1729 	 */
1730 	if (vdevice->vtarget->raidVolume) {
1731 		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1732 		    "task abort: raid volume (sc=%p)\n",
1733 		    ioc->name, SCpnt));
1734 		SCpnt->result = DID_RESET << 16;
1735 		retval = FAILED;
1736 		goto out;
1737 	}
1738 
1739 	/* Find this command
1740 	 */
1741 	if ((scpnt_idx = SCPNT_TO_LOOKUP_IDX(ioc, SCpnt)) < 0) {
1742 		/* Cmd not found in ScsiLookup.
1743 		 * Do OS callback.
1744 		 */
1745 		SCpnt->result = DID_RESET << 16;
1746 		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "task abort: "
1747 		   "Command not in the active list! (sc=%p)\n", ioc->name,
1748 		   SCpnt));
1749 		retval = SUCCESS;
1750 		goto out;
1751 	}
1752 
1753 	if (ioc->timeouts < -1)
1754 		ioc->timeouts++;
1755 
1756 	if (mpt_fwfault_debug)
1757 		mpt_halt_firmware(ioc);
1758 
1759 	/* Most important!  Set TaskMsgContext to SCpnt's MsgContext!
1760 	 * (the IO to be ABORT'd)
1761 	 *
1762 	 * NOTE: Since we do not byteswap MsgContext, we do not
1763 	 *	 swap it here either.  It is an opaque cookie to
1764 	 *	 the controller, so it does not matter. -DaveM
1765 	 */
1766 	mf = MPT_INDEX_2_MFPTR(ioc, scpnt_idx);
1767 	ctx2abort = mf->u.frame.hwhdr.msgctxu.MsgContext;
1768 	retval = mptscsih_IssueTaskMgmt(hd,
1769 			 MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
1770 			 vdevice->vtarget->channel,
1771 			 vdevice->vtarget->id, vdevice->lun,
1772 			 ctx2abort, mptscsih_get_tm_timeout(ioc));
1773 
1774 	if (SCPNT_TO_LOOKUP_IDX(ioc, SCpnt) == scpnt_idx) {
1775 		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1776 		    "task abort: command still in active list! (sc=%p)\n",
1777 		    ioc->name, SCpnt));
1778 		retval = FAILED;
1779 	} else {
1780 		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1781 		    "task abort: command cleared from active list! (sc=%p)\n",
1782 		    ioc->name, SCpnt));
1783 		retval = SUCCESS;
1784 	}
1785 
1786  out:
1787 	printk(MYIOC_s_INFO_FMT "task abort: %s (rv=%04x) (sc=%p)\n",
1788 	    ioc->name, ((retval == SUCCESS) ? "SUCCESS" : "FAILED"), retval,
1789 	    SCpnt);
1790 
1791 	return retval;
1792 }
1793 
1794 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1795 /**
1796  *	mptscsih_dev_reset - Perform a SCSI TARGET_RESET!  new_eh variant
1797  *	@SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1798  *
1799  *	(linux scsi_host_template.eh_dev_reset_handler routine)
1800  *
1801  *	Returns SUCCESS or FAILED.
1802  **/
1803 int
1804 mptscsih_dev_reset(struct scsi_cmnd * SCpnt)
1805 {
1806 	MPT_SCSI_HOST	*hd;
1807 	int		 retval;
1808 	VirtDevice	 *vdevice;
1809 	MPT_ADAPTER	*ioc;
1810 
1811 	/* If we can't locate our host adapter structure, return FAILED status.
1812 	 */
1813 	if ((hd = shost_priv(SCpnt->device->host)) == NULL){
1814 		printk(KERN_ERR MYNAM ": target reset: "
1815 		   "Can't locate host! (sc=%p)\n", SCpnt);
1816 		return FAILED;
1817 	}
1818 
1819 	ioc = hd->ioc;
1820 	printk(MYIOC_s_INFO_FMT "attempting target reset! (sc=%p)\n",
1821 	       ioc->name, SCpnt);
1822 	scsi_print_command(SCpnt);
1823 
1824 	vdevice = SCpnt->device->hostdata;
1825 	if (!vdevice || !vdevice->vtarget) {
1826 		retval = 0;
1827 		goto out;
1828 	}
1829 
1830 	/* Target reset to hidden raid component is not supported
1831 	 */
1832 	if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
1833 		retval = FAILED;
1834 		goto out;
1835 	}
1836 
1837 	retval = mptscsih_IssueTaskMgmt(hd,
1838 				MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
1839 				vdevice->vtarget->channel,
1840 				vdevice->vtarget->id, 0, 0,
1841 				mptscsih_get_tm_timeout(ioc));
1842 
1843  out:
1844 	printk (MYIOC_s_INFO_FMT "target reset: %s (sc=%p)\n",
1845 	    ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1846 
1847 	if (retval == 0)
1848 		return SUCCESS;
1849 	else
1850 		return FAILED;
1851 }
1852 
1853 
1854 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1855 /**
1856  *	mptscsih_bus_reset - Perform a SCSI BUS_RESET!	new_eh variant
1857  *	@SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1858  *
1859  *	(linux scsi_host_template.eh_bus_reset_handler routine)
1860  *
1861  *	Returns SUCCESS or FAILED.
1862  **/
1863 int
1864 mptscsih_bus_reset(struct scsi_cmnd * SCpnt)
1865 {
1866 	MPT_SCSI_HOST	*hd;
1867 	int		 retval;
1868 	VirtDevice	 *vdevice;
1869 	MPT_ADAPTER	*ioc;
1870 
1871 	/* If we can't locate our host adapter structure, return FAILED status.
1872 	 */
1873 	if ((hd = shost_priv(SCpnt->device->host)) == NULL){
1874 		printk(KERN_ERR MYNAM ": bus reset: "
1875 		   "Can't locate host! (sc=%p)\n", SCpnt);
1876 		return FAILED;
1877 	}
1878 
1879 	ioc = hd->ioc;
1880 	printk(MYIOC_s_INFO_FMT "attempting bus reset! (sc=%p)\n",
1881 	       ioc->name, SCpnt);
1882 	scsi_print_command(SCpnt);
1883 
1884 	if (ioc->timeouts < -1)
1885 		ioc->timeouts++;
1886 
1887 	vdevice = SCpnt->device->hostdata;
1888 	if (!vdevice || !vdevice->vtarget)
1889 		return SUCCESS;
1890 	retval = mptscsih_IssueTaskMgmt(hd,
1891 					MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1892 					vdevice->vtarget->channel, 0, 0, 0,
1893 					mptscsih_get_tm_timeout(ioc));
1894 
1895 	printk(MYIOC_s_INFO_FMT "bus reset: %s (sc=%p)\n",
1896 	    ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1897 
1898 	if (retval == 0)
1899 		return SUCCESS;
1900 	else
1901 		return FAILED;
1902 }
1903 
1904 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1905 /**
1906  *	mptscsih_host_reset - Perform a SCSI host adapter RESET (new_eh variant)
1907  *	@SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1908  *
1909  *	(linux scsi_host_template.eh_host_reset_handler routine)
1910  *
1911  *	Returns SUCCESS or FAILED.
1912  */
1913 int
1914 mptscsih_host_reset(struct scsi_cmnd *SCpnt)
1915 {
1916 	MPT_SCSI_HOST *  hd;
1917 	int              status = SUCCESS;
1918 	MPT_ADAPTER	*ioc;
1919 	int		retval;
1920 
1921 	/*  If we can't locate the host to reset, then we failed. */
1922 	if ((hd = shost_priv(SCpnt->device->host)) == NULL){
1923 		printk(KERN_ERR MYNAM ": host reset: "
1924 		    "Can't locate host! (sc=%p)\n", SCpnt);
1925 		return FAILED;
1926 	}
1927 
1928 	/* make sure we have no outstanding commands at this stage */
1929 	mptscsih_flush_running_cmds(hd);
1930 
1931 	ioc = hd->ioc;
1932 	printk(MYIOC_s_INFO_FMT "attempting host reset! (sc=%p)\n",
1933 	    ioc->name, SCpnt);
1934 
1935 	/*  If our attempts to reset the host failed, then return a failed
1936 	 *  status.  The host will be taken off line by the SCSI mid-layer.
1937 	 */
1938 	retval = mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
1939 	if (retval < 0)
1940 		status = FAILED;
1941 	else
1942 		status = SUCCESS;
1943 
1944 	printk(MYIOC_s_INFO_FMT "host reset: %s (sc=%p)\n",
1945 	    ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1946 
1947 	return status;
1948 }
1949 
1950 static int
1951 mptscsih_taskmgmt_reply(MPT_ADAPTER *ioc, u8 type,
1952 	SCSITaskMgmtReply_t *pScsiTmReply)
1953 {
1954 	u16			 iocstatus;
1955 	u32			 termination_count;
1956 	int			 retval;
1957 
1958 	if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
1959 		retval = FAILED;
1960 		goto out;
1961 	}
1962 
1963 	DBG_DUMP_TM_REPLY_FRAME(ioc, (u32 *)pScsiTmReply);
1964 
1965 	iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
1966 	termination_count = le32_to_cpu(pScsiTmReply->TerminationCount);
1967 
1968 	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1969 	    "TaskMgmt fw_channel = %d, fw_id = %d, task_type = 0x%02X,\n"
1970 	    "\tiocstatus = 0x%04X, loginfo = 0x%08X, response_code = 0x%02X,\n"
1971 	    "\tterm_cmnds = %d\n", ioc->name, pScsiTmReply->Bus,
1972 	    pScsiTmReply->TargetID, type, le16_to_cpu(pScsiTmReply->IOCStatus),
1973 	    le32_to_cpu(pScsiTmReply->IOCLogInfo), pScsiTmReply->ResponseCode,
1974 	    termination_count));
1975 
1976 	if (ioc->facts.MsgVersion >= MPI_VERSION_01_05 &&
1977 	    pScsiTmReply->ResponseCode)
1978 		mptscsih_taskmgmt_response_code(ioc,
1979 		    pScsiTmReply->ResponseCode);
1980 
1981 	if (iocstatus == MPI_IOCSTATUS_SUCCESS) {
1982 		retval = 0;
1983 		goto out;
1984 	}
1985 
1986 	retval = FAILED;
1987 	if (type == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK) {
1988 		if (termination_count == 1)
1989 			retval = 0;
1990 		goto out;
1991 	}
1992 
1993 	if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
1994 	   iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED)
1995 		retval = 0;
1996 
1997  out:
1998 	return retval;
1999 }
2000 
2001 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2002 void
2003 mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code)
2004 {
2005 	char *desc;
2006 
2007 	switch (response_code) {
2008 	case MPI_SCSITASKMGMT_RSP_TM_COMPLETE:
2009 		desc = "The task completed.";
2010 		break;
2011 	case MPI_SCSITASKMGMT_RSP_INVALID_FRAME:
2012 		desc = "The IOC received an invalid frame status.";
2013 		break;
2014 	case MPI_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
2015 		desc = "The task type is not supported.";
2016 		break;
2017 	case MPI_SCSITASKMGMT_RSP_TM_FAILED:
2018 		desc = "The requested task failed.";
2019 		break;
2020 	case MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED:
2021 		desc = "The task completed successfully.";
2022 		break;
2023 	case MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN:
2024 		desc = "The LUN request is invalid.";
2025 		break;
2026 	case MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
2027 		desc = "The task is in the IOC queue and has not been sent to target.";
2028 		break;
2029 	default:
2030 		desc = "unknown";
2031 		break;
2032 	}
2033 	printk(MYIOC_s_INFO_FMT "Response Code(0x%08x): F/W: %s\n",
2034 		ioc->name, response_code, desc);
2035 }
2036 EXPORT_SYMBOL(mptscsih_taskmgmt_response_code);
2037 
2038 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2039 /**
2040  *	mptscsih_taskmgmt_complete - Registered with Fusion MPT base driver
2041  *	@ioc: Pointer to MPT_ADAPTER structure
2042  *	@mf: Pointer to SCSI task mgmt request frame
2043  *	@mr: Pointer to SCSI task mgmt reply frame
2044  *
2045  *	This routine is called from mptbase.c::mpt_interrupt() at the completion
2046  *	of any SCSI task management request.
2047  *	This routine is registered with the MPT (base) driver at driver
2048  *	load/init time via the mpt_register() API call.
2049  *
2050  *	Returns 1 indicating alloc'd request frame ptr should be freed.
2051  **/
2052 int
2053 mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf,
2054 	MPT_FRAME_HDR *mr)
2055 {
2056 	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2057 		"TaskMgmt completed (mf=%p, mr=%p)\n", ioc->name, mf, mr));
2058 
2059 	ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
2060 
2061 	if (!mr)
2062 		goto out;
2063 
2064 	ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
2065 	memcpy(ioc->taskmgmt_cmds.reply, mr,
2066 	    min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
2067  out:
2068 	if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
2069 		mpt_clear_taskmgmt_in_progress_flag(ioc);
2070 		ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
2071 		complete(&ioc->taskmgmt_cmds.done);
2072 		if (ioc->bus_type == SAS)
2073 			ioc->schedule_target_reset(ioc);
2074 		return 1;
2075 	}
2076 	return 0;
2077 }
2078 
2079 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2080 /*
2081  *	This is anyones guess quite frankly.
2082  */
2083 int
2084 mptscsih_bios_param(struct scsi_device * sdev, struct block_device *bdev,
2085 		sector_t capacity, int geom[])
2086 {
2087 	int		heads;
2088 	int		sectors;
2089 	sector_t	cylinders;
2090 	ulong 		dummy;
2091 
2092 	heads = 64;
2093 	sectors = 32;
2094 
2095 	dummy = heads * sectors;
2096 	cylinders = capacity;
2097 	sector_div(cylinders,dummy);
2098 
2099 	/*
2100 	 * Handle extended translation size for logical drives
2101 	 * > 1Gb
2102 	 */
2103 	if ((ulong)capacity >= 0x200000) {
2104 		heads = 255;
2105 		sectors = 63;
2106 		dummy = heads * sectors;
2107 		cylinders = capacity;
2108 		sector_div(cylinders,dummy);
2109 	}
2110 
2111 	/* return result */
2112 	geom[0] = heads;
2113 	geom[1] = sectors;
2114 	geom[2] = cylinders;
2115 
2116 	return 0;
2117 }
2118 
2119 /* Search IOC page 3 to determine if this is hidden physical disk
2120  *
2121  */
2122 int
2123 mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id)
2124 {
2125 	struct inactive_raid_component_info *component_info;
2126 	int i, j;
2127 	RaidPhysDiskPage1_t *phys_disk;
2128 	int rc = 0;
2129 	int num_paths;
2130 
2131 	if (!ioc->raid_data.pIocPg3)
2132 		goto out;
2133 	for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2134 		if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
2135 		    (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
2136 			rc = 1;
2137 			goto out;
2138 		}
2139 	}
2140 
2141 	if (ioc->bus_type != SAS)
2142 		goto out;
2143 
2144 	/*
2145 	 * Check if dual path
2146 	 */
2147 	for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2148 		num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
2149 		    ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
2150 		if (num_paths < 2)
2151 			continue;
2152 		phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
2153 		   (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
2154 		if (!phys_disk)
2155 			continue;
2156 		if ((mpt_raid_phys_disk_pg1(ioc,
2157 		    ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
2158 		    phys_disk))) {
2159 			kfree(phys_disk);
2160 			continue;
2161 		}
2162 		for (j = 0; j < num_paths; j++) {
2163 			if ((phys_disk->Path[j].Flags &
2164 			    MPI_RAID_PHYSDISK1_FLAG_INVALID))
2165 				continue;
2166 			if ((phys_disk->Path[j].Flags &
2167 			    MPI_RAID_PHYSDISK1_FLAG_BROKEN))
2168 				continue;
2169 			if ((id == phys_disk->Path[j].PhysDiskID) &&
2170 			    (channel == phys_disk->Path[j].PhysDiskBus)) {
2171 				rc = 1;
2172 				kfree(phys_disk);
2173 				goto out;
2174 			}
2175 		}
2176 		kfree(phys_disk);
2177 	}
2178 
2179 
2180 	/*
2181 	 * Check inactive list for matching phys disks
2182 	 */
2183 	if (list_empty(&ioc->raid_data.inactive_list))
2184 		goto out;
2185 
2186 	mutex_lock(&ioc->raid_data.inactive_list_mutex);
2187 	list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
2188 	    list) {
2189 		if ((component_info->d.PhysDiskID == id) &&
2190 		    (component_info->d.PhysDiskBus == channel))
2191 			rc = 1;
2192 	}
2193 	mutex_unlock(&ioc->raid_data.inactive_list_mutex);
2194 
2195  out:
2196 	return rc;
2197 }
2198 EXPORT_SYMBOL(mptscsih_is_phys_disk);
2199 
2200 u8
2201 mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
2202 {
2203 	struct inactive_raid_component_info *component_info;
2204 	int i, j;
2205 	RaidPhysDiskPage1_t *phys_disk;
2206 	int rc = -ENXIO;
2207 	int num_paths;
2208 
2209 	if (!ioc->raid_data.pIocPg3)
2210 		goto out;
2211 	for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2212 		if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
2213 		    (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
2214 			rc = ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum;
2215 			goto out;
2216 		}
2217 	}
2218 
2219 	if (ioc->bus_type != SAS)
2220 		goto out;
2221 
2222 	/*
2223 	 * Check if dual path
2224 	 */
2225 	for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2226 		num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
2227 		    ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
2228 		if (num_paths < 2)
2229 			continue;
2230 		phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
2231 		   (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
2232 		if (!phys_disk)
2233 			continue;
2234 		if ((mpt_raid_phys_disk_pg1(ioc,
2235 		    ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
2236 		    phys_disk))) {
2237 			kfree(phys_disk);
2238 			continue;
2239 		}
2240 		for (j = 0; j < num_paths; j++) {
2241 			if ((phys_disk->Path[j].Flags &
2242 			    MPI_RAID_PHYSDISK1_FLAG_INVALID))
2243 				continue;
2244 			if ((phys_disk->Path[j].Flags &
2245 			    MPI_RAID_PHYSDISK1_FLAG_BROKEN))
2246 				continue;
2247 			if ((id == phys_disk->Path[j].PhysDiskID) &&
2248 			    (channel == phys_disk->Path[j].PhysDiskBus)) {
2249 				rc = phys_disk->PhysDiskNum;
2250 				kfree(phys_disk);
2251 				goto out;
2252 			}
2253 		}
2254 		kfree(phys_disk);
2255 	}
2256 
2257 	/*
2258 	 * Check inactive list for matching phys disks
2259 	 */
2260 	if (list_empty(&ioc->raid_data.inactive_list))
2261 		goto out;
2262 
2263 	mutex_lock(&ioc->raid_data.inactive_list_mutex);
2264 	list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
2265 	    list) {
2266 		if ((component_info->d.PhysDiskID == id) &&
2267 		    (component_info->d.PhysDiskBus == channel))
2268 			rc = component_info->d.PhysDiskNum;
2269 	}
2270 	mutex_unlock(&ioc->raid_data.inactive_list_mutex);
2271 
2272  out:
2273 	return rc;
2274 }
2275 EXPORT_SYMBOL(mptscsih_raid_id_to_num);
2276 
2277 /*
2278  *	OS entry point to allow for host driver to free allocated memory
2279  *	Called if no device present or device being unloaded
2280  */
2281 void
2282 mptscsih_slave_destroy(struct scsi_device *sdev)
2283 {
2284 	struct Scsi_Host	*host = sdev->host;
2285 	MPT_SCSI_HOST		*hd = shost_priv(host);
2286 	VirtTarget		*vtarget;
2287 	VirtDevice		*vdevice;
2288 	struct scsi_target 	*starget;
2289 
2290 	starget = scsi_target(sdev);
2291 	vtarget = starget->hostdata;
2292 	vdevice = sdev->hostdata;
2293 	if (!vdevice)
2294 		return;
2295 
2296 	mptscsih_search_running_cmds(hd, vdevice);
2297 	vtarget->num_luns--;
2298 	mptscsih_synchronize_cache(hd, vdevice);
2299 	kfree(vdevice);
2300 	sdev->hostdata = NULL;
2301 }
2302 
2303 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2304 /*
2305  *	mptscsih_change_queue_depth - This function will set a devices queue depth
2306  *	@sdev: per scsi_device pointer
2307  *	@qdepth: requested queue depth
2308  *
2309  *	Adding support for new 'change_queue_depth' api.
2310 */
2311 int
2312 mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
2313 {
2314 	MPT_SCSI_HOST		*hd = shost_priv(sdev->host);
2315 	VirtTarget 		*vtarget;
2316 	struct scsi_target 	*starget;
2317 	int			max_depth;
2318 	MPT_ADAPTER		*ioc = hd->ioc;
2319 
2320 	starget = scsi_target(sdev);
2321 	vtarget = starget->hostdata;
2322 
2323 	if (ioc->bus_type == SPI) {
2324 		if (!(vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
2325 			max_depth = 1;
2326 		else if (sdev->type == TYPE_DISK &&
2327 			 vtarget->minSyncFactor <= MPT_ULTRA160)
2328 			max_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
2329 		else
2330 			max_depth = MPT_SCSI_CMD_PER_DEV_LOW;
2331 	} else
2332 		 max_depth = ioc->sh->can_queue;
2333 
2334 	if (!sdev->tagged_supported)
2335 		max_depth = 1;
2336 
2337 	if (qdepth > max_depth)
2338 		qdepth = max_depth;
2339 
2340 	return scsi_change_queue_depth(sdev, qdepth);
2341 }
2342 
2343 /*
2344  *	OS entry point to adjust the queue_depths on a per-device basis.
2345  *	Called once per device the bus scan. Use it to force the queue_depth
2346  *	member to 1 if a device does not support Q tags.
2347  *	Return non-zero if fails.
2348  */
2349 int
2350 mptscsih_slave_configure(struct scsi_device *sdev)
2351 {
2352 	struct Scsi_Host	*sh = sdev->host;
2353 	VirtTarget		*vtarget;
2354 	VirtDevice		*vdevice;
2355 	struct scsi_target 	*starget;
2356 	MPT_SCSI_HOST		*hd = shost_priv(sh);
2357 	MPT_ADAPTER		*ioc = hd->ioc;
2358 
2359 	starget = scsi_target(sdev);
2360 	vtarget = starget->hostdata;
2361 	vdevice = sdev->hostdata;
2362 
2363 	dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2364 		"device @ %p, channel=%d, id=%d, lun=%llu\n",
2365 		ioc->name, sdev, sdev->channel, sdev->id, sdev->lun));
2366 	if (ioc->bus_type == SPI)
2367 		dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2368 		    "sdtr %d wdtr %d ppr %d inq length=%d\n",
2369 		    ioc->name, sdev->sdtr, sdev->wdtr,
2370 		    sdev->ppr, sdev->inquiry_len));
2371 
2372 	vdevice->configured_lun = 1;
2373 
2374 	dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2375 		"Queue depth=%d, tflags=%x\n",
2376 		ioc->name, sdev->queue_depth, vtarget->tflags));
2377 
2378 	if (ioc->bus_type == SPI)
2379 		dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2380 		    "negoFlags=%x, maxOffset=%x, SyncFactor=%x\n",
2381 		    ioc->name, vtarget->negoFlags, vtarget->maxOffset,
2382 		    vtarget->minSyncFactor));
2383 
2384 	mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH);
2385 	dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2386 		"tagged %d, simple %d\n",
2387 		ioc->name,sdev->tagged_supported, sdev->simple_tags));
2388 
2389 	blk_queue_dma_alignment (sdev->request_queue, 512 - 1);
2390 
2391 	return 0;
2392 }
2393 
2394 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2395 /*
2396  *  Private routines...
2397  */
2398 
2399 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2400 /* Utility function to copy sense data from the scsi_cmnd buffer
2401  * to the FC and SCSI target structures.
2402  *
2403  */
2404 static void
2405 mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply)
2406 {
2407 	VirtDevice	*vdevice;
2408 	SCSIIORequest_t	*pReq;
2409 	u32		 sense_count = le32_to_cpu(pScsiReply->SenseCount);
2410 	MPT_ADAPTER 	*ioc = hd->ioc;
2411 
2412 	/* Get target structure
2413 	 */
2414 	pReq = (SCSIIORequest_t *) mf;
2415 	vdevice = sc->device->hostdata;
2416 
2417 	if (sense_count) {
2418 		u8 *sense_data;
2419 		int req_index;
2420 
2421 		/* Copy the sense received into the scsi command block. */
2422 		req_index = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2423 		sense_data = ((u8 *)ioc->sense_buf_pool + (req_index * MPT_SENSE_BUFFER_ALLOC));
2424 		memcpy(sc->sense_buffer, sense_data, MPT_SENSE_BUFFER_ALLOC);
2425 
2426 		/* Log SMART data (asc = 0x5D, non-IM case only) if required.
2427 		 */
2428 		if ((ioc->events) && (ioc->eventTypes & (1 << MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE))) {
2429 			if ((sense_data[12] == 0x5D) && (vdevice->vtarget->raidVolume == 0)) {
2430 				int idx;
2431 
2432 				idx = ioc->eventContext % MPTCTL_EVENT_LOG_SIZE;
2433 				ioc->events[idx].event = MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE;
2434 				ioc->events[idx].eventContext = ioc->eventContext;
2435 
2436 				ioc->events[idx].data[0] = (pReq->LUN[1] << 24) |
2437 					(MPI_EVENT_SCSI_DEV_STAT_RC_SMART_DATA << 16) |
2438 					(sc->device->channel << 8) | sc->device->id;
2439 
2440 				ioc->events[idx].data[1] = (sense_data[13] << 8) | sense_data[12];
2441 
2442 				ioc->eventContext++;
2443 				if (ioc->pcidev->vendor ==
2444 				    PCI_VENDOR_ID_IBM) {
2445 					mptscsih_issue_sep_command(ioc,
2446 					    vdevice->vtarget, MPI_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
2447 					vdevice->vtarget->tflags |=
2448 					    MPT_TARGET_FLAGS_LED_ON;
2449 				}
2450 			}
2451 		}
2452 	} else {
2453 		dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Hmmm... SenseData len=0! (?)\n",
2454 				ioc->name));
2455 	}
2456 }
2457 
2458 /**
2459  * mptscsih_get_scsi_lookup - retrieves scmd entry
2460  * @ioc: Pointer to MPT_ADAPTER structure
2461  * @i: index into the array
2462  *
2463  * Returns the scsi_cmd pointer
2464  */
2465 struct scsi_cmnd *
2466 mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i)
2467 {
2468 	unsigned long	flags;
2469 	struct scsi_cmnd *scmd;
2470 
2471 	spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2472 	scmd = ioc->ScsiLookup[i];
2473 	spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2474 
2475 	return scmd;
2476 }
2477 EXPORT_SYMBOL(mptscsih_get_scsi_lookup);
2478 
2479 /**
2480  * mptscsih_getclear_scsi_lookup -  retrieves and clears scmd entry from ScsiLookup[] array list
2481  * @ioc: Pointer to MPT_ADAPTER structure
2482  * @i: index into the array
2483  *
2484  * Returns the scsi_cmd pointer
2485  *
2486  **/
2487 static struct scsi_cmnd *
2488 mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i)
2489 {
2490 	unsigned long	flags;
2491 	struct scsi_cmnd *scmd;
2492 
2493 	spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2494 	scmd = ioc->ScsiLookup[i];
2495 	ioc->ScsiLookup[i] = NULL;
2496 	spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2497 
2498 	return scmd;
2499 }
2500 
2501 /**
2502  * mptscsih_set_scsi_lookup - write a scmd entry into the ScsiLookup[] array list
2503  *
2504  * @ioc: Pointer to MPT_ADAPTER structure
2505  * @i: index into the array
2506  * @scmd: scsi_cmnd pointer
2507  *
2508  **/
2509 static void
2510 mptscsih_set_scsi_lookup(MPT_ADAPTER *ioc, int i, struct scsi_cmnd *scmd)
2511 {
2512 	unsigned long	flags;
2513 
2514 	spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2515 	ioc->ScsiLookup[i] = scmd;
2516 	spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2517 }
2518 
2519 /**
2520  * SCPNT_TO_LOOKUP_IDX - searches for a given scmd in the ScsiLookup[] array list
2521  * @ioc: Pointer to MPT_ADAPTER structure
2522  * @sc: scsi_cmnd pointer
2523  */
2524 static int
2525 SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *sc)
2526 {
2527 	unsigned long	flags;
2528 	int i, index=-1;
2529 
2530 	spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2531 	for (i = 0; i < ioc->req_depth; i++) {
2532 		if (ioc->ScsiLookup[i] == sc) {
2533 			index = i;
2534 			goto out;
2535 		}
2536 	}
2537 
2538  out:
2539 	spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2540 	return index;
2541 }
2542 
2543 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2544 int
2545 mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
2546 {
2547 	MPT_SCSI_HOST	*hd;
2548 
2549 	if (ioc->sh == NULL || shost_priv(ioc->sh) == NULL)
2550 		return 0;
2551 
2552 	hd = shost_priv(ioc->sh);
2553 	switch (reset_phase) {
2554 	case MPT_IOC_SETUP_RESET:
2555 		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2556 		    "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__));
2557 		break;
2558 	case MPT_IOC_PRE_RESET:
2559 		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2560 		    "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__));
2561 		mptscsih_flush_running_cmds(hd);
2562 		break;
2563 	case MPT_IOC_POST_RESET:
2564 		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2565 		    "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__));
2566 		if (ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING) {
2567 			ioc->internal_cmds.status |=
2568 				MPT_MGMT_STATUS_DID_IOCRESET;
2569 			complete(&ioc->internal_cmds.done);
2570 		}
2571 		break;
2572 	default:
2573 		break;
2574 	}
2575 	return 1;		/* currently means nothing really */
2576 }
2577 
2578 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2579 int
2580 mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
2581 {
2582 	u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
2583 
2584 	devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2585 		"MPT event (=%02Xh) routed to SCSI host driver!\n",
2586 		ioc->name, event));
2587 
2588 	if ((event == MPI_EVENT_IOC_BUS_RESET ||
2589 	    event == MPI_EVENT_EXT_BUS_RESET) &&
2590 	    (ioc->bus_type == SPI) && (ioc->soft_resets < -1))
2591 			ioc->soft_resets++;
2592 
2593 	return 1;		/* currently means nothing really */
2594 }
2595 
2596 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2597 /*
2598  *  Bus Scan and Domain Validation functionality ...
2599  */
2600 
2601 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2602 /*
2603  *	mptscsih_scandv_complete - Scan and DV callback routine registered
2604  *	to Fustion MPT (base) driver.
2605  *
2606  *	@ioc: Pointer to MPT_ADAPTER structure
2607  *	@mf: Pointer to original MPT request frame
2608  *	@mr: Pointer to MPT reply frame (NULL if TurboReply)
2609  *
2610  *	This routine is called from mpt.c::mpt_interrupt() at the completion
2611  *	of any SCSI IO request.
2612  *	This routine is registered with the Fusion MPT (base) driver at driver
2613  *	load/init time via the mpt_register() API call.
2614  *
2615  *	Returns 1 indicating alloc'd request frame ptr should be freed.
2616  *
2617  *	Remark: Sets a completion code and (possibly) saves sense data
2618  *	in the IOC member localReply structure.
2619  *	Used ONLY for DV and other internal commands.
2620  */
2621 int
2622 mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2623 				MPT_FRAME_HDR *reply)
2624 {
2625 	SCSIIORequest_t *pReq;
2626 	SCSIIOReply_t	*pReply;
2627 	u8		 cmd;
2628 	u16		 req_idx;
2629 	u8	*sense_data;
2630 	int		 sz;
2631 
2632 	ioc->internal_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
2633 	ioc->internal_cmds.completion_code = MPT_SCANDV_GOOD;
2634 	if (!reply)
2635 		goto out;
2636 
2637 	pReply = (SCSIIOReply_t *) reply;
2638 	pReq = (SCSIIORequest_t *) req;
2639 	ioc->internal_cmds.completion_code =
2640 	    mptscsih_get_completion_code(ioc, req, reply);
2641 	ioc->internal_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
2642 	memcpy(ioc->internal_cmds.reply, reply,
2643 	    min(MPT_DEFAULT_FRAME_SIZE, 4 * reply->u.reply.MsgLength));
2644 	cmd = reply->u.hdr.Function;
2645 	if (((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) ||
2646 	    (cmd == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) &&
2647 	    (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
2648 		req_idx = le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
2649 		sense_data = ((u8 *)ioc->sense_buf_pool +
2650 		    (req_idx * MPT_SENSE_BUFFER_ALLOC));
2651 		sz = min_t(int, pReq->SenseBufferLength,
2652 		    MPT_SENSE_BUFFER_ALLOC);
2653 		memcpy(ioc->internal_cmds.sense, sense_data, sz);
2654 	}
2655  out:
2656 	if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING))
2657 		return 0;
2658 	ioc->internal_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
2659 	complete(&ioc->internal_cmds.done);
2660 	return 1;
2661 }
2662 
2663 
2664 /**
2665  *	mptscsih_get_completion_code - get completion code from MPT request
2666  *	@ioc: Pointer to MPT_ADAPTER structure
2667  *	@req: Pointer to original MPT request frame
2668  *	@reply: Pointer to MPT reply frame (NULL if TurboReply)
2669  *
2670  **/
2671 static int
2672 mptscsih_get_completion_code(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2673 				MPT_FRAME_HDR *reply)
2674 {
2675 	SCSIIOReply_t	*pReply;
2676 	MpiRaidActionReply_t *pr;
2677 	u8		 scsi_status;
2678 	u16		 status;
2679 	int		 completion_code;
2680 
2681 	pReply = (SCSIIOReply_t *)reply;
2682 	status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
2683 	scsi_status = pReply->SCSIStatus;
2684 
2685 	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2686 	    "IOCStatus=%04xh, SCSIState=%02xh, SCSIStatus=%02xh,"
2687 	    "IOCLogInfo=%08xh\n", ioc->name, status, pReply->SCSIState,
2688 	    scsi_status, le32_to_cpu(pReply->IOCLogInfo)));
2689 
2690 	switch (status) {
2691 
2692 	case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE:	/* 0x0043 */
2693 		completion_code = MPT_SCANDV_SELECTION_TIMEOUT;
2694 		break;
2695 
2696 	case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR:		/* 0x0046 */
2697 	case MPI_IOCSTATUS_SCSI_TASK_TERMINATED:	/* 0x0048 */
2698 	case MPI_IOCSTATUS_SCSI_IOC_TERMINATED:		/* 0x004B */
2699 	case MPI_IOCSTATUS_SCSI_EXT_TERMINATED:		/* 0x004C */
2700 		completion_code = MPT_SCANDV_DID_RESET;
2701 		break;
2702 
2703 	case MPI_IOCSTATUS_BUSY:
2704 	case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES:
2705 		completion_code = MPT_SCANDV_BUSY;
2706 		break;
2707 
2708 	case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN:		/* 0x0045 */
2709 	case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR:	/* 0x0040 */
2710 	case MPI_IOCSTATUS_SUCCESS:			/* 0x0000 */
2711 		if (pReply->Function == MPI_FUNCTION_CONFIG) {
2712 			completion_code = MPT_SCANDV_GOOD;
2713 		} else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) {
2714 			pr = (MpiRaidActionReply_t *)reply;
2715 			if (le16_to_cpu(pr->ActionStatus) ==
2716 				MPI_RAID_ACTION_ASTATUS_SUCCESS)
2717 				completion_code = MPT_SCANDV_GOOD;
2718 			else
2719 				completion_code = MPT_SCANDV_SOME_ERROR;
2720 		} else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)
2721 			completion_code = MPT_SCANDV_SENSE;
2722 		else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) {
2723 			if (req->u.scsireq.CDB[0] == INQUIRY)
2724 				completion_code = MPT_SCANDV_ISSUE_SENSE;
2725 			else
2726 				completion_code = MPT_SCANDV_DID_RESET;
2727 		} else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS)
2728 			completion_code = MPT_SCANDV_DID_RESET;
2729 		else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
2730 			completion_code = MPT_SCANDV_DID_RESET;
2731 		else if (scsi_status == MPI_SCSI_STATUS_BUSY)
2732 			completion_code = MPT_SCANDV_BUSY;
2733 		else
2734 			completion_code = MPT_SCANDV_GOOD;
2735 		break;
2736 
2737 	case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR:		/* 0x0047 */
2738 		if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
2739 			completion_code = MPT_SCANDV_DID_RESET;
2740 		else
2741 			completion_code = MPT_SCANDV_SOME_ERROR;
2742 		break;
2743 	default:
2744 		completion_code = MPT_SCANDV_SOME_ERROR;
2745 		break;
2746 
2747 	}	/* switch(status) */
2748 
2749 	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2750 	    "  completionCode set to %08xh\n", ioc->name, completion_code));
2751 	return completion_code;
2752 }
2753 
2754 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2755 /**
2756  *	mptscsih_do_cmd - Do internal command.
2757  *	@hd: MPT_SCSI_HOST pointer
2758  *	@io: INTERNAL_CMD pointer.
2759  *
2760  *	Issue the specified internally generated command and do command
2761  *	specific cleanup. For bus scan / DV only.
2762  *	NOTES: If command is Inquiry and status is good,
2763  *	initialize a target structure, save the data
2764  *
2765  *	Remark: Single threaded access only.
2766  *
2767  *	Return:
2768  *		< 0 if an illegal command or no resources
2769  *
2770  *		   0 if good
2771  *
2772  *		 > 0 if command complete but some type of completion error.
2773  */
2774 static int
2775 mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io)
2776 {
2777 	MPT_FRAME_HDR	*mf;
2778 	SCSIIORequest_t	*pScsiReq;
2779 	int		 my_idx, ii, dir;
2780 	int		 timeout;
2781 	char		 cmdLen;
2782 	char		 CDB[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
2783 	u8		 cmd = io->cmd;
2784 	MPT_ADAPTER *ioc = hd->ioc;
2785 	int		 ret = 0;
2786 	unsigned long	 timeleft;
2787 	unsigned long	 flags;
2788 
2789 	/* don't send internal command during diag reset */
2790 	spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
2791 	if (ioc->ioc_reset_in_progress) {
2792 		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2793 		dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2794 			"%s: busy with host reset\n", ioc->name, __func__));
2795 		return MPT_SCANDV_BUSY;
2796 	}
2797 	spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2798 
2799 	mutex_lock(&ioc->internal_cmds.mutex);
2800 
2801 	/* Set command specific information
2802 	 */
2803 	switch (cmd) {
2804 	case INQUIRY:
2805 		cmdLen = 6;
2806 		dir = MPI_SCSIIO_CONTROL_READ;
2807 		CDB[0] = cmd;
2808 		CDB[4] = io->size;
2809 		timeout = 10;
2810 		break;
2811 
2812 	case TEST_UNIT_READY:
2813 		cmdLen = 6;
2814 		dir = MPI_SCSIIO_CONTROL_READ;
2815 		timeout = 10;
2816 		break;
2817 
2818 	case START_STOP:
2819 		cmdLen = 6;
2820 		dir = MPI_SCSIIO_CONTROL_READ;
2821 		CDB[0] = cmd;
2822 		CDB[4] = 1;	/*Spin up the disk */
2823 		timeout = 15;
2824 		break;
2825 
2826 	case REQUEST_SENSE:
2827 		cmdLen = 6;
2828 		CDB[0] = cmd;
2829 		CDB[4] = io->size;
2830 		dir = MPI_SCSIIO_CONTROL_READ;
2831 		timeout = 10;
2832 		break;
2833 
2834 	case READ_BUFFER:
2835 		cmdLen = 10;
2836 		dir = MPI_SCSIIO_CONTROL_READ;
2837 		CDB[0] = cmd;
2838 		if (io->flags & MPT_ICFLAG_ECHO) {
2839 			CDB[1] = 0x0A;
2840 		} else {
2841 			CDB[1] = 0x02;
2842 		}
2843 
2844 		if (io->flags & MPT_ICFLAG_BUF_CAP) {
2845 			CDB[1] |= 0x01;
2846 		}
2847 		CDB[6] = (io->size >> 16) & 0xFF;
2848 		CDB[7] = (io->size >>  8) & 0xFF;
2849 		CDB[8] = io->size & 0xFF;
2850 		timeout = 10;
2851 		break;
2852 
2853 	case WRITE_BUFFER:
2854 		cmdLen = 10;
2855 		dir = MPI_SCSIIO_CONTROL_WRITE;
2856 		CDB[0] = cmd;
2857 		if (io->flags & MPT_ICFLAG_ECHO) {
2858 			CDB[1] = 0x0A;
2859 		} else {
2860 			CDB[1] = 0x02;
2861 		}
2862 		CDB[6] = (io->size >> 16) & 0xFF;
2863 		CDB[7] = (io->size >>  8) & 0xFF;
2864 		CDB[8] = io->size & 0xFF;
2865 		timeout = 10;
2866 		break;
2867 
2868 	case RESERVE:
2869 		cmdLen = 6;
2870 		dir = MPI_SCSIIO_CONTROL_READ;
2871 		CDB[0] = cmd;
2872 		timeout = 10;
2873 		break;
2874 
2875 	case RELEASE:
2876 		cmdLen = 6;
2877 		dir = MPI_SCSIIO_CONTROL_READ;
2878 		CDB[0] = cmd;
2879 		timeout = 10;
2880 		break;
2881 
2882 	case SYNCHRONIZE_CACHE:
2883 		cmdLen = 10;
2884 		dir = MPI_SCSIIO_CONTROL_READ;
2885 		CDB[0] = cmd;
2886 //		CDB[1] = 0x02;	/* set immediate bit */
2887 		timeout = 10;
2888 		break;
2889 
2890 	default:
2891 		/* Error Case */
2892 		ret = -EFAULT;
2893 		goto out;
2894 	}
2895 
2896 	/* Get and Populate a free Frame
2897 	 * MsgContext set in mpt_get_msg_frame call
2898 	 */
2899 	if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
2900 		dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: No msg frames!\n",
2901 		    ioc->name, __func__));
2902 		ret = MPT_SCANDV_BUSY;
2903 		goto out;
2904 	}
2905 
2906 	pScsiReq = (SCSIIORequest_t *) mf;
2907 
2908 	/* Get the request index */
2909 	my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2910 	ADD_INDEX_LOG(my_idx); /* for debug */
2911 
2912 	if (io->flags & MPT_ICFLAG_PHYS_DISK) {
2913 		pScsiReq->TargetID = io->physDiskNum;
2914 		pScsiReq->Bus = 0;
2915 		pScsiReq->ChainOffset = 0;
2916 		pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
2917 	} else {
2918 		pScsiReq->TargetID = io->id;
2919 		pScsiReq->Bus = io->channel;
2920 		pScsiReq->ChainOffset = 0;
2921 		pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
2922 	}
2923 
2924 	pScsiReq->CDBLength = cmdLen;
2925 	pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
2926 
2927 	pScsiReq->Reserved = 0;
2928 
2929 	pScsiReq->MsgFlags = mpt_msg_flags(ioc);
2930 	/* MsgContext set in mpt_get_msg_fram call  */
2931 
2932 	int_to_scsilun(io->lun, (struct scsi_lun *)pScsiReq->LUN);
2933 
2934 	if (io->flags & MPT_ICFLAG_TAGGED_CMD)
2935 		pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_SIMPLEQ);
2936 	else
2937 		pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
2938 
2939 	if (cmd == REQUEST_SENSE) {
2940 		pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
2941 		devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2942 		    "%s: Untagged! 0x%02x\n", ioc->name, __func__, cmd));
2943 	}
2944 
2945 	for (ii = 0; ii < 16; ii++)
2946 		pScsiReq->CDB[ii] = CDB[ii];
2947 
2948 	pScsiReq->DataLength = cpu_to_le32(io->size);
2949 	pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma
2950 					   + (my_idx * MPT_SENSE_BUFFER_ALLOC));
2951 
2952 	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2953 	    "%s: Sending Command 0x%02x for fw_channel=%d fw_id=%d lun=%llu\n",
2954 	    ioc->name, __func__, cmd, io->channel, io->id, io->lun));
2955 
2956 	if (dir == MPI_SCSIIO_CONTROL_READ)
2957 		ioc->add_sge((char *) &pScsiReq->SGL,
2958 		    MPT_SGE_FLAGS_SSIMPLE_READ | io->size, io->data_dma);
2959 	else
2960 		ioc->add_sge((char *) &pScsiReq->SGL,
2961 		    MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size, io->data_dma);
2962 
2963 	INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
2964 	mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
2965 	timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done,
2966 	    timeout*HZ);
2967 	if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2968 		ret = MPT_SCANDV_DID_RESET;
2969 		dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2970 		    "%s: TIMED OUT for cmd=0x%02x\n", ioc->name, __func__,
2971 		    cmd));
2972 		if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2973 			mpt_free_msg_frame(ioc, mf);
2974 			goto out;
2975 		}
2976 		if (!timeleft) {
2977 			printk(MYIOC_s_WARN_FMT
2978 			       "Issuing Reset from %s!! doorbell=0x%08xh"
2979 			       " cmd=0x%02x\n",
2980 			       ioc->name, __func__, mpt_GetIocState(ioc, 0),
2981 			       cmd);
2982 			mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2983 			mpt_free_msg_frame(ioc, mf);
2984 		}
2985 		goto out;
2986 	}
2987 
2988 	ret = ioc->internal_cmds.completion_code;
2989 	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: success, rc=0x%02x\n",
2990 			ioc->name, __func__, ret));
2991 
2992  out:
2993 	CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
2994 	mutex_unlock(&ioc->internal_cmds.mutex);
2995 	return ret;
2996 }
2997 
2998 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2999 /**
3000  *	mptscsih_synchronize_cache - Send SYNCHRONIZE_CACHE to all disks.
3001  *	@hd: Pointer to a SCSI HOST structure
3002  *	@vdevice: virtual target device
3003  *
3004  *	Uses the ISR, but with special processing.
3005  *	MUST be single-threaded.
3006  *
3007  */
3008 static void
3009 mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
3010 {
3011 	INTERNAL_CMD		 iocmd;
3012 
3013 	/* Ignore hidden raid components, this is handled when the command
3014 	 * is sent to the volume
3015 	 */
3016 	if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
3017 		return;
3018 
3019 	if (vdevice->vtarget->type != TYPE_DISK || vdevice->vtarget->deleted ||
3020 	    !vdevice->configured_lun)
3021 		return;
3022 
3023 	/* Following parameters will not change
3024 	 * in this routine.
3025 	 */
3026 	iocmd.cmd = SYNCHRONIZE_CACHE;
3027 	iocmd.flags = 0;
3028 	iocmd.physDiskNum = -1;
3029 	iocmd.data = NULL;
3030 	iocmd.data_dma = -1;
3031 	iocmd.size = 0;
3032 	iocmd.rsvd = iocmd.rsvd2 = 0;
3033 	iocmd.channel = vdevice->vtarget->channel;
3034 	iocmd.id = vdevice->vtarget->id;
3035 	iocmd.lun = vdevice->lun;
3036 
3037 	mptscsih_do_cmd(hd, &iocmd);
3038 }
3039 
3040 static ssize_t
3041 mptscsih_version_fw_show(struct device *dev, struct device_attribute *attr,
3042 			 char *buf)
3043 {
3044 	struct Scsi_Host *host = class_to_shost(dev);
3045 	MPT_SCSI_HOST	*hd = shost_priv(host);
3046 	MPT_ADAPTER *ioc = hd->ioc;
3047 
3048 	return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
3049 	    (ioc->facts.FWVersion.Word & 0xFF000000) >> 24,
3050 	    (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,
3051 	    (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
3052 	    ioc->facts.FWVersion.Word & 0x000000FF);
3053 }
3054 static DEVICE_ATTR(version_fw, S_IRUGO, mptscsih_version_fw_show, NULL);
3055 
3056 static ssize_t
3057 mptscsih_version_bios_show(struct device *dev, struct device_attribute *attr,
3058 			   char *buf)
3059 {
3060 	struct Scsi_Host *host = class_to_shost(dev);
3061 	MPT_SCSI_HOST	*hd = shost_priv(host);
3062 	MPT_ADAPTER *ioc = hd->ioc;
3063 
3064 	return snprintf(buf, PAGE_SIZE, "%02x.%02x.%02x.%02x\n",
3065 	    (ioc->biosVersion & 0xFF000000) >> 24,
3066 	    (ioc->biosVersion & 0x00FF0000) >> 16,
3067 	    (ioc->biosVersion & 0x0000FF00) >> 8,
3068 	    ioc->biosVersion & 0x000000FF);
3069 }
3070 static DEVICE_ATTR(version_bios, S_IRUGO, mptscsih_version_bios_show, NULL);
3071 
3072 static ssize_t
3073 mptscsih_version_mpi_show(struct device *dev, struct device_attribute *attr,
3074 			  char *buf)
3075 {
3076 	struct Scsi_Host *host = class_to_shost(dev);
3077 	MPT_SCSI_HOST	*hd = shost_priv(host);
3078 	MPT_ADAPTER *ioc = hd->ioc;
3079 
3080 	return snprintf(buf, PAGE_SIZE, "%03x\n", ioc->facts.MsgVersion);
3081 }
3082 static DEVICE_ATTR(version_mpi, S_IRUGO, mptscsih_version_mpi_show, NULL);
3083 
3084 static ssize_t
3085 mptscsih_version_product_show(struct device *dev,
3086 			      struct device_attribute *attr,
3087 char *buf)
3088 {
3089 	struct Scsi_Host *host = class_to_shost(dev);
3090 	MPT_SCSI_HOST	*hd = shost_priv(host);
3091 	MPT_ADAPTER *ioc = hd->ioc;
3092 
3093 	return snprintf(buf, PAGE_SIZE, "%s\n", ioc->prod_name);
3094 }
3095 static DEVICE_ATTR(version_product, S_IRUGO,
3096     mptscsih_version_product_show, NULL);
3097 
3098 static ssize_t
3099 mptscsih_version_nvdata_persistent_show(struct device *dev,
3100 					struct device_attribute *attr,
3101 					char *buf)
3102 {
3103 	struct Scsi_Host *host = class_to_shost(dev);
3104 	MPT_SCSI_HOST	*hd = shost_priv(host);
3105 	MPT_ADAPTER *ioc = hd->ioc;
3106 
3107 	return snprintf(buf, PAGE_SIZE, "%02xh\n",
3108 	    ioc->nvdata_version_persistent);
3109 }
3110 static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO,
3111     mptscsih_version_nvdata_persistent_show, NULL);
3112 
3113 static ssize_t
3114 mptscsih_version_nvdata_default_show(struct device *dev,
3115 				     struct device_attribute *attr, char *buf)
3116 {
3117 	struct Scsi_Host *host = class_to_shost(dev);
3118 	MPT_SCSI_HOST	*hd = shost_priv(host);
3119 	MPT_ADAPTER *ioc = hd->ioc;
3120 
3121 	return snprintf(buf, PAGE_SIZE, "%02xh\n",ioc->nvdata_version_default);
3122 }
3123 static DEVICE_ATTR(version_nvdata_default, S_IRUGO,
3124     mptscsih_version_nvdata_default_show, NULL);
3125 
3126 static ssize_t
3127 mptscsih_board_name_show(struct device *dev, struct device_attribute *attr,
3128 			 char *buf)
3129 {
3130 	struct Scsi_Host *host = class_to_shost(dev);
3131 	MPT_SCSI_HOST	*hd = shost_priv(host);
3132 	MPT_ADAPTER *ioc = hd->ioc;
3133 
3134 	return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_name);
3135 }
3136 static DEVICE_ATTR(board_name, S_IRUGO, mptscsih_board_name_show, NULL);
3137 
3138 static ssize_t
3139 mptscsih_board_assembly_show(struct device *dev,
3140 			     struct device_attribute *attr, char *buf)
3141 {
3142 	struct Scsi_Host *host = class_to_shost(dev);
3143 	MPT_SCSI_HOST	*hd = shost_priv(host);
3144 	MPT_ADAPTER *ioc = hd->ioc;
3145 
3146 	return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_assembly);
3147 }
3148 static DEVICE_ATTR(board_assembly, S_IRUGO,
3149     mptscsih_board_assembly_show, NULL);
3150 
3151 static ssize_t
3152 mptscsih_board_tracer_show(struct device *dev, struct device_attribute *attr,
3153 			   char *buf)
3154 {
3155 	struct Scsi_Host *host = class_to_shost(dev);
3156 	MPT_SCSI_HOST	*hd = shost_priv(host);
3157 	MPT_ADAPTER *ioc = hd->ioc;
3158 
3159 	return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_tracer);
3160 }
3161 static DEVICE_ATTR(board_tracer, S_IRUGO,
3162     mptscsih_board_tracer_show, NULL);
3163 
3164 static ssize_t
3165 mptscsih_io_delay_show(struct device *dev, struct device_attribute *attr,
3166 		       char *buf)
3167 {
3168 	struct Scsi_Host *host = class_to_shost(dev);
3169 	MPT_SCSI_HOST	*hd = shost_priv(host);
3170 	MPT_ADAPTER *ioc = hd->ioc;
3171 
3172 	return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay);
3173 }
3174 static DEVICE_ATTR(io_delay, S_IRUGO,
3175     mptscsih_io_delay_show, NULL);
3176 
3177 static ssize_t
3178 mptscsih_device_delay_show(struct device *dev, struct device_attribute *attr,
3179 			   char *buf)
3180 {
3181 	struct Scsi_Host *host = class_to_shost(dev);
3182 	MPT_SCSI_HOST	*hd = shost_priv(host);
3183 	MPT_ADAPTER *ioc = hd->ioc;
3184 
3185 	return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay);
3186 }
3187 static DEVICE_ATTR(device_delay, S_IRUGO,
3188     mptscsih_device_delay_show, NULL);
3189 
3190 static ssize_t
3191 mptscsih_debug_level_show(struct device *dev, struct device_attribute *attr,
3192 			  char *buf)
3193 {
3194 	struct Scsi_Host *host = class_to_shost(dev);
3195 	MPT_SCSI_HOST	*hd = shost_priv(host);
3196 	MPT_ADAPTER *ioc = hd->ioc;
3197 
3198 	return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->debug_level);
3199 }
3200 static ssize_t
3201 mptscsih_debug_level_store(struct device *dev, struct device_attribute *attr,
3202 			   const char *buf, size_t count)
3203 {
3204 	struct Scsi_Host *host = class_to_shost(dev);
3205 	MPT_SCSI_HOST	*hd = shost_priv(host);
3206 	MPT_ADAPTER *ioc = hd->ioc;
3207 	int val = 0;
3208 
3209 	if (sscanf(buf, "%x", &val) != 1)
3210 		return -EINVAL;
3211 
3212 	ioc->debug_level = val;
3213 	printk(MYIOC_s_INFO_FMT "debug_level=%08xh\n",
3214 				ioc->name, ioc->debug_level);
3215 	return strlen(buf);
3216 }
3217 static DEVICE_ATTR(debug_level, S_IRUGO | S_IWUSR,
3218 	mptscsih_debug_level_show, mptscsih_debug_level_store);
3219 
3220 static struct attribute *mptscsih_host_attrs[] = {
3221 	&dev_attr_version_fw.attr,
3222 	&dev_attr_version_bios.attr,
3223 	&dev_attr_version_mpi.attr,
3224 	&dev_attr_version_product.attr,
3225 	&dev_attr_version_nvdata_persistent.attr,
3226 	&dev_attr_version_nvdata_default.attr,
3227 	&dev_attr_board_name.attr,
3228 	&dev_attr_board_assembly.attr,
3229 	&dev_attr_board_tracer.attr,
3230 	&dev_attr_io_delay.attr,
3231 	&dev_attr_device_delay.attr,
3232 	&dev_attr_debug_level.attr,
3233 	NULL,
3234 };
3235 
3236 static const struct attribute_group mptscsih_host_attr_group = {
3237 	.attrs = mptscsih_host_attrs
3238 };
3239 
3240 const struct attribute_group *mptscsih_host_attr_groups[] = {
3241 	&mptscsih_host_attr_group,
3242 	NULL
3243 };
3244 EXPORT_SYMBOL(mptscsih_host_attr_groups);
3245 
3246 EXPORT_SYMBOL(mptscsih_remove);
3247 EXPORT_SYMBOL(mptscsih_shutdown);
3248 #ifdef CONFIG_PM
3249 EXPORT_SYMBOL(mptscsih_suspend);
3250 EXPORT_SYMBOL(mptscsih_resume);
3251 #endif
3252 EXPORT_SYMBOL(mptscsih_show_info);
3253 EXPORT_SYMBOL(mptscsih_info);
3254 EXPORT_SYMBOL(mptscsih_qcmd);
3255 EXPORT_SYMBOL(mptscsih_slave_destroy);
3256 EXPORT_SYMBOL(mptscsih_slave_configure);
3257 EXPORT_SYMBOL(mptscsih_abort);
3258 EXPORT_SYMBOL(mptscsih_dev_reset);
3259 EXPORT_SYMBOL(mptscsih_bus_reset);
3260 EXPORT_SYMBOL(mptscsih_host_reset);
3261 EXPORT_SYMBOL(mptscsih_bios_param);
3262 EXPORT_SYMBOL(mptscsih_io_done);
3263 EXPORT_SYMBOL(mptscsih_taskmgmt_complete);
3264 EXPORT_SYMBOL(mptscsih_scandv_complete);
3265 EXPORT_SYMBOL(mptscsih_event_process);
3266 EXPORT_SYMBOL(mptscsih_ioc_reset);
3267 EXPORT_SYMBOL(mptscsih_change_queue_depth);
3268 
3269 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3270