git.oblomov.eu Git - linux-2.6/blob - drivers/message/fusion/mptscsih.c

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