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.
6 * Copyright (c) 1999-2008 LSI Corporation
7 * (mailto:DL-MPTFusionLinux@lsi.com)
10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
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.
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.
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.
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
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
45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
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> /* needed for in_interrupt() proto */
56 #include <linux/reboot.h> /* notifier code */
57 #include <linux/workqueue.h>
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>
68 #include "lsi/mpi_log_sas.h"
70 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
71 #define my_NAME "Fusion MPT SCSI Host driver"
72 #define my_VERSION MPT_LINUX_VERSION_COMMON
73 #define MYNAM "mptscsih"
75 MODULE_AUTHOR(MODULEAUTHOR);
76 MODULE_DESCRIPTION(my_NAME);
77 MODULE_LICENSE("GPL");
78 MODULE_VERSION(my_VERSION);
80 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
82 * Other private/forward protos...
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);
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);
97 int mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id,
98 u64 lun, int ctx2abort, ulong timeout);
100 int mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset);
101 int mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
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);
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 *);
117 int mptscsih_suspend(struct pci_dev *pdev, pm_message_t state);
118 int mptscsih_resume(struct pci_dev *pdev);
121 #define SNS_LEN(scp) SCSI_SENSE_BUFFERSIZE
124 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
126 * mptscsih_getFreeChainBuffer - Function to get a free chain
127 * from the MPT_SCSI_HOST FreeChainQ.
128 * @ioc: Pointer to MPT_ADAPTER structure
129 * @req_idx: Index of the SCSI IO request frame. (output)
131 * return SUCCESS or FAILED
134 mptscsih_getFreeChainBuffer(MPT_ADAPTER *ioc, int *retIndex)
136 MPT_FRAME_HDR *chainBuf;
141 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "getFreeChainBuffer called\n",
143 spin_lock_irqsave(&ioc->FreeQlock, flags);
144 if (!list_empty(&ioc->FreeChainQ)) {
147 chainBuf = list_entry(ioc->FreeChainQ.next, MPT_FRAME_HDR,
148 u.frame.linkage.list);
149 list_del(&chainBuf->u.frame.linkage.list);
150 offset = (u8 *)chainBuf - (u8 *)ioc->ChainBuffer;
151 chain_idx = offset / ioc->req_sz;
153 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT
154 "getFreeChainBuffer chainBuf=%p ChainBuffer=%p offset=%d chain_idx=%d\n",
155 ioc->name, chainBuf, ioc->ChainBuffer, offset, chain_idx));
158 chain_idx = MPT_HOST_NO_CHAIN;
159 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "getFreeChainBuffer failed\n",
162 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
164 *retIndex = chain_idx;
166 } /* mptscsih_getFreeChainBuffer() */
168 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
170 * mptscsih_AddSGE - Add a SGE (plus chain buffers) to the
171 * SCSIIORequest_t Message Frame.
172 * @ioc: Pointer to MPT_ADAPTER structure
173 * @SCpnt: Pointer to scsi_cmnd structure
174 * @pReq: Pointer to SCSIIORequest_t structure
179 mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt,
180 SCSIIORequest_t *pReq, int req_idx)
184 struct scatterlist *sg;
186 int sges_left, sg_done;
187 int chain_idx = MPT_HOST_NO_CHAIN;
189 int numSgeSlots, numSgeThisFrame;
190 u32 sgflags, sgdir, thisxfer = 0;
191 int chain_dma_off = 0;
197 sgdir = le32_to_cpu(pReq->Control) & MPI_SCSIIO_CONTROL_DATADIRECTION_MASK;
198 if (sgdir == MPI_SCSIIO_CONTROL_WRITE) {
199 sgdir = MPT_TRANSFER_HOST_TO_IOC;
201 sgdir = MPT_TRANSFER_IOC_TO_HOST;
204 psge = (char *) &pReq->SGL;
205 frm_sz = ioc->req_sz;
207 /* Map the data portion, if any.
208 * sges_left = 0 if no data transfer.
210 sges_left = scsi_dma_map(SCpnt);
214 /* Handle the SG case.
216 sg = scsi_sglist(SCpnt);
218 sgeOffset = sizeof(SCSIIORequest_t) - sizeof(SGE_IO_UNION);
221 /* Prior to entering this loop - the following must be set
222 * current MF: sgeOffset (bytes)
223 * chainSge (Null if original MF is not a chain buffer)
224 * sg_done (num SGE done for this MF)
228 numSgeSlots = ((frm_sz - sgeOffset) / ioc->SGE_size);
229 numSgeThisFrame = (sges_left < numSgeSlots) ? sges_left : numSgeSlots;
231 sgflags = MPT_SGE_FLAGS_SIMPLE_ELEMENT | sgdir;
233 /* Get first (num - 1) SG elements
234 * Skip any SG entries with a length of 0
235 * NOTE: at finish, sg and psge pointed to NEXT data/location positions
237 for (ii=0; ii < (numSgeThisFrame-1); ii++) {
238 thisxfer = sg_dma_len(sg);
240 /* Get next SG element from the OS */
246 v2 = sg_dma_address(sg);
247 ioc->add_sge(psge, sgflags | thisxfer, v2);
249 /* Get next SG element from the OS */
251 psge += ioc->SGE_size;
252 sgeOffset += ioc->SGE_size;
256 if (numSgeThisFrame == sges_left) {
257 /* Add last element, end of buffer and end of list flags.
259 sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT |
260 MPT_SGE_FLAGS_END_OF_BUFFER |
261 MPT_SGE_FLAGS_END_OF_LIST;
263 /* Add last SGE and set termination flags.
264 * Note: Last SGE may have a length of 0 - which should be ok.
266 thisxfer = sg_dma_len(sg);
268 v2 = sg_dma_address(sg);
269 ioc->add_sge(psge, sgflags | thisxfer, v2);
270 sgeOffset += ioc->SGE_size;
274 /* The current buffer is a chain buffer,
275 * but there is not another one.
276 * Update the chain element
277 * Offset and Length fields.
279 ioc->add_chain((char *)chainSge, 0, sgeOffset,
280 ioc->ChainBufferDMA + chain_dma_off);
282 /* The current buffer is the original MF
283 * and there is no Chain buffer.
285 pReq->ChainOffset = 0;
286 RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor) + 1) & 0x03;
287 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT
288 "Single Buffer RequestNB=%x, sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset));
289 ioc->RequestNB[req_idx] = RequestNB;
292 /* At least one chain buffer is needed.
293 * Complete the first MF
294 * - last SGE element, set the LastElement bit
295 * - set ChainOffset (words) for orig MF
296 * (OR finish previous MF chain buffer)
297 * - update MFStructPtr ChainIndex
298 * - Populate chain element
303 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SG: Chain Required! sg done %d\n",
304 ioc->name, sg_done));
306 /* Set LAST_ELEMENT flag for last non-chain element
307 * in the buffer. Since psge points at the NEXT
308 * SGE element, go back one SGE element, update the flags
309 * and reset the pointer. (Note: sgflags & thisxfer are already
313 u32 *ptmp = (u32 *) (psge - ioc->SGE_size);
314 sgflags = le32_to_cpu(*ptmp);
315 sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT;
316 *ptmp = cpu_to_le32(sgflags);
320 /* The current buffer is a chain buffer.
321 * chainSge points to the previous Chain Element.
322 * Update its chain element Offset and Length (must
323 * include chain element size) fields.
324 * Old chain element is now complete.
326 u8 nextChain = (u8) (sgeOffset >> 2);
327 sgeOffset += ioc->SGE_size;
328 ioc->add_chain((char *)chainSge, nextChain, sgeOffset,
329 ioc->ChainBufferDMA + chain_dma_off);
331 /* The original MF buffer requires a chain buffer -
333 * Last element in this MF is a chain element.
335 pReq->ChainOffset = (u8) (sgeOffset >> 2);
336 RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor) + 1) & 0x03;
337 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Chain Buffer Needed, RequestNB=%x sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset));
338 ioc->RequestNB[req_idx] = RequestNB;
341 sges_left -= sg_done;
344 /* NOTE: psge points to the beginning of the chain element
345 * in current buffer. Get a chain buffer.
347 if ((mptscsih_getFreeChainBuffer(ioc, &newIndex)) == FAILED) {
348 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
349 "getFreeChainBuffer FAILED SCSI cmd=%02x (%p)\n",
350 ioc->name, pReq->CDB[0], SCpnt));
354 /* Update the tracking arrays.
355 * If chainSge == NULL, update ReqToChain, else ChainToChain
358 ioc->ChainToChain[chain_idx] = newIndex;
360 ioc->ReqToChain[req_idx] = newIndex;
362 chain_idx = newIndex;
363 chain_dma_off = ioc->req_sz * chain_idx;
365 /* Populate the chainSGE for the current buffer.
366 * - Set chain buffer pointer to psge and fill
367 * out the Address and Flags fields.
369 chainSge = (char *) psge;
370 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT " Current buff @ %p (index 0x%x)",
371 ioc->name, psge, req_idx));
373 /* Start the SGE for the next buffer
375 psge = (char *) (ioc->ChainBuffer + chain_dma_off);
379 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT " Chain buff @ %p (index 0x%x)\n",
380 ioc->name, psge, chain_idx));
382 /* Start the SGE for the next buffer
389 } /* mptscsih_AddSGE() */
392 mptscsih_issue_sep_command(MPT_ADAPTER *ioc, VirtTarget *vtarget,
396 SEPRequest_t *SEPMsg;
398 if (ioc->bus_type != SAS)
401 /* Not supported for hidden raid components
403 if (vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
406 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
407 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: no msg frames!!\n",
408 ioc->name,__func__));
412 SEPMsg = (SEPRequest_t *)mf;
413 SEPMsg->Function = MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
414 SEPMsg->Bus = vtarget->channel;
415 SEPMsg->TargetID = vtarget->id;
416 SEPMsg->Action = MPI_SEP_REQ_ACTION_WRITE_STATUS;
417 SEPMsg->SlotStatus = SlotStatus;
418 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
419 "Sending SEP cmd=%x channel=%d id=%d\n",
420 ioc->name, SlotStatus, SEPMsg->Bus, SEPMsg->TargetID));
421 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
424 #ifdef CONFIG_FUSION_LOGGING
426 * mptscsih_info_scsiio - debug print info on reply frame
427 * @ioc: Pointer to MPT_ADAPTER structure
428 * @sc: original scsi cmnd pointer
429 * @pScsiReply: Pointer to MPT reply frame
431 * MPT_DEBUG_REPLY needs to be enabled to obtain this info
433 * Refer to lsi/mpi.h.
436 mptscsih_info_scsiio(MPT_ADAPTER *ioc, struct scsi_cmnd *sc, SCSIIOReply_t * pScsiReply)
443 ioc_status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK;
445 switch (ioc_status) {
447 case MPI_IOCSTATUS_SUCCESS:
450 case MPI_IOCSTATUS_SCSI_INVALID_BUS:
451 desc = "invalid bus";
453 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID:
454 desc = "invalid target_id";
456 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
457 desc = "device not there";
459 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN:
460 desc = "data overrun";
462 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN:
463 desc = "data underrun";
465 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR:
466 desc = "I/O data error";
468 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR:
469 desc = "protocol error";
471 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED:
472 desc = "task terminated";
474 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
475 desc = "residual mismatch";
477 case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
478 desc = "task management failed";
480 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED:
481 desc = "IOC terminated";
483 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED:
484 desc = "ext terminated";
491 switch (pScsiReply->SCSIStatus)
494 case MPI_SCSI_STATUS_SUCCESS:
497 case MPI_SCSI_STATUS_CHECK_CONDITION:
498 desc1 = "check condition";
500 case MPI_SCSI_STATUS_CONDITION_MET:
501 desc1 = "condition met";
503 case MPI_SCSI_STATUS_BUSY:
506 case MPI_SCSI_STATUS_INTERMEDIATE:
507 desc1 = "intermediate";
509 case MPI_SCSI_STATUS_INTERMEDIATE_CONDMET:
510 desc1 = "intermediate condmet";
512 case MPI_SCSI_STATUS_RESERVATION_CONFLICT:
513 desc1 = "reservation conflict";
515 case MPI_SCSI_STATUS_COMMAND_TERMINATED:
516 desc1 = "command terminated";
518 case MPI_SCSI_STATUS_TASK_SET_FULL:
519 desc1 = "task set full";
521 case MPI_SCSI_STATUS_ACA_ACTIVE:
522 desc1 = "aca active";
524 case MPI_SCSI_STATUS_FCPEXT_DEVICE_LOGGED_OUT:
525 desc1 = "fcpext device logged out";
527 case MPI_SCSI_STATUS_FCPEXT_NO_LINK:
528 desc1 = "fcpext no link";
530 case MPI_SCSI_STATUS_FCPEXT_UNASSIGNED:
531 desc1 = "fcpext unassigned";
538 scsi_print_command(sc);
539 printk(MYIOC_s_DEBUG_FMT "\tfw_channel = %d, fw_id = %d, lun = %llu\n",
540 ioc->name, pScsiReply->Bus, pScsiReply->TargetID, sc->device->lun);
541 printk(MYIOC_s_DEBUG_FMT "\trequest_len = %d, underflow = %d, "
542 "resid = %d\n", ioc->name, scsi_bufflen(sc), sc->underflow,
544 printk(MYIOC_s_DEBUG_FMT "\ttag = %d, transfer_count = %d, "
545 "sc->result = %08X\n", ioc->name, le16_to_cpu(pScsiReply->TaskTag),
546 le32_to_cpu(pScsiReply->TransferCount), sc->result);
548 printk(MYIOC_s_DEBUG_FMT "\tiocstatus = %s (0x%04x), "
549 "scsi_status = %s (0x%02x), scsi_state = (0x%02x)\n",
550 ioc->name, desc, ioc_status, desc1, pScsiReply->SCSIStatus,
551 pScsiReply->SCSIState);
553 if (pScsiReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID) {
554 skey = sc->sense_buffer[2] & 0x0F;
555 asc = sc->sense_buffer[12];
556 ascq = sc->sense_buffer[13];
558 printk(MYIOC_s_DEBUG_FMT "\t[sense_key,asc,ascq]: "
559 "[0x%02x,0x%02x,0x%02x]\n", ioc->name, skey, asc, ascq);
563 * Look for + dump FCP ResponseInfo[]!
565 if (pScsiReply->SCSIState & MPI_SCSI_STATE_RESPONSE_INFO_VALID &&
566 pScsiReply->ResponseInfo)
567 printk(MYIOC_s_DEBUG_FMT "response_info = %08xh\n",
568 ioc->name, le32_to_cpu(pScsiReply->ResponseInfo));
572 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
574 * mptscsih_io_done - Main SCSI IO callback routine registered to
575 * Fusion MPT (base) driver
576 * @ioc: Pointer to MPT_ADAPTER structure
577 * @mf: Pointer to original MPT request frame
578 * @r: Pointer to MPT reply frame (NULL if TurboReply)
580 * This routine is called from mpt.c::mpt_interrupt() at the completion
581 * of any SCSI IO request.
582 * This routine is registered with the Fusion MPT (base) driver at driver
583 * load/init time via the mpt_register() API call.
585 * Returns 1 indicating alloc'd request frame ptr should be freed.
588 mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
590 struct scsi_cmnd *sc;
592 SCSIIORequest_t *pScsiReq;
593 SCSIIOReply_t *pScsiReply;
594 u16 req_idx, req_idx_MR;
598 hd = shost_priv(ioc->sh);
599 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
600 req_idx_MR = (mr != NULL) ?
601 le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx) : req_idx;
603 /* Special case, where already freed message frame is received from
604 * Firmware. It happens with Resetting IOC.
605 * Return immediately. Do not care
607 if ((req_idx != req_idx_MR) ||
608 (le32_to_cpu(mf->u.frame.linkage.arg1) == 0xdeadbeaf))
611 sc = mptscsih_getclear_scsi_lookup(ioc, req_idx);
613 MPIHeader_t *hdr = (MPIHeader_t *)mf;
615 /* Remark: writeSDP1 will use the ScsiDoneCtx
616 * If a SCSI I/O cmd, device disabled by OS and
617 * completion done. Cannot touch sc struct. Just free mem.
619 if (hdr->Function == MPI_FUNCTION_SCSI_IO_REQUEST)
620 printk(MYIOC_s_ERR_FMT "NULL ScsiCmd ptr!\n",
623 mptscsih_freeChainBuffers(ioc, req_idx);
627 if ((unsigned char *)mf != sc->host_scribble) {
628 mptscsih_freeChainBuffers(ioc, req_idx);
632 if (ioc->bus_type == SAS) {
633 VirtDevice *vdevice = sc->device->hostdata;
635 if (!vdevice || !vdevice->vtarget ||
636 vdevice->vtarget->deleted) {
637 sc->result = DID_NO_CONNECT << 16;
642 sc->host_scribble = NULL;
643 sc->result = DID_OK << 16; /* Set default reply as OK */
644 pScsiReq = (SCSIIORequest_t *) mf;
645 pScsiReply = (SCSIIOReply_t *) mr;
647 if((ioc->facts.MsgVersion >= MPI_VERSION_01_05) && pScsiReply){
648 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT
649 "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d,task-tag=%d)\n",
650 ioc->name, mf, mr, sc, req_idx, pScsiReply->TaskTag));
652 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT
653 "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d)\n",
654 ioc->name, mf, mr, sc, req_idx));
657 if (pScsiReply == NULL) {
658 /* special context reply handling */
663 u8 scsi_state, scsi_status;
666 status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK;
668 scsi_state = pScsiReply->SCSIState;
669 scsi_status = pScsiReply->SCSIStatus;
670 xfer_cnt = le32_to_cpu(pScsiReply->TransferCount);
671 scsi_set_resid(sc, scsi_bufflen(sc) - xfer_cnt);
672 log_info = le32_to_cpu(pScsiReply->IOCLogInfo);
675 * if we get a data underrun indication, yet no data was
676 * transferred and the SCSI status indicates that the
677 * command was never started, change the data underrun
680 if (status == MPI_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 &&
681 (scsi_status == MPI_SCSI_STATUS_BUSY ||
682 scsi_status == MPI_SCSI_STATUS_RESERVATION_CONFLICT ||
683 scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)) {
684 status = MPI_IOCSTATUS_SUCCESS;
687 if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)
688 mptscsih_copy_sense_data(sc, hd, mf, pScsiReply);
691 * Look for + dump FCP ResponseInfo[]!
693 if (scsi_state & MPI_SCSI_STATE_RESPONSE_INFO_VALID &&
694 pScsiReply->ResponseInfo) {
695 printk(MYIOC_s_NOTE_FMT "[%d:%d:%d:%llu] "
696 "FCP_ResponseInfo=%08xh\n", ioc->name,
697 sc->device->host->host_no, sc->device->channel,
698 sc->device->id, sc->device->lun,
699 le32_to_cpu(pScsiReply->ResponseInfo));
703 case MPI_IOCSTATUS_BUSY: /* 0x0002 */
704 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
706 * Maybe: DRIVER_BUSY | SUGGEST_RETRY | DID_SOFT_ERROR (retry)
707 * But not: DID_BUS_BUSY lest one risk
708 * killing interrupt handler:-(
710 sc->result = SAM_STAT_BUSY;
713 case MPI_IOCSTATUS_SCSI_INVALID_BUS: /* 0x0041 */
714 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID: /* 0x0042 */
715 sc->result = DID_BAD_TARGET << 16;
718 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
719 /* Spoof to SCSI Selection Timeout! */
720 if (ioc->bus_type != FC)
721 sc->result = DID_NO_CONNECT << 16;
722 /* else fibre, just stall until rescan event */
724 sc->result = DID_REQUEUE << 16;
726 if (hd->sel_timeout[pScsiReq->TargetID] < 0xFFFF)
727 hd->sel_timeout[pScsiReq->TargetID]++;
729 vdevice = sc->device->hostdata;
732 vtarget = vdevice->vtarget;
733 if (vtarget->tflags & MPT_TARGET_FLAGS_LED_ON) {
734 mptscsih_issue_sep_command(ioc, vtarget,
735 MPI_SEP_REQ_SLOTSTATUS_UNCONFIGURED);
736 vtarget->tflags &= ~MPT_TARGET_FLAGS_LED_ON;
740 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
741 if ( ioc->bus_type == SAS ) {
743 le16_to_cpu(pScsiReply->IOCStatus);
745 MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
747 ((log_info & SAS_LOGINFO_MASK) ==
748 SAS_LOGINFO_NEXUS_LOSS)) {
749 VirtDevice *vdevice =
750 sc->device->hostdata;
752 /* flag the device as being in
753 * device removal delay so we can
754 * notify the midlayer to hold off
756 if (vdevice && vdevice->
761 "Skipping Raid Volume"
769 (DID_TRANSPORT_DISRUPTED
773 } else if (ioc->bus_type == FC) {
775 * The FC IOC may kill a request for variety of
776 * reasons, some of which may be recovered by a
777 * retry, some which are unlikely to be
778 * recovered. Return DID_ERROR instead of
779 * DID_RESET to permit retry of the command,
780 * just not an infinite number of them
782 sc->result = DID_ERROR << 16;
787 * Allow non-SAS & non-NEXUS_LOSS to drop into below code
790 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
791 /* Linux handles an unsolicited DID_RESET better
792 * than an unsolicited DID_ABORT.
794 sc->result = DID_RESET << 16;
797 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
798 if (ioc->bus_type == FC)
799 sc->result = DID_ERROR << 16;
801 sc->result = DID_RESET << 16;
804 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */
805 scsi_set_resid(sc, scsi_bufflen(sc) - xfer_cnt);
806 if((xfer_cnt==0)||(sc->underflow > xfer_cnt))
807 sc->result=DID_SOFT_ERROR << 16;
808 else /* Sufficient data transfer occurred */
809 sc->result = (DID_OK << 16) | scsi_status;
810 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
811 "RESIDUAL_MISMATCH: result=%x on channel=%d id=%d\n",
812 ioc->name, sc->result, sc->device->channel, sc->device->id));
815 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
817 * Do upfront check for valid SenseData and give it
820 sc->result = (DID_OK << 16) | scsi_status;
821 if (!(scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
824 * For an Errata on LSI53C1030
825 * When the length of request data
826 * and transfer data are different
827 * with result of command (READ or VERIFY),
828 * DID_SOFT_ERROR is set.
830 if (ioc->bus_type == SPI) {
831 if ((pScsiReq->CDB[0] == READ_6 && ((pScsiReq->CDB[1] & 0x02) == 0)) ||
832 pScsiReq->CDB[0] == READ_10 ||
833 pScsiReq->CDB[0] == READ_12 ||
834 (pScsiReq->CDB[0] == READ_16 &&
835 ((pScsiReq->CDB[1] & 0x02) == 0)) ||
836 pScsiReq->CDB[0] == VERIFY ||
837 pScsiReq->CDB[0] == VERIFY_16) {
838 if (scsi_bufflen(sc) !=
841 DID_SOFT_ERROR << 16;
842 printk(KERN_WARNING "Errata"
843 "on LSI53C1030 occurred."
844 "sc->req_bufflen=0x%02x,"
852 if (xfer_cnt < sc->underflow) {
853 if (scsi_status == SAM_STAT_BUSY)
854 sc->result = SAM_STAT_BUSY;
856 sc->result = DID_SOFT_ERROR << 16;
858 if (scsi_state & (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)) {
861 sc->result = DID_SOFT_ERROR << 16;
863 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
864 /* Not real sure here either... */
865 sc->result = DID_RESET << 16;
870 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
871 " sc->underflow={report ERR if < %02xh bytes xfer'd}\n",
872 ioc->name, sc->underflow));
873 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
874 " ActBytesXferd=%02xh\n", ioc->name, xfer_cnt));
878 if (scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)
879 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
883 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: /* 0x0044 */
884 scsi_set_resid(sc, 0);
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) {
890 } else if (scsi_state &
891 MPI_SCSI_STATE_AUTOSENSE_VALID) {
894 * For potential trouble on LSI53C1030.
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.
901 if ((ioc->bus_type == SPI) &&
902 (sc->sense_buffer[2] & 0x20)) {
905 sc->sense_buffer[3] << 24 |
906 sc->sense_buffer[4] << 16 |
907 sc->sense_buffer[5] << 8 |
909 if (((sc->sense_buffer[3] & 0x80) ==
910 0x80) && (scsi_bufflen(sc)
912 sc->sense_buffer[2] =
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" ,
923 if (((sc->sense_buffer[3] & 0x80)
926 xfer_cnt + difftransfer)) {
927 sc->sense_buffer[2] =
929 sc->sense_buffer[12] = 0xff;
930 sc->sense_buffer[13] = 0xff;
932 "Errata on LSI53C1030 occurred"
933 "sc->req_bufflen=0x%02x,"
935 "difftransfer=0x%02x\n",
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.
948 if (pScsiReply->SCSIStatus == MPI_SCSI_STATUS_TASK_SET_FULL)
949 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
952 else if (scsi_state &
953 (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)
958 sc->result = DID_SOFT_ERROR << 16;
960 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
961 /* Not real sure here either... */
962 sc->result = DID_RESET << 16;
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.
969 * Not real sure here either so do nothing... */
972 if (sc->result == MPI_SCSI_STATUS_TASK_SET_FULL)
973 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
976 * Reservation Conflict, Busy,
977 * Command Terminated, CHECK
981 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
982 sc->result = DID_SOFT_ERROR << 16;
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 */
997 sc->result = DID_SOFT_ERROR << 16;
1000 } /* switch(status) */
1002 #ifdef CONFIG_FUSION_LOGGING
1003 if (sc->result && (ioc->debug_level & MPT_DEBUG_REPLY))
1004 mptscsih_info_scsiio(ioc, sc, pScsiReply);
1007 } /* end of address reply case */
1009 /* Unmap the DMA buffers, if any. */
1012 sc->scsi_done(sc); /* Issue the command callback */
1014 /* Free Chain buffers */
1015 mptscsih_freeChainBuffers(ioc, req_idx);
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
1027 * Must be called while new I/Os are being queued.
1030 mptscsih_flush_running_cmds(MPT_SCSI_HOST *hd)
1032 MPT_ADAPTER *ioc = hd->ioc;
1033 struct scsi_cmnd *sc;
1034 SCSIIORequest_t *mf = NULL;
1038 for (ii= 0; ii < ioc->req_depth; ii++) {
1039 sc = mptscsih_getclear_scsi_lookup(ioc, ii);
1042 mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(ioc, ii);
1047 mptscsih_freeChainBuffers(ioc, ii);
1048 mpt_free_msg_frame(ioc, (MPT_FRAME_HDR *)mf);
1049 if ((unsigned char *)mf != sc->host_scribble)
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));
1060 EXPORT_SYMBOL(mptscsih_flush_running_cmds);
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
1074 * Called from slave_destroy.
1077 mptscsih_search_running_cmds(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
1079 SCSIIORequest_t *mf = NULL;
1081 struct scsi_cmnd *sc;
1082 struct scsi_lun lun;
1083 MPT_ADAPTER *ioc = hd->ioc;
1084 unsigned long flags;
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) {
1090 mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(ioc, ii);
1093 /* If the device is a hidden raid component, then its
1094 * expected that the mf->function will be RAID_SCSI_IO
1096 if (vdevice->vtarget->tflags &
1097 MPT_TARGET_FLAGS_RAID_COMPONENT && mf->Function !=
1098 MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)
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))
1107 if ((unsigned char *)mf != sc->host_scribble)
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);
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,
1122 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
1125 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1129 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1131 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
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
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.
1144 mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq)
1146 long time = jiffies;
1150 if (sc->device == NULL)
1152 if (sc->device->host == NULL)
1154 if ((hd = shost_priv(sc->device->host)) == NULL)
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;
1164 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1166 * mptscsih_remove - Removed scsi devices
1167 * @pdev: Pointer to pci_dev structure
1172 mptscsih_remove(struct pci_dev *pdev)
1174 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1175 struct Scsi_Host *host = ioc->sh;
1179 scsi_remove_host(host);
1181 if((hd = shost_priv(host)) == NULL)
1184 mptscsih_shutdown(pdev);
1188 if (ioc->ScsiLookup != NULL) {
1189 sz1 = ioc->req_depth * sizeof(void *);
1190 kfree(ioc->ScsiLookup);
1191 ioc->ScsiLookup = NULL;
1194 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1195 "Free'd ScsiLookup (%d) memory\n",
1198 kfree(hd->info_kbuf);
1200 /* NULL the Scsi_Host pointer
1204 scsi_host_put(host);
1210 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1212 * mptscsih_shutdown - reboot notifier
1216 mptscsih_shutdown(struct pci_dev *pdev)
1221 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1223 * mptscsih_suspend - Fusion MPT scsi driver suspend routine.
1228 mptscsih_suspend(struct pci_dev *pdev, pm_message_t state)
1230 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1232 scsi_block_requests(ioc->sh);
1233 flush_scheduled_work();
1234 mptscsih_shutdown(pdev);
1235 return mpt_suspend(pdev,state);
1238 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1240 * mptscsih_resume - Fusion MPT scsi driver resume routine.
1245 mptscsih_resume(struct pci_dev *pdev)
1247 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1250 rc = mpt_resume(pdev);
1251 scsi_unblock_requests(ioc->sh);
1257 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1259 * mptscsih_info - Return information about MPT adapter
1260 * @SChost: Pointer to Scsi_Host structure
1262 * (linux scsi_host_template.info routine)
1264 * Returns pointer to buffer where information was written.
1267 mptscsih_info(struct Scsi_Host *SChost)
1272 h = shost_priv(SChost);
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';
1279 mpt_print_ioc_summary(h->ioc, h->info_kbuf, &size, 0, 0);
1280 h->info_kbuf[size-1] = '\0';
1282 return h->info_kbuf;
1285 int mptscsih_show_info(struct seq_file *m, struct Scsi_Host *host)
1287 MPT_SCSI_HOST *hd = shost_priv(host);
1288 MPT_ADAPTER *ioc = hd->ioc;
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);
1298 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1299 #define ADD_INDEX_LOG(req_ent) do { } while(0)
1301 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1303 * mptscsih_qcmd - Primary Fusion MPT SCSI initiator IO start routine.
1304 * @SCpnt: Pointer to scsi_cmnd structure
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.
1310 * Returns 0. (rtn value discarded by linux scsi mid-layer)
1313 mptscsih_qcmd(struct scsi_cmnd *SCpnt)
1317 SCSIIORequest_t *pScsiReq;
1318 VirtDevice *vdevice = SCpnt->device->hostdata;
1327 hd = shost_priv(SCpnt->device->host);
1330 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "qcmd: SCpnt=%p\n",
1333 if (ioc->taskmgmt_quiesce_io)
1334 return SCSI_MLQUEUE_HOST_BUSY;
1337 * Put together a MPT SCSI request...
1339 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
1340 dprintk(ioc, printk(MYIOC_s_WARN_FMT "QueueCmd, no msg frames!!\n",
1342 return SCSI_MLQUEUE_HOST_BUSY;
1345 pScsiReq = (SCSIIORequest_t *) mf;
1347 my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1349 ADD_INDEX_LOG(my_idx);
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...
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) */
1363 scsidir = MPI_SCSIIO_CONTROL_NODATATRANSFER;
1366 /* Default to untagged. Once a target structure has been allocated,
1367 * use the Inquiry data to determine if device supports tagged.
1369 if ((vdevice->vtarget->tflags & MPT_TARGET_FLAGS_Q_YES)
1370 && (SCpnt->device->tagged_supported)) {
1371 scsictl = scsidir | MPI_SCSIIO_CONTROL_SIMPLEQ;
1372 if (SCpnt->request && SCpnt->request->ioprio) {
1373 if (((SCpnt->request->ioprio & 0x7) == 1) ||
1374 !(SCpnt->request->ioprio & 0x7))
1375 scsictl |= MPI_SCSIIO_CONTROL_HEADOFQ;
1378 scsictl = scsidir | MPI_SCSIIO_CONTROL_UNTAGGED;
1381 /* Use the above information to set up the message frame
1383 pScsiReq->TargetID = (u8) vdevice->vtarget->id;
1384 pScsiReq->Bus = vdevice->vtarget->channel;
1385 pScsiReq->ChainOffset = 0;
1386 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
1387 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
1389 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
1390 pScsiReq->CDBLength = SCpnt->cmd_len;
1391 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1392 pScsiReq->Reserved = 0;
1393 pScsiReq->MsgFlags = mpt_msg_flags(ioc);
1394 int_to_scsilun(SCpnt->device->lun, (struct scsi_lun *)pScsiReq->LUN);
1395 pScsiReq->Control = cpu_to_le32(scsictl);
1398 * Write SCSI CDB into the message
1400 cmd_len = SCpnt->cmd_len;
1401 for (ii=0; ii < cmd_len; ii++)
1402 pScsiReq->CDB[ii] = SCpnt->cmnd[ii];
1404 for (ii=cmd_len; ii < 16; ii++)
1405 pScsiReq->CDB[ii] = 0;
1408 pScsiReq->DataLength = cpu_to_le32(datalen);
1410 /* SenseBuffer low address */
1411 pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma
1412 + (my_idx * MPT_SENSE_BUFFER_ALLOC));
1414 /* Now add the SG list
1415 * Always have a SGE even if null length.
1418 /* Add a NULL SGE */
1419 ioc->add_sge((char *)&pScsiReq->SGL,
1420 MPT_SGE_FLAGS_SSIMPLE_READ | 0,
1423 /* Add a 32 or 64 bit SGE */
1424 if (mptscsih_AddSGE(ioc, SCpnt, pScsiReq, my_idx) != SUCCESS)
1428 SCpnt->host_scribble = (unsigned char *)mf;
1429 mptscsih_set_scsi_lookup(ioc, my_idx, SCpnt);
1431 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
1432 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Issued SCSI cmd (%p) mf=%p idx=%d\n",
1433 ioc->name, SCpnt, mf, my_idx));
1434 DBG_DUMP_REQUEST_FRAME(ioc, (u32 *)mf);
1438 mptscsih_freeChainBuffers(ioc, my_idx);
1439 mpt_free_msg_frame(ioc, mf);
1440 return SCSI_MLQUEUE_HOST_BUSY;
1443 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1445 * mptscsih_freeChainBuffers - Function to free chain buffers associated
1446 * with a SCSI IO request
1447 * @hd: Pointer to the MPT_SCSI_HOST instance
1448 * @req_idx: Index of the SCSI IO request frame.
1450 * Called if SG chain buffer allocation fails and mptscsih callbacks.
1454 mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx)
1456 MPT_FRAME_HDR *chain;
1457 unsigned long flags;
1461 /* Get the first chain index and reset
1464 chain_idx = ioc->ReqToChain[req_idx];
1465 ioc->ReqToChain[req_idx] = MPT_HOST_NO_CHAIN;
1467 while (chain_idx != MPT_HOST_NO_CHAIN) {
1469 /* Save the next chain buffer index */
1470 next = ioc->ChainToChain[chain_idx];
1472 /* Free this chain buffer and reset
1475 ioc->ChainToChain[chain_idx] = MPT_HOST_NO_CHAIN;
1477 chain = (MPT_FRAME_HDR *) (ioc->ChainBuffer
1478 + (chain_idx * ioc->req_sz));
1480 spin_lock_irqsave(&ioc->FreeQlock, flags);
1481 list_add_tail(&chain->u.frame.linkage.list, &ioc->FreeChainQ);
1482 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1484 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "FreeChainBuffers (index %d)\n",
1485 ioc->name, chain_idx));
1493 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1498 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1500 * mptscsih_IssueTaskMgmt - Generic send Task Management function.
1501 * @hd: Pointer to MPT_SCSI_HOST structure
1502 * @type: Task Management type
1503 * @channel: channel number for task management
1504 * @id: Logical Target ID for reset (if appropriate)
1505 * @lun: Logical Unit for reset (if appropriate)
1506 * @ctx2abort: Context for the task to be aborted (if appropriate)
1507 * @timeout: timeout for task management control
1509 * Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
1510 * or a non-interrupt thread. In the former, must not call schedule().
1512 * Not all fields are meaningfull for all task types.
1514 * Returns 0 for SUCCESS, or FAILED.
1518 mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, u64 lun,
1519 int ctx2abort, ulong timeout)
1522 SCSITaskMgmt_t *pScsiTm;
1525 MPT_ADAPTER *ioc = hd->ioc;
1526 unsigned long timeleft;
1527 u8 issue_hard_reset;
1529 unsigned long time_count;
1531 issue_hard_reset = 0;
1532 ioc_raw_state = mpt_GetIocState(ioc, 0);
1534 if ((ioc_raw_state & MPI_IOC_STATE_MASK) != MPI_IOC_STATE_OPERATIONAL) {
1535 printk(MYIOC_s_WARN_FMT
1536 "TaskMgmt type=%x: IOC Not operational (0x%x)!\n",
1537 ioc->name, type, ioc_raw_state);
1538 printk(MYIOC_s_WARN_FMT "Issuing HardReset from %s!!\n",
1539 ioc->name, __func__);
1540 if (mpt_HardResetHandler(ioc, CAN_SLEEP) < 0)
1541 printk(MYIOC_s_WARN_FMT "TaskMgmt HardReset "
1542 "FAILED!!\n", ioc->name);
1546 /* DOORBELL ACTIVE check is not required if
1547 * MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q is supported.
1550 if (!((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q)
1551 && (ioc->facts.MsgVersion >= MPI_VERSION_01_05)) &&
1552 (ioc_raw_state & MPI_DOORBELL_ACTIVE)) {
1553 printk(MYIOC_s_WARN_FMT
1554 "TaskMgmt type=%x: ioc_state: "
1555 "DOORBELL_ACTIVE (0x%x)!\n",
1556 ioc->name, type, ioc_raw_state);
1560 mutex_lock(&ioc->taskmgmt_cmds.mutex);
1561 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
1567 /* Return Fail to calling function if no message frames available.
1569 if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) {
1570 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1571 "TaskMgmt no msg frames!!\n", ioc->name));
1573 mpt_clear_taskmgmt_in_progress_flag(ioc);
1576 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
1579 /* Format the Request
1581 pScsiTm = (SCSITaskMgmt_t *) mf;
1582 pScsiTm->TargetID = id;
1583 pScsiTm->Bus = channel;
1584 pScsiTm->ChainOffset = 0;
1585 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
1587 pScsiTm->Reserved = 0;
1588 pScsiTm->TaskType = type;
1589 pScsiTm->Reserved1 = 0;
1590 pScsiTm->MsgFlags = (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS)
1591 ? MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION : 0;
1593 int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
1595 for (ii=0; ii < 7; ii++)
1596 pScsiTm->Reserved2[ii] = 0;
1598 pScsiTm->TaskMsgContext = ctx2abort;
1600 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt: ctx2abort (0x%08x) "
1601 "task_type = 0x%02X, timeout = %ld\n", ioc->name, ctx2abort,
1604 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)pScsiTm);
1606 INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
1607 time_count = jiffies;
1608 if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
1609 (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
1610 mpt_put_msg_frame_hi_pri(ioc->TaskCtx, ioc, mf);
1612 retval = mpt_send_handshake_request(ioc->TaskCtx, ioc,
1613 sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
1615 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1616 "TaskMgmt handshake FAILED!(mf=%p, rc=%d) \n",
1617 ioc->name, mf, retval));
1618 mpt_free_msg_frame(ioc, mf);
1619 mpt_clear_taskmgmt_in_progress_flag(ioc);
1624 timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done,
1626 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
1628 dtmprintk(ioc, printk(MYIOC_s_ERR_FMT
1629 "TaskMgmt TIMED OUT!(mf=%p)\n", ioc->name, mf));
1630 mpt_clear_taskmgmt_in_progress_flag(ioc);
1631 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
1633 issue_hard_reset = 1;
1637 retval = mptscsih_taskmgmt_reply(ioc, type,
1638 (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply);
1640 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1641 "TaskMgmt completed (%d seconds)\n",
1642 ioc->name, jiffies_to_msecs(jiffies - time_count)/1000));
1646 CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
1647 if (issue_hard_reset) {
1648 printk(MYIOC_s_WARN_FMT
1649 "Issuing Reset from %s!! doorbell=0x%08x\n",
1650 ioc->name, __func__, mpt_GetIocState(ioc, 0));
1651 retval = (ioc->bus_type == SAS) ?
1652 mpt_HardResetHandler(ioc, CAN_SLEEP) :
1653 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
1654 mpt_free_msg_frame(ioc, mf);
1657 retval = (retval == 0) ? 0 : FAILED;
1658 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
1661 EXPORT_SYMBOL(mptscsih_IssueTaskMgmt);
1664 mptscsih_get_tm_timeout(MPT_ADAPTER *ioc)
1666 switch (ioc->bus_type) {
1677 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1679 * mptscsih_abort - Abort linux scsi_cmnd routine, new_eh variant
1680 * @SCpnt: Pointer to scsi_cmnd structure, IO to be aborted
1682 * (linux scsi_host_template.eh_abort_handler routine)
1684 * Returns SUCCESS or FAILED.
1687 mptscsih_abort(struct scsi_cmnd * SCpnt)
1694 VirtDevice *vdevice;
1697 /* If we can't locate our host adapter structure, return FAILED status.
1699 if ((hd = shost_priv(SCpnt->device->host)) == NULL) {
1700 SCpnt->result = DID_RESET << 16;
1701 SCpnt->scsi_done(SCpnt);
1702 printk(KERN_ERR MYNAM ": task abort: "
1703 "can't locate host! (sc=%p)\n", SCpnt);
1708 printk(MYIOC_s_INFO_FMT "attempting task abort! (sc=%p)\n",
1710 scsi_print_command(SCpnt);
1712 vdevice = SCpnt->device->hostdata;
1713 if (!vdevice || !vdevice->vtarget) {
1714 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1715 "task abort: device has been deleted (sc=%p)\n",
1717 SCpnt->result = DID_NO_CONNECT << 16;
1718 SCpnt->scsi_done(SCpnt);
1723 /* Task aborts are not supported for hidden raid components.
1725 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
1726 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1727 "task abort: hidden raid component (sc=%p)\n",
1729 SCpnt->result = DID_RESET << 16;
1734 /* Task aborts are not supported for volumes.
1736 if (vdevice->vtarget->raidVolume) {
1737 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1738 "task abort: raid volume (sc=%p)\n",
1740 SCpnt->result = DID_RESET << 16;
1745 /* Find this command
1747 if ((scpnt_idx = SCPNT_TO_LOOKUP_IDX(ioc, SCpnt)) < 0) {
1748 /* Cmd not found in ScsiLookup.
1751 SCpnt->result = DID_RESET << 16;
1752 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "task abort: "
1753 "Command not in the active list! (sc=%p)\n", ioc->name,
1759 if (ioc->timeouts < -1)
1762 if (mpt_fwfault_debug)
1763 mpt_halt_firmware(ioc);
1765 /* Most important! Set TaskMsgContext to SCpnt's MsgContext!
1766 * (the IO to be ABORT'd)
1768 * NOTE: Since we do not byteswap MsgContext, we do not
1769 * swap it here either. It is an opaque cookie to
1770 * the controller, so it does not matter. -DaveM
1772 mf = MPT_INDEX_2_MFPTR(ioc, scpnt_idx);
1773 ctx2abort = mf->u.frame.hwhdr.msgctxu.MsgContext;
1774 retval = mptscsih_IssueTaskMgmt(hd,
1775 MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
1776 vdevice->vtarget->channel,
1777 vdevice->vtarget->id, vdevice->lun,
1778 ctx2abort, mptscsih_get_tm_timeout(ioc));
1780 if (SCPNT_TO_LOOKUP_IDX(ioc, SCpnt) == scpnt_idx) {
1781 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1782 "task abort: command still in active list! (sc=%p)\n",
1786 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1787 "task abort: command cleared from active list! (sc=%p)\n",
1793 printk(MYIOC_s_INFO_FMT "task abort: %s (rv=%04x) (sc=%p)\n",
1794 ioc->name, ((retval == SUCCESS) ? "SUCCESS" : "FAILED"), retval,
1800 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1802 * mptscsih_dev_reset - Perform a SCSI TARGET_RESET! new_eh variant
1803 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1805 * (linux scsi_host_template.eh_dev_reset_handler routine)
1807 * Returns SUCCESS or FAILED.
1810 mptscsih_dev_reset(struct scsi_cmnd * SCpnt)
1814 VirtDevice *vdevice;
1817 /* If we can't locate our host adapter structure, return FAILED status.
1819 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
1820 printk(KERN_ERR MYNAM ": target reset: "
1821 "Can't locate host! (sc=%p)\n", SCpnt);
1826 printk(MYIOC_s_INFO_FMT "attempting target reset! (sc=%p)\n",
1828 scsi_print_command(SCpnt);
1830 vdevice = SCpnt->device->hostdata;
1831 if (!vdevice || !vdevice->vtarget) {
1836 /* Target reset to hidden raid component is not supported
1838 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
1843 retval = mptscsih_IssueTaskMgmt(hd,
1844 MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
1845 vdevice->vtarget->channel,
1846 vdevice->vtarget->id, 0, 0,
1847 mptscsih_get_tm_timeout(ioc));
1850 printk (MYIOC_s_INFO_FMT "target reset: %s (sc=%p)\n",
1851 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1860 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1862 * mptscsih_bus_reset - Perform a SCSI BUS_RESET! new_eh variant
1863 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1865 * (linux scsi_host_template.eh_bus_reset_handler routine)
1867 * Returns SUCCESS or FAILED.
1870 mptscsih_bus_reset(struct scsi_cmnd * SCpnt)
1874 VirtDevice *vdevice;
1877 /* If we can't locate our host adapter structure, return FAILED status.
1879 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
1880 printk(KERN_ERR MYNAM ": bus reset: "
1881 "Can't locate host! (sc=%p)\n", SCpnt);
1886 printk(MYIOC_s_INFO_FMT "attempting bus reset! (sc=%p)\n",
1888 scsi_print_command(SCpnt);
1890 if (ioc->timeouts < -1)
1893 vdevice = SCpnt->device->hostdata;
1894 if (!vdevice || !vdevice->vtarget)
1896 retval = mptscsih_IssueTaskMgmt(hd,
1897 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1898 vdevice->vtarget->channel, 0, 0, 0,
1899 mptscsih_get_tm_timeout(ioc));
1901 printk(MYIOC_s_INFO_FMT "bus reset: %s (sc=%p)\n",
1902 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1910 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1912 * mptscsih_host_reset - Perform a SCSI host adapter RESET (new_eh variant)
1913 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1915 * (linux scsi_host_template.eh_host_reset_handler routine)
1917 * Returns SUCCESS or FAILED.
1920 mptscsih_host_reset(struct scsi_cmnd *SCpnt)
1923 int status = SUCCESS;
1927 /* If we can't locate the host to reset, then we failed. */
1928 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
1929 printk(KERN_ERR MYNAM ": host reset: "
1930 "Can't locate host! (sc=%p)\n", SCpnt);
1934 /* make sure we have no outstanding commands at this stage */
1935 mptscsih_flush_running_cmds(hd);
1938 printk(MYIOC_s_INFO_FMT "attempting host reset! (sc=%p)\n",
1941 /* If our attempts to reset the host failed, then return a failed
1942 * status. The host will be taken off line by the SCSI mid-layer.
1944 retval = mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
1950 printk(MYIOC_s_INFO_FMT "host reset: %s (sc=%p)\n",
1951 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1957 mptscsih_taskmgmt_reply(MPT_ADAPTER *ioc, u8 type,
1958 SCSITaskMgmtReply_t *pScsiTmReply)
1961 u32 termination_count;
1964 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
1969 DBG_DUMP_TM_REPLY_FRAME(ioc, (u32 *)pScsiTmReply);
1971 iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
1972 termination_count = le32_to_cpu(pScsiTmReply->TerminationCount);
1974 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1975 "TaskMgmt fw_channel = %d, fw_id = %d, task_type = 0x%02X,\n"
1976 "\tiocstatus = 0x%04X, loginfo = 0x%08X, response_code = 0x%02X,\n"
1977 "\tterm_cmnds = %d\n", ioc->name, pScsiTmReply->Bus,
1978 pScsiTmReply->TargetID, type, le16_to_cpu(pScsiTmReply->IOCStatus),
1979 le32_to_cpu(pScsiTmReply->IOCLogInfo), pScsiTmReply->ResponseCode,
1980 termination_count));
1982 if (ioc->facts.MsgVersion >= MPI_VERSION_01_05 &&
1983 pScsiTmReply->ResponseCode)
1984 mptscsih_taskmgmt_response_code(ioc,
1985 pScsiTmReply->ResponseCode);
1987 if (iocstatus == MPI_IOCSTATUS_SUCCESS) {
1993 if (type == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK) {
1994 if (termination_count == 1)
1999 if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
2000 iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED)
2007 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2009 mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code)
2013 switch (response_code) {
2014 case MPI_SCSITASKMGMT_RSP_TM_COMPLETE:
2015 desc = "The task completed.";
2017 case MPI_SCSITASKMGMT_RSP_INVALID_FRAME:
2018 desc = "The IOC received an invalid frame status.";
2020 case MPI_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
2021 desc = "The task type is not supported.";
2023 case MPI_SCSITASKMGMT_RSP_TM_FAILED:
2024 desc = "The requested task failed.";
2026 case MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED:
2027 desc = "The task completed successfully.";
2029 case MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN:
2030 desc = "The LUN request is invalid.";
2032 case MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
2033 desc = "The task is in the IOC queue and has not been sent to target.";
2039 printk(MYIOC_s_INFO_FMT "Response Code(0x%08x): F/W: %s\n",
2040 ioc->name, response_code, desc);
2042 EXPORT_SYMBOL(mptscsih_taskmgmt_response_code);
2044 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2046 * mptscsih_taskmgmt_complete - Registered with Fusion MPT base driver
2047 * @ioc: Pointer to MPT_ADAPTER structure
2048 * @mf: Pointer to SCSI task mgmt request frame
2049 * @mr: Pointer to SCSI task mgmt reply frame
2051 * This routine is called from mptbase.c::mpt_interrupt() at the completion
2052 * of any SCSI task management request.
2053 * This routine is registered with the MPT (base) driver at driver
2054 * load/init time via the mpt_register() API call.
2056 * Returns 1 indicating alloc'd request frame ptr should be freed.
2059 mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf,
2062 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2063 "TaskMgmt completed (mf=%p, mr=%p)\n", ioc->name, mf, mr));
2065 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
2070 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
2071 memcpy(ioc->taskmgmt_cmds.reply, mr,
2072 min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
2074 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
2075 mpt_clear_taskmgmt_in_progress_flag(ioc);
2076 ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
2077 complete(&ioc->taskmgmt_cmds.done);
2078 if (ioc->bus_type == SAS)
2079 ioc->schedule_target_reset(ioc);
2085 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2087 * This is anyones guess quite frankly.
2090 mptscsih_bios_param(struct scsi_device * sdev, struct block_device *bdev,
2091 sector_t capacity, int geom[])
2101 dummy = heads * sectors;
2102 cylinders = capacity;
2103 sector_div(cylinders,dummy);
2106 * Handle extended translation size for logical drives
2109 if ((ulong)capacity >= 0x200000) {
2112 dummy = heads * sectors;
2113 cylinders = capacity;
2114 sector_div(cylinders,dummy);
2120 geom[2] = cylinders;
2125 /* Search IOC page 3 to determine if this is hidden physical disk
2129 mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id)
2131 struct inactive_raid_component_info *component_info;
2133 RaidPhysDiskPage1_t *phys_disk;
2137 if (!ioc->raid_data.pIocPg3)
2139 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2140 if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
2141 (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
2147 if (ioc->bus_type != SAS)
2151 * Check if dual path
2153 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2154 num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
2155 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
2158 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
2159 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
2162 if ((mpt_raid_phys_disk_pg1(ioc,
2163 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
2168 for (j = 0; j < num_paths; j++) {
2169 if ((phys_disk->Path[j].Flags &
2170 MPI_RAID_PHYSDISK1_FLAG_INVALID))
2172 if ((phys_disk->Path[j].Flags &
2173 MPI_RAID_PHYSDISK1_FLAG_BROKEN))
2175 if ((id == phys_disk->Path[j].PhysDiskID) &&
2176 (channel == phys_disk->Path[j].PhysDiskBus)) {
2187 * Check inactive list for matching phys disks
2189 if (list_empty(&ioc->raid_data.inactive_list))
2192 mutex_lock(&ioc->raid_data.inactive_list_mutex);
2193 list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
2195 if ((component_info->d.PhysDiskID == id) &&
2196 (component_info->d.PhysDiskBus == channel))
2199 mutex_unlock(&ioc->raid_data.inactive_list_mutex);
2204 EXPORT_SYMBOL(mptscsih_is_phys_disk);
2207 mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
2209 struct inactive_raid_component_info *component_info;
2211 RaidPhysDiskPage1_t *phys_disk;
2215 if (!ioc->raid_data.pIocPg3)
2217 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2218 if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
2219 (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
2220 rc = ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum;
2225 if (ioc->bus_type != SAS)
2229 * Check if dual path
2231 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2232 num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
2233 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
2236 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
2237 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
2240 if ((mpt_raid_phys_disk_pg1(ioc,
2241 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
2246 for (j = 0; j < num_paths; j++) {
2247 if ((phys_disk->Path[j].Flags &
2248 MPI_RAID_PHYSDISK1_FLAG_INVALID))
2250 if ((phys_disk->Path[j].Flags &
2251 MPI_RAID_PHYSDISK1_FLAG_BROKEN))
2253 if ((id == phys_disk->Path[j].PhysDiskID) &&
2254 (channel == phys_disk->Path[j].PhysDiskBus)) {
2255 rc = phys_disk->PhysDiskNum;
2264 * Check inactive list for matching phys disks
2266 if (list_empty(&ioc->raid_data.inactive_list))
2269 mutex_lock(&ioc->raid_data.inactive_list_mutex);
2270 list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
2272 if ((component_info->d.PhysDiskID == id) &&
2273 (component_info->d.PhysDiskBus == channel))
2274 rc = component_info->d.PhysDiskNum;
2276 mutex_unlock(&ioc->raid_data.inactive_list_mutex);
2281 EXPORT_SYMBOL(mptscsih_raid_id_to_num);
2284 * OS entry point to allow for host driver to free allocated memory
2285 * Called if no device present or device being unloaded
2288 mptscsih_slave_destroy(struct scsi_device *sdev)
2290 struct Scsi_Host *host = sdev->host;
2291 MPT_SCSI_HOST *hd = shost_priv(host);
2292 VirtTarget *vtarget;
2293 VirtDevice *vdevice;
2294 struct scsi_target *starget;
2296 starget = scsi_target(sdev);
2297 vtarget = starget->hostdata;
2298 vdevice = sdev->hostdata;
2302 mptscsih_search_running_cmds(hd, vdevice);
2303 vtarget->num_luns--;
2304 mptscsih_synchronize_cache(hd, vdevice);
2306 sdev->hostdata = NULL;
2309 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2311 * mptscsih_change_queue_depth - This function will set a devices queue depth
2312 * @sdev: per scsi_device pointer
2313 * @qdepth: requested queue depth
2314 * @reason: calling context
2316 * Adding support for new 'change_queue_depth' api.
2319 mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
2321 MPT_SCSI_HOST *hd = shost_priv(sdev->host);
2322 VirtTarget *vtarget;
2323 struct scsi_target *starget;
2326 MPT_ADAPTER *ioc = hd->ioc;
2328 starget = scsi_target(sdev);
2329 vtarget = starget->hostdata;
2331 if (reason != SCSI_QDEPTH_DEFAULT)
2334 if (ioc->bus_type == SPI) {
2335 if (!(vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
2337 else if (sdev->type == TYPE_DISK &&
2338 vtarget->minSyncFactor <= MPT_ULTRA160)
2339 max_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
2341 max_depth = MPT_SCSI_CMD_PER_DEV_LOW;
2343 max_depth = ioc->sh->can_queue;
2345 if (!sdev->tagged_supported)
2348 if (qdepth > max_depth)
2353 tagged = MSG_SIMPLE_TAG;
2355 scsi_adjust_queue_depth(sdev, tagged, qdepth);
2356 return sdev->queue_depth;
2360 * OS entry point to adjust the queue_depths on a per-device basis.
2361 * Called once per device the bus scan. Use it to force the queue_depth
2362 * member to 1 if a device does not support Q tags.
2363 * Return non-zero if fails.
2366 mptscsih_slave_configure(struct scsi_device *sdev)
2368 struct Scsi_Host *sh = sdev->host;
2369 VirtTarget *vtarget;
2370 VirtDevice *vdevice;
2371 struct scsi_target *starget;
2372 MPT_SCSI_HOST *hd = shost_priv(sh);
2373 MPT_ADAPTER *ioc = hd->ioc;
2375 starget = scsi_target(sdev);
2376 vtarget = starget->hostdata;
2377 vdevice = sdev->hostdata;
2379 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2380 "device @ %p, channel=%d, id=%d, lun=%llu\n",
2381 ioc->name, sdev, sdev->channel, sdev->id, sdev->lun));
2382 if (ioc->bus_type == SPI)
2383 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2384 "sdtr %d wdtr %d ppr %d inq length=%d\n",
2385 ioc->name, sdev->sdtr, sdev->wdtr,
2386 sdev->ppr, sdev->inquiry_len));
2388 vdevice->configured_lun = 1;
2390 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2391 "Queue depth=%d, tflags=%x\n",
2392 ioc->name, sdev->queue_depth, vtarget->tflags));
2394 if (ioc->bus_type == SPI)
2395 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2396 "negoFlags=%x, maxOffset=%x, SyncFactor=%x\n",
2397 ioc->name, vtarget->negoFlags, vtarget->maxOffset,
2398 vtarget->minSyncFactor));
2400 mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH,
2401 SCSI_QDEPTH_DEFAULT);
2402 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2403 "tagged %d, simple %d, ordered %d\n",
2404 ioc->name,sdev->tagged_supported, sdev->simple_tags,
2405 sdev->ordered_tags));
2407 blk_queue_dma_alignment (sdev->request_queue, 512 - 1);
2412 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2414 * Private routines...
2417 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2418 /* Utility function to copy sense data from the scsi_cmnd buffer
2419 * to the FC and SCSI target structures.
2423 mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply)
2425 VirtDevice *vdevice;
2426 SCSIIORequest_t *pReq;
2427 u32 sense_count = le32_to_cpu(pScsiReply->SenseCount);
2428 MPT_ADAPTER *ioc = hd->ioc;
2430 /* Get target structure
2432 pReq = (SCSIIORequest_t *) mf;
2433 vdevice = sc->device->hostdata;
2439 /* Copy the sense received into the scsi command block. */
2440 req_index = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2441 sense_data = ((u8 *)ioc->sense_buf_pool + (req_index * MPT_SENSE_BUFFER_ALLOC));
2442 memcpy(sc->sense_buffer, sense_data, SNS_LEN(sc));
2444 /* Log SMART data (asc = 0x5D, non-IM case only) if required.
2446 if ((ioc->events) && (ioc->eventTypes & (1 << MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE))) {
2447 if ((sense_data[12] == 0x5D) && (vdevice->vtarget->raidVolume == 0)) {
2450 idx = ioc->eventContext % MPTCTL_EVENT_LOG_SIZE;
2451 ioc->events[idx].event = MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE;
2452 ioc->events[idx].eventContext = ioc->eventContext;
2454 ioc->events[idx].data[0] = (pReq->LUN[1] << 24) |
2455 (MPI_EVENT_SCSI_DEV_STAT_RC_SMART_DATA << 16) |
2456 (sc->device->channel << 8) | sc->device->id;
2458 ioc->events[idx].data[1] = (sense_data[13] << 8) | sense_data[12];
2460 ioc->eventContext++;
2461 if (ioc->pcidev->vendor ==
2462 PCI_VENDOR_ID_IBM) {
2463 mptscsih_issue_sep_command(ioc,
2464 vdevice->vtarget, MPI_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
2465 vdevice->vtarget->tflags |=
2466 MPT_TARGET_FLAGS_LED_ON;
2471 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Hmmm... SenseData len=0! (?)\n",
2477 * mptscsih_get_scsi_lookup - retrieves scmd entry
2478 * @ioc: Pointer to MPT_ADAPTER structure
2479 * @i: index into the array
2481 * Returns the scsi_cmd pointer
2484 mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i)
2486 unsigned long flags;
2487 struct scsi_cmnd *scmd;
2489 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2490 scmd = ioc->ScsiLookup[i];
2491 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2495 EXPORT_SYMBOL(mptscsih_get_scsi_lookup);
2498 * mptscsih_getclear_scsi_lookup - retrieves and clears scmd entry from ScsiLookup[] array list
2499 * @ioc: Pointer to MPT_ADAPTER structure
2500 * @i: index into the array
2502 * Returns the scsi_cmd pointer
2505 static struct scsi_cmnd *
2506 mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i)
2508 unsigned long flags;
2509 struct scsi_cmnd *scmd;
2511 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2512 scmd = ioc->ScsiLookup[i];
2513 ioc->ScsiLookup[i] = NULL;
2514 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2520 * mptscsih_set_scsi_lookup - write a scmd entry into the ScsiLookup[] array list
2522 * @ioc: Pointer to MPT_ADAPTER structure
2523 * @i: index into the array
2524 * @scmd: scsi_cmnd pointer
2528 mptscsih_set_scsi_lookup(MPT_ADAPTER *ioc, int i, struct scsi_cmnd *scmd)
2530 unsigned long flags;
2532 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2533 ioc->ScsiLookup[i] = scmd;
2534 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2538 * SCPNT_TO_LOOKUP_IDX - searches for a given scmd in the ScsiLookup[] array list
2539 * @ioc: Pointer to MPT_ADAPTER structure
2540 * @sc: scsi_cmnd pointer
2543 SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *sc)
2545 unsigned long flags;
2548 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2549 for (i = 0; i < ioc->req_depth; i++) {
2550 if (ioc->ScsiLookup[i] == sc) {
2557 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2561 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2563 mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
2567 if (ioc->sh == NULL || shost_priv(ioc->sh) == NULL)
2570 hd = shost_priv(ioc->sh);
2571 switch (reset_phase) {
2572 case MPT_IOC_SETUP_RESET:
2573 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2574 "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__));
2576 case MPT_IOC_PRE_RESET:
2577 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2578 "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__));
2579 mptscsih_flush_running_cmds(hd);
2581 case MPT_IOC_POST_RESET:
2582 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2583 "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__));
2584 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING) {
2585 ioc->internal_cmds.status |=
2586 MPT_MGMT_STATUS_DID_IOCRESET;
2587 complete(&ioc->internal_cmds.done);
2593 return 1; /* currently means nothing really */
2596 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2598 mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
2600 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
2602 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2603 "MPT event (=%02Xh) routed to SCSI host driver!\n",
2606 if ((event == MPI_EVENT_IOC_BUS_RESET ||
2607 event == MPI_EVENT_EXT_BUS_RESET) &&
2608 (ioc->bus_type == SPI) && (ioc->soft_resets < -1))
2611 return 1; /* currently means nothing really */
2614 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2616 * Bus Scan and Domain Validation functionality ...
2619 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2621 * mptscsih_scandv_complete - Scan and DV callback routine registered
2622 * to Fustion MPT (base) driver.
2624 * @ioc: Pointer to MPT_ADAPTER structure
2625 * @mf: Pointer to original MPT request frame
2626 * @mr: Pointer to MPT reply frame (NULL if TurboReply)
2628 * This routine is called from mpt.c::mpt_interrupt() at the completion
2629 * of any SCSI IO request.
2630 * This routine is registered with the Fusion MPT (base) driver at driver
2631 * load/init time via the mpt_register() API call.
2633 * Returns 1 indicating alloc'd request frame ptr should be freed.
2635 * Remark: Sets a completion code and (possibly) saves sense data
2636 * in the IOC member localReply structure.
2637 * Used ONLY for DV and other internal commands.
2640 mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2641 MPT_FRAME_HDR *reply)
2643 SCSIIORequest_t *pReq;
2644 SCSIIOReply_t *pReply;
2650 ioc->internal_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
2651 ioc->internal_cmds.completion_code = MPT_SCANDV_GOOD;
2655 pReply = (SCSIIOReply_t *) reply;
2656 pReq = (SCSIIORequest_t *) req;
2657 ioc->internal_cmds.completion_code =
2658 mptscsih_get_completion_code(ioc, req, reply);
2659 ioc->internal_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
2660 memcpy(ioc->internal_cmds.reply, reply,
2661 min(MPT_DEFAULT_FRAME_SIZE, 4 * reply->u.reply.MsgLength));
2662 cmd = reply->u.hdr.Function;
2663 if (((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) ||
2664 (cmd == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) &&
2665 (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
2666 req_idx = le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
2667 sense_data = ((u8 *)ioc->sense_buf_pool +
2668 (req_idx * MPT_SENSE_BUFFER_ALLOC));
2669 sz = min_t(int, pReq->SenseBufferLength,
2670 MPT_SENSE_BUFFER_ALLOC);
2671 memcpy(ioc->internal_cmds.sense, sense_data, sz);
2674 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING))
2676 ioc->internal_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
2677 complete(&ioc->internal_cmds.done);
2683 * mptscsih_get_completion_code - get completion code from MPT request
2684 * @ioc: Pointer to MPT_ADAPTER structure
2685 * @req: Pointer to original MPT request frame
2686 * @reply: Pointer to MPT reply frame (NULL if TurboReply)
2690 mptscsih_get_completion_code(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2691 MPT_FRAME_HDR *reply)
2693 SCSIIOReply_t *pReply;
2694 MpiRaidActionReply_t *pr;
2697 int completion_code;
2699 pReply = (SCSIIOReply_t *)reply;
2700 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
2701 scsi_status = pReply->SCSIStatus;
2703 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2704 "IOCStatus=%04xh, SCSIState=%02xh, SCSIStatus=%02xh,"
2705 "IOCLogInfo=%08xh\n", ioc->name, status, pReply->SCSIState,
2706 scsi_status, le32_to_cpu(pReply->IOCLogInfo)));
2710 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
2711 completion_code = MPT_SCANDV_SELECTION_TIMEOUT;
2714 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
2715 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
2716 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
2717 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
2718 completion_code = MPT_SCANDV_DID_RESET;
2721 case MPI_IOCSTATUS_BUSY:
2722 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES:
2723 completion_code = MPT_SCANDV_BUSY;
2726 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
2727 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
2728 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
2729 if (pReply->Function == MPI_FUNCTION_CONFIG) {
2730 completion_code = MPT_SCANDV_GOOD;
2731 } else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) {
2732 pr = (MpiRaidActionReply_t *)reply;
2733 if (le16_to_cpu(pr->ActionStatus) ==
2734 MPI_RAID_ACTION_ASTATUS_SUCCESS)
2735 completion_code = MPT_SCANDV_GOOD;
2737 completion_code = MPT_SCANDV_SOME_ERROR;
2738 } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)
2739 completion_code = MPT_SCANDV_SENSE;
2740 else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) {
2741 if (req->u.scsireq.CDB[0] == INQUIRY)
2742 completion_code = MPT_SCANDV_ISSUE_SENSE;
2744 completion_code = MPT_SCANDV_DID_RESET;
2745 } else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS)
2746 completion_code = MPT_SCANDV_DID_RESET;
2747 else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
2748 completion_code = MPT_SCANDV_DID_RESET;
2749 else if (scsi_status == MPI_SCSI_STATUS_BUSY)
2750 completion_code = MPT_SCANDV_BUSY;
2752 completion_code = MPT_SCANDV_GOOD;
2755 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
2756 if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
2757 completion_code = MPT_SCANDV_DID_RESET;
2759 completion_code = MPT_SCANDV_SOME_ERROR;
2762 completion_code = MPT_SCANDV_SOME_ERROR;
2765 } /* switch(status) */
2767 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2768 " completionCode set to %08xh\n", ioc->name, completion_code));
2769 return completion_code;
2772 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2774 * mptscsih_do_cmd - Do internal command.
2775 * @hd: MPT_SCSI_HOST pointer
2776 * @io: INTERNAL_CMD pointer.
2778 * Issue the specified internally generated command and do command
2779 * specific cleanup. For bus scan / DV only.
2780 * NOTES: If command is Inquiry and status is good,
2781 * initialize a target structure, save the data
2783 * Remark: Single threaded access only.
2786 * < 0 if an illegal command or no resources
2790 * > 0 if command complete but some type of completion error.
2793 mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io)
2796 SCSIIORequest_t *pScsiReq;
2797 int my_idx, ii, dir;
2800 char CDB[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
2802 MPT_ADAPTER *ioc = hd->ioc;
2804 unsigned long timeleft;
2805 unsigned long flags;
2807 /* don't send internal command during diag reset */
2808 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
2809 if (ioc->ioc_reset_in_progress) {
2810 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2811 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2812 "%s: busy with host reset\n", ioc->name, __func__));
2813 return MPT_SCANDV_BUSY;
2815 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2817 mutex_lock(&ioc->internal_cmds.mutex);
2819 /* Set command specific information
2824 dir = MPI_SCSIIO_CONTROL_READ;
2830 case TEST_UNIT_READY:
2832 dir = MPI_SCSIIO_CONTROL_READ;
2838 dir = MPI_SCSIIO_CONTROL_READ;
2840 CDB[4] = 1; /*Spin up the disk */
2848 dir = MPI_SCSIIO_CONTROL_READ;
2854 dir = MPI_SCSIIO_CONTROL_READ;
2856 if (io->flags & MPT_ICFLAG_ECHO) {
2862 if (io->flags & MPT_ICFLAG_BUF_CAP) {
2865 CDB[6] = (io->size >> 16) & 0xFF;
2866 CDB[7] = (io->size >> 8) & 0xFF;
2867 CDB[8] = io->size & 0xFF;
2873 dir = MPI_SCSIIO_CONTROL_WRITE;
2875 if (io->flags & MPT_ICFLAG_ECHO) {
2880 CDB[6] = (io->size >> 16) & 0xFF;
2881 CDB[7] = (io->size >> 8) & 0xFF;
2882 CDB[8] = io->size & 0xFF;
2888 dir = MPI_SCSIIO_CONTROL_READ;
2895 dir = MPI_SCSIIO_CONTROL_READ;
2900 case SYNCHRONIZE_CACHE:
2902 dir = MPI_SCSIIO_CONTROL_READ;
2904 // CDB[1] = 0x02; /* set immediate bit */
2914 /* Get and Populate a free Frame
2915 * MsgContext set in mpt_get_msg_frame call
2917 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
2918 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: No msg frames!\n",
2919 ioc->name, __func__));
2920 ret = MPT_SCANDV_BUSY;
2924 pScsiReq = (SCSIIORequest_t *) mf;
2926 /* Get the request index */
2927 my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2928 ADD_INDEX_LOG(my_idx); /* for debug */
2930 if (io->flags & MPT_ICFLAG_PHYS_DISK) {
2931 pScsiReq->TargetID = io->physDiskNum;
2933 pScsiReq->ChainOffset = 0;
2934 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
2936 pScsiReq->TargetID = io->id;
2937 pScsiReq->Bus = io->channel;
2938 pScsiReq->ChainOffset = 0;
2939 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
2942 pScsiReq->CDBLength = cmdLen;
2943 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
2945 pScsiReq->Reserved = 0;
2947 pScsiReq->MsgFlags = mpt_msg_flags(ioc);
2948 /* MsgContext set in mpt_get_msg_fram call */
2950 int_to_scsilun(io->lun, (struct scsi_lun *)pScsiReq->LUN);
2952 if (io->flags & MPT_ICFLAG_TAGGED_CMD)
2953 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_SIMPLEQ);
2955 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
2957 if (cmd == REQUEST_SENSE) {
2958 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
2959 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2960 "%s: Untagged! 0x%02x\n", ioc->name, __func__, cmd));
2963 for (ii = 0; ii < 16; ii++)
2964 pScsiReq->CDB[ii] = CDB[ii];
2966 pScsiReq->DataLength = cpu_to_le32(io->size);
2967 pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma
2968 + (my_idx * MPT_SENSE_BUFFER_ALLOC));
2970 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2971 "%s: Sending Command 0x%02x for fw_channel=%d fw_id=%d lun=%llu\n",
2972 ioc->name, __func__, cmd, io->channel, io->id, io->lun));
2974 if (dir == MPI_SCSIIO_CONTROL_READ)
2975 ioc->add_sge((char *) &pScsiReq->SGL,
2976 MPT_SGE_FLAGS_SSIMPLE_READ | io->size, io->data_dma);
2978 ioc->add_sge((char *) &pScsiReq->SGL,
2979 MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size, io->data_dma);
2981 INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
2982 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
2983 timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done,
2985 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2986 ret = MPT_SCANDV_DID_RESET;
2987 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2988 "%s: TIMED OUT for cmd=0x%02x\n", ioc->name, __func__,
2990 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2991 mpt_free_msg_frame(ioc, mf);
2995 printk(MYIOC_s_WARN_FMT
2996 "Issuing Reset from %s!! doorbell=0x%08xh"
2998 ioc->name, __func__, mpt_GetIocState(ioc, 0),
3000 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
3001 mpt_free_msg_frame(ioc, mf);
3006 ret = ioc->internal_cmds.completion_code;
3007 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: success, rc=0x%02x\n",
3008 ioc->name, __func__, ret));
3011 CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
3012 mutex_unlock(&ioc->internal_cmds.mutex);
3016 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3018 * mptscsih_synchronize_cache - Send SYNCHRONIZE_CACHE to all disks.
3019 * @hd: Pointer to a SCSI HOST structure
3020 * @vdevice: virtual target device
3022 * Uses the ISR, but with special processing.
3023 * MUST be single-threaded.
3027 mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
3031 /* Ignore hidden raid components, this is handled when the command
3032 * is sent to the volume
3034 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
3037 if (vdevice->vtarget->type != TYPE_DISK || vdevice->vtarget->deleted ||
3038 !vdevice->configured_lun)
3041 /* Following parameters will not change
3044 iocmd.cmd = SYNCHRONIZE_CACHE;
3046 iocmd.physDiskNum = -1;
3048 iocmd.data_dma = -1;
3050 iocmd.rsvd = iocmd.rsvd2 = 0;
3051 iocmd.channel = vdevice->vtarget->channel;
3052 iocmd.id = vdevice->vtarget->id;
3053 iocmd.lun = vdevice->lun;
3055 mptscsih_do_cmd(hd, &iocmd);
3059 mptscsih_version_fw_show(struct device *dev, struct device_attribute *attr,
3062 struct Scsi_Host *host = class_to_shost(dev);
3063 MPT_SCSI_HOST *hd = shost_priv(host);
3064 MPT_ADAPTER *ioc = hd->ioc;
3066 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
3067 (ioc->facts.FWVersion.Word & 0xFF000000) >> 24,
3068 (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,
3069 (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
3070 ioc->facts.FWVersion.Word & 0x000000FF);
3072 static DEVICE_ATTR(version_fw, S_IRUGO, mptscsih_version_fw_show, NULL);
3075 mptscsih_version_bios_show(struct device *dev, struct device_attribute *attr,
3078 struct Scsi_Host *host = class_to_shost(dev);
3079 MPT_SCSI_HOST *hd = shost_priv(host);
3080 MPT_ADAPTER *ioc = hd->ioc;
3082 return snprintf(buf, PAGE_SIZE, "%02x.%02x.%02x.%02x\n",
3083 (ioc->biosVersion & 0xFF000000) >> 24,
3084 (ioc->biosVersion & 0x00FF0000) >> 16,
3085 (ioc->biosVersion & 0x0000FF00) >> 8,
3086 ioc->biosVersion & 0x000000FF);
3088 static DEVICE_ATTR(version_bios, S_IRUGO, mptscsih_version_bios_show, NULL);
3091 mptscsih_version_mpi_show(struct device *dev, struct device_attribute *attr,
3094 struct Scsi_Host *host = class_to_shost(dev);
3095 MPT_SCSI_HOST *hd = shost_priv(host);
3096 MPT_ADAPTER *ioc = hd->ioc;
3098 return snprintf(buf, PAGE_SIZE, "%03x\n", ioc->facts.MsgVersion);
3100 static DEVICE_ATTR(version_mpi, S_IRUGO, mptscsih_version_mpi_show, NULL);
3103 mptscsih_version_product_show(struct device *dev,
3104 struct device_attribute *attr,
3107 struct Scsi_Host *host = class_to_shost(dev);
3108 MPT_SCSI_HOST *hd = shost_priv(host);
3109 MPT_ADAPTER *ioc = hd->ioc;
3111 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->prod_name);
3113 static DEVICE_ATTR(version_product, S_IRUGO,
3114 mptscsih_version_product_show, NULL);
3117 mptscsih_version_nvdata_persistent_show(struct device *dev,
3118 struct device_attribute *attr,
3121 struct Scsi_Host *host = class_to_shost(dev);
3122 MPT_SCSI_HOST *hd = shost_priv(host);
3123 MPT_ADAPTER *ioc = hd->ioc;
3125 return snprintf(buf, PAGE_SIZE, "%02xh\n",
3126 ioc->nvdata_version_persistent);
3128 static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO,
3129 mptscsih_version_nvdata_persistent_show, NULL);
3132 mptscsih_version_nvdata_default_show(struct device *dev,
3133 struct device_attribute *attr, char *buf)
3135 struct Scsi_Host *host = class_to_shost(dev);
3136 MPT_SCSI_HOST *hd = shost_priv(host);
3137 MPT_ADAPTER *ioc = hd->ioc;
3139 return snprintf(buf, PAGE_SIZE, "%02xh\n",ioc->nvdata_version_default);
3141 static DEVICE_ATTR(version_nvdata_default, S_IRUGO,
3142 mptscsih_version_nvdata_default_show, NULL);
3145 mptscsih_board_name_show(struct device *dev, struct device_attribute *attr,
3148 struct Scsi_Host *host = class_to_shost(dev);
3149 MPT_SCSI_HOST *hd = shost_priv(host);
3150 MPT_ADAPTER *ioc = hd->ioc;
3152 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_name);
3154 static DEVICE_ATTR(board_name, S_IRUGO, mptscsih_board_name_show, NULL);
3157 mptscsih_board_assembly_show(struct device *dev,
3158 struct device_attribute *attr, char *buf)
3160 struct Scsi_Host *host = class_to_shost(dev);
3161 MPT_SCSI_HOST *hd = shost_priv(host);
3162 MPT_ADAPTER *ioc = hd->ioc;
3164 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_assembly);
3166 static DEVICE_ATTR(board_assembly, S_IRUGO,
3167 mptscsih_board_assembly_show, NULL);
3170 mptscsih_board_tracer_show(struct device *dev, struct device_attribute *attr,
3173 struct Scsi_Host *host = class_to_shost(dev);
3174 MPT_SCSI_HOST *hd = shost_priv(host);
3175 MPT_ADAPTER *ioc = hd->ioc;
3177 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_tracer);
3179 static DEVICE_ATTR(board_tracer, S_IRUGO,
3180 mptscsih_board_tracer_show, NULL);
3183 mptscsih_io_delay_show(struct device *dev, struct device_attribute *attr,
3186 struct Scsi_Host *host = class_to_shost(dev);
3187 MPT_SCSI_HOST *hd = shost_priv(host);
3188 MPT_ADAPTER *ioc = hd->ioc;
3190 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay);
3192 static DEVICE_ATTR(io_delay, S_IRUGO,
3193 mptscsih_io_delay_show, NULL);
3196 mptscsih_device_delay_show(struct device *dev, struct device_attribute *attr,
3199 struct Scsi_Host *host = class_to_shost(dev);
3200 MPT_SCSI_HOST *hd = shost_priv(host);
3201 MPT_ADAPTER *ioc = hd->ioc;
3203 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay);
3205 static DEVICE_ATTR(device_delay, S_IRUGO,
3206 mptscsih_device_delay_show, NULL);
3209 mptscsih_debug_level_show(struct device *dev, struct device_attribute *attr,
3212 struct Scsi_Host *host = class_to_shost(dev);
3213 MPT_SCSI_HOST *hd = shost_priv(host);
3214 MPT_ADAPTER *ioc = hd->ioc;
3216 return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->debug_level);
3219 mptscsih_debug_level_store(struct device *dev, struct device_attribute *attr,
3220 const char *buf, size_t count)
3222 struct Scsi_Host *host = class_to_shost(dev);
3223 MPT_SCSI_HOST *hd = shost_priv(host);
3224 MPT_ADAPTER *ioc = hd->ioc;
3227 if (sscanf(buf, "%x", &val) != 1)
3230 ioc->debug_level = val;
3231 printk(MYIOC_s_INFO_FMT "debug_level=%08xh\n",
3232 ioc->name, ioc->debug_level);
3235 static DEVICE_ATTR(debug_level, S_IRUGO | S_IWUSR,
3236 mptscsih_debug_level_show, mptscsih_debug_level_store);
3238 struct device_attribute *mptscsih_host_attrs[] = {
3239 &dev_attr_version_fw,
3240 &dev_attr_version_bios,
3241 &dev_attr_version_mpi,
3242 &dev_attr_version_product,
3243 &dev_attr_version_nvdata_persistent,
3244 &dev_attr_version_nvdata_default,
3245 &dev_attr_board_name,
3246 &dev_attr_board_assembly,
3247 &dev_attr_board_tracer,
3249 &dev_attr_device_delay,
3250 &dev_attr_debug_level,
3254 EXPORT_SYMBOL(mptscsih_host_attrs);
3256 EXPORT_SYMBOL(mptscsih_remove);
3257 EXPORT_SYMBOL(mptscsih_shutdown);
3259 EXPORT_SYMBOL(mptscsih_suspend);
3260 EXPORT_SYMBOL(mptscsih_resume);
3262 EXPORT_SYMBOL(mptscsih_show_info);
3263 EXPORT_SYMBOL(mptscsih_info);
3264 EXPORT_SYMBOL(mptscsih_qcmd);
3265 EXPORT_SYMBOL(mptscsih_slave_destroy);
3266 EXPORT_SYMBOL(mptscsih_slave_configure);
3267 EXPORT_SYMBOL(mptscsih_abort);
3268 EXPORT_SYMBOL(mptscsih_dev_reset);
3269 EXPORT_SYMBOL(mptscsih_bus_reset);
3270 EXPORT_SYMBOL(mptscsih_host_reset);
3271 EXPORT_SYMBOL(mptscsih_bios_param);
3272 EXPORT_SYMBOL(mptscsih_io_done);
3273 EXPORT_SYMBOL(mptscsih_taskmgmt_complete);
3274 EXPORT_SYMBOL(mptscsih_scandv_complete);
3275 EXPORT_SYMBOL(mptscsih_event_process);
3276 EXPORT_SYMBOL(mptscsih_ioc_reset);
3277 EXPORT_SYMBOL(mptscsih_change_queue_depth);
3279 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/