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