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