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(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                 dtmprintk((MYIOC_s_WARN_FMT "Post-Reset complete.\n", ioc->name));
2525
2526         }
2527
2528         return 1;               /* currently means nothing really */
2529 }
2530
2531 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2532 int
2533 mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
2534 {
2535         MPT_SCSI_HOST *hd;
2536         u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
2537
2538         devtverboseprintk((MYIOC_s_INFO_FMT "MPT event (=%02Xh) routed to SCSI host driver!\n",
2539                         ioc->name, event));
2540
2541         if (ioc->sh == NULL ||
2542                 ((hd = (MPT_SCSI_HOST *)ioc->sh->hostdata) == NULL))
2543                 return 1;
2544
2545         switch (event) {
2546         case MPI_EVENT_UNIT_ATTENTION:                  /* 03 */
2547                 /* FIXME! */
2548                 break;
2549         case MPI_EVENT_IOC_BUS_RESET:                   /* 04 */
2550         case MPI_EVENT_EXT_BUS_RESET:                   /* 05 */
2551                 if (hd && (ioc->bus_type == SPI) && (hd->soft_resets < -1))
2552                         hd->soft_resets++;
2553                 break;
2554         case MPI_EVENT_LOGOUT:                          /* 09 */
2555                 /* FIXME! */
2556                 break;
2557
2558         case MPI_EVENT_RESCAN:                          /* 06 */
2559                 break;
2560
2561                 /*
2562                  *  CHECKME! Don't think we need to do
2563                  *  anything for these, but...
2564                  */
2565         case MPI_EVENT_LINK_STATUS_CHANGE:              /* 07 */
2566         case MPI_EVENT_LOOP_STATE_CHANGE:               /* 08 */
2567                 /*
2568                  *  CHECKME!  Falling thru...
2569                  */
2570                 break;
2571
2572         case MPI_EVENT_INTEGRATED_RAID:                 /* 0B */
2573                 break;
2574
2575         case MPI_EVENT_NONE:                            /* 00 */
2576         case MPI_EVENT_LOG_DATA:                        /* 01 */
2577         case MPI_EVENT_STATE_CHANGE:                    /* 02 */
2578         case MPI_EVENT_EVENT_CHANGE:                    /* 0A */
2579         default:
2580                 dprintk((KERN_INFO "  Ignoring event (=%02Xh)\n", event));
2581                 break;
2582         }
2583
2584         return 1;               /* currently means nothing really */
2585 }
2586
2587 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2588 /*
2589  *      mptscsih_initTarget - Target, LUN alloc/free functionality.
2590  *      @hd: Pointer to MPT_SCSI_HOST structure
2591  *      @vtarget: per target private data
2592  *      @sdev: SCSI device
2593  *
2594  *      NOTE: It's only SAFE to call this routine if data points to
2595  *      sane & valid STANDARD INQUIRY data!
2596  *
2597  *      Allocate and initialize memory for this target.
2598  *      Save inquiry data.
2599  *
2600  */
2601 static void
2602 mptscsih_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
2603                     struct scsi_device *sdev)
2604 {
2605         dinitprintk((MYIOC_s_INFO_FMT "initTarget bus=%d id=%d lun=%d hd=%p\n",
2606                 hd->ioc->name, vtarget->bus_id, vtarget->target_id, lun, hd));
2607
2608         /* Is LUN supported? If so, upper 2 bits will be 0
2609         * in first byte of inquiry data.
2610         */
2611         if (sdev->inq_periph_qual != 0)
2612                 return;
2613
2614         if (vtarget == NULL)
2615                 return;
2616
2617         vtarget->type = sdev->type;
2618
2619         if (hd->ioc->bus_type != SPI)
2620                 return;
2621
2622         if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
2623                 /* Treat all Processors as SAF-TE if
2624                  * command line option is set */
2625                 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
2626                 mptscsih_writeIOCPage4(hd, vtarget->target_id, vtarget->bus_id);
2627         }else if ((sdev->type == TYPE_PROCESSOR) &&
2628                 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
2629                 if (sdev->inquiry_len > 49 ) {
2630                         if (sdev->inquiry[44] == 'S' &&
2631                             sdev->inquiry[45] == 'A' &&
2632                             sdev->inquiry[46] == 'F' &&
2633                             sdev->inquiry[47] == '-' &&
2634                             sdev->inquiry[48] == 'T' &&
2635                             sdev->inquiry[49] == 'E' ) {
2636                                 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
2637                                 mptscsih_writeIOCPage4(hd, vtarget->target_id, vtarget->bus_id);
2638                         }
2639                 }
2640         }
2641         mptscsih_setTargetNegoParms(hd, vtarget, sdev);
2642 }
2643
2644 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2645 /*
2646  *  Update the target negotiation parameters based on the
2647  *  the Inquiry data, adapter capabilities, and NVRAM settings.
2648  *
2649  */
2650 static void
2651 mptscsih_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
2652                             struct scsi_device *sdev)
2653 {
2654         SpiCfgData *pspi_data = &hd->ioc->spi_data;
2655         int  id = (int) target->target_id;
2656         int  nvram;
2657         u8 width = MPT_NARROW;
2658         u8 factor = MPT_ASYNC;
2659         u8 offset = 0;
2660         u8 nfactor;
2661         u8 noQas = 1;
2662
2663         target->negoFlags = pspi_data->noQas;
2664
2665         /* noQas == 0 => device supports QAS. */
2666
2667         if (sdev->scsi_level < SCSI_2) {
2668                 width = 0;
2669                 factor = MPT_ULTRA2;
2670                 offset = pspi_data->maxSyncOffset;
2671                 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
2672         } else {
2673                 if (scsi_device_wide(sdev)) {
2674                         width = 1;
2675                 }
2676
2677                 if (scsi_device_sync(sdev)) {
2678                         factor = pspi_data->minSyncFactor;
2679                         if (!scsi_device_dt(sdev))
2680                                         factor = MPT_ULTRA2;
2681                         else {
2682                                 if (!scsi_device_ius(sdev) &&
2683                                     !scsi_device_qas(sdev))
2684                                         factor = MPT_ULTRA160;
2685                                 else {
2686                                         factor = MPT_ULTRA320;
2687                                         if (scsi_device_qas(sdev)) {
2688                                                 ddvtprintk((KERN_INFO "Enabling QAS due to byte56=%02x on id=%d!\n", byte56, id));
2689                                                 noQas = 0;
2690                                         }
2691                                         if (sdev->type == TYPE_TAPE &&
2692                                             scsi_device_ius(sdev))
2693                                                 target->negoFlags |= MPT_TAPE_NEGO_IDP;
2694                                 }
2695                         }
2696                         offset = pspi_data->maxSyncOffset;
2697
2698                         /* If RAID, never disable QAS
2699                          * else if non RAID, do not disable
2700                          *   QAS if bit 1 is set
2701                          * bit 1 QAS support, non-raid only
2702                          * bit 0 IU support
2703                          */
2704                         if (target->raidVolume == 1) {
2705                                 noQas = 0;
2706                         }
2707                 } else {
2708                         factor = MPT_ASYNC;
2709                         offset = 0;
2710                 }
2711         }
2712
2713         if (!sdev->tagged_supported) {
2714                 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
2715         }
2716
2717         /* Update tflags based on NVRAM settings. (SCSI only)
2718          */
2719         if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
2720                 nvram = pspi_data->nvram[id];
2721                 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
2722
2723                 if (width)
2724                         width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
2725
2726                 if (offset > 0) {
2727                         /* Ensure factor is set to the
2728                          * maximum of: adapter, nvram, inquiry
2729                          */
2730                         if (nfactor) {
2731                                 if (nfactor < pspi_data->minSyncFactor )
2732                                         nfactor = pspi_data->minSyncFactor;
2733
2734                                 factor = max(factor, nfactor);
2735                                 if (factor == MPT_ASYNC)
2736                                         offset = 0;
2737                         } else {
2738                                 offset = 0;
2739                                 factor = MPT_ASYNC;
2740                 }
2741                 } else {
2742                         factor = MPT_ASYNC;
2743                 }
2744         }
2745
2746         /* Make sure data is consistent
2747          */
2748         if ((!width) && (factor < MPT_ULTRA2)) {
2749                 factor = MPT_ULTRA2;
2750         }
2751
2752         /* Save the data to the target structure.
2753          */
2754         target->minSyncFactor = factor;
2755         target->maxOffset = offset;
2756         target->maxWidth = width;
2757
2758         target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
2759
2760         /* Disable unused features.
2761          */
2762         if (!width)
2763                 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
2764
2765         if (!offset)
2766                 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
2767
2768         if ( factor > MPT_ULTRA320 )
2769                 noQas = 0;
2770
2771         if (noQas && (pspi_data->noQas == 0)) {
2772                 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
2773                 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
2774
2775                 /* Disable QAS in a mixed configuration case
2776                  */
2777
2778                 ddvtprintk((KERN_INFO "Disabling QAS due to noQas=%02x on id=%d!\n", noQas, id));
2779         }
2780 }
2781
2782 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2783
2784 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2785 /*
2786  *  SCSI Config Page functionality ...
2787  */
2788
2789 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2790 /*      mptscsih_writeIOCPage4  - write IOC Page 4
2791  *      @hd: Pointer to a SCSI Host Structure
2792  *      @target_id: write IOC Page4 for this ID & Bus
2793  *
2794  *      Return: -EAGAIN if unable to obtain a Message Frame
2795  *              or 0 if success.
2796  *
2797  *      Remark: We do not wait for a return, write pages sequentially.
2798  */
2799 static int
2800 mptscsih_writeIOCPage4(MPT_SCSI_HOST *hd, int target_id, int bus)
2801 {
2802         MPT_ADAPTER             *ioc = hd->ioc;
2803         Config_t                *pReq;
2804         IOCPage4_t              *IOCPage4Ptr;
2805         MPT_FRAME_HDR           *mf;
2806         dma_addr_t               dataDma;
2807         u16                      req_idx;
2808         u32                      frameOffset;
2809         u32                      flagsLength;
2810         int                      ii;
2811
2812         /* Get a MF for this command.
2813          */
2814         if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
2815                 dfailprintk((MYIOC_s_WARN_FMT "writeIOCPage4 : no msg frames!\n",
2816                                         ioc->name));
2817                 return -EAGAIN;
2818         }
2819
2820         /* Set the request and the data pointers.
2821          * Place data at end of MF.
2822          */
2823         pReq = (Config_t *)mf;
2824
2825         req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2826         frameOffset = ioc->req_sz - sizeof(IOCPage4_t);
2827
2828         /* Complete the request frame (same for all requests).
2829          */
2830         pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
2831         pReq->Reserved = 0;
2832         pReq->ChainOffset = 0;
2833         pReq->Function = MPI_FUNCTION_CONFIG;
2834         pReq->ExtPageLength = 0;
2835         pReq->ExtPageType = 0;
2836         pReq->MsgFlags = 0;
2837         for (ii=0; ii < 8; ii++) {
2838                 pReq->Reserved2[ii] = 0;
2839         }
2840
2841         IOCPage4Ptr = ioc->spi_data.pIocPg4;
2842         dataDma = ioc->spi_data.IocPg4_dma;
2843         ii = IOCPage4Ptr->ActiveSEP++;
2844         IOCPage4Ptr->SEP[ii].SEPTargetID = target_id;
2845         IOCPage4Ptr->SEP[ii].SEPBus = bus;
2846         pReq->Header = IOCPage4Ptr->Header;
2847         pReq->PageAddress = cpu_to_le32(target_id | (bus << 8 ));
2848
2849         /* Add a SGE to the config request.
2850          */
2851         flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
2852                 (IOCPage4Ptr->Header.PageLength + ii) * 4;
2853
2854         mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
2855
2856         dinitprintk((MYIOC_s_INFO_FMT
2857                 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
2858                         ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, target_id, bus));
2859
2860         mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
2861
2862         return 0;
2863 }
2864
2865 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2866 /*
2867  *  Bus Scan and Domain Validation functionality ...
2868  */
2869
2870 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2871 /*
2872  *      mptscsih_scandv_complete - Scan and DV callback routine registered
2873  *      to Fustion MPT (base) driver.
2874  *
2875  *      @ioc: Pointer to MPT_ADAPTER structure
2876  *      @mf: Pointer to original MPT request frame
2877  *      @mr: Pointer to MPT reply frame (NULL if TurboReply)
2878  *
2879  *      This routine is called from mpt.c::mpt_interrupt() at the completion
2880  *      of any SCSI IO request.
2881  *      This routine is registered with the Fusion MPT (base) driver at driver
2882  *      load/init time via the mpt_register() API call.
2883  *
2884  *      Returns 1 indicating alloc'd request frame ptr should be freed.
2885  *
2886  *      Remark: Sets a completion code and (possibly) saves sense data
2887  *      in the IOC member localReply structure.
2888  *      Used ONLY for DV and other internal commands.
2889  */
2890 int
2891 mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
2892 {
2893         MPT_SCSI_HOST   *hd;
2894         SCSIIORequest_t *pReq;
2895         int              completionCode;
2896         u16              req_idx;
2897
2898         hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
2899
2900         if ((mf == NULL) ||
2901             (mf >= MPT_INDEX_2_MFPTR(ioc, ioc->req_depth))) {
2902                 printk(MYIOC_s_ERR_FMT
2903                         "ScanDvComplete, %s req frame ptr! (=%p)\n",
2904                                 ioc->name, mf?"BAD":"NULL", (void *) mf);
2905                 goto wakeup;
2906         }
2907
2908         del_timer(&hd->timer);
2909         req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2910         hd->ScsiLookup[req_idx] = NULL;
2911         pReq = (SCSIIORequest_t *) mf;
2912
2913         if (mf != hd->cmdPtr) {
2914                 printk(MYIOC_s_WARN_FMT "ScanDvComplete (mf=%p, cmdPtr=%p, idx=%d)\n",
2915                                 hd->ioc->name, (void *)mf, (void *) hd->cmdPtr, req_idx);
2916         }
2917         hd->cmdPtr = NULL;
2918
2919         ddvprintk((MYIOC_s_INFO_FMT "ScanDvComplete (mf=%p,mr=%p,idx=%d)\n",
2920                         hd->ioc->name, mf, mr, req_idx));
2921
2922         hd->pLocal = &hd->localReply;
2923         hd->pLocal->scsiStatus = 0;
2924
2925         /* If target struct exists, clear sense valid flag.
2926          */
2927         if (mr == NULL) {
2928                 completionCode = MPT_SCANDV_GOOD;
2929         } else {
2930                 SCSIIOReply_t   *pReply;
2931                 u16              status;
2932                 u8               scsi_status;
2933
2934                 pReply = (SCSIIOReply_t *) mr;
2935
2936                 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
2937                 scsi_status = pReply->SCSIStatus;
2938
2939                 ddvtprintk((KERN_NOTICE "  IOCStatus=%04xh, SCSIState=%02xh, SCSIStatus=%02xh, IOCLogInfo=%08xh\n",
2940                              status, pReply->SCSIState, scsi_status,
2941                              le32_to_cpu(pReply->IOCLogInfo)));
2942
2943                 switch(status) {
2944
2945                 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE:       /* 0x0043 */
2946                         completionCode = MPT_SCANDV_SELECTION_TIMEOUT;
2947                         break;
2948
2949                 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR:          /* 0x0046 */
2950                 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED:        /* 0x0048 */
2951                 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED:         /* 0x004B */
2952                 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED:         /* 0x004C */
2953                         completionCode = MPT_SCANDV_DID_RESET;
2954                         break;
2955
2956                 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN:          /* 0x0045 */
2957                 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR:        /* 0x0040 */
2958                 case MPI_IOCSTATUS_SUCCESS:                     /* 0x0000 */
2959                         if (pReply->Function == MPI_FUNCTION_CONFIG) {
2960                                 ConfigReply_t *pr = (ConfigReply_t *)mr;
2961                                 completionCode = MPT_SCANDV_GOOD;
2962                                 hd->pLocal->header.PageVersion = pr->Header.PageVersion;
2963                                 hd->pLocal->header.PageLength = pr->Header.PageLength;
2964                                 hd->pLocal->header.PageNumber = pr->Header.PageNumber;
2965                                 hd->pLocal->header.PageType = pr->Header.PageType;
2966
2967                         } else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) {
2968                                 /* If the RAID Volume request is successful,
2969                                  * return GOOD, else indicate that
2970                                  * some type of error occurred.
2971                                  */
2972                                 MpiRaidActionReply_t    *pr = (MpiRaidActionReply_t *)mr;
2973                                 if (le16_to_cpu(pr->ActionStatus) == MPI_RAID_ACTION_ASTATUS_SUCCESS)
2974                                         completionCode = MPT_SCANDV_GOOD;
2975                                 else
2976                                         completionCode = MPT_SCANDV_SOME_ERROR;
2977                                 memcpy(hd->pLocal->sense, pr, sizeof(hd->pLocal->sense));
2978
2979                         } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID) {
2980                                 u8              *sense_data;
2981                                 int              sz;
2982
2983                                 /* save sense data in global structure
2984                                  */
2985                                 completionCode = MPT_SCANDV_SENSE;
2986                                 hd->pLocal->scsiStatus = scsi_status;
2987                                 sense_data = ((u8 *)hd->ioc->sense_buf_pool +
2988                                         (req_idx * MPT_SENSE_BUFFER_ALLOC));
2989
2990                                 sz = min_t(int, pReq->SenseBufferLength,
2991                                                         SCSI_STD_SENSE_BYTES);
2992                                 memcpy(hd->pLocal->sense, sense_data, sz);
2993
2994                                 ddvprintk((KERN_NOTICE "  Check Condition, sense ptr %p\n",
2995                                                 sense_data));
2996                         } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) {
2997                                 if (pReq->CDB[0] == INQUIRY)
2998                                         completionCode = MPT_SCANDV_ISSUE_SENSE;
2999                                 else
3000                                         completionCode = MPT_SCANDV_DID_RESET;
3001                         }
3002                         else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS)
3003                                 completionCode = MPT_SCANDV_DID_RESET;
3004                         else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
3005                                 completionCode = MPT_SCANDV_DID_RESET;
3006                         else {
3007                                 completionCode = MPT_SCANDV_GOOD;
3008                                 hd->pLocal->scsiStatus = scsi_status;
3009                         }
3010                         break;
3011
3012                 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR:         /* 0x0047 */
3013                         if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
3014                                 completionCode = MPT_SCANDV_DID_RESET;
3015                         else
3016                                 completionCode = MPT_SCANDV_SOME_ERROR;
3017                         break;
3018
3019                 default:
3020                         completionCode = MPT_SCANDV_SOME_ERROR;
3021                         break;
3022
3023                 }       /* switch(status) */
3024
3025                 ddvtprintk((KERN_NOTICE "  completionCode set to %08xh\n",
3026                                 completionCode));
3027         } /* end of address reply case */
3028
3029         hd->pLocal->completion = completionCode;
3030
3031         /* MF and RF are freed in mpt_interrupt
3032          */
3033 wakeup:
3034         /* Free Chain buffers (will never chain) in scan or dv */
3035         //mptscsih_freeChainBuffers(ioc, req_idx);
3036
3037         /*
3038          * Wake up the original calling thread
3039          */
3040         hd->scandv_wait_done = 1;
3041         wake_up(&hd->scandv_waitq);
3042
3043         return 1;
3044 }
3045
3046 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3047 /*      mptscsih_timer_expired - Call back for timer process.
3048  *      Used only for dv functionality.
3049  *      @data: Pointer to MPT_SCSI_HOST recast as an unsigned long
3050  *
3051  */
3052 void
3053 mptscsih_timer_expired(unsigned long data)
3054 {
3055         MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) data;
3056
3057         ddvprintk((MYIOC_s_WARN_FMT "Timer Expired! Cmd %p\n", hd->ioc->name, hd->cmdPtr));
3058
3059         if (hd->cmdPtr) {
3060                 MPIHeader_t *cmd = (MPIHeader_t *)hd->cmdPtr;
3061
3062                 if (cmd->Function == MPI_FUNCTION_SCSI_IO_REQUEST) {
3063                         /* Desire to issue a task management request here.
3064                          * TM requests MUST be single threaded.
3065                          * If old eh code and no TM current, issue request.
3066                          * If new eh code, do nothing. Wait for OS cmd timeout
3067                          *      for bus reset.
3068                          */
3069                         ddvtprintk((MYIOC_s_NOTE_FMT "DV Cmd Timeout: NoOp\n", hd->ioc->name));
3070                 } else {
3071                         /* Perform a FW reload */
3072                         if (mpt_HardResetHandler(hd->ioc, NO_SLEEP) < 0) {
3073                                 printk(MYIOC_s_WARN_FMT "Firmware Reload FAILED!\n", hd->ioc->name);
3074                         }
3075                 }
3076         } else {
3077                 /* This should NEVER happen */
3078                 printk(MYIOC_s_WARN_FMT "Null cmdPtr!!!!\n", hd->ioc->name);
3079         }
3080
3081         /* No more processing.
3082          * TM call will generate an interrupt for SCSI TM Management.
3083          * The FW will reply to all outstanding commands, callback will finish cleanup.
3084          * Hard reset clean-up will free all resources.
3085          */
3086         ddvprintk((MYIOC_s_WARN_FMT "Timer Expired Complete!\n", hd->ioc->name));
3087
3088         return;
3089 }
3090
3091
3092 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3093 /**
3094  *      mptscsih_do_cmd - Do internal command.
3095  *      @hd: MPT_SCSI_HOST pointer
3096  *      @io: INTERNAL_CMD pointer.
3097  *
3098  *      Issue the specified internally generated command and do command
3099  *      specific cleanup. For bus scan / DV only.
3100  *      NOTES: If command is Inquiry and status is good,
3101  *      initialize a target structure, save the data
3102  *
3103  *      Remark: Single threaded access only.
3104  *
3105  *      Return:
3106  *              < 0 if an illegal command or no resources
3107  *
3108  *                 0 if good
3109  *
3110  *               > 0 if command complete but some type of completion error.
3111  */
3112 static int
3113 mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io)
3114 {
3115         MPT_FRAME_HDR   *mf;
3116         SCSIIORequest_t *pScsiReq;
3117         SCSIIORequest_t  ReqCopy;
3118         int              my_idx, ii, dir;
3119         int              rc, cmdTimeout;
3120         int             in_isr;
3121         char             cmdLen;
3122         char             CDB[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
3123         char             cmd = io->cmd;
3124
3125         in_isr = in_interrupt();
3126         if (in_isr) {
3127                 dprintk((MYIOC_s_WARN_FMT "Internal SCSI IO request not allowed in ISR context!\n",
3128                                 hd->ioc->name));
3129                 return -EPERM;
3130         }
3131
3132
3133         /* Set command specific information
3134          */
3135         switch (cmd) {
3136         case INQUIRY:
3137                 cmdLen = 6;
3138                 dir = MPI_SCSIIO_CONTROL_READ;
3139                 CDB[0] = cmd;
3140                 CDB[4] = io->size;
3141                 cmdTimeout = 10;
3142                 break;
3143
3144         case TEST_UNIT_READY:
3145                 cmdLen = 6;
3146                 dir = MPI_SCSIIO_CONTROL_READ;
3147                 cmdTimeout = 10;
3148                 break;
3149
3150         case START_STOP:
3151                 cmdLen = 6;
3152                 dir = MPI_SCSIIO_CONTROL_READ;
3153                 CDB[0] = cmd;
3154                 CDB[4] = 1;     /*Spin up the disk */
3155                 cmdTimeout = 15;
3156                 break;
3157
3158         case REQUEST_SENSE:
3159                 cmdLen = 6;
3160                 CDB[0] = cmd;
3161                 CDB[4] = io->size;
3162                 dir = MPI_SCSIIO_CONTROL_READ;
3163                 cmdTimeout = 10;
3164                 break;
3165
3166         case READ_BUFFER:
3167                 cmdLen = 10;
3168                 dir = MPI_SCSIIO_CONTROL_READ;
3169                 CDB[0] = cmd;
3170                 if (io->flags & MPT_ICFLAG_ECHO) {
3171                         CDB[1] = 0x0A;
3172                 } else {
3173                         CDB[1] = 0x02;
3174                 }
3175
3176                 if (io->flags & MPT_ICFLAG_BUF_CAP) {
3177                         CDB[1] |= 0x01;
3178                 }
3179                 CDB[6] = (io->size >> 16) & 0xFF;
3180                 CDB[7] = (io->size >>  8) & 0xFF;
3181                 CDB[8] = io->size & 0xFF;
3182                 cmdTimeout = 10;
3183                 break;
3184
3185         case WRITE_BUFFER:
3186                 cmdLen = 10;
3187                 dir = MPI_SCSIIO_CONTROL_WRITE;
3188                 CDB[0] = cmd;
3189                 if (io->flags & MPT_ICFLAG_ECHO) {
3190                         CDB[1] = 0x0A;
3191                 } else {
3192                         CDB[1] = 0x02;
3193                 }
3194                 CDB[6] = (io->size >> 16) & 0xFF;
3195                 CDB[7] = (io->size >>  8) & 0xFF;
3196                 CDB[8] = io->size & 0xFF;
3197                 cmdTimeout = 10;
3198                 break;
3199
3200         case RESERVE:
3201                 cmdLen = 6;
3202                 dir = MPI_SCSIIO_CONTROL_READ;
3203                 CDB[0] = cmd;
3204                 cmdTimeout = 10;
3205                 break;
3206
3207         case RELEASE:
3208                 cmdLen = 6;
3209                 dir = MPI_SCSIIO_CONTROL_READ;
3210                 CDB[0] = cmd;
3211                 cmdTimeout = 10;
3212                 break;
3213
3214         case SYNCHRONIZE_CACHE:
3215                 cmdLen = 10;
3216                 dir = MPI_SCSIIO_CONTROL_READ;
3217                 CDB[0] = cmd;
3218 //              CDB[1] = 0x02;  /* set immediate bit */
3219                 cmdTimeout = 10;
3220                 break;
3221
3222         default:
3223                 /* Error Case */
3224                 return -EFAULT;
3225         }
3226
3227         /* Get and Populate a free Frame
3228          */
3229         if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
3230                 ddvprintk((MYIOC_s_WARN_FMT "No msg frames!\n",
3231                                         hd->ioc->name));
3232                 return -EBUSY;
3233         }
3234
3235         pScsiReq = (SCSIIORequest_t *) mf;
3236
3237         /* Get the request index */
3238         my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
3239         ADD_INDEX_LOG(my_idx); /* for debug */
3240
3241         if (io->flags & MPT_ICFLAG_PHYS_DISK) {
3242                 pScsiReq->TargetID = io->physDiskNum;
3243                 pScsiReq->Bus = 0;
3244                 pScsiReq->ChainOffset = 0;
3245                 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
3246         } else {
3247                 pScsiReq->TargetID = io->id;
3248                 pScsiReq->Bus = io->bus;
3249                 pScsiReq->ChainOffset = 0;
3250                 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
3251         }
3252
3253         pScsiReq->CDBLength = cmdLen;
3254         pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
3255
3256         pScsiReq->Reserved = 0;
3257
3258         pScsiReq->MsgFlags = mpt_msg_flags();
3259         /* MsgContext set in mpt_get_msg_fram call  */
3260
3261         for (ii=0; ii < 8; ii++)
3262                 pScsiReq->LUN[ii] = 0;
3263         pScsiReq->LUN[1] = io->lun;
3264
3265         if (io->flags & MPT_ICFLAG_TAGGED_CMD)
3266                 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_SIMPLEQ);
3267         else
3268                 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
3269
3270         if (cmd == REQUEST_SENSE) {
3271                 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
3272                 ddvprintk((MYIOC_s_INFO_FMT "Untagged! 0x%2x\n",
3273                         hd->ioc->name, cmd));
3274         }
3275
3276         for (ii=0; ii < 16; ii++)
3277                 pScsiReq->CDB[ii] = CDB[ii];
3278
3279         pScsiReq->DataLength = cpu_to_le32(io->size);
3280         pScsiReq->SenseBufferLowAddr = cpu_to_le32(hd->ioc->sense_buf_low_dma
3281                                            + (my_idx * MPT_SENSE_BUFFER_ALLOC));
3282
3283         ddvprintk((MYIOC_s_INFO_FMT "Sending Command 0x%x for (%d:%d:%d)\n",
3284                         hd->ioc->name, cmd, io->bus, io->id, io->lun));
3285
3286         if (dir == MPI_SCSIIO_CONTROL_READ) {
3287                 mpt_add_sge((char *) &pScsiReq->SGL,
3288                         MPT_SGE_FLAGS_SSIMPLE_READ | io->size,
3289                         io->data_dma);
3290         } else {
3291                 mpt_add_sge((char *) &pScsiReq->SGL,
3292                         MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size,
3293                         io->data_dma);
3294         }
3295
3296         /* The ISR will free the request frame, but we need
3297          * the information to initialize the target. Duplicate.
3298          */
3299         memcpy(&ReqCopy, pScsiReq, sizeof(SCSIIORequest_t));
3300
3301         /* Issue this command after:
3302          *      finish init
3303          *      add timer
3304          * Wait until the reply has been received
3305          *  ScsiScanDvCtx callback function will
3306          *      set hd->pLocal;
3307          *      set scandv_wait_done and call wake_up
3308          */
3309         hd->pLocal = NULL;
3310         hd->timer.expires = jiffies + HZ*cmdTimeout;
3311         hd->scandv_wait_done = 0;
3312
3313         /* Save cmd pointer, for resource free if timeout or
3314          * FW reload occurs
3315          */
3316         hd->cmdPtr = mf;
3317
3318         add_timer(&hd->timer);
3319         mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
3320         wait_event(hd->scandv_waitq, hd->scandv_wait_done);
3321
3322         if (hd->pLocal) {
3323                 rc = hd->pLocal->completion;
3324                 hd->pLocal->skip = 0;
3325
3326                 /* Always set fatal error codes in some cases.
3327                  */
3328                 if (rc == MPT_SCANDV_SELECTION_TIMEOUT)
3329                         rc = -ENXIO;
3330                 else if (rc == MPT_SCANDV_SOME_ERROR)
3331                         rc =  -rc;
3332         } else {
3333                 rc = -EFAULT;
3334                 /* This should never happen. */
3335                 ddvprintk((MYIOC_s_INFO_FMT "_do_cmd: Null pLocal!!!\n",
3336                                 hd->ioc->name));
3337         }
3338
3339         return rc;
3340 }
3341
3342 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3343 /**
3344  *      mptscsih_synchronize_cache - Send SYNCHRONIZE_CACHE to all disks.
3345  *      @hd: Pointer to a SCSI HOST structure
3346  *      @vtarget: per device private data
3347  *      @lun: lun
3348  *
3349  *      Uses the ISR, but with special processing.
3350  *      MUST be single-threaded.
3351  *
3352  */
3353 static void
3354 mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
3355 {
3356         INTERNAL_CMD             iocmd;
3357
3358         /* Following parameters will not change
3359          * in this routine.
3360          */
3361         iocmd.cmd = SYNCHRONIZE_CACHE;
3362         iocmd.flags = 0;
3363         iocmd.physDiskNum = -1;
3364         iocmd.data = NULL;
3365         iocmd.data_dma = -1;
3366         iocmd.size = 0;
3367         iocmd.rsvd = iocmd.rsvd2 = 0;
3368         iocmd.bus = vdevice->vtarget->bus_id;
3369         iocmd.id = vdevice->vtarget->target_id;
3370         iocmd.lun = (u8)vdevice->lun;
3371
3372         if ((vdevice->vtarget->type == TYPE_DISK) &&
3373             (vdevice->configured_lun))
3374                 mptscsih_do_cmd(hd, &iocmd);
3375 }
3376
3377 EXPORT_SYMBOL(mptscsih_remove);
3378 EXPORT_SYMBOL(mptscsih_shutdown);
3379 #ifdef CONFIG_PM
3380 EXPORT_SYMBOL(mptscsih_suspend);
3381 EXPORT_SYMBOL(mptscsih_resume);
3382 #endif
3383 EXPORT_SYMBOL(mptscsih_proc_info);
3384 EXPORT_SYMBOL(mptscsih_info);
3385 EXPORT_SYMBOL(mptscsih_qcmd);
3386 EXPORT_SYMBOL(mptscsih_target_alloc);
3387 EXPORT_SYMBOL(mptscsih_slave_alloc);
3388 EXPORT_SYMBOL(mptscsih_target_destroy);
3389 EXPORT_SYMBOL(mptscsih_slave_destroy);
3390 EXPORT_SYMBOL(mptscsih_slave_configure);
3391 EXPORT_SYMBOL(mptscsih_abort);
3392 EXPORT_SYMBOL(mptscsih_dev_reset);
3393 EXPORT_SYMBOL(mptscsih_bus_reset);
3394 EXPORT_SYMBOL(mptscsih_host_reset);
3395 EXPORT_SYMBOL(mptscsih_bios_param);
3396 EXPORT_SYMBOL(mptscsih_io_done);
3397 EXPORT_SYMBOL(mptscsih_taskmgmt_complete);
3398 EXPORT_SYMBOL(mptscsih_scandv_complete);
3399 EXPORT_SYMBOL(mptscsih_event_process);
3400 EXPORT_SYMBOL(mptscsih_ioc_reset);
3401 EXPORT_SYMBOL(mptscsih_change_queue_depth);
3402 EXPORT_SYMBOL(mptscsih_timer_expired);
3403 EXPORT_SYMBOL(mptscsih_TMHandler);
3404
3405 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/