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