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