drivers/message/fusion/mptscsih.c

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