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