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 typedef struct _negoparms {
 118         u8 width;
 119         u8 offset;
 120         u8 factor;
 121         u8 flags;
 122 } NEGOPARMS;
 123
 124 typedef struct _dv_parameters {
 125         NEGOPARMS        max;
 126         NEGOPARMS        now;
 127         u8               cmd;
 128         u8               id;
 129         u16              pad1;
 130 } DVPARAMETERS;
 131
 132 /*
 133  *  Other private/forward protos...
 134  */
 135 int             mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
 136 static void     mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq);
 137 int             mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
 138
 139 static int      mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt,
 140                                  SCSIIORequest_t *pReq, int req_idx);
 141 static void     mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx);
 142 static void     mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply);
 143 static int      mptscsih_tm_pending_wait(MPT_SCSI_HOST * hd);
 144 static int      mptscsih_tm_wait_for_completion(MPT_SCSI_HOST * hd, ulong timeout );
 145 static u32      SCPNT_TO_LOOKUP_IDX(struct scsi_cmnd *sc);
 146
 147 static int      mptscsih_TMHandler(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 target, u8 lun, int ctx2abort, ulong timeout);
 148 static int      mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 target, u8 lun, int ctx2abort, ulong timeout);
 149
 150 int             mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset);
 151 int             mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
 152
 153 static void     mptscsih_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget, u8 lun, char *data, int dlen);
 154 static void     mptscsih_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *vtarget, char byte56);
 155 static void     mptscsih_setDevicePage1Flags (u8 width, u8 factor, u8 offset, int *requestedPtr, int *configurationPtr, u8 flags);
 156 static void     mptscsih_no_negotiate(MPT_SCSI_HOST *hd, struct scsi_cmnd *sc);
 157 static int      mptscsih_writeSDP1(MPT_SCSI_HOST *hd, int portnum, int target, int flags);
 158 static int      mptscsih_writeIOCPage4(MPT_SCSI_HOST *hd, int target_id, int bus);
 159 int             mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
 160 static int      mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *iocmd);
 161 static void     mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice);
 162 static void     mptscsih_negotiate_to_asyn_narrow(MPT_SCSI_HOST *hd, VirtTarget *vtarget);
 163 static int      mptscsih_is_phys_disk(MPT_ADAPTER *ioc, int id);
 164
 165 static struct work_struct   mptscsih_persistTask;
 166
 167 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION
 168 static int      mptscsih_do_raid(MPT_SCSI_HOST *hd, u8 action, INTERNAL_CMD *io);
 169 static void     mptscsih_domainValidation(void *hd);
 170 static void     mptscsih_qas_check(MPT_SCSI_HOST *hd, int id);
 171 static int      mptscsih_doDv(MPT_SCSI_HOST *hd, int channel, int target);
 172 static void     mptscsih_dv_parms(MPT_SCSI_HOST *hd, DVPARAMETERS *dv,void *pPage);
 173 static void     mptscsih_fillbuf(char *buffer, int size, int index, int width);
 174 static void     mptscsih_set_dvflags_raid(MPT_SCSI_HOST *hd, int id);
 175 static void     mptscsih_set_dvflags(MPT_SCSI_HOST *hd, struct scsi_cmnd *sc);
 176 #endif
 177
 178 void            mptscsih_remove(struct pci_dev *);
 179 void            mptscsih_shutdown(struct pci_dev *);
 180 #ifdef CONFIG_PM
 181 int             mptscsih_suspend(struct pci_dev *pdev, pm_message_t state);
 182 int             mptscsih_resume(struct pci_dev *pdev);
 183 #endif
 184
 185 #define SNS_LEN(scp)    sizeof((scp)->sense_buffer)
 186
 187 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION
 188 /*
 189  * Domain Validation task structure
 190  */
 191 static DEFINE_SPINLOCK(dvtaskQ_lock);
 192 static int dvtaskQ_active = 0;
 193 static int dvtaskQ_release = 0;
 194 static struct work_struct       dvTaskQ_task;
 195 #endif
 196
 197 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 198 /**
 199  *      mptscsih_add_sge - Place a simple SGE at address pAddr.
 200  *      @pAddr: virtual address for SGE
 201  *      @flagslength: SGE flags and data transfer length
 202  *      @dma_addr: Physical address
 203  *
 204  *      This routine places a MPT request frame back on the MPT adapter's
 205  *      FreeQ.
 206  */
 207 static inline void
 208 mptscsih_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
 209 {
 210         if (sizeof(dma_addr_t) == sizeof(u64)) {
 211                 SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
 212                 u32 tmp = dma_addr & 0xFFFFFFFF;
 213
 214                 pSge->FlagsLength = cpu_to_le32(flagslength);
 215                 pSge->Address.Low = cpu_to_le32(tmp);
 216                 tmp = (u32) ((u64)dma_addr >> 32);
 217                 pSge->Address.High = cpu_to_le32(tmp);
 218
 219         } else {
 220                 SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
 221                 pSge->FlagsLength = cpu_to_le32(flagslength);
 222                 pSge->Address = cpu_to_le32(dma_addr);
 223         }
 224 } /* mptscsih_add_sge() */
 225
 226 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 227 /**
 228  *      mptscsih_add_chain - Place a chain SGE at address pAddr.
 229  *      @pAddr: virtual address for SGE
 230  *      @next: nextChainOffset value (u32's)
 231  *      @length: length of next SGL segment
 232  *      @dma_addr: Physical address
 233  *
 234  *      This routine places a MPT request frame back on the MPT adapter's
 235  *      FreeQ.
 236  */
 237 static inline void
 238 mptscsih_add_chain(char *pAddr, u8 next, u16 length, dma_addr_t dma_addr)
 239 {
 240         if (sizeof(dma_addr_t) == sizeof(u64)) {
 241                 SGEChain64_t *pChain = (SGEChain64_t *) pAddr;
 242                 u32 tmp = dma_addr & 0xFFFFFFFF;
 243
 244                 pChain->Length = cpu_to_le16(length);
 245                 pChain->Flags = MPI_SGE_FLAGS_CHAIN_ELEMENT | mpt_addr_size();
 246
 247                 pChain->NextChainOffset = next;
 248
 249                 pChain->Address.Low = cpu_to_le32(tmp);
 250                 tmp = (u32) ((u64)dma_addr >> 32);
 251                 pChain->Address.High = cpu_to_le32(tmp);
 252         } else {
 253                 SGEChain32_t *pChain = (SGEChain32_t *) pAddr;
 254                 pChain->Length = cpu_to_le16(length);
 255                 pChain->Flags = MPI_SGE_FLAGS_CHAIN_ELEMENT | mpt_addr_size();
 256                 pChain->NextChainOffset = next;
 257                 pChain->Address = cpu_to_le32(dma_addr);
 258         }
 259 } /* mptscsih_add_chain() */
 260
 261 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 262 /*
 263  *      mptscsih_getFreeChainBuffer - Function to get a free chain
 264  *      from the MPT_SCSI_HOST FreeChainQ.
 265  *      @ioc: Pointer to MPT_ADAPTER structure
 266  *      @req_idx: Index of the SCSI IO request frame. (output)
 267  *
 268  *      return SUCCESS or FAILED
 269  */
 270 static inline int
 271 mptscsih_getFreeChainBuffer(MPT_ADAPTER *ioc, int *retIndex)
 272 {
 273         MPT_FRAME_HDR *chainBuf;
 274         unsigned long flags;
 275         int rc;
 276         int chain_idx;
 277
 278         dsgprintk((MYIOC_s_INFO_FMT "getFreeChainBuffer called\n",
 279                         ioc->name));
 280         spin_lock_irqsave(&ioc->FreeQlock, flags);
 281         if (!list_empty(&ioc->FreeChainQ)) {
 282                 int offset;
 283
 284                 chainBuf = list_entry(ioc->FreeChainQ.next, MPT_FRAME_HDR,
 285                                 u.frame.linkage.list);
 286                 list_del(&chainBuf->u.frame.linkage.list);
 287                 offset = (u8 *)chainBuf - (u8 *)ioc->ChainBuffer;
 288                 chain_idx = offset / ioc->req_sz;
 289                 rc = SUCCESS;
 290                 dsgprintk((MYIOC_s_ERR_FMT "getFreeChainBuffer chainBuf=%p ChainBuffer=%p offset=%d chain_idx=%d\n",
 291                         ioc->name, chainBuf, ioc->ChainBuffer, offset, chain_idx));
 292         } else {
 293                 rc = FAILED;
 294                 chain_idx = MPT_HOST_NO_CHAIN;
 295                 dfailprintk((MYIOC_s_INFO_FMT "getFreeChainBuffer failed\n",
 296                         ioc->name));
 297         }
 298         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
 299
 300         *retIndex = chain_idx;
 301         return rc;
 302 } /* mptscsih_getFreeChainBuffer() */
 303
 304 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 305 /*
 306  *      mptscsih_AddSGE - Add a SGE (plus chain buffers) to the
 307  *      SCSIIORequest_t Message Frame.
 308  *      @ioc: Pointer to MPT_ADAPTER structure
 309  *      @SCpnt: Pointer to scsi_cmnd structure
 310  *      @pReq: Pointer to SCSIIORequest_t structure
 311  *
 312  *      Returns ...
 313  */
 314 static int
 315 mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt,
 316                 SCSIIORequest_t *pReq, int req_idx)
 317 {
 318         char    *psge;
 319         char    *chainSge;
 320         struct scatterlist *sg;
 321         int      frm_sz;
 322         int      sges_left, sg_done;
 323         int      chain_idx = MPT_HOST_NO_CHAIN;
 324         int      sgeOffset;
 325         int      numSgeSlots, numSgeThisFrame;
 326         u32      sgflags, sgdir, thisxfer = 0;
 327         int      chain_dma_off = 0;
 328         int      newIndex;
 329         int      ii;
 330         dma_addr_t v2;
 331         u32     RequestNB;
 332
 333         sgdir = le32_to_cpu(pReq->Control) & MPI_SCSIIO_CONTROL_DATADIRECTION_MASK;
 334         if (sgdir == MPI_SCSIIO_CONTROL_WRITE)  {
 335                 sgdir = MPT_TRANSFER_HOST_TO_IOC;
 336         } else {
 337                 sgdir = MPT_TRANSFER_IOC_TO_HOST;
 338         }
 339
 340         psge = (char *) &pReq->SGL;
 341         frm_sz = ioc->req_sz;
 342
 343         /* Map the data portion, if any.
 344          * sges_left  = 0 if no data transfer.
 345          */
 346         if ( (sges_left = SCpnt->use_sg) ) {
 347                 sges_left = pci_map_sg(ioc->pcidev,
 348                                (struct scatterlist *) SCpnt->request_buffer,
 349                                SCpnt->use_sg,
 350                                SCpnt->sc_data_direction);
 351                 if (sges_left == 0)
 352                         return FAILED;
 353         } else if (SCpnt->request_bufflen) {
 354                 SCpnt->SCp.dma_handle = pci_map_single(ioc->pcidev,
 355                                       SCpnt->request_buffer,
 356                                       SCpnt->request_bufflen,
 357                                       SCpnt->sc_data_direction);
 358                 dsgprintk((MYIOC_s_INFO_FMT "SG: non-SG for %p, len=%d\n",
 359                                 ioc->name, SCpnt, SCpnt->request_bufflen));
 360                 mptscsih_add_sge((char *) &pReq->SGL,
 361                         0xD1000000|MPT_SGE_FLAGS_ADDRESSING|sgdir|SCpnt->request_bufflen,
 362                         SCpnt->SCp.dma_handle);
 363
 364                 return SUCCESS;
 365         }
 366
 367         /* Handle the SG case.
 368          */
 369         sg = (struct scatterlist *) SCpnt->request_buffer;
 370         sg_done  = 0;
 371         sgeOffset = sizeof(SCSIIORequest_t) - sizeof(SGE_IO_UNION);
 372         chainSge = NULL;
 373
 374         /* Prior to entering this loop - the following must be set
 375          * current MF:  sgeOffset (bytes)
 376          *              chainSge (Null if original MF is not a chain buffer)
 377          *              sg_done (num SGE done for this MF)
 378          */
 379
 380 nextSGEset:
 381         numSgeSlots = ((frm_sz - sgeOffset) / (sizeof(u32) + sizeof(dma_addr_t)) );
 382         numSgeThisFrame = (sges_left < numSgeSlots) ? sges_left : numSgeSlots;
 383
 384         sgflags = MPT_SGE_FLAGS_SIMPLE_ELEMENT | MPT_SGE_FLAGS_ADDRESSING | sgdir;
 385
 386         /* Get first (num - 1) SG elements
 387          * Skip any SG entries with a length of 0
 388          * NOTE: at finish, sg and psge pointed to NEXT data/location positions
 389          */
 390         for (ii=0; ii < (numSgeThisFrame-1); ii++) {
 391                 thisxfer = sg_dma_len(sg);
 392                 if (thisxfer == 0) {
 393                         sg ++; /* Get next SG element from the OS */
 394                         sg_done++;
 395                         continue;
 396                 }
 397
 398                 v2 = sg_dma_address(sg);
 399                 mptscsih_add_sge(psge, sgflags | thisxfer, v2);
 400
 401                 sg++;           /* Get next SG element from the OS */
 402                 psge += (sizeof(u32) + sizeof(dma_addr_t));
 403                 sgeOffset += (sizeof(u32) + sizeof(dma_addr_t));
 404                 sg_done++;
 405         }
 406
 407         if (numSgeThisFrame == sges_left) {
 408                 /* Add last element, end of buffer and end of list flags.
 409                  */
 410                 sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT |
 411                                 MPT_SGE_FLAGS_END_OF_BUFFER |
 412                                 MPT_SGE_FLAGS_END_OF_LIST;
 413
 414                 /* Add last SGE and set termination flags.
 415                  * Note: Last SGE may have a length of 0 - which should be ok.
 416                  */
 417                 thisxfer = sg_dma_len(sg);
 418
 419                 v2 = sg_dma_address(sg);
 420                 mptscsih_add_sge(psge, sgflags | thisxfer, v2);
 421                 /*
 422                 sg++;
 423                 psge += (sizeof(u32) + sizeof(dma_addr_t));
 424                 */
 425                 sgeOffset += (sizeof(u32) + sizeof(dma_addr_t));
 426                 sg_done++;
 427
 428                 if (chainSge) {
 429                         /* The current buffer is a chain buffer,
 430                          * but there is not another one.
 431                          * Update the chain element
 432                          * Offset and Length fields.
 433                          */
 434                         mptscsih_add_chain((char *)chainSge, 0, sgeOffset, ioc->ChainBufferDMA + chain_dma_off);
 435                 } else {
 436                         /* The current buffer is the original MF
 437                          * and there is no Chain buffer.
 438                          */
 439                         pReq->ChainOffset = 0;
 440                         RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor)  + 1) & 0x03;
 441                         dsgprintk((MYIOC_s_INFO_FMT
 442                             "Single Buffer RequestNB=%x, sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset));
 443                         ioc->RequestNB[req_idx] = RequestNB;
 444                 }
 445         } else {
 446                 /* At least one chain buffer is needed.
 447                  * Complete the first MF
 448                  *  - last SGE element, set the LastElement bit
 449                  *  - set ChainOffset (words) for orig MF
 450                  *             (OR finish previous MF chain buffer)
 451                  *  - update MFStructPtr ChainIndex
 452                  *  - Populate chain element
 453                  * Also
 454                  * Loop until done.
 455                  */
 456
 457                 dsgprintk((MYIOC_s_INFO_FMT "SG: Chain Required! sg done %d\n",
 458                                 ioc->name, sg_done));
 459
 460                 /* Set LAST_ELEMENT flag for last non-chain element
 461                  * in the buffer. Since psge points at the NEXT
 462                  * SGE element, go back one SGE element, update the flags
 463                  * and reset the pointer. (Note: sgflags & thisxfer are already
 464                  * set properly).
 465                  */
 466                 if (sg_done) {
 467                         u32 *ptmp = (u32 *) (psge - (sizeof(u32) + sizeof(dma_addr_t)));
 468                         sgflags = le32_to_cpu(*ptmp);
 469                         sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT;
 470                         *ptmp = cpu_to_le32(sgflags);
 471                 }
 472
 473                 if (chainSge) {
 474                         /* The current buffer is a chain buffer.
 475                          * chainSge points to the previous Chain Element.
 476                          * Update its chain element Offset and Length (must
 477                          * include chain element size) fields.
 478                          * Old chain element is now complete.
 479                          */
 480                         u8 nextChain = (u8) (sgeOffset >> 2);
 481                         sgeOffset += (sizeof(u32) + sizeof(dma_addr_t));
 482                         mptscsih_add_chain((char *)chainSge, nextChain, sgeOffset, ioc->ChainBufferDMA + chain_dma_off);
 483                 } else {
 484                         /* The original MF buffer requires a chain buffer -
 485                          * set the offset.
 486                          * Last element in this MF is a chain element.
 487                          */
 488                         pReq->ChainOffset = (u8) (sgeOffset >> 2);
 489                         RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor)  + 1) & 0x03;
 490                         dsgprintk((MYIOC_s_ERR_FMT "Chain Buffer Needed, RequestNB=%x sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset));
 491                         ioc->RequestNB[req_idx] = RequestNB;
 492                 }
 493
 494                 sges_left -= sg_done;
 495
 496
 497                 /* NOTE: psge points to the beginning of the chain element
 498                  * in current buffer. Get a chain buffer.
 499                  */
 500                 if ((mptscsih_getFreeChainBuffer(ioc, &newIndex)) == FAILED) {
 501                         dfailprintk((MYIOC_s_INFO_FMT
 502                             "getFreeChainBuffer FAILED SCSI cmd=%02x (%p)\n",
 503                             ioc->name, pReq->CDB[0], SCpnt));
 504                         return FAILED;
 505                 }
 506
 507                 /* Update the tracking arrays.
 508                  * If chainSge == NULL, update ReqToChain, else ChainToChain
 509                  */
 510                 if (chainSge) {
 511                         ioc->ChainToChain[chain_idx] = newIndex;
 512                 } else {
 513                         ioc->ReqToChain[req_idx] = newIndex;
 514                 }
 515                 chain_idx = newIndex;
 516                 chain_dma_off = ioc->req_sz * chain_idx;
 517
 518                 /* Populate the chainSGE for the current buffer.
 519                  * - Set chain buffer pointer to psge and fill
 520                  *   out the Address and Flags fields.
 521                  */
 522                 chainSge = (char *) psge;
 523                 dsgprintk((KERN_INFO "  Current buff @ %p (index 0x%x)",
 524                                 psge, req_idx));
 525
 526                 /* Start the SGE for the next buffer
 527                  */
 528                 psge = (char *) (ioc->ChainBuffer + chain_dma_off);
 529                 sgeOffset = 0;
 530                 sg_done = 0;
 531
 532                 dsgprintk((KERN_INFO "  Chain buff @ %p (index 0x%x)\n",
 533                                 psge, chain_idx));
 534
 535                 /* Start the SGE for the next buffer
 536                  */
 537
 538                 goto nextSGEset;
 539         }
 540
 541         return SUCCESS;
 542 } /* mptscsih_AddSGE() */
 543
 544 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 545 /*
 546  *      mptscsih_io_done - Main SCSI IO callback routine registered to
 547  *      Fusion MPT (base) driver
 548  *      @ioc: Pointer to MPT_ADAPTER structure
 549  *      @mf: Pointer to original MPT request frame
 550  *      @r: Pointer to MPT reply frame (NULL if TurboReply)
 551  *
 552  *      This routine is called from mpt.c::mpt_interrupt() at the completion
 553  *      of any SCSI IO request.
 554  *      This routine is registered with the Fusion MPT (base) driver at driver
 555  *      load/init time via the mpt_register() API call.
 556  *
 557  *      Returns 1 indicating alloc'd request frame ptr should be freed.
 558  */
 559 int
 560 mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
 561 {
 562         struct scsi_cmnd        *sc;
 563         MPT_SCSI_HOST   *hd;
 564         SCSIIORequest_t *pScsiReq;
 565         SCSIIOReply_t   *pScsiReply;
 566         u16              req_idx;
 567
 568         hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
 569
 570         req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
 571         sc = hd->ScsiLookup[req_idx];
 572         if (sc == NULL) {
 573                 MPIHeader_t *hdr = (MPIHeader_t *)mf;
 574
 575                 /* Remark: writeSDP1 will use the ScsiDoneCtx
 576                  * If a SCSI I/O cmd, device disabled by OS and
 577                  * completion done. Cannot touch sc struct. Just free mem.
 578                  */
 579                 if (hdr->Function == MPI_FUNCTION_SCSI_IO_REQUEST)
 580                         printk(MYIOC_s_ERR_FMT "NULL ScsiCmd ptr!\n",
 581                         ioc->name);
 582
 583                 mptscsih_freeChainBuffers(ioc, req_idx);
 584                 return 1;
 585         }
 586
 587         sc->result = DID_OK << 16;              /* Set default reply as OK */
 588         pScsiReq = (SCSIIORequest_t *) mf;
 589         pScsiReply = (SCSIIOReply_t *) mr;
 590
 591         if((ioc->facts.MsgVersion >= MPI_VERSION_01_05) && pScsiReply){
 592                 dmfprintk((MYIOC_s_INFO_FMT
 593                         "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d,task-tag=%d)\n",
 594                         ioc->name, mf, mr, sc, req_idx, pScsiReply->TaskTag));
 595         }else{
 596                 dmfprintk((MYIOC_s_INFO_FMT
 597                         "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d)\n",
 598                         ioc->name, mf, mr, sc, req_idx));
 599         }
 600
 601         if (pScsiReply == NULL) {
 602                 /* special context reply handling */
 603                 ;
 604         } else {
 605                 u32      xfer_cnt;
 606                 u16      status;
 607                 u8       scsi_state, scsi_status;
 608
 609                 status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK;
 610                 scsi_state = pScsiReply->SCSIState;
 611                 scsi_status = pScsiReply->SCSIStatus;
 612                 xfer_cnt = le32_to_cpu(pScsiReply->TransferCount);
 613                 sc->resid = sc->request_bufflen - xfer_cnt;
 614
 615                 /*
 616                  *  if we get a data underrun indication, yet no data was
 617                  *  transferred and the SCSI status indicates that the
 618                  *  command was never started, change the data underrun
 619                  *  to success
 620                  */
 621                 if (status == MPI_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 &&
 622                     (scsi_status == MPI_SCSI_STATUS_BUSY ||
 623                      scsi_status == MPI_SCSI_STATUS_RESERVATION_CONFLICT ||
 624                      scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)) {
 625                         status = MPI_IOCSTATUS_SUCCESS;
 626                 }
 627
 628                 dreplyprintk((KERN_NOTICE "Reply ha=%d id=%d lun=%d:\n"
 629                         "IOCStatus=%04xh SCSIState=%02xh SCSIStatus=%02xh\n"
 630                         "resid=%d bufflen=%d xfer_cnt=%d\n",
 631                         ioc->id, sc->device->id, sc->device->lun,
 632                         status, scsi_state, scsi_status, sc->resid,
 633                         sc->request_bufflen, xfer_cnt));
 634
 635                 if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)
 636                         mptscsih_copy_sense_data(sc, hd, mf, pScsiReply);
 637
 638                 /*
 639                  *  Look for + dump FCP ResponseInfo[]!
 640                  */
 641                 if (scsi_state & MPI_SCSI_STATE_RESPONSE_INFO_VALID &&
 642                     pScsiReply->ResponseInfo) {
 643                         printk(KERN_NOTICE "ha=%d id=%d lun=%d: "
 644                         "FCP_ResponseInfo=%08xh\n",
 645                         ioc->id, sc->device->id, sc->device->lun,
 646                         le32_to_cpu(pScsiReply->ResponseInfo));
 647                 }
 648
 649                 switch(status) {
 650                 case MPI_IOCSTATUS_BUSY:                        /* 0x0002 */
 651                         /* CHECKME!
 652                          * Maybe: DRIVER_BUSY | SUGGEST_RETRY | DID_SOFT_ERROR (retry)
 653                          * But not: DID_BUS_BUSY lest one risk
 654                          * killing interrupt handler:-(
 655                          */
 656                         sc->result = SAM_STAT_BUSY;
 657                         break;
 658
 659                 case MPI_IOCSTATUS_SCSI_INVALID_BUS:            /* 0x0041 */
 660                 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID:       /* 0x0042 */
 661                         sc->result = DID_BAD_TARGET << 16;
 662                         break;
 663
 664                 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE:       /* 0x0043 */
 665                         /* Spoof to SCSI Selection Timeout! */
 666                         sc->result = DID_NO_CONNECT << 16;
 667
 668                         if (hd->sel_timeout[pScsiReq->TargetID] < 0xFFFF)
 669                                 hd->sel_timeout[pScsiReq->TargetID]++;
 670                         break;
 671
 672                 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED:        /* 0x0048 */
 673                 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED:         /* 0x004B */
 674                 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED:         /* 0x004C */
 675                         /* Linux handles an unsolicited DID_RESET better
 676                          * than an unsolicited DID_ABORT.
 677                          */
 678                         sc->result = DID_RESET << 16;
 679
 680                         /* GEM Workaround. */
 681                         if (ioc->bus_type == SPI)
 682                                 mptscsih_no_negotiate(hd, sc);
 683                         break;
 684
 685                 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:      /* 0x0049 */
 686                         sc->resid = sc->request_bufflen - xfer_cnt;
 687                         if((xfer_cnt==0)||(sc->underflow > xfer_cnt))
 688                                 sc->result=DID_SOFT_ERROR << 16;
 689                         else /* Sufficient data transfer occurred */
 690                                 sc->result = (DID_OK << 16) | scsi_status;
 691                         dreplyprintk((KERN_NOTICE
 692                             "RESIDUAL_MISMATCH: result=%x on id=%d\n", sc->result, sc->device->id));
 693                         break;
 694
 695                 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN:          /* 0x0045 */
 696                         /*
 697                          *  Do upfront check for valid SenseData and give it
 698                          *  precedence!
 699                          */
 700                         sc->result = (DID_OK << 16) | scsi_status;
 701                         if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) {
 702                                 /* Have already saved the status and sense data
 703                                  */
 704                                 ;
 705                         } else {
 706                                 if (xfer_cnt < sc->underflow) {
 707                                         if (scsi_status == SAM_STAT_BUSY)
 708                                                 sc->result = SAM_STAT_BUSY;
 709                                         else
 710                                                 sc->result = DID_SOFT_ERROR << 16;
 711                                 }
 712                                 if (scsi_state & (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)) {
 713                                         /* What to do?
 714                                         */
 715                                         sc->result = DID_SOFT_ERROR << 16;
 716                                 }
 717                                 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
 718                                         /*  Not real sure here either...  */
 719                                         sc->result = DID_RESET << 16;
 720                                 }
 721                         }
 722
 723                         dreplyprintk((KERN_NOTICE "  sc->underflow={report ERR if < %02xh bytes xfer'd}\n",
 724                                         sc->underflow));
 725                         dreplyprintk((KERN_NOTICE "  ActBytesXferd=%02xh\n", xfer_cnt));
 726                         /* Report Queue Full
 727                          */
 728                         if (scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)
 729                                 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
 730
 731                         break;
 732
 733                 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR:        /* 0x0040 */
 734                 case MPI_IOCSTATUS_SUCCESS:                     /* 0x0000 */
 735                         if (scsi_status == MPI_SCSI_STATUS_BUSY)
 736                                 sc->result = (DID_BUS_BUSY << 16) | scsi_status;
 737                         else
 738                                 sc->result = (DID_OK << 16) | scsi_status;
 739                         if (scsi_state == 0) {
 740                                 ;
 741                         } else if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) {
 742                                 /*
 743                                  * If running against circa 200003dd 909 MPT f/w,
 744                                  * may get this (AUTOSENSE_VALID) for actual TASK_SET_FULL
 745                                  * (QUEUE_FULL) returned from device! --> get 0x0000?128
 746                                  * and with SenseBytes set to 0.
 747                                  */
 748                                 if (pScsiReply->SCSIStatus == MPI_SCSI_STATUS_TASK_SET_FULL)
 749                                         mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
 750
 751                         }
 752                         else if (scsi_state &
 753                                  (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)
 754                            ) {
 755                                 /*
 756                                  * What to do?
 757                                  */
 758                                 sc->result = DID_SOFT_ERROR << 16;
 759                         }
 760                         else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
 761                                 /*  Not real sure here either...  */
 762                                 sc->result = DID_RESET << 16;
 763                         }
 764                         else if (scsi_state & MPI_SCSI_STATE_QUEUE_TAG_REJECTED) {
 765                                 /* Device Inq. data indicates that it supports
 766                                  * QTags, but rejects QTag messages.
 767                                  * This command completed OK.
 768                                  *
 769                                  * Not real sure here either so do nothing...  */
 770                         }
 771
 772                         if (sc->result == MPI_SCSI_STATUS_TASK_SET_FULL)
 773                                 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
 774
 775                         /* Add handling of:
 776                          * Reservation Conflict, Busy,
 777                          * Command Terminated, CHECK
 778                          */
 779                         break;
 780
 781                 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR:         /* 0x0047 */
 782                         sc->result = DID_SOFT_ERROR << 16;
 783                         break;
 784
 785                 case MPI_IOCSTATUS_INVALID_FUNCTION:            /* 0x0001 */
 786                 case MPI_IOCSTATUS_INVALID_SGL:                 /* 0x0003 */
 787                 case MPI_IOCSTATUS_INTERNAL_ERROR:              /* 0x0004 */
 788                 case MPI_IOCSTATUS_RESERVED:                    /* 0x0005 */
 789                 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES:      /* 0x0006 */
 790                 case MPI_IOCSTATUS_INVALID_FIELD:               /* 0x0007 */
 791                 case MPI_IOCSTATUS_INVALID_STATE:               /* 0x0008 */
 792                 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN:           /* 0x0044 */
 793                 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR:          /* 0x0046 */
 794                 case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED:       /* 0x004A */
 795                 default:
 796                         /*
 797                          * What to do?
 798                          */
 799                         sc->result = DID_SOFT_ERROR << 16;
 800                         break;
 801
 802                 }       /* switch(status) */
 803
 804                 dreplyprintk((KERN_NOTICE "  sc->result is %08xh\n", sc->result));
 805         } /* end of address reply case */
 806
 807         /* Unmap the DMA buffers, if any. */
 808         if (sc->use_sg) {
 809                 pci_unmap_sg(ioc->pcidev, (struct scatterlist *) sc->request_buffer,
 810                             sc->use_sg, sc->sc_data_direction);
 811         } else if (sc->request_bufflen) {
 812                 pci_unmap_single(ioc->pcidev, sc->SCp.dma_handle,
 813                                 sc->request_bufflen, sc->sc_data_direction);
 814         }
 815
 816         hd->ScsiLookup[req_idx] = NULL;
 817
 818         sc->scsi_done(sc);              /* Issue the command callback */
 819
 820         /* Free Chain buffers */
 821         mptscsih_freeChainBuffers(ioc, req_idx);
 822         return 1;
 823 }
 824
 825 /*
 826  *      mptscsih_flush_running_cmds - For each command found, search
 827  *              Scsi_Host instance taskQ and reply to OS.
 828  *              Called only if recovering from a FW reload.
 829  *      @hd: Pointer to a SCSI HOST structure
 830  *
 831  *      Returns: None.
 832  *
 833  *      Must be called while new I/Os are being queued.
 834  */
 835 static void
 836 mptscsih_flush_running_cmds(MPT_SCSI_HOST *hd)
 837 {
 838         MPT_ADAPTER *ioc = hd->ioc;
 839         struct scsi_cmnd        *SCpnt;
 840         MPT_FRAME_HDR   *mf;
 841         int              ii;
 842         int              max = ioc->req_depth;
 843
 844         dprintk((KERN_INFO MYNAM ": flush_ScsiLookup called\n"));
 845         for (ii= 0; ii < max; ii++) {
 846                 if ((SCpnt = hd->ScsiLookup[ii]) != NULL) {
 847
 848                         /* Command found.
 849                          */
 850
 851                         /* Null ScsiLookup index
 852                          */
 853                         hd->ScsiLookup[ii] = NULL;
 854
 855                         mf = MPT_INDEX_2_MFPTR(ioc, ii);
 856                         dmfprintk(( "flush: ScsiDone (mf=%p,sc=%p)\n",
 857                                         mf, SCpnt));
 858
 859                         /* Set status, free OS resources (SG DMA buffers)
 860                          * Do OS callback
 861                          * Free driver resources (chain, msg buffers)
 862                          */
 863                         if (SCpnt->use_sg) {
 864                                 pci_unmap_sg(ioc->pcidev,
 865                                         (struct scatterlist *) SCpnt->request_buffer,
 866                                         SCpnt->use_sg,
 867                                         SCpnt->sc_data_direction);
 868                         } else if (SCpnt->request_bufflen) {
 869                                 pci_unmap_single(ioc->pcidev,
 870                                         SCpnt->SCp.dma_handle,
 871                                         SCpnt->request_bufflen,
 872                                         SCpnt->sc_data_direction);
 873                         }
 874                         SCpnt->result = DID_RESET << 16;
 875                         SCpnt->host_scribble = NULL;
 876
 877                         /* Free Chain buffers */
 878                         mptscsih_freeChainBuffers(ioc, ii);
 879
 880                         /* Free Message frames */
 881                         mpt_free_msg_frame(ioc, mf);
 882
 883                         SCpnt->scsi_done(SCpnt);        /* Issue the command callback */
 884                 }
 885         }
 886
 887         return;
 888 }
 889
 890 /*
 891  *      mptscsih_search_running_cmds - Delete any commands associated
 892  *              with the specified target and lun. Function called only
 893  *              when a lun is disable by mid-layer.
 894  *              Do NOT access the referenced scsi_cmnd structure or
 895  *              members. Will cause either a paging or NULL ptr error.
 896  *      @hd: Pointer to a SCSI HOST structure
 897  *      @vdevice: per device private data
 898  *
 899  *      Returns: None.
 900  *
 901  *      Called from slave_destroy.
 902  */
 903 static void
 904 mptscsih_search_running_cmds(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
 905 {
 906         SCSIIORequest_t *mf = NULL;
 907         int              ii;
 908         int              max = hd->ioc->req_depth;
 909         struct scsi_cmnd *sc;
 910
 911         dsprintk((KERN_INFO MYNAM ": search_running target %d lun %d max %d\n",
 912                         vdevice->target_id, vdevice->lun, max));
 913
 914         for (ii=0; ii < max; ii++) {
 915                 if ((sc = hd->ScsiLookup[ii]) != NULL) {
 916
 917                         mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(hd->ioc, ii);
 918
 919                         dsprintk(( "search_running: found (sc=%p, mf = %p) target %d, lun %d \n",
 920                                         hd->ScsiLookup[ii], mf, mf->TargetID, mf->LUN[1]));
 921
 922                         if ((mf->TargetID != ((u8)vdevice->target_id)) || (mf->LUN[1] != ((u8) vdevice->lun)))
 923                                 continue;
 924
 925                         /* Cleanup
 926                          */
 927                         hd->ScsiLookup[ii] = NULL;
 928                         mptscsih_freeChainBuffers(hd->ioc, ii);
 929                         mpt_free_msg_frame(hd->ioc, (MPT_FRAME_HDR *)mf);
 930                         if (sc->use_sg) {
 931                                 pci_unmap_sg(hd->ioc->pcidev,
 932                                 (struct scatterlist *) sc->request_buffer,
 933                                         sc->use_sg,
 934                                         sc->sc_data_direction);
 935                         } else if (sc->request_bufflen) {
 936                                 pci_unmap_single(hd->ioc->pcidev,
 937                                         sc->SCp.dma_handle,
 938                                         sc->request_bufflen,
 939                                         sc->sc_data_direction);
 940                         }
 941                         sc->host_scribble = NULL;
 942                         sc->result = DID_NO_CONNECT << 16;
 943                         sc->scsi_done(sc);
 944                 }
 945         }
 946         return;
 947 }
 948
 949 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 950
 951 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 952 /*
 953  *      mptscsih_report_queue_full - Report QUEUE_FULL status returned
 954  *      from a SCSI target device.
 955  *      @sc: Pointer to scsi_cmnd structure
 956  *      @pScsiReply: Pointer to SCSIIOReply_t
 957  *      @pScsiReq: Pointer to original SCSI request
 958  *
 959  *      This routine periodically reports QUEUE_FULL status returned from a
 960  *      SCSI target device.  It reports this to the console via kernel
 961  *      printk() API call, not more than once every 10 seconds.
 962  */
 963 static void
 964 mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq)
 965 {
 966         long time = jiffies;
 967         MPT_SCSI_HOST           *hd;
 968
 969         if (sc->device == NULL)
 970                 return;
 971         if (sc->device->host == NULL)
 972                 return;
 973         if ((hd = (MPT_SCSI_HOST *)sc->device->host->hostdata) == NULL)
 974                 return;
 975
 976         if (time - hd->last_queue_full > 10 * HZ) {
 977                 dprintk((MYIOC_s_WARN_FMT "Device (%d:%d:%d) reported QUEUE_FULL!\n",
 978                                 hd->ioc->name, 0, sc->device->id, sc->device->lun));
 979                 hd->last_queue_full = time;
 980         }
 981 }
 982
 983 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 984 /*
 985  *      mptscsih_remove - Removed scsi devices
 986  *      @pdev: Pointer to pci_dev structure
 987  *
 988  *
 989  */
 990 void
 991 mptscsih_remove(struct pci_dev *pdev)
 992 {
 993         MPT_ADAPTER             *ioc = pci_get_drvdata(pdev);
 994         struct Scsi_Host        *host = ioc->sh;
 995         MPT_SCSI_HOST           *hd;
 996 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION
 997         int                     count;
 998         unsigned long           flags;
 999 #endif
1000         int sz1;
1001
1002         if(!host) {
1003                 mpt_detach(pdev);
1004                 return;
1005         }
1006
1007         scsi_remove_host(host);
1008
1009         if((hd = (MPT_SCSI_HOST *)host->hostdata) == NULL)
1010                 return;
1011
1012 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION
1013         /* Check DV thread active */
1014         count = 10 * HZ;
1015         spin_lock_irqsave(&dvtaskQ_lock, flags);
1016         if (dvtaskQ_active) {
1017                 spin_unlock_irqrestore(&dvtaskQ_lock, flags);
1018                 while(dvtaskQ_active && --count)
1019                         schedule_timeout_interruptible(1);
1020         } else {
1021                 spin_unlock_irqrestore(&dvtaskQ_lock, flags);
1022         }
1023         if (!count)
1024                 printk(KERN_ERR MYNAM ": ERROR - DV thread still active!\n");
1025 #if defined(MPT_DEBUG_DV) || defined(MPT_DEBUG_DV_TINY)
1026         else
1027                 printk(KERN_ERR MYNAM ": DV thread orig %d, count %d\n", 10 * HZ, count);
1028 #endif
1029 #endif
1030
1031         mptscsih_shutdown(pdev);
1032
1033         sz1=0;
1034
1035         if (hd->ScsiLookup != NULL) {
1036                 sz1 = hd->ioc->req_depth * sizeof(void *);
1037                 kfree(hd->ScsiLookup);
1038                 hd->ScsiLookup = NULL;
1039         }
1040
1041         /*
1042          * Free pointer array.
1043          */
1044         kfree(hd->Targets);
1045         hd->Targets = NULL;
1046
1047         dprintk((MYIOC_s_INFO_FMT
1048             "Free'd ScsiLookup (%d) memory\n",
1049             hd->ioc->name, sz1));
1050
1051         kfree(hd->info_kbuf);
1052
1053         /* NULL the Scsi_Host pointer
1054          */
1055         hd->ioc->sh = NULL;
1056
1057         scsi_host_put(host);
1058
1059         mpt_detach(pdev);
1060
1061 }
1062
1063 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1064 /*
1065  *      mptscsih_shutdown - reboot notifier
1066  *
1067  */
1068 void
1069 mptscsih_shutdown(struct pci_dev *pdev)
1070 {
1071         MPT_ADAPTER             *ioc = pci_get_drvdata(pdev);
1072         struct Scsi_Host        *host = ioc->sh;
1073         MPT_SCSI_HOST           *hd;
1074
1075         if(!host)
1076                 return;
1077
1078         hd = (MPT_SCSI_HOST *)host->hostdata;
1079
1080 }
1081
1082 #ifdef CONFIG_PM
1083 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1084 /*
1085  *      mptscsih_suspend - Fusion MPT scsi driver suspend routine.
1086  *
1087  *
1088  */
1089 int
1090 mptscsih_suspend(struct pci_dev *pdev, pm_message_t state)
1091 {
1092         mptscsih_shutdown(pdev);
1093         return mpt_suspend(pdev,state);
1094 }
1095
1096 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1097 /*
1098  *      mptscsih_resume - Fusion MPT scsi driver resume routine.
1099  *
1100  *
1101  */
1102 int
1103 mptscsih_resume(struct pci_dev *pdev)
1104 {
1105         MPT_ADAPTER             *ioc = pci_get_drvdata(pdev);
1106         struct Scsi_Host        *host = ioc->sh;
1107         MPT_SCSI_HOST           *hd;
1108
1109         mpt_resume(pdev);
1110
1111         if(!host)
1112                 return 0;
1113
1114         hd = (MPT_SCSI_HOST *)host->hostdata;
1115         if(!hd)
1116                 return 0;
1117
1118 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION
1119         {
1120         unsigned long lflags;
1121         spin_lock_irqsave(&dvtaskQ_lock, lflags);
1122         if (!dvtaskQ_active) {
1123                 dvtaskQ_active = 1;
1124                 spin_unlock_irqrestore(&dvtaskQ_lock, lflags);
1125                 INIT_WORK(&dvTaskQ_task,
1126                   mptscsih_domainValidation, (void *) hd);
1127                 schedule_work(&dvTaskQ_task);
1128         } else {
1129                 spin_unlock_irqrestore(&dvtaskQ_lock, lflags);
1130         }
1131         }
1132 #endif
1133         return 0;
1134 }
1135
1136 #endif
1137
1138 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1139 /**
1140  *      mptscsih_info - Return information about MPT adapter
1141  *      @SChost: Pointer to Scsi_Host structure
1142  *
1143  *      (linux scsi_host_template.info routine)
1144  *
1145  *      Returns pointer to buffer where information was written.
1146  */
1147 const char *
1148 mptscsih_info(struct Scsi_Host *SChost)
1149 {
1150         MPT_SCSI_HOST *h;
1151         int size = 0;
1152
1153         h = (MPT_SCSI_HOST *)SChost->hostdata;
1154
1155         if (h) {
1156                 if (h->info_kbuf == NULL)
1157                         if ((h->info_kbuf = kmalloc(0x1000 /* 4Kb */, GFP_KERNEL)) == NULL)
1158                                 return h->info_kbuf;
1159                 h->info_kbuf[0] = '\0';
1160
1161                 mpt_print_ioc_summary(h->ioc, h->info_kbuf, &size, 0, 0);
1162                 h->info_kbuf[size-1] = '\0';
1163         }
1164
1165         return h->info_kbuf;
1166 }
1167
1168 struct info_str {
1169         char *buffer;
1170         int   length;
1171         int   offset;
1172         int   pos;
1173 };
1174
1175 static void
1176 mptscsih_copy_mem_info(struct info_str *info, char *data, int len)
1177 {
1178         if (info->pos + len > info->length)
1179                 len = info->length - info->pos;
1180
1181         if (info->pos + len < info->offset) {
1182                 info->pos += len;
1183                 return;
1184         }
1185
1186         if (info->pos < info->offset) {
1187                 data += (info->offset - info->pos);
1188                 len  -= (info->offset - info->pos);
1189         }
1190
1191         if (len > 0) {
1192                 memcpy(info->buffer + info->pos, data, len);
1193                 info->pos += len;
1194         }
1195 }
1196
1197 static int
1198 mptscsih_copy_info(struct info_str *info, char *fmt, ...)
1199 {
1200         va_list args;
1201         char buf[81];
1202         int len;
1203
1204         va_start(args, fmt);
1205         len = vsprintf(buf, fmt, args);
1206         va_end(args);
1207
1208         mptscsih_copy_mem_info(info, buf, len);
1209         return len;
1210 }
1211
1212 static int
1213 mptscsih_host_info(MPT_ADAPTER *ioc, char *pbuf, off_t offset, int len)
1214 {
1215         struct info_str info;
1216
1217         info.buffer     = pbuf;
1218         info.length     = len;
1219         info.offset     = offset;
1220         info.pos        = 0;
1221
1222         mptscsih_copy_info(&info, "%s: %s, ", ioc->name, ioc->prod_name);
1223         mptscsih_copy_info(&info, "%s%08xh, ", MPT_FW_REV_MAGIC_ID_STRING, ioc->facts.FWVersion.Word);
1224         mptscsih_copy_info(&info, "Ports=%d, ", ioc->facts.NumberOfPorts);
1225         mptscsih_copy_info(&info, "MaxQ=%d\n", ioc->req_depth);
1226
1227         return ((info.pos > info.offset) ? info.pos - info.offset : 0);
1228 }
1229
1230 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1231 /**
1232  *      mptscsih_proc_info - Return information about MPT adapter
1233  *
1234  *      (linux scsi_host_template.info routine)
1235  *
1236  *      buffer: if write, user data; if read, buffer for user
1237  *      length: if write, return length;
1238  *      offset: if write, 0; if read, the current offset into the buffer from
1239  *              the previous read.
1240  *      hostno: scsi host number
1241  *      func:   if write = 1; if read = 0
1242  */
1243 int
1244 mptscsih_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
1245                         int length, int func)
1246 {
1247         MPT_SCSI_HOST   *hd = (MPT_SCSI_HOST *)host->hostdata;
1248         MPT_ADAPTER     *ioc = hd->ioc;
1249         int size = 0;
1250
1251         if (func) {
1252                 /*
1253                  * write is not supported
1254                  */
1255         } else {
1256                 if (start)
1257                         *start = buffer;
1258
1259                 size = mptscsih_host_info(ioc, buffer, offset, length);
1260         }
1261
1262         return size;
1263 }
1264
1265 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1266 #define ADD_INDEX_LOG(req_ent)  do { } while(0)
1267
1268 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1269 /**
1270  *      mptscsih_qcmd - Primary Fusion MPT SCSI initiator IO start routine.
1271  *      @SCpnt: Pointer to scsi_cmnd structure
1272  *      @done: Pointer SCSI mid-layer IO completion function
1273  *
1274  *      (linux scsi_host_template.queuecommand routine)
1275  *      This is the primary SCSI IO start routine.  Create a MPI SCSIIORequest
1276  *      from a linux scsi_cmnd request and send it to the IOC.
1277  *
1278  *      Returns 0. (rtn value discarded by linux scsi mid-layer)
1279  */
1280 int
1281 mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1282 {
1283         MPT_SCSI_HOST           *hd;
1284         MPT_FRAME_HDR           *mf;
1285         SCSIIORequest_t         *pScsiReq;
1286         VirtDevice              *vdev = SCpnt->device->hostdata;
1287         int      lun;
1288         u32      datalen;
1289         u32      scsictl;
1290         u32      scsidir;
1291         u32      cmd_len;
1292         int      my_idx;
1293         int      ii;
1294
1295         hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata;
1296         lun = SCpnt->device->lun;
1297         SCpnt->scsi_done = done;
1298
1299         dmfprintk((MYIOC_s_INFO_FMT "qcmd: SCpnt=%p, done()=%p\n",
1300                         (hd && hd->ioc) ? hd->ioc->name : "ioc?", SCpnt, done));
1301
1302         if (hd->resetPending) {
1303                 dtmprintk((MYIOC_s_WARN_FMT "qcmd: SCpnt=%p timeout + 60HZ\n",
1304                         (hd && hd->ioc) ? hd->ioc->name : "ioc?", SCpnt));
1305                 return SCSI_MLQUEUE_HOST_BUSY;
1306         }
1307
1308         /*
1309          *  Put together a MPT SCSI request...
1310          */
1311         if ((mf = mpt_get_msg_frame(hd->ioc->DoneCtx, hd->ioc)) == NULL) {
1312                 dprintk((MYIOC_s_WARN_FMT "QueueCmd, no msg frames!!\n",
1313                                 hd->ioc->name));
1314                 return SCSI_MLQUEUE_HOST_BUSY;
1315         }
1316
1317         pScsiReq = (SCSIIORequest_t *) mf;
1318
1319         my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1320
1321         ADD_INDEX_LOG(my_idx);
1322
1323         /*    TUR's being issued with scsictl=0x02000000 (DATA_IN)!
1324          *    Seems we may receive a buffer (datalen>0) even when there
1325          *    will be no data transfer!  GRRRRR...
1326          */
1327         if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
1328                 datalen = SCpnt->request_bufflen;
1329                 scsidir = MPI_SCSIIO_CONTROL_READ;      /* DATA IN  (host<--ioc<--dev) */
1330         } else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) {
1331                 datalen = SCpnt->request_bufflen;
1332                 scsidir = MPI_SCSIIO_CONTROL_WRITE;     /* DATA OUT (host-->ioc-->dev) */
1333         } else {
1334                 datalen = 0;
1335                 scsidir = MPI_SCSIIO_CONTROL_NODATATRANSFER;
1336         }
1337
1338         /* Default to untagged. Once a target structure has been allocated,
1339          * use the Inquiry data to determine if device supports tagged.
1340          */
1341         if (vdev
1342             && (vdev->vtarget->tflags & MPT_TARGET_FLAGS_Q_YES)
1343             && (SCpnt->device->tagged_supported)) {
1344                 scsictl = scsidir | MPI_SCSIIO_CONTROL_SIMPLEQ;
1345         } else {
1346                 scsictl = scsidir | MPI_SCSIIO_CONTROL_UNTAGGED;
1347         }
1348
1349         /* Use the above information to set up the message frame
1350          */
1351         pScsiReq->TargetID = (u8) vdev->target_id;
1352         pScsiReq->Bus = vdev->bus_id;
1353         pScsiReq->ChainOffset = 0;
1354         pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
1355         pScsiReq->CDBLength = SCpnt->cmd_len;
1356         pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1357         pScsiReq->Reserved = 0;
1358         pScsiReq->MsgFlags = mpt_msg_flags();
1359         pScsiReq->LUN[0] = 0;
1360         pScsiReq->LUN[1] = lun;
1361         pScsiReq->LUN[2] = 0;
1362         pScsiReq->LUN[3] = 0;
1363         pScsiReq->LUN[4] = 0;
1364         pScsiReq->LUN[5] = 0;
1365         pScsiReq->LUN[6] = 0;
1366         pScsiReq->LUN[7] = 0;
1367         pScsiReq->Control = cpu_to_le32(scsictl);
1368
1369         /*
1370          *  Write SCSI CDB into the message
1371          */
1372         cmd_len = SCpnt->cmd_len;
1373         for (ii=0; ii < cmd_len; ii++)
1374                 pScsiReq->CDB[ii] = SCpnt->cmnd[ii];
1375
1376         for (ii=cmd_len; ii < 16; ii++)
1377                 pScsiReq->CDB[ii] = 0;
1378
1379         /* DataLength */
1380         pScsiReq->DataLength = cpu_to_le32(datalen);
1381
1382         /* SenseBuffer low address */
1383         pScsiReq->SenseBufferLowAddr = cpu_to_le32(hd->ioc->sense_buf_low_dma
1384                                            + (my_idx * MPT_SENSE_BUFFER_ALLOC));
1385
1386         /* Now add the SG list
1387          * Always have a SGE even if null length.
1388          */
1389         if (datalen == 0) {
1390                 /* Add a NULL SGE */
1391                 mptscsih_add_sge((char *)&pScsiReq->SGL, MPT_SGE_FLAGS_SSIMPLE_READ | 0,
1392                         (dma_addr_t) -1);
1393         } else {
1394                 /* Add a 32 or 64 bit SGE */
1395                 if (mptscsih_AddSGE(hd->ioc, SCpnt, pScsiReq, my_idx) != SUCCESS)
1396                         goto fail;
1397         }
1398
1399         hd->ScsiLookup[my_idx] = SCpnt;
1400         SCpnt->host_scribble = NULL;
1401
1402 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION
1403         if (hd->ioc->bus_type == SPI) {
1404                 int dvStatus = hd->ioc->spi_data.dvStatus[vdev->target_id];
1405                 int issueCmd = 1;
1406
1407                 if (dvStatus || hd->ioc->spi_data.forceDv) {
1408
1409                         if ((dvStatus & MPT_SCSICFG_NEED_DV) ||
1410                                 (hd->ioc->spi_data.forceDv & MPT_SCSICFG_NEED_DV)) {
1411                                 unsigned long lflags;
1412                                 /* Schedule DV if necessary */
1413                                 spin_lock_irqsave(&dvtaskQ_lock, lflags);
1414                                 if (!dvtaskQ_active) {
1415                                         dvtaskQ_active = 1;
1416                                         spin_unlock_irqrestore(&dvtaskQ_lock, lflags);
1417                                         INIT_WORK(&dvTaskQ_task, mptscsih_domainValidation, (void *) hd);
1418
1419                                         schedule_work(&dvTaskQ_task);
1420                                 } else {
1421                                         spin_unlock_irqrestore(&dvtaskQ_lock, lflags);
1422                                 }
1423                                 hd->ioc->spi_data.forceDv &= ~MPT_SCSICFG_NEED_DV;
1424                         }
1425
1426                         /* Trying to do DV to this target, extend timeout.
1427                          * Wait to issue until flag is clear
1428                          */
1429                         if (dvStatus & MPT_SCSICFG_DV_PENDING) {
1430                                 mod_timer(&SCpnt->eh_timeout, jiffies + 40 * HZ);
1431                                 issueCmd = 0;
1432                         }
1433
1434                         /* Set the DV flags.
1435                          */
1436                         if (dvStatus & MPT_SCSICFG_DV_NOT_DONE)
1437                                 mptscsih_set_dvflags(hd, SCpnt);
1438
1439                         if (!issueCmd)
1440                                 goto fail;
1441                 }
1442         }
1443 #endif
1444
1445         mpt_put_msg_frame(hd->ioc->DoneCtx, hd->ioc, mf);
1446         dmfprintk((MYIOC_s_INFO_FMT "Issued SCSI cmd (%p) mf=%p idx=%d\n",
1447                         hd->ioc->name, SCpnt, mf, my_idx));
1448         DBG_DUMP_REQUEST_FRAME(mf)
1449         return 0;
1450
1451  fail:
1452         hd->ScsiLookup[my_idx] = NULL;
1453         mptscsih_freeChainBuffers(hd->ioc, my_idx);
1454         mpt_free_msg_frame(hd->ioc, mf);
1455         return SCSI_MLQUEUE_HOST_BUSY;
1456 }
1457
1458 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1459 /*
1460  *      mptscsih_freeChainBuffers - Function to free chain buffers associated
1461  *      with a SCSI IO request
1462  *      @hd: Pointer to the MPT_SCSI_HOST instance
1463  *      @req_idx: Index of the SCSI IO request frame.
1464  *
1465  *      Called if SG chain buffer allocation fails and mptscsih callbacks.
1466  *      No return.
1467  */
1468 static void
1469 mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx)
1470 {
1471         MPT_FRAME_HDR *chain;
1472         unsigned long flags;
1473         int chain_idx;
1474         int next;
1475
1476         /* Get the first chain index and reset
1477          * tracker state.
1478          */
1479         chain_idx = ioc->ReqToChain[req_idx];
1480         ioc->ReqToChain[req_idx] = MPT_HOST_NO_CHAIN;
1481
1482         while (chain_idx != MPT_HOST_NO_CHAIN) {
1483
1484                 /* Save the next chain buffer index */
1485                 next = ioc->ChainToChain[chain_idx];
1486
1487                 /* Free this chain buffer and reset
1488                  * tracker
1489                  */
1490                 ioc->ChainToChain[chain_idx] = MPT_HOST_NO_CHAIN;
1491
1492                 chain = (MPT_FRAME_HDR *) (ioc->ChainBuffer
1493                                         + (chain_idx * ioc->req_sz));
1494
1495                 spin_lock_irqsave(&ioc->FreeQlock, flags);
1496                 list_add_tail(&chain->u.frame.linkage.list, &ioc->FreeChainQ);
1497                 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1498
1499                 dmfprintk((MYIOC_s_INFO_FMT "FreeChainBuffers (index %d)\n",
1500                                 ioc->name, chain_idx));
1501
1502                 /* handle next */
1503                 chain_idx = next;
1504         }
1505         return;
1506 }
1507
1508 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1509 /*
1510  *      Reset Handling
1511  */
1512
1513 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1514 /*
1515  *      mptscsih_TMHandler - Generic handler for SCSI Task Management.
1516  *      Fall through to mpt_HardResetHandler if: not operational, too many
1517  *      failed TM requests or handshake failure.
1518  *
1519  *      @ioc: Pointer to MPT_ADAPTER structure
1520  *      @type: Task Management type
1521  *      @target: Logical Target ID for reset (if appropriate)
1522  *      @lun: Logical Unit for reset (if appropriate)
1523  *      @ctx2abort: Context for the task to be aborted (if appropriate)
1524  *
1525  *      Remark: Currently invoked from a non-interrupt thread (_bh).
1526  *
1527  *      Remark: With old EH code, at most 1 SCSI TaskMgmt function per IOC
1528  *      will be active.
1529  *
1530  *      Returns 0 for SUCCESS or -1 if FAILED.
1531  */
1532 static int
1533 mptscsih_TMHandler(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 target, u8 lun, int ctx2abort, ulong timeout)
1534 {
1535         MPT_ADAPTER     *ioc;
1536         int              rc = -1;
1537         int              doTask = 1;
1538         u32              ioc_raw_state;
1539         unsigned long    flags;
1540
1541         /* If FW is being reloaded currently, return success to
1542          * the calling function.
1543          */
1544         if (hd == NULL)
1545                 return 0;
1546
1547         ioc = hd->ioc;
1548         if (ioc == NULL) {
1549                 printk(KERN_ERR MYNAM " TMHandler" " NULL ioc!\n");
1550                 return FAILED;
1551         }
1552         dtmprintk((MYIOC_s_INFO_FMT "TMHandler Entered!\n", ioc->name));
1553
1554         // SJR - CHECKME - Can we avoid this here?
1555         // (mpt_HardResetHandler has this check...)
1556         spin_lock_irqsave(&ioc->diagLock, flags);
1557         if ((ioc->diagPending) || (ioc->alt_ioc && ioc->alt_ioc->diagPending)) {
1558                 spin_unlock_irqrestore(&ioc->diagLock, flags);
1559                 return FAILED;
1560         }
1561         spin_unlock_irqrestore(&ioc->diagLock, flags);
1562
1563         /*  Wait a fixed amount of time for the TM pending flag to be cleared.
1564          *  If we time out and not bus reset, then we return a FAILED status to the caller.
1565          *  The call to mptscsih_tm_pending_wait() will set the pending flag if we are
1566          *  successful. Otherwise, reload the FW.
1567          */
1568         if (mptscsih_tm_pending_wait(hd) == FAILED) {
1569                 if (type == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK) {
1570                         dtmprintk((KERN_INFO MYNAM ": %s: TMHandler abort: "
1571                            "Timed out waiting for last TM (%d) to complete! \n",
1572                            hd->ioc->name, hd->tmPending));
1573                         return FAILED;
1574                 } else if (type == MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET) {
1575                         dtmprintk((KERN_INFO MYNAM ": %s: TMHandler target reset: "
1576                            "Timed out waiting for last TM (%d) to complete! \n",
1577                            hd->ioc->name, hd->tmPending));
1578                         return FAILED;
1579                 } else if (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) {
1580                         dtmprintk((KERN_INFO MYNAM ": %s: TMHandler bus reset: "
1581                            "Timed out waiting for last TM (%d) to complete! \n",
1582                            hd->ioc->name, hd->tmPending));
1583                         if (hd->tmPending & (1 << MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS))
1584                                 return FAILED;
1585
1586                         doTask = 0;
1587                 }
1588         } else {
1589                 spin_lock_irqsave(&hd->ioc->FreeQlock, flags);
1590                 hd->tmPending |=  (1 << type);
1591                 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
1592         }
1593
1594         /* Is operational?
1595          */
1596         ioc_raw_state = mpt_GetIocState(hd->ioc, 0);
1597
1598 #ifdef MPT_DEBUG_RESET
1599         if ((ioc_raw_state & MPI_IOC_STATE_MASK) != MPI_IOC_STATE_OPERATIONAL) {
1600                 printk(MYIOC_s_WARN_FMT
1601                         "TM Handler: IOC Not operational(0x%x)!\n",
1602                         hd->ioc->name, ioc_raw_state);
1603         }
1604 #endif
1605
1606         if (doTask && ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_OPERATIONAL)
1607                                 && !(ioc_raw_state & MPI_DOORBELL_ACTIVE)) {
1608
1609                 /* Isse the Task Mgmt request.
1610                  */
1611                 if (hd->hard_resets < -1)
1612                         hd->hard_resets++;
1613                 rc = mptscsih_IssueTaskMgmt(hd, type, channel, target, lun, ctx2abort, timeout);
1614                 if (rc) {
1615                         printk(MYIOC_s_INFO_FMT "Issue of TaskMgmt failed!\n", hd->ioc->name);
1616                 } else {
1617                         dtmprintk((MYIOC_s_INFO_FMT "Issue of TaskMgmt Successful!\n", hd->ioc->name));
1618                 }
1619         }
1620
1621         /* Only fall through to the HRH if this is a bus reset
1622          */
1623         if ((type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) && (rc ||
1624                 ioc->reload_fw || (ioc->alt_ioc && ioc->alt_ioc->reload_fw))) {
1625                 dtmprintk((MYIOC_s_INFO_FMT "Calling HardReset! \n",
1626                          hd->ioc->name));
1627                 rc = mpt_HardResetHandler(hd->ioc, CAN_SLEEP);
1628         }
1629
1630         dtmprintk((MYIOC_s_INFO_FMT "TMHandler rc = %d!\n", hd->ioc->name, rc));
1631
1632         return rc;
1633 }
1634
1635
1636 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1637 /*
1638  *      mptscsih_IssueTaskMgmt - Generic send Task Management function.
1639  *      @hd: Pointer to MPT_SCSI_HOST structure
1640  *      @type: Task Management type
1641  *      @target: Logical Target ID for reset (if appropriate)
1642  *      @lun: Logical Unit for reset (if appropriate)
1643  *      @ctx2abort: Context for the task to be aborted (if appropriate)
1644  *
1645  *      Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
1646  *      or a non-interrupt thread.  In the former, must not call schedule().
1647  *
1648  *      Not all fields are meaningfull for all task types.
1649  *
1650  *      Returns 0 for SUCCESS, -999 for "no msg frames",
1651  *      else other non-zero value returned.
1652  */
1653 static int
1654 mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 target, u8 lun, int ctx2abort, ulong timeout)
1655 {
1656         MPT_FRAME_HDR   *mf;
1657         SCSITaskMgmt_t  *pScsiTm;
1658         int              ii;
1659         int              retval;
1660
1661         /* Return Fail to calling function if no message frames available.
1662          */
1663         if ((mf = mpt_get_msg_frame(hd->ioc->TaskCtx, hd->ioc)) == NULL) {
1664                 dfailprintk((MYIOC_s_ERR_FMT "IssueTaskMgmt, no msg frames!!\n",
1665                                 hd->ioc->name));
1666                 return FAILED;
1667         }
1668         dtmprintk((MYIOC_s_INFO_FMT "IssueTaskMgmt request @ %p\n",
1669                         hd->ioc->name, mf));
1670
1671         /* Format the Request
1672          */
1673         pScsiTm = (SCSITaskMgmt_t *) mf;
1674         pScsiTm->TargetID = target;
1675         pScsiTm->Bus = channel;
1676         pScsiTm->ChainOffset = 0;
1677         pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
1678
1679         pScsiTm->Reserved = 0;
1680         pScsiTm->TaskType = type;
1681         pScsiTm->Reserved1 = 0;
1682         pScsiTm->MsgFlags = (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS)
1683                     ? MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION : 0;
1684
1685         for (ii= 0; ii < 8; ii++) {
1686                 pScsiTm->LUN[ii] = 0;
1687         }
1688         pScsiTm->LUN[1] = lun;
1689
1690         for (ii=0; ii < 7; ii++)
1691                 pScsiTm->Reserved2[ii] = 0;
1692
1693         pScsiTm->TaskMsgContext = ctx2abort;
1694
1695         dtmprintk((MYIOC_s_INFO_FMT "IssueTaskMgmt: ctx2abort (0x%08x) type=%d\n",
1696                         hd->ioc->name, ctx2abort, type));
1697
1698         DBG_DUMP_TM_REQUEST_FRAME((u32 *)pScsiTm);
1699
1700         if ((retval = mpt_send_handshake_request(hd->ioc->TaskCtx, hd->ioc,
1701                 sizeof(SCSITaskMgmt_t), (u32*)pScsiTm,
1702                 CAN_SLEEP)) != 0) {
1703                 dfailprintk((MYIOC_s_ERR_FMT "_send_handshake FAILED!"
1704                         " (hd %p, ioc %p, mf %p) \n", hd->ioc->name, hd,
1705                         hd->ioc, mf));
1706                 mpt_free_msg_frame(hd->ioc, mf);
1707                 return retval;
1708         }
1709
1710         if(mptscsih_tm_wait_for_completion(hd, timeout) == FAILED) {
1711                 dfailprintk((MYIOC_s_ERR_FMT "_wait_for_completion FAILED!"
1712                         " (hd %p, ioc %p, mf %p) \n", hd->ioc->name, hd,
1713                         hd->ioc, mf));
1714                 mpt_free_msg_frame(hd->ioc, mf);
1715                 dtmprintk((MYIOC_s_INFO_FMT "Calling HardReset! \n",
1716                          hd->ioc->name));
1717                 retval = mpt_HardResetHandler(hd->ioc, CAN_SLEEP);
1718         }
1719
1720         return retval;
1721 }
1722
1723 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1724 /**
1725  *      mptscsih_abort - Abort linux scsi_cmnd routine, new_eh variant
1726  *      @SCpnt: Pointer to scsi_cmnd structure, IO to be aborted
1727  *
1728  *      (linux scsi_host_template.eh_abort_handler routine)
1729  *
1730  *      Returns SUCCESS or FAILED.
1731  */
1732 int
1733 mptscsih_abort(struct scsi_cmnd * SCpnt)
1734 {
1735         MPT_SCSI_HOST   *hd;
1736         MPT_ADAPTER     *ioc;
1737         MPT_FRAME_HDR   *mf;
1738         u32              ctx2abort;
1739         int              scpnt_idx;
1740         int              retval;
1741         VirtDevice       *vdev;
1742
1743         /* If we can't locate our host adapter structure, return FAILED status.
1744          */
1745         if ((hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata) == NULL) {
1746                 SCpnt->result = DID_RESET << 16;
1747                 SCpnt->scsi_done(SCpnt);
1748                 dfailprintk((KERN_INFO MYNAM ": mptscsih_abort: "
1749                            "Can't locate host! (sc=%p)\n",
1750                            SCpnt));
1751                 return FAILED;
1752         }
1753
1754         ioc = hd->ioc;
1755         if (hd->resetPending) {
1756                 return FAILED;
1757         }
1758
1759         if (hd->timeouts < -1)
1760                 hd->timeouts++;
1761
1762         /* Find this command
1763          */
1764         if ((scpnt_idx = SCPNT_TO_LOOKUP_IDX(SCpnt)) < 0) {
1765                 /* Cmd not found in ScsiLookup.
1766                  * Do OS callback.
1767                  */
1768                 SCpnt->result = DID_RESET << 16;
1769                 dtmprintk((KERN_INFO MYNAM ": %s: mptscsih_abort: "
1770                            "Command not in the active list! (sc=%p)\n",
1771                            hd->ioc->name, SCpnt));
1772                 return SUCCESS;
1773         }
1774
1775         printk(KERN_WARNING MYNAM ": %s: attempting task abort! (sc=%p)\n",
1776                hd->ioc->name, SCpnt);
1777         scsi_print_command(SCpnt);
1778
1779         /* Most important!  Set TaskMsgContext to SCpnt's MsgContext!
1780          * (the IO to be ABORT'd)
1781          *
1782          * NOTE: Since we do not byteswap MsgContext, we do not
1783          *       swap it here either.  It is an opaque cookie to
1784          *       the controller, so it does not matter. -DaveM
1785          */
1786         mf = MPT_INDEX_2_MFPTR(hd->ioc, scpnt_idx);
1787         ctx2abort = mf->u.frame.hwhdr.msgctxu.MsgContext;
1788
1789         hd->abortSCpnt = SCpnt;
1790
1791         vdev = SCpnt->device->hostdata;
1792         retval = mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
1793                 vdev->bus_id, vdev->target_id, vdev->lun,
1794                 ctx2abort, 2 /* 2 second timeout */);
1795
1796         printk (KERN_WARNING MYNAM ": %s: task abort: %s (sc=%p)\n",
1797                 hd->ioc->name,
1798                 ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1799
1800         if (retval == 0)
1801                 return SUCCESS;
1802
1803         if(retval != FAILED ) {
1804                 hd->tmPending = 0;
1805                 hd->tmState = TM_STATE_NONE;
1806         }
1807         return FAILED;
1808 }
1809
1810 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1811 /**
1812  *      mptscsih_dev_reset - Perform a SCSI TARGET_RESET!  new_eh variant
1813  *      @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1814  *
1815  *      (linux scsi_host_template.eh_dev_reset_handler routine)
1816  *
1817  *      Returns SUCCESS or FAILED.
1818  */
1819 int
1820 mptscsih_dev_reset(struct scsi_cmnd * SCpnt)
1821 {
1822         MPT_SCSI_HOST   *hd;
1823         int              retval;
1824         VirtDevice       *vdev;
1825
1826         /* If we can't locate our host adapter structure, return FAILED status.
1827          */
1828         if ((hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata) == NULL){
1829                 dtmprintk((KERN_INFO MYNAM ": mptscsih_dev_reset: "
1830                            "Can't locate host! (sc=%p)\n",
1831                            SCpnt));
1832                 return FAILED;
1833         }
1834
1835         if (hd->resetPending)
1836                 return FAILED;
1837
1838         printk(KERN_WARNING MYNAM ": %s: attempting target reset! (sc=%p)\n",
1839                hd->ioc->name, SCpnt);
1840         scsi_print_command(SCpnt);
1841
1842         vdev = SCpnt->device->hostdata;
1843         retval = mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
1844                 vdev->bus_id, vdev->target_id,
1845                 0, 0, 5 /* 5 second timeout */);
1846
1847         printk (KERN_WARNING MYNAM ": %s: target reset: %s (sc=%p)\n",
1848                 hd->ioc->name,
1849                 ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1850
1851         if (retval == 0)
1852                 return SUCCESS;
1853
1854         if(retval != FAILED ) {
1855                 hd->tmPending = 0;
1856                 hd->tmState = TM_STATE_NONE;
1857         }
1858         return FAILED;
1859 }
1860
1861 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1862 /**
1863  *      mptscsih_bus_reset - Perform a SCSI BUS_RESET!  new_eh variant
1864  *      @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1865  *
1866  *      (linux scsi_host_template.eh_bus_reset_handler routine)
1867  *
1868  *      Returns SUCCESS or FAILED.
1869  */
1870 int
1871 mptscsih_bus_reset(struct scsi_cmnd * SCpnt)
1872 {
1873         MPT_SCSI_HOST   *hd;
1874         int              retval;
1875         VirtDevice       *vdev;
1876
1877         /* If we can't locate our host adapter structure, return FAILED status.
1878          */
1879         if ((hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata) == NULL){
1880                 dtmprintk((KERN_INFO MYNAM ": mptscsih_bus_reset: "
1881                            "Can't locate host! (sc=%p)\n",
1882                            SCpnt ) );
1883                 return FAILED;
1884         }
1885
1886         printk(KERN_WARNING MYNAM ": %s: attempting bus reset! (sc=%p)\n",
1887                hd->ioc->name, SCpnt);
1888         scsi_print_command(SCpnt);
1889
1890         if (hd->timeouts < -1)
1891                 hd->timeouts++;
1892
1893         vdev = SCpnt->device->hostdata;
1894         retval = mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1895                 vdev->bus_id, 0, 0, 0, 5 /* 5 second timeout */);
1896
1897         printk (KERN_WARNING MYNAM ": %s: bus reset: %s (sc=%p)\n",
1898                 hd->ioc->name,
1899                 ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1900
1901         if (retval == 0)
1902                 return SUCCESS;
1903
1904         if(retval != FAILED ) {
1905                 hd->tmPending = 0;
1906                 hd->tmState = TM_STATE_NONE;
1907         }
1908         return FAILED;
1909 }
1910
1911 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1912 /**
1913  *      mptscsih_host_reset - Perform a SCSI host adapter RESET!
1914  *      new_eh variant
1915  *      @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1916  *
1917  *      (linux scsi_host_template.eh_host_reset_handler routine)
1918  *
1919  *      Returns SUCCESS or FAILED.
1920  */
1921 int
1922 mptscsih_host_reset(struct scsi_cmnd *SCpnt)
1923 {
1924         MPT_SCSI_HOST *  hd;
1925         int              status = SUCCESS;
1926
1927         /*  If we can't locate the host to reset, then we failed. */
1928         if ((hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata) == NULL){
1929                 dtmprintk( ( KERN_INFO MYNAM ": mptscsih_host_reset: "
1930                              "Can't locate host! (sc=%p)\n",
1931                              SCpnt ) );
1932                 return FAILED;
1933         }
1934
1935         printk(KERN_WARNING MYNAM ": %s: Attempting host reset! (sc=%p)\n",
1936                hd->ioc->name, SCpnt);
1937
1938         /*  If our attempts to reset the host failed, then return a failed
1939          *  status.  The host will be taken off line by the SCSI mid-layer.
1940          */
1941         if (mpt_HardResetHandler(hd->ioc, CAN_SLEEP) < 0){
1942                 status = FAILED;
1943         } else {
1944                 /*  Make sure TM pending is cleared and TM state is set to
1945                  *  NONE.
1946                  */
1947                 hd->tmPending = 0;
1948                 hd->tmState = TM_STATE_NONE;
1949         }
1950
1951         dtmprintk( ( KERN_INFO MYNAM ": mptscsih_host_reset: "
1952                      "Status = %s\n",
1953                      (status == SUCCESS) ? "SUCCESS" : "FAILED" ) );
1954
1955         return status;
1956 }
1957
1958 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1959 /**
1960  *      mptscsih_tm_pending_wait - wait for pending task management request to
1961  *              complete.
1962  *      @hd: Pointer to MPT host structure.
1963  *
1964  *      Returns {SUCCESS,FAILED}.
1965  */
1966 static int
1967 mptscsih_tm_pending_wait(MPT_SCSI_HOST * hd)
1968 {
1969         unsigned long  flags;
1970         int            loop_count = 4 * 10;  /* Wait 10 seconds */
1971         int            status = FAILED;
1972
1973         do {
1974                 spin_lock_irqsave(&hd->ioc->FreeQlock, flags);
1975                 if (hd->tmState == TM_STATE_NONE) {
1976                         hd->tmState = TM_STATE_IN_PROGRESS;
1977                         hd->tmPending = 1;
1978                         spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
1979                         status = SUCCESS;
1980                         break;
1981                 }
1982                 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
1983                 msleep(250);
1984         } while (--loop_count);
1985
1986         return status;
1987 }
1988
1989 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1990 /**
1991  *      mptscsih_tm_wait_for_completion - wait for completion of TM task
1992  *      @hd: Pointer to MPT host structure.
1993  *
1994  *      Returns {SUCCESS,FAILED}.
1995  */
1996 static int
1997 mptscsih_tm_wait_for_completion(MPT_SCSI_HOST * hd, ulong timeout )
1998 {
1999         unsigned long  flags;
2000         int            loop_count = 4 * timeout;
2001         int            status = FAILED;
2002
2003         do {
2004                 spin_lock_irqsave(&hd->ioc->FreeQlock, flags);
2005                 if(hd->tmPending == 0) {
2006                         status = SUCCESS;
2007                         spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
2008                         break;
2009                 }
2010                 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
2011                 msleep_interruptible(250);
2012         } while (--loop_count);
2013
2014         return status;
2015 }
2016
2017 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2018 /**
2019  *      mptscsih_taskmgmt_complete - Registered with Fusion MPT base driver
2020  *      @ioc: Pointer to MPT_ADAPTER structure
2021  *      @mf: Pointer to SCSI task mgmt request frame
2022  *      @mr: Pointer to SCSI task mgmt reply frame
2023  *
2024  *      This routine is called from mptbase.c::mpt_interrupt() at the completion
2025  *      of any SCSI task management request.
2026  *      This routine is registered with the MPT (base) driver at driver
2027  *      load/init time via the mpt_register() API call.
2028  *
2029  *      Returns 1 indicating alloc'd request frame ptr should be freed.
2030  */
2031 int
2032 mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
2033 {
2034         SCSITaskMgmtReply_t     *pScsiTmReply;
2035         SCSITaskMgmt_t          *pScsiTmReq;
2036         MPT_SCSI_HOST           *hd;
2037         unsigned long            flags;
2038         u16                      iocstatus;
2039         u8                       tmType;
2040
2041         dtmprintk((MYIOC_s_WARN_FMT "TaskMgmt completed (mf=%p,mr=%p)\n",
2042                         ioc->name, mf, mr));
2043         if (ioc->sh) {
2044                 /* Depending on the thread, a timer is activated for
2045                  * the TM request.  Delete this timer on completion of TM.
2046                  * Decrement count of outstanding TM requests.
2047                  */
2048                 hd = (MPT_SCSI_HOST *)ioc->sh->hostdata;
2049         } else {
2050                 dtmprintk((MYIOC_s_WARN_FMT "TaskMgmt Complete: NULL Scsi Host Ptr\n",
2051                         ioc->name));
2052                 return 1;
2053         }
2054
2055         if (mr == NULL) {
2056                 dtmprintk((MYIOC_s_WARN_FMT "ERROR! TaskMgmt Reply: NULL Request %p\n",
2057                         ioc->name, mf));
2058                 return 1;
2059         } else {
2060                 pScsiTmReply = (SCSITaskMgmtReply_t*)mr;
2061                 pScsiTmReq = (SCSITaskMgmt_t*)mf;
2062
2063                 /* Figure out if this was ABORT_TASK, TARGET_RESET, or BUS_RESET! */
2064                 tmType = pScsiTmReq->TaskType;
2065
2066                 dtmprintk((MYIOC_s_WARN_FMT "  TaskType = %d, TerminationCount=%d\n",
2067                                 ioc->name, tmType, le32_to_cpu(pScsiTmReply->TerminationCount)));
2068                 DBG_DUMP_TM_REPLY_FRAME((u32 *)pScsiTmReply);
2069
2070                 iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
2071                 dtmprintk((MYIOC_s_WARN_FMT "  SCSI TaskMgmt (%d) IOCStatus=%04x IOCLogInfo=%08x\n",
2072                         ioc->name, tmType, iocstatus, le32_to_cpu(pScsiTmReply->IOCLogInfo)));
2073                 /* Error?  (anything non-zero?) */
2074                 if (iocstatus) {
2075
2076                         /* clear flags and continue.
2077                          */
2078                         if (tmType == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK)
2079                                 hd->abortSCpnt = NULL;
2080
2081                         /* If an internal command is present
2082                          * or the TM failed - reload the FW.
2083                          * FC FW may respond FAILED to an ABORT
2084                          */
2085                         if (tmType == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) {
2086                                 if ((hd->cmdPtr) ||
2087                                     (iocstatus == MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED)) {
2088                                         if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0) {
2089                                                 printk((KERN_WARNING
2090                                                         " Firmware Reload FAILED!!\n"));
2091                                         }
2092                                 }
2093                         }
2094                 } else {
2095                         dtmprintk((MYIOC_s_WARN_FMT " TaskMgmt SUCCESS\n", ioc->name));
2096
2097                         hd->abortSCpnt = NULL;
2098
2099                 }
2100         }
2101
2102         spin_lock_irqsave(&ioc->FreeQlock, flags);
2103         hd->tmPending = 0;
2104         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
2105         hd->tmState = TM_STATE_NONE;
2106
2107         return 1;
2108 }
2109
2110 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2111 /*
2112  *      This is anyones guess quite frankly.
2113  */
2114 int
2115 mptscsih_bios_param(struct scsi_device * sdev, struct block_device *bdev,
2116                 sector_t capacity, int geom[])
2117 {
2118         int             heads;
2119         int             sectors;
2120         sector_t        cylinders;
2121         ulong           dummy;
2122
2123         heads = 64;
2124         sectors = 32;
2125
2126         dummy = heads * sectors;
2127         cylinders = capacity;
2128         sector_div(cylinders,dummy);
2129
2130         /*
2131          * Handle extended translation size for logical drives
2132          * > 1Gb
2133          */
2134         if ((ulong)capacity >= 0x200000) {
2135                 heads = 255;
2136                 sectors = 63;
2137                 dummy = heads * sectors;
2138                 cylinders = capacity;
2139                 sector_div(cylinders,dummy);
2140         }
2141
2142         /* return result */
2143         geom[0] = heads;
2144         geom[1] = sectors;
2145         geom[2] = cylinders;
2146
2147         dprintk((KERN_NOTICE
2148                 ": bios_param: Id=%i Lun=%i Channel=%i CHS=%i/%i/%i\n",
2149                 sdev->id, sdev->lun,sdev->channel,(int)cylinders,heads,sectors));
2150
2151         return 0;
2152 }
2153
2154 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2155 /*
2156  *      OS entry point to allow host driver to alloc memory
2157  *      for each scsi target. Called once per device the bus scan.
2158  *      Return non-zero if allocation fails.
2159  */
2160 int
2161 mptscsih_target_alloc(struct scsi_target *starget)
2162 {
2163         VirtTarget              *vtarget;
2164
2165         vtarget = kmalloc(sizeof(VirtTarget), GFP_KERNEL);
2166         if (!vtarget)
2167                 return -ENOMEM;
2168         memset(vtarget, 0, sizeof(VirtTarget));
2169         starget->hostdata = vtarget;
2170         return 0;
2171 }
2172
2173 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2174 /*
2175  *      OS entry point to allow host driver to alloc memory
2176  *      for each scsi device. Called once per device the bus scan.
2177  *      Return non-zero if allocation fails.
2178  */
2179 int
2180 mptscsih_slave_alloc(struct scsi_device *sdev)
2181 {
2182         struct Scsi_Host        *host = sdev->host;
2183         MPT_SCSI_HOST           *hd = (MPT_SCSI_HOST *)host->hostdata;
2184         VirtTarget              *vtarget;
2185         VirtDevice              *vdev;
2186         struct scsi_target      *starget;
2187
2188         vdev = kmalloc(sizeof(VirtDevice), GFP_KERNEL);
2189         if (!vdev) {
2190                 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
2191                                 hd->ioc->name, sizeof(VirtDevice));
2192                 return -ENOMEM;
2193         }
2194
2195         memset(vdev, 0, sizeof(VirtDevice));
2196         vdev->ioc_id = hd->ioc->id;
2197         vdev->target_id = sdev->id;
2198         vdev->bus_id = sdev->channel;
2199         vdev->lun = sdev->lun;
2200         sdev->hostdata = vdev;
2201
2202         starget = scsi_target(sdev);
2203         vtarget = starget->hostdata;
2204         vdev->vtarget = vtarget;
2205
2206         if (vtarget->num_luns == 0) {
2207                 hd->Targets[sdev->id] = vtarget;
2208                 vtarget->ioc_id = hd->ioc->id;
2209                 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
2210                 vtarget->target_id = sdev->id;
2211                 vtarget->bus_id = sdev->channel;
2212                 if (hd->ioc->bus_type == SPI) {
2213                         if (hd->ioc->raid_data.isRaid & (1 << sdev->id)) {
2214                                 vtarget->raidVolume = 1;
2215                                 ddvtprintk((KERN_INFO
2216                                     "RAID Volume @ id %d\n", sdev->id));
2217                         }
2218                 } else {
2219                         vtarget->tflags |= MPT_TARGET_FLAGS_VALID_INQUIRY;
2220                 }
2221         }
2222         vtarget->num_luns++;
2223         return 0;
2224 }
2225
2226 /*
2227  *      OS entry point to allow for host driver to free allocated memory
2228  *      Called if no device present or device being unloaded
2229  */
2230 void
2231 mptscsih_target_destroy(struct scsi_target *starget)
2232 {
2233         if (starget->hostdata)
2234                 kfree(starget->hostdata);
2235         starget->hostdata = NULL;
2236 }
2237
2238 /*
2239  *      OS entry point to allow for host driver to free allocated memory
2240  *      Called if no device present or device being unloaded
2241  */
2242 void
2243 mptscsih_slave_destroy(struct scsi_device *sdev)
2244 {
2245         struct Scsi_Host        *host = sdev->host;
2246         MPT_SCSI_HOST           *hd = (MPT_SCSI_HOST *)host->hostdata;
2247         VirtTarget              *vtarget;
2248         VirtDevice              *vdevice;
2249         struct scsi_target      *starget;
2250
2251         starget = scsi_target(sdev);
2252         vtarget = starget->hostdata;
2253         vdevice = sdev->hostdata;
2254
2255         mptscsih_search_running_cmds(hd, vdevice);
2256         vtarget->luns[0] &= ~(1 << vdevice->lun);
2257         vtarget->num_luns--;
2258         if (vtarget->num_luns == 0) {
2259                 mptscsih_negotiate_to_asyn_narrow(hd, vtarget);
2260                 if (hd->ioc->bus_type == SPI) {
2261                         if (mptscsih_is_phys_disk(hd->ioc, vtarget->target_id)) {
2262                                 hd->ioc->spi_data.forceDv |= MPT_SCSICFG_RELOAD_IOC_PG3;
2263                         } else {
2264                                 hd->ioc->spi_data.dvStatus[vtarget->target_id] =
2265                                         MPT_SCSICFG_NEGOTIATE;
2266                                 if (!hd->negoNvram) {
2267                                         hd->ioc->spi_data.dvStatus[vtarget->target_id] |=
2268                                                 MPT_SCSICFG_DV_NOT_DONE;
2269                                 }
2270                         }
2271                 }
2272                 hd->Targets[sdev->id] = NULL;
2273         }
2274         mptscsih_synchronize_cache(hd, vdevice);
2275         kfree(vdevice);
2276         sdev->hostdata = NULL;
2277 }
2278
2279 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2280 /*
2281  *      mptscsih_change_queue_depth - This function will set a devices queue depth
2282  *      @sdev: per scsi_device pointer
2283  *      @qdepth: requested queue depth
2284  *
2285  *      Adding support for new 'change_queue_depth' api.
2286 */
2287 int
2288 mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
2289 {
2290         MPT_SCSI_HOST           *hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
2291         VirtTarget              *vtarget;
2292         struct scsi_target      *starget;
2293         int                     max_depth;
2294         int                     tagged;
2295
2296         starget = scsi_target(sdev);
2297         vtarget = starget->hostdata;
2298
2299         if (hd->ioc->bus_type == SPI) {
2300                 if (vtarget->tflags & MPT_TARGET_FLAGS_VALID_INQUIRY) {
2301                         if (!(vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
2302                                 max_depth = 1;
2303                         else if (((vtarget->inq_data[0] & 0x1f) == 0x00) &&
2304                                  (vtarget->minSyncFactor <= MPT_ULTRA160 ))
2305                                 max_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
2306                         else
2307                                 max_depth = MPT_SCSI_CMD_PER_DEV_LOW;
2308                 } else {
2309                         /* error case - No Inq. Data */
2310                         max_depth = 1;
2311                 }
2312         } else
2313                 max_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
2314
2315         if (qdepth > max_depth)
2316                 qdepth = max_depth;
2317         if (qdepth == 1)
2318                 tagged = 0;
2319         else
2320                 tagged = MSG_SIMPLE_TAG;
2321
2322         scsi_adjust_queue_depth(sdev, tagged, qdepth);
2323         return sdev->queue_depth;
2324 }
2325
2326 /*
2327  *      OS entry point to adjust the queue_depths on a per-device basis.
2328  *      Called once per device the bus scan. Use it to force the queue_depth
2329  *      member to 1 if a device does not support Q tags.
2330  *      Return non-zero if fails.
2331  */
2332 int
2333 mptscsih_slave_configure(struct scsi_device *sdev)
2334 {
2335         struct Scsi_Host        *sh = sdev->host;
2336         VirtTarget              *vtarget;
2337         VirtDevice              *vdevice;
2338         struct scsi_target      *starget;
2339         MPT_SCSI_HOST           *hd = (MPT_SCSI_HOST *)sh->hostdata;
2340         int                     indexed_lun, lun_index;
2341
2342         starget = scsi_target(sdev);
2343         vtarget = starget->hostdata;
2344         vdevice = sdev->hostdata;
2345
2346         dsprintk((MYIOC_s_INFO_FMT
2347                 "device @ %p, id=%d, LUN=%d, channel=%d\n",
2348                 hd->ioc->name, sdev, sdev->id, sdev->lun, sdev->channel));
2349         if (hd->ioc->bus_type == SPI)
2350                 dsprintk((MYIOC_s_INFO_FMT
2351                     "sdtr %d wdtr %d ppr %d inq length=%d\n",
2352                     hd->ioc->name, sdev->sdtr, sdev->wdtr,
2353                     sdev->ppr, sdev->inquiry_len));
2354
2355         if (sdev->id > sh->max_id) {
2356                 /* error case, should never happen */
2357                 scsi_adjust_queue_depth(sdev, 0, 1);
2358                 goto slave_configure_exit;
2359         }
2360
2361         vdevice->configured_lun=1;
2362         lun_index = (vdevice->lun >> 5);  /* 32 luns per lun_index */
2363         indexed_lun = (vdevice->lun % 32);
2364         vtarget->luns[lun_index] |= (1 << indexed_lun);
2365         mptscsih_initTarget(hd, vtarget, sdev->lun, sdev->inquiry,
2366             sdev->inquiry_len );
2367         mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH);
2368
2369         dsprintk((MYIOC_s_INFO_FMT
2370                 "Queue depth=%d, tflags=%x\n",
2371                 hd->ioc->name, sdev->queue_depth, vtarget->tflags));
2372
2373         if (hd->ioc->bus_type == SPI)
2374                 dsprintk((MYIOC_s_INFO_FMT
2375                     "negoFlags=%x, maxOffset=%x, SyncFactor=%x\n",
2376                     hd->ioc->name, vtarget->negoFlags, vtarget->maxOffset,
2377                     vtarget->minSyncFactor));
2378
2379 slave_configure_exit:
2380
2381         dsprintk((MYIOC_s_INFO_FMT
2382                 "tagged %d, simple %d, ordered %d\n",
2383                 hd->ioc->name,sdev->tagged_supported, sdev->simple_tags,
2384                 sdev->ordered_tags));
2385
2386         return 0;
2387 }
2388
2389 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2390 /*
2391  *  Private routines...
2392  */
2393
2394 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2395 /* Utility function to copy sense data from the scsi_cmnd buffer
2396  * to the FC and SCSI target structures.
2397  *
2398  */
2399 static void
2400 mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply)
2401 {
2402         VirtDevice      *vdev;
2403         SCSIIORequest_t *pReq;
2404         u32              sense_count = le32_to_cpu(pScsiReply->SenseCount);
2405
2406         /* Get target structure
2407          */
2408         pReq = (SCSIIORequest_t *) mf;
2409         vdev = sc->device->hostdata;
2410
2411         if (sense_count) {
2412                 u8 *sense_data;
2413                 int req_index;
2414
2415                 /* Copy the sense received into the scsi command block. */
2416                 req_index = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2417                 sense_data = ((u8 *)hd->ioc->sense_buf_pool + (req_index * MPT_SENSE_BUFFER_ALLOC));
2418                 memcpy(sc->sense_buffer, sense_data, SNS_LEN(sc));
2419
2420                 /* Log SMART data (asc = 0x5D, non-IM case only) if required.
2421                  */
2422                 if ((hd->ioc->events) && (hd->ioc->eventTypes & (1 << MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE))) {
2423                         if ((sense_data[12] == 0x5D) && (vdev->vtarget->raidVolume == 0)) {
2424                                 int idx;
2425                                 MPT_ADAPTER *ioc = hd->ioc;
2426
2427                                 idx = ioc->eventContext % ioc->eventLogSize;
2428                                 ioc->events[idx].event = MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE;
2429                                 ioc->events[idx].eventContext = ioc->eventContext;
2430
2431                                 ioc->events[idx].data[0] = (pReq->LUN[1] << 24) ||
2432                                         (MPI_EVENT_SCSI_DEV_STAT_RC_SMART_DATA << 16) ||
2433                                         (sc->device->channel << 8) || sc->device->id;
2434
2435                                 ioc->events[idx].data[1] = (sense_data[13] << 8) || sense_data[12];
2436
2437                                 ioc->eventContext++;
2438                         }
2439                 }
2440         } else {
2441                 dprintk((MYIOC_s_INFO_FMT "Hmmm... SenseData len=0! (?)\n",
2442                                 hd->ioc->name));
2443         }
2444 }
2445
2446 static u32
2447 SCPNT_TO_LOOKUP_IDX(struct scsi_cmnd *sc)
2448 {
2449         MPT_SCSI_HOST *hd;
2450         int i;
2451
2452         hd = (MPT_SCSI_HOST *) sc->device->host->hostdata;
2453
2454         for (i = 0; i < hd->ioc->req_depth; i++) {
2455                 if (hd->ScsiLookup[i] == sc) {
2456                         return i;
2457                 }
2458         }
2459
2460         return -1;
2461 }
2462
2463 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2464 int
2465 mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
2466 {
2467         MPT_SCSI_HOST   *hd;
2468         unsigned long    flags;
2469         int             ii;
2470
2471         dtmprintk((KERN_WARNING MYNAM
2472                         ": IOC %s_reset routed to SCSI host driver!\n",
2473                         reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
2474                         reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
2475
2476         /* If a FW reload request arrives after base installed but
2477          * before all scsi hosts have been attached, then an alt_ioc
2478          * may have a NULL sh pointer.
2479          */
2480         if ((ioc->sh == NULL) || (ioc->sh->hostdata == NULL))
2481                 return 0;
2482         else
2483                 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
2484
2485         if (reset_phase == MPT_IOC_SETUP_RESET) {
2486                 dtmprintk((MYIOC_s_WARN_FMT "Setup-Diag Reset\n", ioc->name));
2487
2488                 /* Clean Up:
2489                  * 1. Set Hard Reset Pending Flag
2490                  * All new commands go to doneQ
2491                  */
2492                 hd->resetPending = 1;
2493
2494         } else if (reset_phase == MPT_IOC_PRE_RESET) {
2495                 dtmprintk((MYIOC_s_WARN_FMT "Pre-Diag Reset\n", ioc->name));
2496
2497                 /* 2. Flush running commands
2498                  *      Clean ScsiLookup (and associated memory)
2499                  *      AND clean mytaskQ
2500                  */
2501
2502                 /* 2b. Reply to OS all known outstanding I/O commands.
2503                  */
2504                 mptscsih_flush_running_cmds(hd);
2505
2506                 /* 2c. If there was an internal command that
2507                  * has not completed, configuration or io request,
2508                  * free these resources.
2509                  */
2510                 if (hd->cmdPtr) {
2511                         del_timer(&hd->timer);
2512                         mpt_free_msg_frame(ioc, hd->cmdPtr);
2513                 }
2514
2515                 dtmprintk((MYIOC_s_WARN_FMT "Pre-Reset complete.\n", ioc->name));
2516
2517         } else {
2518                 dtmprintk((MYIOC_s_WARN_FMT "Post-Diag Reset\n", ioc->name));
2519
2520                 /* Once a FW reload begins, all new OS commands are
2521                  * redirected to the doneQ w/ a reset status.
2522                  * Init all control structures.
2523                  */
2524
2525                 /* ScsiLookup initialization
2526                  */
2527                 for (ii=0; ii < hd->ioc->req_depth; ii++)
2528                         hd->ScsiLookup[ii] = NULL;
2529
2530                 /* 2. Chain Buffer initialization
2531                  */
2532
2533                 /* 4. Renegotiate to all devices, if SPI
2534                  */
2535                 if (ioc->bus_type == SPI) {
2536                         dnegoprintk(("writeSDP1: ALL_IDS USE_NVRAM\n"));
2537                         mptscsih_writeSDP1(hd, 0, 0, MPT_SCSICFG_ALL_IDS | MPT_SCSICFG_USE_NVRAM);
2538                 }
2539
2540                 /* 5. Enable new commands to be posted
2541                  */
2542                 spin_lock_irqsave(&ioc->FreeQlock, flags);
2543                 hd->tmPending = 0;
2544                 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
2545                 hd->resetPending = 0;
2546                 hd->tmState = TM_STATE_NONE;
2547
2548                 /* 6. If there was an internal command,
2549                  * wake this process up.
2550                  */
2551                 if (hd->cmdPtr) {
2552                         /*
2553                          * Wake up the original calling thread
2554                          */
2555                         hd->pLocal = &hd->localReply;
2556                         hd->pLocal->completion = MPT_SCANDV_DID_RESET;
2557                         hd->scandv_wait_done = 1;
2558                         wake_up(&hd->scandv_waitq);
2559                         hd->cmdPtr = NULL;
2560                 }
2561
2562                 /* 7. Set flag to force DV and re-read IOC Page 3
2563                  */
2564                 if (ioc->bus_type == SPI) {
2565                         ioc->spi_data.forceDv = MPT_SCSICFG_NEED_DV | MPT_SCSICFG_RELOAD_IOC_PG3;
2566                         ddvtprintk(("Set reload IOC Pg3 Flag\n"));
2567                 }
2568
2569                 dtmprintk((MYIOC_s_WARN_FMT "Post-Reset complete.\n", ioc->name));
2570
2571         }
2572
2573         return 1;               /* currently means nothing really */
2574 }
2575
2576 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2577 /* work queue thread to clear the persitency table */
2578 static void
2579 mptscsih_sas_persist_clear_table(void * arg)
2580 {
2581         MPT_ADAPTER *ioc = (MPT_ADAPTER *)arg;
2582
2583         mptbase_sas_persist_operation(ioc, MPI_SAS_OP_CLEAR_NOT_PRESENT);
2584 }
2585
2586 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2587 int
2588 mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
2589 {
2590         MPT_SCSI_HOST *hd;
2591         u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
2592
2593         devtprintk((MYIOC_s_INFO_FMT "MPT event (=%02Xh) routed to SCSI host driver!\n",
2594                         ioc->name, event));
2595
2596         if (ioc->sh == NULL ||
2597                 ((hd = (MPT_SCSI_HOST *)ioc->sh->hostdata) == NULL))
2598                 return 1;
2599
2600         switch (event) {
2601         case MPI_EVENT_UNIT_ATTENTION:                  /* 03 */
2602                 /* FIXME! */
2603                 break;
2604         case MPI_EVENT_IOC_BUS_RESET:                   /* 04 */
2605         case MPI_EVENT_EXT_BUS_RESET:                   /* 05 */
2606                 if (hd && (ioc->bus_type == SPI) && (hd->soft_resets < -1))
2607                         hd->soft_resets++;
2608                 break;
2609         case MPI_EVENT_LOGOUT:                          /* 09 */
2610                 /* FIXME! */
2611                 break;
2612
2613                 /*
2614                  *  CHECKME! Don't think we need to do
2615                  *  anything for these, but...
2616                  */
2617         case MPI_EVENT_RESCAN:                          /* 06 */
2618         case MPI_EVENT_LINK_STATUS_CHANGE:              /* 07 */
2619         case MPI_EVENT_LOOP_STATE_CHANGE:               /* 08 */
2620                 /*
2621                  *  CHECKME!  Falling thru...
2622                  */
2623                 break;
2624
2625         case MPI_EVENT_INTEGRATED_RAID:                 /* 0B */
2626         {
2627 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION
2628                 pMpiEventDataRaid_t pRaidEventData =
2629                     (pMpiEventDataRaid_t) pEvReply->Data;
2630                 /* Domain Validation Needed */
2631                 if (ioc->bus_type == SPI &&
2632                     pRaidEventData->ReasonCode ==
2633                     MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED)
2634                         mptscsih_set_dvflags_raid(hd, pRaidEventData->PhysDiskNum);
2635 #endif
2636                 break;
2637         }
2638
2639         /* Persistent table is full. */
2640         case MPI_EVENT_PERSISTENT_TABLE_FULL:
2641                 INIT_WORK(&mptscsih_persistTask,
2642                     mptscsih_sas_persist_clear_table,(void *)ioc);
2643                 schedule_work(&mptscsih_persistTask);
2644                 break;
2645
2646         case MPI_EVENT_NONE:                            /* 00 */
2647         case MPI_EVENT_LOG_DATA:                        /* 01 */
2648         case MPI_EVENT_STATE_CHANGE:                    /* 02 */
2649         case MPI_EVENT_EVENT_CHANGE:                    /* 0A */
2650         default:
2651                 dprintk((KERN_INFO "  Ignoring event (=%02Xh)\n", event));
2652                 break;
2653         }
2654
2655         return 1;               /* currently means nothing really */
2656 }
2657
2658 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2659 /*
2660  *      mptscsih_initTarget - Target, LUN alloc/free functionality.
2661  *      @hd: Pointer to MPT_SCSI_HOST structure
2662  *      @vtarget: per target private data
2663  *      @lun: SCSI LUN id
2664  *      @data: Pointer to data
2665  *      @dlen: Number of INQUIRY bytes
2666  *
2667  *      NOTE: It's only SAFE to call this routine if data points to
2668  *      sane & valid STANDARD INQUIRY data!
2669  *
2670  *      Allocate and initialize memory for this target.
2671  *      Save inquiry data.
2672  *
2673  */
2674 static void
2675 mptscsih_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget, u8 lun, char *data, int dlen)
2676 {
2677         SpiCfgData      *pSpi;
2678         char            data_56;
2679         int             inq_len;
2680
2681         dinitprintk((MYIOC_s_INFO_FMT "initTarget bus=%d id=%d lun=%d hd=%p\n",
2682                 hd->ioc->name, vtarget->bus_id, vtarget->target_id, lun, hd));
2683
2684         /*
2685          * If the peripheral qualifier filter is enabled then if the target reports a 0x1
2686          * (i.e. The targer is capable of supporting the specified peripheral device type
2687          * on this logical unit; however, the physical device is not currently connected
2688          * to this logical unit) it will be converted to a 0x3 (i.e. The target is not
2689          * capable of supporting a physical device on this logical unit). This is to work
2690          * around a bug in th emid-layer in some distributions in which the mid-layer will
2691          * continue to try to communicate to the LUN and evntually create a dummy LUN.
2692         */
2693         if (hd->mpt_pq_filter && dlen && (data[0] & 0xE0))
2694                 data[0] |= 0x40;
2695
2696         /* Is LUN supported? If so, upper 2 bits will be 0
2697         * in first byte of inquiry data.
2698         */
2699         if (data[0] & 0xe0)
2700                 return;
2701
2702         if (vtarget == NULL)
2703                 return;
2704
2705         if (data)
2706                 vtarget->type = data[0];
2707
2708         if (hd->ioc->bus_type != SPI)
2709                 return;
2710
2711         if ((data[0] == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
2712                 /* Treat all Processors as SAF-TE if
2713                  * command line option is set */
2714                 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
2715                 mptscsih_writeIOCPage4(hd, vtarget->target_id, vtarget->bus_id);
2716         }else if ((data[0] == TYPE_PROCESSOR) &&
2717                 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
2718                 if ( dlen > 49 ) {
2719                         vtarget->tflags |= MPT_TARGET_FLAGS_VALID_INQUIRY;
2720                         if ( data[44] == 'S' &&
2721                              data[45] == 'A' &&
2722                              data[46] == 'F' &&
2723                              data[47] == '-' &&
2724                              data[48] == 'T' &&
2725                              data[49] == 'E' ) {
2726                                 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
2727                                 mptscsih_writeIOCPage4(hd, vtarget->target_id, vtarget->bus_id);
2728                         }
2729                 }
2730         }
2731         if (!(vtarget->tflags & MPT_TARGET_FLAGS_VALID_INQUIRY)) {
2732                 inq_len = dlen < 8 ? dlen : 8;
2733                 memcpy (vtarget->inq_data, data, inq_len);
2734                 /* If have not done DV, set the DV flag.
2735                  */
2736                 pSpi = &hd->ioc->spi_data;
2737                 if ((data[0] == TYPE_TAPE) || (data[0] == TYPE_PROCESSOR)) {
2738                         if (pSpi->dvStatus[vtarget->target_id] & MPT_SCSICFG_DV_NOT_DONE)
2739                                 pSpi->dvStatus[vtarget->target_id] |= MPT_SCSICFG_NEED_DV;
2740                 }
2741                 vtarget->tflags |= MPT_TARGET_FLAGS_VALID_INQUIRY;
2742
2743                 data_56 = 0x0F;  /* Default to full capabilities if Inq data length is < 57 */
2744                 if (dlen > 56) {
2745                         if ( (!(vtarget->tflags & MPT_TARGET_FLAGS_VALID_56))) {
2746                         /* Update the target capabilities
2747                          */
2748                                 data_56 = data[56];
2749                                 vtarget->tflags |= MPT_TARGET_FLAGS_VALID_56;
2750                         }
2751                 }
2752                 mptscsih_setTargetNegoParms(hd, vtarget, data_56);
2753         } else {
2754                 /* Initial Inquiry may not request enough data bytes to
2755                  * obtain byte 57.  DV will; if target doesn't return
2756                  * at least 57 bytes, data[56] will be zero. */
2757                 if (dlen > 56) {
2758                         if ( (!(vtarget->tflags & MPT_TARGET_FLAGS_VALID_56))) {
2759                         /* Update the target capabilities
2760                          */
2761                                 data_56 = data[56];
2762                                 vtarget->tflags |= MPT_TARGET_FLAGS_VALID_56;
2763                                 mptscsih_setTargetNegoParms(hd, vtarget, data_56);
2764                         }
2765                 }
2766         }
2767 }
2768
2769 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2770 /*
2771  *  Update the target negotiation parameters based on the
2772  *  the Inquiry data, adapter capabilities, and NVRAM settings.
2773  *
2774  */
2775 static void
2776 mptscsih_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target, char byte56)
2777 {
2778         SpiCfgData *pspi_data = &hd->ioc->spi_data;
2779         int  id = (int) target->target_id;
2780         int  nvram;
2781         VirtTarget      *vtarget;
2782         int ii;
2783         u8 width = MPT_NARROW;
2784         u8 factor = MPT_ASYNC;
2785         u8 offset = 0;
2786         u8 version, nfactor;
2787         u8 noQas = 1;
2788
2789         target->negoFlags = pspi_data->noQas;
2790
2791         /* noQas == 0 => device supports QAS. Need byte 56 of Inq to determine
2792          * support. If available, default QAS to off and allow enabling.
2793          * If not available, default QAS to on, turn off for non-disks.
2794          */
2795
2796         /* Set flags based on Inquiry data
2797          */
2798         version = target->inq_data[2] & 0x07;
2799         if (version < 2) {
2800                 width = 0;
2801                 factor = MPT_ULTRA2;
2802                 offset = pspi_data->maxSyncOffset;
2803                 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
2804         } else {
2805                 if (target->inq_data[7] & 0x20) {
2806                         width = 1;
2807                 }
2808
2809                 if (target->inq_data[7] & 0x10) {
2810                         factor = pspi_data->minSyncFactor;
2811                         if (target->tflags & MPT_TARGET_FLAGS_VALID_56) {
2812                                 /* bits 2 & 3 show Clocking support */
2813                                 if ((byte56 & 0x0C) == 0)
2814                                         factor = MPT_ULTRA2;
2815                                 else {
2816                                         if ((byte56 & 0x03) == 0)
2817                                                 factor = MPT_ULTRA160;
2818                                         else {
2819                                                 factor = MPT_ULTRA320;
2820                                                 if (byte56 & 0x02)
2821                                                 {
2822                                                         ddvtprintk((KERN_INFO "Enabling QAS due to byte56=%02x on id=%d!\n", byte56, id));
2823                                                         noQas = 0;
2824                                                 }
2825                                                 if (target->inq_data[0] == TYPE_TAPE) {
2826                                                         if (byte56 & 0x01)
2827                                                                 target->negoFlags |= MPT_TAPE_NEGO_IDP;
2828                                                 }
2829                                         }
2830                                 }
2831                         } else {
2832                                 ddvtprintk((KERN_INFO "Enabling QAS on id=%d due to ~TARGET_FLAGS_VALID_56!\n", id));
2833                                 noQas = 0;
2834                         }
2835
2836                         offset = pspi_data->maxSyncOffset;
2837
2838                         /* If RAID, never disable QAS
2839                          * else if non RAID, do not disable
2840                          *   QAS if bit 1 is set
2841                          * bit 1 QAS support, non-raid only
2842                          * bit 0 IU support
2843                          */
2844                         if (target->raidVolume == 1) {
2845                                 noQas = 0;
2846                         }
2847                 } else {
2848                         factor = MPT_ASYNC;
2849                         offset = 0;
2850                 }
2851         }
2852
2853         if ( (target->inq_data[7] & 0x02) == 0) {
2854                 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
2855         }
2856
2857         /* Update tflags based on NVRAM settings. (SCSI only)
2858          */
2859         if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
2860                 nvram = pspi_data->nvram[id];
2861                 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
2862
2863                 if (width)
2864                         width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
2865
2866                 if (offset > 0) {
2867                         /* Ensure factor is set to the
2868                          * maximum of: adapter, nvram, inquiry
2869                          */
2870                         if (nfactor) {
2871                                 if (nfactor < pspi_data->minSyncFactor )
2872                                         nfactor = pspi_data->minSyncFactor;
2873
2874                                 factor = max(factor, nfactor);
2875                                 if (factor == MPT_ASYNC)
2876                                         offset = 0;
2877                         } else {
2878                                 offset = 0;
2879                                 factor = MPT_ASYNC;
2880                 }
2881                 } else {
2882                         factor = MPT_ASYNC;
2883                 }
2884         }
2885
2886         /* Make sure data is consistent
2887          */
2888         if ((!width) && (factor < MPT_ULTRA2)) {
2889                 factor = MPT_ULTRA2;
2890         }
2891
2892         /* Save the data to the target structure.
2893          */
2894         target->minSyncFactor = factor;
2895         target->maxOffset = offset;
2896         target->maxWidth = width;
2897
2898         target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
2899
2900         /* Disable unused features.
2901          */
2902         if (!width)
2903                 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
2904
2905         if (!offset)
2906                 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
2907
2908         if ( factor > MPT_ULTRA320 )
2909                 noQas = 0;
2910
2911         /* GEM, processor WORKAROUND
2912          */
2913         if ((target->inq_data[0] == TYPE_PROCESSOR) || (target->inq_data[0] > 0x08)) {
2914                 target->negoFlags |= (MPT_TARGET_NO_NEGO_WIDE | MPT_TARGET_NO_NEGO_SYNC);
2915                 pspi_data->dvStatus[id] |= MPT_SCSICFG_BLK_NEGO;
2916         } else {
2917                 if (noQas && (pspi_data->noQas == 0)) {
2918                         pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
2919                         target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
2920
2921                         /* Disable QAS in a mixed configuration case
2922                         */
2923
2924                         ddvtprintk((KERN_INFO "Disabling QAS due to noQas=%02x on id=%d!\n", noQas, id));
2925                         for (ii = 0; ii < id; ii++) {
2926                                 if ( (vtarget = hd->Targets[ii]) ) {
2927                                         vtarget->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
2928                                         mptscsih_writeSDP1(hd, 0, ii, vtarget->negoFlags);
2929                                 }
2930                         }
2931                 }
2932         }
2933
2934         /* Write SDP1 on this I/O to this target */
2935         if (pspi_data->dvStatus[id] & MPT_SCSICFG_NEGOTIATE) {
2936                 ddvtprintk((KERN_INFO "MPT_SCSICFG_NEGOTIATE on id=%d!\n", id));
2937                 mptscsih_writeSDP1(hd, 0, id, hd->negoNvram);
2938                 pspi_data->dvStatus[id] &= ~MPT_SCSICFG_NEGOTIATE;
2939         } else if (pspi_data->dvStatus[id] & MPT_SCSICFG_BLK_NEGO) {
2940                 ddvtprintk((KERN_INFO "MPT_SCSICFG_BLK_NEGO on id=%d!\n", id));
2941                 mptscsih_writeSDP1(hd, 0, id, MPT_SCSICFG_BLK_NEGO);
2942                 pspi_data->dvStatus[id] &= ~MPT_SCSICFG_BLK_NEGO;
2943         }
2944 }
2945
2946 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2947 /*
2948  * If no Target, bus reset on 1st I/O. Set the flag to
2949  * prevent any future negotiations to this device.
2950  */
2951 static void
2952 mptscsih_no_negotiate(MPT_SCSI_HOST *hd, struct scsi_cmnd *sc)
2953 {
2954         VirtDevice      *vdev;
2955
2956         if ((vdev = sc->device->hostdata) != NULL)
2957                 hd->ioc->spi_data.dvStatus[vdev->target_id] |= MPT_SCSICFG_BLK_NEGO;
2958         return;
2959 }
2960
2961 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2962 /*
2963  *  SCSI Config Page functionality ...
2964  */
2965 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2966 /*      mptscsih_setDevicePage1Flags  - add Requested and Configuration fields flags
2967  *      based on width, factor and offset parameters.
2968  *      @width: bus width
2969  *      @factor: sync factor
2970  *      @offset: sync offset
2971  *      @requestedPtr: pointer to requested values (updated)
2972  *      @configurationPtr: pointer to configuration values (updated)
2973  *      @flags: flags to block WDTR or SDTR negotiation
2974  *
2975  *      Return: None.
2976  *
2977  *      Remark: Called by writeSDP1 and _dv_params
2978  */
2979 static void
2980 mptscsih_setDevicePage1Flags (u8 width, u8 factor, u8 offset, int *requestedPtr, int *configurationPtr, u8 flags)
2981 {
2982         u8 nowide = flags & MPT_TARGET_NO_NEGO_WIDE;
2983         u8 nosync = flags & MPT_TARGET_NO_NEGO_SYNC;
2984
2985         *configurationPtr = 0;
2986         *requestedPtr = width ? MPI_SCSIDEVPAGE1_RP_WIDE : 0;
2987         *requestedPtr |= (offset << 16) | (factor << 8);
2988
2989         if (width && offset && !nowide && !nosync) {
2990                 if (factor < MPT_ULTRA160) {
2991                         *requestedPtr |= (MPI_SCSIDEVPAGE1_RP_IU + MPI_SCSIDEVPAGE1_RP_DT);
2992                         if ((flags & MPT_TARGET_NO_NEGO_QAS) == 0)
2993                                 *requestedPtr |= MPI_SCSIDEVPAGE1_RP_QAS;
2994                         if (flags & MPT_TAPE_NEGO_IDP)
2995                                 *requestedPtr |= 0x08000000;
2996                 } else if (factor < MPT_ULTRA2) {
2997                         *requestedPtr |= MPI_SCSIDEVPAGE1_RP_DT;
2998                 }
2999         }
3000
3001         if (nowide)
3002                 *configurationPtr |= MPI_SCSIDEVPAGE1_CONF_WDTR_DISALLOWED;
3003
3004         if (nosync)
3005                 *configurationPtr |= MPI_SCSIDEVPAGE1_CONF_SDTR_DISALLOWED;
3006
3007         return;
3008 }
3009
3010 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3011 /*      mptscsih_writeSDP1  - write SCSI Device Page 1
3012  *      @hd: Pointer to a SCSI Host Strucutre
3013  *      @portnum: IOC port number
3014  *      @target_id: writeSDP1 for single ID
3015  *      @flags: MPT_SCSICFG_ALL_IDS, MPT_SCSICFG_USE_NVRAM, MPT_SCSICFG_BLK_NEGO
3016  *
3017  *      Return: -EFAULT if read of config page header fails
3018  *              or 0 if success.
3019  *
3020  *      Remark: If a target has been found, the settings from the
3021  *              target structure are used, else the device is set
3022  *              to async/narrow.
3023  *
3024  *      Remark: Called during init and after a FW reload.
3025  *      Remark: We do not wait for a return, write pages sequentially.
3026  */
3027 static int
3028 mptscsih_writeSDP1(MPT_SCSI_HOST *hd, int portnum, int target_id, int flags)
3029 {
3030         MPT_ADAPTER             *ioc = hd->ioc;
3031         Config_t                *pReq;
3032         SCSIDevicePage1_t       *pData;
3033         VirtTarget              *vtarget=NULL;
3034         MPT_FRAME_HDR           *mf;
3035         dma_addr_t               dataDma;
3036         u16                      req_idx;
3037         u32                      frameOffset;
3038         u32                      requested, configuration, flagsLength;
3039         int                      ii, nvram;
3040         int                      id = 0, maxid = 0;
3041         u8                       width;
3042         u8                       factor;
3043         u8                       offset;
3044         u8                       bus = 0;
3045         u8                       negoFlags;
3046         u8                       maxwidth, maxoffset, maxfactor;
3047
3048         if (ioc->spi_data.sdp1length == 0)
3049                 return 0;
3050
3051         if (flags & MPT_SCSICFG_ALL_IDS) {
3052                 id = 0;
3053                 maxid = ioc->sh->max_id - 1;
3054         } else if (ioc->sh) {
3055                 id = target_id;
3056                 maxid = min_t(int, id, ioc->sh->max_id - 1);
3057         }
3058
3059         for (; id <= maxid; id++) {
3060
3061                 if (id == ioc->pfacts[portnum].PortSCSIID)
3062                         continue;
3063
3064                 /* Use NVRAM to get adapter and target maximums
3065                  * Data over-riden by target structure information, if present
3066                  */
3067                 maxwidth = ioc->spi_data.maxBusWidth;
3068                 maxoffset = ioc->spi_data.maxSyncOffset;
3069                 maxfactor = ioc->spi_data.minSyncFactor;
3070                 if (ioc->spi_data.nvram && (ioc->spi_data.nvram[id] != MPT_HOST_NVRAM_INVALID)) {
3071                         nvram = ioc->spi_data.nvram[id];
3072
3073                         if (maxwidth)
3074                                 maxwidth = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
3075
3076                         if (maxoffset > 0) {
3077                                 maxfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
3078                                 if (maxfactor == 0) {
3079                                         /* Key for async */
3080                                         maxfactor = MPT_ASYNC;
3081                                         maxoffset = 0;
3082                                 } else if (maxfactor < ioc->spi_data.minSyncFactor) {
3083                                         maxfactor = ioc->spi_data.minSyncFactor;
3084                                 }
3085                         } else
3086                                 maxfactor = MPT_ASYNC;
3087                 }
3088
3089                 /* Set the negotiation flags.
3090                  */
3091                 negoFlags = ioc->spi_data.noQas;
3092                 if (!maxwidth)
3093                         negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
3094
3095                 if (!maxoffset)
3096                         negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
3097
3098                 if (flags & MPT_SCSICFG_USE_NVRAM) {
3099                         width = maxwidth;
3100                         factor = maxfactor;
3101                         offset = maxoffset;
3102                 } else {
3103                         width = 0;
3104                         factor = MPT_ASYNC;
3105                         offset = 0;
3106                         //negoFlags = 0;
3107                         //negoFlags = MPT_TARGET_NO_NEGO_SYNC;
3108                 }
3109
3110                 /* If id is not a raid volume, get the updated
3111                  * transmission settings from the target structure.
3112                  */
3113                 if (hd->Targets && (vtarget = hd->Targets[id]) && !vtarget->raidVolume) {
3114                         width = vtarget->maxWidth;
3115                         factor = vtarget->minSyncFactor;
3116                         offset = vtarget->maxOffset;
3117                         negoFlags = vtarget->negoFlags;
3118                 }
3119
3120 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION
3121                 /* Force to async and narrow if DV has not been executed
3122                  * for this ID
3123                  */
3124                 if ((hd->ioc->spi_data.dvStatus[id] & MPT_SCSICFG_DV_NOT_DONE) != 0) {
3125                         width = 0;
3126                         factor = MPT_ASYNC;
3127                         offset = 0;
3128                 }
3129 #endif
3130
3131                 if (flags & MPT_SCSICFG_BLK_NEGO)
3132                         negoFlags |= MPT_TARGET_NO_NEGO_WIDE | MPT_TARGET_NO_NEGO_SYNC;
3133
3134                 mptscsih_setDevicePage1Flags(width, factor, offset,
3135                                         &requested, &configuration, negoFlags);
3136                 dnegoprintk(("writeSDP1: id=%d width=%d factor=%x offset=%x negoFlags=%x request=%x config=%x\n",
3137                         target_id, width, factor, offset, negoFlags, requested, configuration));
3138
3139                 /* Get a MF for this command.
3140                  */
3141                 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
3142                         dfailprintk((MYIOC_s_WARN_FMT "write SDP1: no msg frames!\n",
3143                                 ioc->name));
3144                         return -EAGAIN;
3145                 }
3146
3147                 ddvprintk((MYIOC_s_INFO_FMT "WriteSDP1 (mf=%p, id=%d, req=0x%x, cfg=0x%x)\n",
3148                         hd->ioc->name, mf, id, requested, configuration));
3149
3150
3151                 /* Set the request and the data pointers.
3152                  * Request takes: 36 bytes (32 bit SGE)
3153                  * SCSI Device Page 1 requires 16 bytes
3154                  * 40 + 16 <= size of SCSI IO Request = 56 bytes
3155                  * and MF size >= 64 bytes.
3156                  * Place data at end of MF.
3157                  */
3158                 pReq = (Config_t *)mf;
3159
3160                 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
3161                 frameOffset = ioc->req_sz - sizeof(SCSIDevicePage1_t);
3162
3163                 pData = (SCSIDevicePage1_t *)((u8 *) mf + frameOffset);
3164                 dataDma = ioc->req_frames_dma + (req_idx * ioc->req_sz) + frameOffset;
3165
3166                 /* Complete the request frame (same for all requests).
3167                  */
3168                 pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
3169                 pReq->Reserved = 0;
3170                 pReq->ChainOffset = 0;
3171                 pReq->Function = MPI_FUNCTION_CONFIG;
3172                 pReq->ExtPageLength = 0;
3173                 pReq->ExtPageType = 0;
3174                 pReq->MsgFlags = 0;
3175                 for (ii=0; ii < 8; ii++) {
3176                         pReq->Reserved2[ii] = 0;
3177                 }
3178                 pReq->Header.PageVersion = ioc->spi_data.sdp1version;
3179                 pReq->Header.PageLength = ioc->spi_data.sdp1length;
3180                 pReq->Header.PageNumber = 1;
3181                 pReq->Header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
3182                 pReq->PageAddress = cpu_to_le32(id | (bus << 8 ));
3183
3184                 /* Add a SGE to the config request.
3185                  */
3186                 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE | ioc->spi_data.sdp1length * 4;
3187
3188                 mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
3189
3190                 /* Set up the common data portion
3191                  */
3192                 pData->Header.PageVersion = pReq->Header.PageVersion;
3193                 pData->Header.PageLength = pReq->Header.PageLength;
3194                 pData->Header.PageNumber = pReq->Header.PageNumber;
3195                 pData->Header.PageType = pReq->Header.PageType;
3196                 pData->RequestedParameters = cpu_to_le32(requested);
3197                 pData->Reserved = 0;
3198                 pData->Configuration = cpu_to_le32(configuration);
3199
3200                 dprintk((MYIOC_s_INFO_FMT
3201                         "write SDP1: id %d pgaddr 0x%x req 0x%x config 0x%x\n",
3202                                 ioc->name, id, (id | (bus<<8)),
3203                                 requested, configuration));
3204
3205                 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
3206         }
3207
3208         return 0;
3209 }
3210
3211 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3212 /*      mptscsih_writeIOCPage4  - write IOC Page 4
3213  *      @hd: Pointer to a SCSI Host Structure
3214  *      @target_id: write IOC Page4 for this ID & Bus
3215  *
3216  *      Return: -EAGAIN if unable to obtain a Message Frame
3217  *              or 0 if success.
3218  *
3219  *      Remark: We do not wait for a return, write pages sequentially.
3220  */
3221 static int
3222 mptscsih_writeIOCPage4(MPT_SCSI_HOST *hd, int target_id, int bus)
3223 {
3224         MPT_ADAPTER             *ioc = hd->ioc;
3225         Config_t                *pReq;
3226         IOCPage4_t              *IOCPage4Ptr;
3227         MPT_FRAME_HDR           *mf;
3228         dma_addr_t               dataDma;
3229         u16                      req_idx;
3230         u32                      frameOffset;
3231         u32                      flagsLength;
3232         int                      ii;
3233
3234         /* Get a MF for this command.
3235          */
3236         if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
3237                 dfailprintk((MYIOC_s_WARN_FMT "writeIOCPage4 : no msg frames!\n",
3238                                         ioc->name));
3239                 return -EAGAIN;
3240         }
3241
3242         /* Set the request and the data pointers.
3243          * Place data at end of MF.
3244          */
3245         pReq = (Config_t *)mf;
3246
3247         req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
3248         frameOffset = ioc->req_sz - sizeof(IOCPage4_t);
3249
3250         /* Complete the request frame (same for all requests).
3251          */
3252         pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
3253         pReq->Reserved = 0;
3254         pReq->ChainOffset = 0;
3255         pReq->Function = MPI_FUNCTION_CONFIG;
3256         pReq->ExtPageLength = 0;
3257         pReq->ExtPageType = 0;
3258         pReq->MsgFlags = 0;
3259         for (ii=0; ii < 8; ii++) {
3260                 pReq->Reserved2[ii] = 0;
3261         }
3262
3263         IOCPage4Ptr = ioc->spi_data.pIocPg4;
3264         dataDma = ioc->spi_data.IocPg4_dma;
3265         ii = IOCPage4Ptr->ActiveSEP++;
3266         IOCPage4Ptr->SEP[ii].SEPTargetID = target_id;
3267         IOCPage4Ptr->SEP[ii].SEPBus = bus;
3268         pReq->Header = IOCPage4Ptr->Header;
3269         pReq->PageAddress = cpu_to_le32(target_id | (bus << 8 ));
3270
3271         /* Add a SGE to the config request.
3272          */
3273         flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
3274                 (IOCPage4Ptr->Header.PageLength + ii) * 4;
3275
3276         mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
3277
3278         dinitprintk((MYIOC_s_INFO_FMT
3279                 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
3280                         ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, target_id, bus));
3281
3282         mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
3283
3284         return 0;
3285 }
3286
3287 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3288 /*
3289  *  Bus Scan and Domain Validation functionality ...
3290  */
3291
3292 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3293 /*
3294  *      mptscsih_scandv_complete - Scan and DV callback routine registered
3295  *      to Fustion MPT (base) driver.
3296  *
3297  *      @ioc: Pointer to MPT_ADAPTER structure
3298  *      @mf: Pointer to original MPT request frame
3299  *      @mr: Pointer to MPT reply frame (NULL if TurboReply)
3300  *
3301  *      This routine is called from mpt.c::mpt_interrupt() at the completion
3302  *      of any SCSI IO request.
3303  *      This routine is registered with the Fusion MPT (base) driver at driver
3304  *      load/init time via the mpt_register() API call.
3305  *
3306  *      Returns 1 indicating alloc'd request frame ptr should be freed.
3307  *
3308  *      Remark: Sets a completion code and (possibly) saves sense data
3309  *      in the IOC member localReply structure.
3310  *      Used ONLY for DV and other internal commands.
3311  */
3312 int
3313 mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
3314 {
3315         MPT_SCSI_HOST   *hd;
3316         SCSIIORequest_t *pReq;
3317         int              completionCode;
3318         u16              req_idx;
3319
3320         hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
3321
3322         if ((mf == NULL) ||
3323             (mf >= MPT_INDEX_2_MFPTR(ioc, ioc->req_depth))) {
3324                 printk(MYIOC_s_ERR_FMT
3325                         "ScanDvComplete, %s req frame ptr! (=%p)\n",
3326                                 ioc->name, mf?"BAD":"NULL", (void *) mf);
3327                 goto wakeup;
3328         }
3329
3330         del_timer(&hd->timer);
3331         req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
3332         hd->ScsiLookup[req_idx] = NULL;
3333         pReq = (SCSIIORequest_t *) mf;
3334
3335         if (mf != hd->cmdPtr) {
3336                 printk(MYIOC_s_WARN_FMT "ScanDvComplete (mf=%p, cmdPtr=%p, idx=%d)\n",
3337                                 hd->ioc->name, (void *)mf, (void *) hd->cmdPtr, req_idx);
3338         }
3339         hd->cmdPtr = NULL;
3340
3341         ddvprintk((MYIOC_s_INFO_FMT "ScanDvComplete (mf=%p,mr=%p,idx=%d)\n",
3342                         hd->ioc->name, mf, mr, req_idx));
3343
3344         hd->pLocal = &hd->localReply;
3345         hd->pLocal->scsiStatus = 0;
3346
3347         /* If target struct exists, clear sense valid flag.
3348          */
3349         if (mr == NULL) {
3350                 completionCode = MPT_SCANDV_GOOD;
3351         } else {
3352                 SCSIIOReply_t   *pReply;
3353                 u16              status;
3354                 u8               scsi_status;
3355
3356                 pReply = (SCSIIOReply_t *) mr;
3357
3358                 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
3359                 scsi_status = pReply->SCSIStatus;
3360
3361                 ddvtprintk((KERN_NOTICE "  IOCStatus=%04xh, SCSIState=%02xh, SCSIStatus=%02xh, IOCLogInfo=%08xh\n",
3362                              status, pReply->SCSIState, scsi_status,
3363                              le32_to_cpu(pReply->IOCLogInfo)));
3364
3365                 switch(status) {
3366
3367                 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE:       /* 0x0043 */
3368                         completionCode = MPT_SCANDV_SELECTION_TIMEOUT;
3369                         break;
3370
3371                 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR:          /* 0x0046 */
3372                 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED:        /* 0x0048 */
3373                 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED:         /* 0x004B */
3374                 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED:         /* 0x004C */
3375                         completionCode = MPT_SCANDV_DID_RESET;
3376                         break;
3377
3378                 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN:          /* 0x0045 */
3379                 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR:        /* 0x0040 */
3380                 case MPI_IOCSTATUS_SUCCESS:                     /* 0x0000 */
3381                         if (pReply->Function == MPI_FUNCTION_CONFIG) {
3382                                 ConfigReply_t *pr = (ConfigReply_t *)mr;
3383                                 completionCode = MPT_SCANDV_GOOD;
3384                                 hd->pLocal->header.PageVersion = pr->Header.PageVersion;
3385                                 hd->pLocal->header.PageLength = pr->Header.PageLength;
3386                                 hd->pLocal->header.PageNumber = pr->Header.PageNumber;
3387                                 hd->pLocal->header.PageType = pr->Header.PageType;
3388
3389                         } else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) {
3390                                 /* If the RAID Volume request is successful,
3391                                  * return GOOD, else indicate that
3392                                  * some type of error occurred.
3393                                  */
3394                                 MpiRaidActionReply_t    *pr = (MpiRaidActionReply_t *)mr;
3395                                 if (le16_to_cpu(pr->ActionStatus) == MPI_RAID_ACTION_ASTATUS_SUCCESS)
3396                                         completionCode = MPT_SCANDV_GOOD;
3397                                 else
3398                                         completionCode = MPT_SCANDV_SOME_ERROR;
3399
3400                         } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID) {
3401                                 u8              *sense_data;
3402                                 int              sz;
3403
3404                                 /* save sense data in global structure
3405                                  */
3406                                 completionCode = MPT_SCANDV_SENSE;
3407                                 hd->pLocal->scsiStatus = scsi_status;
3408                                 sense_data = ((u8 *)hd->ioc->sense_buf_pool +
3409                                         (req_idx * MPT_SENSE_BUFFER_ALLOC));
3410
3411                                 sz = min_t(int, pReq->SenseBufferLength,
3412                                                         SCSI_STD_SENSE_BYTES);
3413                                 memcpy(hd->pLocal->sense, sense_data, sz);
3414
3415                                 ddvprintk((KERN_NOTICE "  Check Condition, sense ptr %p\n",
3416                                                 sense_data));
3417                         } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) {
3418                                 if (pReq->CDB[0] == INQUIRY)
3419                                         completionCode = MPT_SCANDV_ISSUE_SENSE;
3420                                 else
3421                                         completionCode = MPT_SCANDV_DID_RESET;
3422                         }
3423                         else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS)
3424                                 completionCode = MPT_SCANDV_DID_RESET;
3425                         else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
3426                                 completionCode = MPT_SCANDV_DID_RESET;
3427                         else {
3428                                 completionCode = MPT_SCANDV_GOOD;
3429                                 hd->pLocal->scsiStatus = scsi_status;
3430                         }
3431                         break;
3432
3433                 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR:         /* 0x0047 */
3434                         if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
3435                                 completionCode = MPT_SCANDV_DID_RESET;
3436                         else
3437                                 completionCode = MPT_SCANDV_SOME_ERROR;
3438                         break;
3439
3440                 default:
3441                         completionCode = MPT_SCANDV_SOME_ERROR;
3442                         break;
3443
3444                 }       /* switch(status) */
3445
3446                 ddvtprintk((KERN_NOTICE "  completionCode set to %08xh\n",
3447                                 completionCode));
3448         } /* end of address reply case */
3449
3450         hd->pLocal->completion = completionCode;
3451
3452         /* MF and RF are freed in mpt_interrupt
3453          */
3454 wakeup:
3455         /* Free Chain buffers (will never chain) in scan or dv */
3456         //mptscsih_freeChainBuffers(ioc, req_idx);
3457
3458         /*
3459          * Wake up the original calling thread
3460          */
3461         hd->scandv_wait_done = 1;
3462         wake_up(&hd->scandv_waitq);
3463
3464         return 1;
3465 }
3466
3467 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3468 /*      mptscsih_timer_expired - Call back for timer process.
3469  *      Used only for dv functionality.
3470  *      @data: Pointer to MPT_SCSI_HOST recast as an unsigned long
3471  *
3472  */
3473 void
3474 mptscsih_timer_expired(unsigned long data)
3475 {
3476         MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) data;
3477
3478         ddvprintk((MYIOC_s_WARN_FMT "Timer Expired! Cmd %p\n", hd->ioc->name, hd->cmdPtr));
3479
3480         if (hd->cmdPtr) {
3481                 MPIHeader_t *cmd = (MPIHeader_t *)hd->cmdPtr;
3482
3483                 if (cmd->Function == MPI_FUNCTION_SCSI_IO_REQUEST) {
3484                         /* Desire to issue a task management request here.
3485                          * TM requests MUST be single threaded.
3486                          * If old eh code and no TM current, issue request.
3487                          * If new eh code, do nothing. Wait for OS cmd timeout
3488                          *      for bus reset.
3489                          */
3490                         ddvtprintk((MYIOC_s_NOTE_FMT "DV Cmd Timeout: NoOp\n", hd->ioc->name));
3491                 } else {
3492                         /* Perform a FW reload */
3493                         if (mpt_HardResetHandler(hd->ioc, NO_SLEEP) < 0) {
3494                                 printk(MYIOC_s_WARN_FMT "Firmware Reload FAILED!\n", hd->ioc->name);
3495                         }
3496                 }
3497         } else {
3498                 /* This should NEVER happen */
3499                 printk(MYIOC_s_WARN_FMT "Null cmdPtr!!!!\n", hd->ioc->name);
3500         }
3501
3502         /* No more processing.
3503          * TM call will generate an interrupt for SCSI TM Management.
3504          * The FW will reply to all outstanding commands, callback will finish cleanup.
3505          * Hard reset clean-up will free all resources.
3506          */
3507         ddvprintk((MYIOC_s_WARN_FMT "Timer Expired Complete!\n", hd->ioc->name));
3508
3509         return;
3510 }
3511
3512 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION
3513 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3514 /*      mptscsih_do_raid - Format and Issue a RAID volume request message.
3515  *      @hd: Pointer to scsi host structure
3516  *      @action: What do be done.
3517  *      @id: Logical target id.
3518  *      @bus: Target locations bus.
3519  *
3520  *      Returns: < 0 on a fatal error
3521  *              0 on success
3522  *
3523  *      Remark: Wait to return until reply processed by the ISR.
3524  */
3525 static int
3526 mptscsih_do_raid(MPT_SCSI_HOST *hd, u8 action, INTERNAL_CMD *io)
3527 {
3528         MpiRaidActionRequest_t  *pReq;
3529         MPT_FRAME_HDR           *mf;
3530         int                     in_isr;
3531
3532         in_isr = in_interrupt();
3533         if (in_isr) {
3534                 dprintk((MYIOC_s_WARN_FMT "Internal raid request not allowed in ISR context!\n",
3535                                 hd->ioc->name));
3536                 return -EPERM;
3537         }
3538
3539         /* Get and Populate a free Frame
3540          */
3541         if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
3542                 ddvprintk((MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
3543                                         hd->ioc->name));
3544                 return -EAGAIN;
3545         }
3546         pReq = (MpiRaidActionRequest_t *)mf;
3547         pReq->Action = action;
3548         pReq->Reserved1 = 0;
3549         pReq->ChainOffset = 0;
3550         pReq->Function = MPI_FUNCTION_RAID_ACTION;
3551         pReq->VolumeID = io->id;
3552         pReq->VolumeBus = io->bus;
3553         pReq->PhysDiskNum = io->physDiskNum;
3554         pReq->MsgFlags = 0;
3555         pReq->Reserved2 = 0;
3556         pReq->ActionDataWord = 0; /* Reserved for this action */
3557         //pReq->ActionDataSGE = 0;
3558
3559         mpt_add_sge((char *)&pReq->ActionDataSGE,
3560                 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
3561
3562         ddvprintk((MYIOC_s_INFO_FMT "RAID Volume action %x id %d\n",
3563                         hd->ioc->name, action, io->id));
3564
3565         hd->pLocal = NULL;
3566         hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
3567         hd->scandv_wait_done = 0;
3568
3569         /* Save cmd pointer, for resource free if timeout or
3570          * FW reload occurs
3571          */
3572         hd->cmdPtr = mf;
3573
3574         add_timer(&hd->timer);
3575         mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
3576         wait_event(hd->scandv_waitq, hd->scandv_wait_done);
3577
3578         if ((hd->pLocal == NULL) || (hd->pLocal->completion != MPT_SCANDV_GOOD))
3579                 return -1;
3580
3581         return 0;
3582 }
3583 #endif /* ~MPTSCSIH_ENABLE_DOMAIN_VALIDATION */
3584
3585 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3586 /**
3587  *      mptscsih_do_cmd - Do internal command.
3588  *      @hd: MPT_SCSI_HOST pointer
3589  *      @io: INTERNAL_CMD pointer.
3590  *
3591  *      Issue the specified internally generated command and do command
3592  *      specific cleanup. For bus scan / DV only.
3593  *      NOTES: If command is Inquiry and status is good,
3594  *      initialize a target structure, save the data
3595  *
3596  *      Remark: Single threaded access only.
3597  *
3598  *      Return:
3599  *              < 0 if an illegal command or no resources
3600  *
3601  *                 0 if good
3602  *
3603  *               > 0 if command complete but some type of completion error.
3604  */
3605 static int
3606 mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io)
3607 {
3608         MPT_FRAME_HDR   *mf;
3609         SCSIIORequest_t *pScsiReq;
3610         SCSIIORequest_t  ReqCopy;
3611         int              my_idx, ii, dir;
3612         int              rc, cmdTimeout;
3613         int             in_isr;
3614         char             cmdLen;
3615         char             CDB[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
3616         char             cmd = io->cmd;
3617
3618         in_isr = in_interrupt();
3619         if (in_isr) {
3620                 dprintk((MYIOC_s_WARN_FMT "Internal SCSI IO request not allowed in ISR context!\n",
3621                                 hd->ioc->name));
3622                 return -EPERM;
3623         }
3624
3625
3626         /* Set command specific information
3627          */
3628         switch (cmd) {
3629         case INQUIRY:
3630                 cmdLen = 6;
3631                 dir = MPI_SCSIIO_CONTROL_READ;
3632                 CDB[0] = cmd;
3633                 CDB[4] = io->size;
3634                 cmdTimeout = 10;
3635                 break;
3636
3637         case TEST_UNIT_READY:
3638                 cmdLen = 6;
3639                 dir = MPI_SCSIIO_CONTROL_READ;
3640                 cmdTimeout = 10;
3641                 break;
3642
3643         case START_STOP:
3644                 cmdLen = 6;
3645                 dir = MPI_SCSIIO_CONTROL_READ;
3646                 CDB[0] = cmd;
3647                 CDB[4] = 1;     /*Spin up the disk */
3648                 cmdTimeout = 15;
3649                 break;
3650
3651         case REQUEST_SENSE:
3652                 cmdLen = 6;
3653                 CDB[0] = cmd;
3654                 CDB[4] = io->size;
3655                 dir = MPI_SCSIIO_CONTROL_READ;
3656                 cmdTimeout = 10;
3657                 break;
3658
3659         case READ_BUFFER:
3660                 cmdLen = 10;
3661                 dir = MPI_SCSIIO_CONTROL_READ;
3662                 CDB[0] = cmd;
3663                 if (io->flags & MPT_ICFLAG_ECHO) {
3664                         CDB[1] = 0x0A;
3665                 } else {
3666                         CDB[1] = 0x02;
3667                 }
3668
3669                 if (io->flags & MPT_ICFLAG_BUF_CAP) {
3670                         CDB[1] |= 0x01;
3671                 }
3672                 CDB[6] = (io->size >> 16) & 0xFF;
3673                 CDB[7] = (io->size >>  8) & 0xFF;
3674                 CDB[8] = io->size & 0xFF;
3675                 cmdTimeout = 10;
3676                 break;
3677
3678         case WRITE_BUFFER:
3679                 cmdLen = 10;
3680                 dir = MPI_SCSIIO_CONTROL_WRITE;
3681                 CDB[0] = cmd;
3682                 if (io->flags & MPT_ICFLAG_ECHO) {
3683                         CDB[1] = 0x0A;
3684                 } else {
3685                         CDB[1] = 0x02;
3686                 }
3687                 CDB[6] = (io->size >> 16) & 0xFF;
3688                 CDB[7] = (io->size >>  8) & 0xFF;
3689                 CDB[8] = io->size & 0xFF;
3690                 cmdTimeout = 10;
3691                 break;
3692
3693         case RESERVE:
3694                 cmdLen = 6;
3695                 dir = MPI_SCSIIO_CONTROL_READ;
3696                 CDB[0] = cmd;
3697                 cmdTimeout = 10;
3698                 break;
3699
3700         case RELEASE:
3701                 cmdLen = 6;
3702                 dir = MPI_SCSIIO_CONTROL_READ;
3703                 CDB[0] = cmd;
3704                 cmdTimeout = 10;
3705                 break;
3706
3707         case SYNCHRONIZE_CACHE:
3708                 cmdLen = 10;
3709                 dir = MPI_SCSIIO_CONTROL_READ;
3710                 CDB[0] = cmd;
3711 //              CDB[1] = 0x02;  /* set immediate bit */
3712                 cmdTimeout = 10;
3713                 break;
3714
3715         default:
3716                 /* Error Case */
3717                 return -EFAULT;
3718         }
3719
3720         /* Get and Populate a free Frame
3721          */
3722         if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
3723                 ddvprintk((MYIOC_s_WARN_FMT "No msg frames!\n",
3724                                         hd->ioc->name));
3725                 return -EBUSY;
3726         }
3727
3728         pScsiReq = (SCSIIORequest_t *) mf;
3729
3730         /* Get the request index */
3731         my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
3732         ADD_INDEX_LOG(my_idx); /* for debug */
3733
3734         if (io->flags & MPT_ICFLAG_PHYS_DISK) {
3735                 pScsiReq->TargetID = io->physDiskNum;
3736                 pScsiReq->Bus = 0;
3737                 pScsiReq->ChainOffset = 0;
3738                 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
3739         } else {
3740                 pScsiReq->TargetID = io->id;
3741                 pScsiReq->Bus = io->bus;
3742                 pScsiReq->ChainOffset = 0;
3743                 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
3744         }
3745
3746         pScsiReq->CDBLength = cmdLen;
3747         pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
3748
3749         pScsiReq->Reserved = 0;
3750
3751         pScsiReq->MsgFlags = mpt_msg_flags();
3752         /* MsgContext set in mpt_get_msg_fram call  */
3753
3754         for (ii=0; ii < 8; ii++)
3755                 pScsiReq->LUN[ii] = 0;
3756         pScsiReq->LUN[1] = io->lun;
3757
3758         if (io->flags & MPT_ICFLAG_TAGGED_CMD)
3759                 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_SIMPLEQ);
3760         else
3761                 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
3762
3763         if (cmd == REQUEST_SENSE) {
3764                 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
3765                 ddvprintk((MYIOC_s_INFO_FMT "Untagged! 0x%2x\n",
3766                         hd->ioc->name, cmd));
3767         }
3768
3769         for (ii=0; ii < 16; ii++)
3770                 pScsiReq->CDB[ii] = CDB[ii];
3771
3772         pScsiReq->DataLength = cpu_to_le32(io->size);
3773         pScsiReq->SenseBufferLowAddr = cpu_to_le32(hd->ioc->sense_buf_low_dma
3774                                            + (my_idx * MPT_SENSE_BUFFER_ALLOC));
3775
3776         ddvprintk((MYIOC_s_INFO_FMT "Sending Command 0x%x for (%d:%d:%d)\n",
3777                         hd->ioc->name, cmd, io->bus, io->id, io->lun));
3778
3779         if (dir == MPI_SCSIIO_CONTROL_READ) {
3780                 mpt_add_sge((char *) &pScsiReq->SGL,
3781                         MPT_SGE_FLAGS_SSIMPLE_READ | io->size,
3782                         io->data_dma);
3783         } else {
3784                 mpt_add_sge((char *) &pScsiReq->SGL,
3785                         MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size,
3786                         io->data_dma);
3787         }
3788
3789         /* The ISR will free the request frame, but we need
3790          * the information to initialize the target. Duplicate.
3791          */
3792         memcpy(&ReqCopy, pScsiReq, sizeof(SCSIIORequest_t));
3793
3794         /* Issue this command after:
3795          *      finish init
3796          *      add timer
3797          * Wait until the reply has been received
3798          *  ScsiScanDvCtx callback function will
3799          *      set hd->pLocal;
3800          *      set scandv_wait_done and call wake_up
3801          */
3802         hd->pLocal = NULL;
3803         hd->timer.expires = jiffies + HZ*cmdTimeout;
3804         hd->scandv_wait_done = 0;
3805
3806         /* Save cmd pointer, for resource free if timeout or
3807          * FW reload occurs
3808          */
3809         hd->cmdPtr = mf;
3810
3811         add_timer(&hd->timer);
3812         mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
3813         wait_event(hd->scandv_waitq, hd->scandv_wait_done);
3814
3815         if (hd->pLocal) {
3816                 rc = hd->pLocal->completion;
3817                 hd->pLocal->skip = 0;
3818
3819                 /* Always set fatal error codes in some cases.
3820                  */
3821                 if (rc == MPT_SCANDV_SELECTION_TIMEOUT)
3822                         rc = -ENXIO;
3823                 else if (rc == MPT_SCANDV_SOME_ERROR)
3824                         rc =  -rc;
3825         } else {
3826                 rc = -EFAULT;
3827                 /* This should never happen. */
3828                 ddvprintk((MYIOC_s_INFO_FMT "_do_cmd: Null pLocal!!!\n",
3829                                 hd->ioc->name));
3830         }
3831
3832         return rc;
3833 }
3834
3835 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3836 /**
3837  *      mptscsih_negotiate_to_asyn_narrow - Restore devices to default state
3838  *      @hd: Pointer to a SCSI HOST structure
3839  *      @vtarget: per device private data
3840  *
3841  *      Uses the ISR, but with special processing.
3842  *      MUST be single-threaded.
3843  *
3844  */
3845 static void
3846 mptscsih_negotiate_to_asyn_narrow(MPT_SCSI_HOST *hd, VirtTarget *vtarget)
3847 {
3848         MPT_ADAPTER             *ioc= hd->ioc;
3849         SCSIDevicePage1_t       *pcfg1Data;
3850         CONFIGPARMS              cfg;
3851         dma_addr_t               cfg1_dma_addr;
3852         ConfigPageHeader_t       header;
3853         int                      id;
3854         int                      requested, configuration, data,i;
3855         u8                       flags, factor;
3856
3857         if (ioc->bus_type != SPI)
3858                 return;
3859
3860         if (!ioc->spi_data.sdp1length)
3861                 return;
3862
3863         pcfg1Data = (SCSIDevicePage1_t *)pci_alloc_consistent(ioc->pcidev,
3864                  ioc->spi_data.sdp1length * 4, &cfg1_dma_addr);
3865
3866         if (pcfg1Data == NULL)
3867                 return;
3868
3869         header.PageVersion = ioc->spi_data.sdp1version;
3870         header.PageLength = ioc->spi_data.sdp1length;
3871         header.PageNumber = 1;
3872         header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
3873         cfg.cfghdr.hdr = &header;
3874         cfg.physAddr = cfg1_dma_addr;
3875         cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
3876         cfg.dir = 1;
3877         cfg.timeout = 0;
3878
3879         if (vtarget->raidVolume && ioc->raid_data.pIocPg3) {
3880                 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
3881                         id = ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID;
3882                         flags = hd->ioc->spi_data.noQas;
3883                         if (hd->ioc->spi_data.nvram && (hd->ioc->spi_data.nvram[id] != MPT_HOST_NVRAM_INVALID)) {
3884                                 data = hd->ioc->spi_data.nvram[id];
3885                                 if (data & MPT_NVRAM_WIDE_DISABLE)
3886                                         flags |= MPT_TARGET_NO_NEGO_WIDE;
3887                                 factor = (data & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
3888                                 if ((factor == 0) || (factor == MPT_ASYNC))
3889                                         flags |= MPT_TARGET_NO_NEGO_SYNC;
3890                         }
3891                         mptscsih_setDevicePage1Flags(0, MPT_ASYNC, 0, &requested,
3892                                 &configuration, flags);
3893                         dnegoprintk(("syncronize cache: id=%d width=0 factor=MPT_ASYNC "
3894                                 "offset=0 negoFlags=%x request=%x config=%x\n",
3895                                 id, flags, requested, configuration));
3896                         pcfg1Data->RequestedParameters = cpu_to_le32(requested);
3897                         pcfg1Data->Reserved = 0;
3898                         pcfg1Data->Configuration = cpu_to_le32(configuration);
3899                         cfg.pageAddr = (vtarget->bus_id<<8) | id;
3900                         mpt_config(hd->ioc, &cfg);
3901                 }
3902         } else {
3903                 flags = vtarget->negoFlags;
3904                 mptscsih_setDevicePage1Flags(0, MPT_ASYNC, 0, &requested,
3905                                 &configuration, flags);
3906                 dnegoprintk(("syncronize cache: id=%d width=0 factor=MPT_ASYNC "
3907                         "offset=0 negoFlags=%x request=%x config=%x\n",
3908                         vtarget->target_id, flags, requested, configuration));
3909                 pcfg1Data->RequestedParameters = cpu_to_le32(requested);
3910                 pcfg1Data->Reserved = 0;
3911                 pcfg1Data->Configuration = cpu_to_le32(configuration);
3912                 cfg.pageAddr = (vtarget->bus_id<<8) | vtarget->target_id;
3913                 mpt_config(hd->ioc, &cfg);
3914         }
3915
3916         if (pcfg1Data)
3917                 pci_free_consistent(ioc->pcidev, header.PageLength * 4, pcfg1Data, cfg1_dma_addr);
3918 }
3919
3920 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3921 /**
3922  *      mptscsih_synchronize_cache - Send SYNCHRONIZE_CACHE to all disks.
3923  *      @hd: Pointer to a SCSI HOST structure
3924  *      @vtarget: per device private data
3925  *      @lun: lun
3926  *
3927  *      Uses the ISR, but with special processing.
3928  *      MUST be single-threaded.
3929  *
3930  */
3931 static void
3932 mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
3933 {
3934         INTERNAL_CMD             iocmd;
3935
3936         /* Following parameters will not change
3937          * in this routine.
3938          */
3939         iocmd.cmd = SYNCHRONIZE_CACHE;
3940         iocmd.flags = 0;
3941         iocmd.physDiskNum = -1;
3942         iocmd.data = NULL;
3943         iocmd.data_dma = -1;
3944         iocmd.size = 0;
3945         iocmd.rsvd = iocmd.rsvd2 = 0;
3946         iocmd.bus = vdevice->bus_id;
3947         iocmd.id = vdevice->target_id;
3948         iocmd.lun = (u8)vdevice->lun;
3949
3950         if ((vdevice->vtarget->type & TYPE_DISK) &&
3951             (vdevice->configured_lun))
3952                 mptscsih_do_cmd(hd, &iocmd);
3953 }
3954
3955 /* Search IOC page 3 to determine if this is hidden physical disk
3956  */
3957 /* Search IOC page 3 to determine if this is hidden physical disk
3958  */
3959 static int
3960 mptscsih_is_phys_disk(MPT_ADAPTER *ioc, int id)
3961 {
3962         int i;
3963
3964         if (!ioc->raid_data.isRaid || !ioc->raid_data.pIocPg3)
3965                 return 0;
3966
3967         for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
3968                 if (id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID)
3969                         return 1;
3970         }
3971
3972         return 0;
3973 }
3974
3975 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION
3976 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3977 /**
3978  *      mptscsih_domainValidation - Top level handler for domain validation.
3979  *      @hd: Pointer to MPT_SCSI_HOST structure.
3980  *
3981  *      Uses the ISR, but with special processing.
3982  *      Called from schedule, should not be in interrupt mode.
3983  *      While thread alive, do dv for all devices needing dv
3984  *
3985  *      Return: None.
3986  */
3987 static void
3988 mptscsih_domainValidation(void *arg)
3989 {
3990         MPT_SCSI_HOST           *hd;
3991         MPT_ADAPTER             *ioc;
3992         unsigned long            flags;
3993         int                      id, maxid, dvStatus, did;
3994         int                      ii, isPhysDisk;
3995
3996         spin_lock_irqsave(&dvtaskQ_lock, flags);
3997         dvtaskQ_active = 1;
3998         if (dvtaskQ_release) {
3999                 dvtaskQ_active = 0;
4000                 spin_unlock_irqrestore(&dvtaskQ_lock, flags);
4001                 return;
4002         }
4003         spin_unlock_irqrestore(&dvtaskQ_lock, flags);
4004
4005         /* For this ioc, loop through all devices and do dv to each device.
4006          * When complete with this ioc, search through the ioc list, and
4007          * for each scsi ioc found, do dv for all devices. Exit when no
4008          * device needs dv.
4009          */
4010         did = 1;
4011         while (did) {
4012                 did = 0;
4013                 list_for_each_entry(ioc, &ioc_list, list) {
4014                         spin_lock_irqsave(&dvtaskQ_lock, flags);
4015                         if (dvtaskQ_release) {
4016                                 dvtaskQ_active = 0;
4017                                 spin_unlock_irqrestore(&dvtaskQ_lock, flags);
4018                                 return;
4019                         }
4020                         spin_unlock_irqrestore(&dvtaskQ_lock, flags);
4021
4022                         msleep(250);
4023
4024                         /* DV only to SPI adapters */
4025                         if (ioc->bus_type != SPI)
4026                                 continue;
4027
4028                         /* Make sure everything looks ok */
4029                         if (ioc->sh == NULL)
4030                                 continue;
4031
4032                         hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
4033                         if (hd == NULL)
4034                                 continue;
4035
4036                         if ((ioc->spi_data.forceDv & MPT_SCSICFG_RELOAD_IOC_PG3) != 0) {
4037                                 mpt_read_ioc_pg_3(ioc);
4038                                 if (ioc->raid_data.pIocPg3) {
4039                                         Ioc3PhysDisk_t *pPDisk = ioc->raid_data.pIocPg3->PhysDisk;
4040                                         int             numPDisk = ioc->raid_data.pIocPg3->NumPhysDisks;
4041
4042                                         while (numPDisk) {
4043                                                 if (ioc->spi_data.dvStatus[pPDisk->PhysDiskID] & MPT_SCSICFG_DV_NOT_DONE)
4044                                                         ioc->spi_data.dvStatus[pPDisk->PhysDiskID] |= MPT_SCSICFG_NEED_DV;
4045
4046                                                 pPDisk++;
4047                                                 numPDisk--;
4048                                         }
4049                                 }
4050                                 ioc->spi_data.forceDv &= ~MPT_SCSICFG_RELOAD_IOC_PG3;
4051                         }
4052
4053                         maxid = min_t(int, ioc->sh->max_id, MPT_MAX_SCSI_DEVICES);
4054
4055                         for (id = 0; id < maxid; id++) {
4056                                 spin_lock_irqsave(&dvtaskQ_lock, flags);
4057                                 if (dvtaskQ_release) {
4058                                         dvtaskQ_active = 0;
4059                                         spin_unlock_irqrestore(&dvtaskQ_lock, flags);
4060                                         return;
4061                                 }
4062                                 spin_unlock_irqrestore(&dvtaskQ_lock, flags);
4063                                 dvStatus = hd->ioc->spi_data.dvStatus[id];
4064
4065                                 if (dvStatus & MPT_SCSICFG_NEED_DV) {
4066                                         did++;
4067                                         hd->ioc->spi_data.dvStatus[id] |= MPT_SCSICFG_DV_PENDING;
4068                                         hd->ioc->spi_data.dvStatus[id] &= ~MPT_SCSICFG_NEED_DV;
4069
4070                                         msleep(250);
4071
4072                                         /* If hidden phys disk, block IO's to all
4073                                          *      raid volumes
4074                                          * else, process normally
4075                                          */
4076                                         isPhysDisk = mptscsih_is_phys_disk(ioc, id);
4077                                         if (isPhysDisk) {
4078                                                 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
4079                                                         if (hd->ioc->raid_data.isRaid & (1 << ii)) {
4080                                                                 hd->ioc->spi_data.dvStatus[ii] |= MPT_SCSICFG_DV_PENDING;
4081                                                         }
4082                                                 }
4083                                         }
4084
4085                                         if(mpt_alt_ioc_wait(hd->ioc)!=0) {
4086                                                 ddvprintk((MYIOC_s_WARN_FMT "alt_ioc busy!\n",
4087                                                     hd->ioc->name));
4088                                                 continue;
4089                                         }
4090
4091                                         if (mptscsih_doDv(hd, 0, id) == 1) {
4092                                                 /* Untagged device was busy, try again
4093                                                  */
4094                                                 hd->ioc->spi_data.dvStatus[id] |= MPT_SCSICFG_NEED_DV;
4095                                                 hd->ioc->spi_data.dvStatus[id] &= ~MPT_SCSICFG_DV_PENDING;
4096                                         } else {
4097                                                 /* DV is complete. Clear flags.
4098                                                  */
4099                                                 hd->ioc->spi_data.dvStatus[id] &= ~(MPT_SCSICFG_DV_NOT_DONE | MPT_SCSICFG_DV_PENDING);
4100                                         }
4101
4102                                         spin_lock(&hd->ioc->initializing_hba_lock);
4103                                         hd->ioc->initializing_hba_lock_flag=0;
4104                                         spin_unlock(&hd->ioc->initializing_hba_lock);
4105
4106                                         if (isPhysDisk) {
4107                                                 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
4108                                                         if (hd->ioc->raid_data.isRaid & (1 << ii)) {
4109                                                                 hd->ioc->spi_data.dvStatus[ii] &= ~MPT_SCSICFG_DV_PENDING;
4110                                                         }
4111                                                 }
4112                                         }
4113
4114                                         if (hd->ioc->spi_data.noQas)
4115                                                 mptscsih_qas_check(hd, id);
4116                                 }
4117                         }
4118                 }
4119         }
4120
4121         spin_lock_irqsave(&dvtaskQ_lock, flags);
4122         dvtaskQ_active = 0;
4123         spin_unlock_irqrestore(&dvtaskQ_lock, flags);
4124
4125         return;
4126 }
4127
4128 /* Write SDP1 if no QAS has been enabled
4129  */
4130 static void
4131 mptscsih_qas_check(MPT_SCSI_HOST *hd, int id)
4132 {
4133         VirtTarget *vtarget;
4134         int ii;
4135
4136         if (hd->Targets == NULL)
4137                 return;
4138
4139         for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
4140                 if (ii == id)
4141                         continue;
4142
4143                 if ((hd->ioc->spi_data.dvStatus[ii] & MPT_SCSICFG_DV_NOT_DONE) != 0)
4144                         continue;
4145
4146                 vtarget = hd->Targets[ii];
4147
4148                 if ((vtarget != NULL) && (!vtarget->raidVolume)) {
4149                         if ((vtarget->negoFlags & hd->ioc->spi_data.noQas) == 0) {
4150                                 vtarget->negoFlags |= hd->ioc->spi_data.noQas;
4151                                 dnegoprintk(("writeSDP1: id=%d flags=0\n", id));
4152                                 mptscsih_writeSDP1(hd, 0, ii, 0);
4153                         }
4154                 } else {
4155                         if (mptscsih_is_phys_disk(hd->ioc, ii) == 1) {
4156                                 dnegoprintk(("writeSDP1: id=%d SCSICFG_USE_NVRAM\n", id));
4157                                 mptscsih_writeSDP1(hd, 0, ii, MPT_SCSICFG_USE_NVRAM);
4158                         }
4159                 }
4160         }
4161         return;
4162 }
4163
4164
4165
4166 #define MPT_GET_NVRAM_VALS      0x01
4167 #define MPT_UPDATE_MAX          0x02
4168 #define MPT_SET_MAX             0x04
4169 #define MPT_SET_MIN             0x08
4170 #define MPT_FALLBACK            0x10
4171 #define MPT_SAVE                0x20
4172
4173 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4174 /**
4175  *      mptscsih_doDv - Perform domain validation to a target.
4176  *      @hd: Pointer to MPT_SCSI_HOST structure.
4177  *      @portnum: IOC port number.
4178  *      @target: Physical ID of this target
4179  *
4180  *      Uses the ISR, but with special processing.
4181  *      MUST be single-threaded.
4182  *      Test will exit if target is at async & narrow.
4183  *
4184  *      Return: None.
4185  */
4186 static int
4187 mptscsih_doDv(MPT_SCSI_HOST *hd, int bus_number, int id)
4188 {
4189         MPT_ADAPTER             *ioc = hd->ioc;
4190         VirtTarget              *vtarget;
4191         SCSIDevicePage1_t       *pcfg1Data;
4192         SCSIDevicePage0_t       *pcfg0Data;
4193         u8                      *pbuf1;
4194         u8                      *pbuf2;
4195         u8                      *pDvBuf;
4196         dma_addr_t               dvbuf_dma = -1;
4197         dma_addr_t               buf1_dma = -1;
4198         dma_addr_t               buf2_dma = -1;
4199         dma_addr_t               cfg1_dma_addr = -1;
4200         dma_addr_t               cfg0_dma_addr = -1;
4201         ConfigPageHeader_t       header1;
4202         ConfigPageHeader_t       header0;
4203         DVPARAMETERS             dv;
4204         INTERNAL_CMD             iocmd;
4205         CONFIGPARMS              cfg;
4206         int                      dv_alloc = 0;
4207         int                      rc, sz = 0;
4208         int                      bufsize = 0;
4209         int                      dataBufSize = 0;
4210         int                      echoBufSize = 0;
4211         int                      notDone;
4212         int                      patt;
4213         int                      repeat;
4214         int                      retcode = 0;
4215         int                      nfactor =  MPT_ULTRA320;
4216         char                     firstPass = 1;
4217         char                     doFallback = 0;
4218         char                     readPage0;
4219         char                     bus, lun;
4220         char                     inq0 = 0;
4221
4222         if (ioc->spi_data.sdp1length == 0)
4223                 return 0;
4224
4225         if (ioc->spi_data.sdp0length == 0)
4226                 return 0;
4227
4228         /* If multiple buses are used, require that the initiator
4229          * id be the same on all buses.
4230          */
4231         if (id == ioc->pfacts[0].PortSCSIID)
4232                 return 0;
4233
4234         lun = 0;
4235         bus = (u8) bus_number;
4236         ddvtprintk((MYIOC_s_NOTE_FMT
4237                         "DV started: bus=%d, id=%d dv @ %p\n",
4238                         ioc->name, bus, id, &dv));
4239
4240         /* Prep DV structure
4241          */
4242         memset (&dv, 0, sizeof(DVPARAMETERS));
4243         dv.id = id;
4244
4245         /* Populate tmax with the current maximum
4246          * transfer parameters for this target.
4247          * Exit if narrow and async.
4248          */
4249         dv.cmd = MPT_GET_NVRAM_VALS;
4250         mptscsih_dv_parms(hd, &dv, NULL);
4251
4252         /* Prep SCSI IO structure
4253          */
4254         iocmd.id = id;
4255         iocmd.bus = bus;
4256         iocmd.lun = lun;
4257         iocmd.flags = 0;
4258         iocmd.physDiskNum = -1;
4259         iocmd.rsvd = iocmd.rsvd2 = 0;
4260
4261         vtarget = hd->Targets[id];
4262
4263         /* Use tagged commands if possible.
4264          */
4265         if (vtarget) {
4266                 if (vtarget->tflags & MPT_TARGET_FLAGS_Q_YES)
4267                         iocmd.flags |= MPT_ICFLAG_TAGGED_CMD;
4268                 else {
4269                         if (hd->ioc->facts.FWVersion.Word < 0x01000600)
4270                                 return 0;
4271
4272                         if ((hd->ioc->facts.FWVersion.Word >= 0x01010000) &&
4273                                 (hd->ioc->facts.FWVersion.Word < 0x01010B00))
4274                                 return 0;
4275                 }
4276         }
4277
4278         /* Prep cfg structure
4279          */
4280         cfg.pageAddr = (bus<<8) | id;
4281         cfg.cfghdr.hdr = NULL;
4282
4283         /* Prep SDP0 header
4284          */
4285         header0.PageVersion = ioc->spi_data.sdp0version;
4286         header0.PageLength = ioc->spi_data.sdp0length;
4287         header0.PageNumber = 0;
4288         header0.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
4289
4290         /* Prep SDP1 header
4291          */
4292         header1.PageVersion = ioc->spi_data.sdp1version;
4293         header1.PageLength = ioc->spi_data.sdp1length;
4294         header1.PageNumber = 1;
4295         header1.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
4296
4297         if (header0.PageLength & 1)
4298                 dv_alloc = (header0.PageLength * 4) + 4;
4299
4300         dv_alloc +=  (2048 + (header1.PageLength * 4));
4301
4302         pDvBuf = pci_alloc_consistent(ioc->pcidev, dv_alloc, &dvbuf_dma);
4303         if (pDvBuf == NULL)
4304                 return 0;
4305
4306         sz = 0;
4307         pbuf1 = (u8 *)pDvBuf;
4308         buf1_dma = dvbuf_dma;
4309         sz +=1024;
4310
4311         pbuf2 = (u8 *) (pDvBuf + sz);
4312         buf2_dma = dvbuf_dma + sz;
4313         sz +=1024;
4314
4315         pcfg0Data = (SCSIDevicePage0_t *) (pDvBuf + sz);
4316         cfg0_dma_addr = dvbuf_dma + sz;
4317         sz += header0.PageLength * 4;
4318
4319         /* 8-byte alignment
4320          */
4321         if (header0.PageLength & 1)
4322                 sz += 4;
4323
4324         pcfg1Data = (SCSIDevicePage1_t *) (pDvBuf + sz);
4325         cfg1_dma_addr = dvbuf_dma + sz;
4326
4327         /* Skip this ID? Set cfg.cfghdr.hdr to force config page write
4328          */
4329         {
4330                 SpiCfgData *pspi_data = &hd->ioc->spi_data;
4331                 if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
4332                         /* Set the factor from nvram */
4333                         nfactor = (pspi_data->nvram[id] & MPT_NVRAM_SYNC_MASK) >> 8;
4334                         if (nfactor < pspi_data->minSyncFactor )
4335                                 nfactor = pspi_data->minSyncFactor;
4336
4337                         if (!(pspi_data->nvram[id] & MPT_NVRAM_ID_SCAN_ENABLE) ||
4338                                 (pspi_data->PortFlags == MPI_SCSIPORTPAGE2_PORT_FLAGS_OFF_DV) ) {
4339
4340                                 ddvprintk((MYIOC_s_NOTE_FMT "DV Skipped: bus, id, lun (%d, %d, %d)\n",
4341                                         ioc->name, bus, id, lun));
4342
4343                                 dv.cmd = MPT_SET_MAX;
4344                                 mptscsih_dv_parms(hd, &dv, (void *)pcfg1Data);
4345                                 cfg.cfghdr.hdr = &header1;
4346
4347                                 /* Save the final negotiated settings to
4348                                  * SCSI device page 1.
4349                                  */
4350                                 cfg.physAddr = cfg1_dma_addr;
4351                                 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
4352                                 cfg.dir = 1;
4353                                 mpt_config(hd->ioc, &cfg);
4354                                 goto target_done;
4355                         }
4356                 }
4357         }
4358
4359         /* Finish iocmd inititialization - hidden or visible disk? */
4360         if (ioc->raid_data.pIocPg3) {
4361                 /* Search IOC page 3 for matching id
4362                  */
4363                 Ioc3PhysDisk_t *pPDisk =  ioc->raid_data.pIocPg3->PhysDisk;
4364                 int             numPDisk = ioc->raid_data.pIocPg3->NumPhysDisks;
4365
4366                 while (numPDisk) {
4367                         if (pPDisk->PhysDiskID == id) {
4368                                 /* match */
4369                                 iocmd.flags |= MPT_ICFLAG_PHYS_DISK;
4370                                 iocmd.physDiskNum = pPDisk->PhysDiskNum;
4371
4372                                 /* Quiesce the IM
4373                                  */
4374                                 if (mptscsih_do_raid(hd, MPI_RAID_ACTION_QUIESCE_PHYS_IO, &iocmd) < 0) {
4375                                         ddvprintk((MYIOC_s_ERR_FMT "RAID Queisce FAILED!\n", ioc->name));
4376                                         goto target_done;
4377                                 }
4378                                 break;
4379                         }
4380                         pPDisk++;
4381                         numPDisk--;
4382                 }
4383         }
4384
4385         /* RAID Volume ID's may double for a physical device. If RAID but
4386          * not a physical ID as well, skip DV.
4387          */
4388         if ((hd->ioc->raid_data.isRaid & (1 << id)) && !(iocmd.flags & MPT_ICFLAG_PHYS_DISK))
4389                 goto target_done;
4390
4391
4392         /* Basic Test.
4393          * Async & Narrow - Inquiry
4394          * Async & Narrow - Inquiry
4395          * Maximum transfer rate - Inquiry
4396          * Compare buffers:
4397          *      If compare, test complete.
4398          *      If miscompare and first pass, repeat
4399          *      If miscompare and not first pass, fall back and repeat
4400          */
4401         hd->pLocal = NULL;
4402         readPage0 = 0;
4403         sz = SCSI_MAX_INQUIRY_BYTES;
4404         rc = MPT_SCANDV_GOOD;
4405         while (1) {
4406                 ddvprintk((MYIOC_s_NOTE_FMT "DV: Start Basic test on id=%d\n", ioc->name, id));
4407                 retcode = 0;
4408                 dv.cmd = MPT_SET_MIN;
4409                 mptscsih_dv_parms(hd, &dv, (void *)pcfg1Data);
4410
4411                 cfg.cfghdr.hdr = &header1;
4412                 cfg.physAddr = cfg1_dma_addr;
4413                 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
4414                 cfg.dir = 1;
4415                 if (mpt_config(hd->ioc, &cfg) != 0)
4416                         goto target_done;
4417
4418                 /* Wide - narrow - wide workaround case
4419                  */
4420                 if ((rc == MPT_SCANDV_ISSUE_SENSE) && dv.max.width) {
4421                         /* Send an untagged command to reset disk Qs corrupted
4422                          * when a parity error occurs on a Request Sense.
4423                          */
4424                         if ((hd->ioc->facts.FWVersion.Word >= 0x01000600) ||
4425                                 ((hd->ioc->facts.FWVersion.Word >= 0x01010000) &&
4426                                 (hd->ioc->facts.FWVersion.Word < 0x01010B00)) ) {
4427
4428                                 iocmd.cmd = REQUEST_SENSE;
4429                                 iocmd.data_dma = buf1_dma;
4430                                 iocmd.data = pbuf1;
4431                                 iocmd.size = 0x12;
4432                                 if (mptscsih_do_cmd(hd, &iocmd) < 0)
4433                                         goto target_done;
4434                                 else {
4435                                         if (hd->pLocal == NULL)
4436                                                 goto target_done;
4437                                         rc = hd->pLocal->completion;
4438                                         if ((rc == MPT_SCANDV_GOOD) || (rc == MPT_SCANDV_SENSE)) {
4439                                                 dv.max.width = 0;
4440                                                 doFallback = 0;
4441                                         } else
4442                                                 goto target_done;
4443                                 }
4444                         } else
4445                                 goto target_done;
4446                 }
4447
4448                 iocmd.cmd = INQUIRY;
4449                 iocmd.data_dma = buf1_dma;
4450                 iocmd.data = pbuf1;
4451                 iocmd.size = sz;
4452                 memset(pbuf1, 0x00, sz);
4453                 if (mptscsih_do_cmd(hd, &iocmd) < 0)
4454                         goto target_done;
4455                 else {
4456                         if (hd->pLocal == NULL)
4457                                 goto target_done;
4458                         rc = hd->pLocal->completion;
4459                         if (rc == MPT_SCANDV_GOOD) {
4460                                 if (hd->pLocal->scsiStatus == SAM_STAT_BUSY) {
4461                                         if ((iocmd.flags & MPT_ICFLAG_TAGGED_CMD) == 0)
4462                                                 retcode = 1;
4463                                         else
4464                                                 retcode = 0;
4465
4466                                         goto target_done;
4467                                 }
4468                         } else if  (rc == MPT_SCANDV_SENSE) {
4469                                 ;
4470                         } else {
4471                                 /* If first command doesn't complete
4472                                  * with a good status or with a check condition,
4473                                  * exit.
4474                                  */
4475                                 goto target_done;
4476                         }
4477                 }
4478
4479                 /* Reset the size for disks
4480                  */
4481                 inq0 = (*pbuf1) & 0x1F;
4482                 if ((inq0 == 0) && vtarget && !vtarget->raidVolume) {
4483                         sz = 0x40;
4484                         iocmd.size = sz;
4485                 }
4486
4487                 /* Another GEM workaround. Check peripheral device type,
4488                  * if PROCESSOR, quit DV.
4489                  */
4490                 if (inq0 == TYPE_PROCESSOR) {
4491                         mptscsih_initTarget(hd,
4492                                 vtarget,
4493                                 lun,
4494                                 pbuf1,
4495                                 sz);
4496                         goto target_done;
4497                 }
4498
4499                 if (inq0 > 0x08)
4500                         goto target_done;
4501
4502                 if (mptscsih_do_cmd(hd, &iocmd) < 0)
4503                         goto target_done;
4504
4505                 if (sz == 0x40) {
4506                         if ((vtarget->maxWidth == 1) && (vtarget->maxOffset) && (nfactor < 0x0A)
4507                                 && (vtarget->minSyncFactor > 0x09)) {
4508                                 if ((pbuf1[56] & 0x04) == 0)
4509                                         ;
4510                                 else if ((pbuf1[56] & 0x01) == 1) {
4511                                         vtarget->minSyncFactor =
4512                                             nfactor > MPT_ULTRA320 ? nfactor : MPT_ULTRA320;
4513                                 } else {
4514                                         vtarget->minSyncFactor =
4515                                             nfactor > MPT_ULTRA160 ? nfactor : MPT_ULTRA160;
4516                                 }
4517
4518                                 dv.max.factor = vtarget->minSyncFactor;
4519
4520                                 if ((pbuf1[56] & 0x02) == 0) {
4521                                         vtarget->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
4522                                         hd->ioc->spi_data.noQas = MPT_TARGET_NO_NEGO_QAS;
4523                                         ddvprintk((MYIOC_s_NOTE_FMT
4524                                             "DV: Start Basic noQas on id=%d due to pbuf1[56]=%x\n",
4525                                             ioc->name, id, pbuf1[56]));
4526                                 }
4527                         }
4528                 }
4529
4530                 if (doFallback)
4531                         dv.cmd = MPT_FALLBACK;
4532                 else
4533                         dv.cmd = MPT_SET_MAX;
4534
4535                 mptscsih_dv_parms(hd, &dv, (void *)pcfg1Data);
4536                 if (mpt_config(hd->ioc, &cfg) != 0)
4537                         goto target_done;
4538
4539                 if ((!dv.now.width) && (!dv.now.offset))
4540                         goto target_done;
4541
4542                 iocmd.cmd = INQUIRY;
4543                 iocmd.data_dma = buf2_dma;
4544                 iocmd.data = pbuf2;
4545                 iocmd.size = sz;
4546                 memset(pbuf2, 0x00, sz);
4547                 if (mptscsih_do_cmd(hd, &iocmd) < 0)
4548                         goto target_done;
4549                 else if (hd->pLocal == NULL)
4550                         goto target_done;
4551                 else {
4552                         /* Save the return code.
4553                          * If this is the first pass,
4554                          * read SCSI Device Page 0
4555                          * and update the target max parameters.
4556                          */
4557                         rc = hd->pLocal->completion;
4558                         doFallback = 0;
4559                         if (rc == MPT_SCANDV_GOOD) {
4560                                 if (!readPage0) {
4561                                         u32 sdp0_info;
4562                                         u32 sdp0_nego;
4563
4564                                         cfg.cfghdr.hdr = &header0;
4565                                         cfg.physAddr = cfg0_dma_addr;
4566                                         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4567                                         cfg.dir = 0;
4568
4569                                         if (mpt_config(hd->ioc, &cfg) != 0)
4570                                                 goto target_done;
4571
4572                                         sdp0_info = le32_to_cpu(pcfg0Data->Information) & 0x0E;
4573                                         sdp0_nego = (le32_to_cpu(pcfg0Data->NegotiatedParameters) & 0xFF00 ) >> 8;
4574
4575                                         /* Quantum and Fujitsu workarounds.
4576                                          * Quantum: PPR U320 -> PPR reply with Ultra2 and wide
4577                                          * Fujitsu: PPR U320 -> Msg Reject and Ultra2 and wide
4578                                          * Resetart with a request for U160.
4579                                          */
4580                                         if ((dv.now.factor == MPT_ULTRA320) && (sdp0_nego == MPT_ULTRA2)) {
4581                                                         doFallback = 1;
4582                                         } else {
4583                                                 dv.cmd = MPT_UPDATE_MAX;
4584                                                 mptscsih_dv_parms(hd, &dv, (void *)pcfg0Data);
4585                                                 /* Update the SCSI device page 1 area
4586                                                  */
4587                                                 pcfg1Data->RequestedParameters = pcfg0Data->NegotiatedParameters;
4588                                                 readPage0 = 1;
4589                                         }
4590                                 }
4591
4592                                 /* Quantum workaround. Restart this test will the fallback
4593                                  * flag set.
4594                                  */
4595                                 if (doFallback == 0) {
4596                                         if (memcmp(pbuf1, pbuf2, sz) != 0) {
4597                                                 if (!firstPass)
4598                                                         doFallback = 1;
4599                                         } else {
4600                                                 ddvprintk((MYIOC_s_NOTE_FMT
4601                                                     "DV:Inquiry compared id=%d, calling initTarget\n", ioc->name, id));
4602                                                 hd->ioc->spi_data.dvStatus[id] &= ~MPT_SCSICFG_DV_NOT_DONE;
4603                                                 mptscsih_initTarget(hd,
4604                                                         vtarget,
4605                                                         lun,
4606                                                         pbuf1,
4607                                                         sz);
4608                                                 break;  /* test complete */
4609                                         }
4610                                 }
4611
4612
4613                         } else if (rc == MPT_SCANDV_ISSUE_SENSE)
4614                                 doFallback = 1; /* set fallback flag */
4615                         else if ((rc == MPT_SCANDV_DID_RESET) ||
4616                                  (rc == MPT_SCANDV_SENSE) ||
4617                                  (rc == MPT_SCANDV_FALLBACK))
4618                                 doFallback = 1; /* set fallback flag */
4619                         else
4620                                 goto target_done;
4621
4622                         firstPass = 0;
4623                 }
4624         }
4625         ddvprintk((MYIOC_s_NOTE_FMT "DV: Basic test on id=%d completed OK.\n", ioc->name, id));
4626
4627         if (ioc->spi_data.mpt_dv == 0)
4628                 goto target_done;
4629
4630         inq0 = (*pbuf1) & 0x1F;
4631
4632         /* Continue only for disks
4633          */
4634         if (inq0 != 0)
4635                 goto target_done;
4636
4637         if ( ioc->spi_data.PortFlags == MPI_SCSIPORTPAGE2_PORT_FLAGS_BASIC_DV_ONLY )
4638                 goto target_done;
4639
4640         /* Start the Enhanced Test.
4641          * 0) issue TUR to clear out check conditions
4642          * 1) read capacity of echo (regular) buffer
4643          * 2) reserve device
4644          * 3) do write-read-compare data pattern test
4645          * 4) release
4646          * 5) update nego parms to target struct
4647          */
4648         cfg.cfghdr.hdr = &header1;
4649         cfg.physAddr = cfg1_dma_addr;
4650         cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
4651         cfg.dir = 1;
4652
4653         iocmd.cmd = TEST_UNIT_READY;
4654         iocmd.data_dma = -1;
4655         iocmd.data = NULL;
4656         iocmd.size = 0;
4657         notDone = 1;
4658         while (notDone) {
4659                 if (mptscsih_do_cmd(hd, &iocmd) < 0)
4660                         goto target_done;
4661
4662                 if (hd->pLocal == NULL)
4663                         goto target_done;
4664
4665                 rc = hd->pLocal->completion;
4666                 if (rc == MPT_SCANDV_GOOD)
4667                         notDone = 0;
4668                 else if (rc == MPT_SCANDV_SENSE) {
4669                         u8 skey = hd->pLocal->sense[2] & 0x0F;
4670                         u8 asc = hd->pLocal->sense[12];
4671                         u8 ascq = hd->pLocal->sense[13];
4672                         ddvprintk((MYIOC_s_INFO_FMT
4673                                 "SenseKey:ASC:ASCQ = (%x:%02x:%02x)\n",
4674                                 ioc->name, skey, asc, ascq));
4675
4676                         if (skey == UNIT_ATTENTION)
4677                                 notDone++; /* repeat */
4678                         else if ((skey == NOT_READY) &&
4679                                         (asc == 0x04)&&(ascq == 0x01)) {
4680                                 /* wait then repeat */
4681                                 mdelay (2000);
4682                                 notDone++;
4683                         } else if ((skey == NOT_READY) && (asc == 0x3A)) {
4684                                 /* no medium, try read test anyway */
4685                                 notDone = 0;
4686                         } else {
4687                                 /* All other errors are fatal.
4688                                  */
4689                                 ddvprintk((MYIOC_s_INFO_FMT "DV: fatal error.",
4690                                                 ioc->name));
4691                                 goto target_done;
4692                         }
4693                 } else
4694                         goto target_done;
4695         }
4696
4697         iocmd.cmd = READ_BUFFER;
4698         iocmd.data_dma = buf1_dma;
4699         iocmd.data = pbuf1;
4700         iocmd.size = 4;
4701         iocmd.flags |= MPT_ICFLAG_BUF_CAP;
4702
4703         dataBufSize = 0;
4704         echoBufSize = 0;
4705         for (patt = 0; patt < 2; patt++) {
4706                 if (patt == 0)
4707                         iocmd.flags |= MPT_ICFLAG_ECHO;
4708                 else
4709                         iocmd.flags &= ~MPT_ICFLAG_ECHO;
4710
4711                 notDone = 1;
4712                 while (notDone) {
4713                         bufsize = 0;
4714
4715                         /* If not ready after 8 trials,
4716                          * give up on this device.
4717                          */
4718                         if (notDone > 8)
4719                                 goto target_done;
4720
4721                         if (mptscsih_do_cmd(hd, &iocmd) < 0)
4722                                 goto target_done;
4723                         else if (hd->pLocal == NULL)
4724                                 goto target_done;
4725                         else {
4726                                 rc = hd->pLocal->completion;
4727                                 ddvprintk(("ReadBuffer Comp Code %d", rc));
4728                                 ddvprintk(("  buff: %0x %0x %0x %0x\n",
4729                                         pbuf1[0], pbuf1[1], pbuf1[2], pbuf1[3]));
4730
4731                                 if (rc == MPT_SCANDV_GOOD) {
4732                                         notDone = 0;
4733                                         if (iocmd.flags & MPT_ICFLAG_ECHO) {
4734                                                 bufsize =  ((pbuf1[2] & 0x1F) <<8) | pbuf1[3];
4735                                                 if (pbuf1[0] & 0x01)
4736                                                         iocmd.flags |= MPT_ICFLAG_EBOS;
4737                                         } else {
4738                                                 bufsize =  pbuf1[1]<<16 | pbuf1[2]<<8 | pbuf1[3];
4739                                         }
4740                                 } else if (rc == MPT_SCANDV_SENSE) {
4741                                         u8 skey = hd->pLocal->sense[2] & 0x0F;
4742                                         u8 asc = hd->pLocal->sense[12];
4743                                         u8 ascq = hd->pLocal->sense[13];
4744                                         ddvprintk((MYIOC_s_INFO_FMT
4745                                                 "SenseKey:ASC:ASCQ = (%x:%02x:%02x)\n",
4746                                                 ioc->name, skey, asc, ascq));
4747                                         if (skey == ILLEGAL_REQUEST) {
4748                                                 notDone = 0;
4749                                         } else if (skey == UNIT_ATTENTION) {
4750                                                 notDone++; /* repeat */
4751                                         } else if ((skey == NOT_READY) &&
4752                                                 (asc == 0x04)&&(ascq == 0x01)) {
4753                                                 /* wait then repeat */
4754                                                 mdelay (2000);
4755                                                 notDone++;
4756                                         } else {
4757                                                 /* All other errors are fatal.
4758                                                  */
4759                                                 ddvprintk((MYIOC_s_INFO_FMT "DV: fatal error.",
4760                                                         ioc->name));
4761                                                 goto target_done;
4762                                         }
4763                                 } else {
4764                                         /* All other errors are fatal
4765                                          */
4766                                         goto target_done;
4767                                 }
4768                         }
4769                 }
4770
4771                 if (iocmd.flags & MPT_ICFLAG_ECHO)
4772                         echoBufSize = bufsize;
4773                 else
4774                         dataBufSize = bufsize;
4775         }
4776         sz = 0;
4777         iocmd.flags &= ~MPT_ICFLAG_BUF_CAP;
4778
4779         /* Use echo buffers if possible,
4780          * Exit if both buffers are 0.
4781          */
4782         if (echoBufSize > 0) {
4783                 iocmd.flags |= MPT_ICFLAG_ECHO;
4784                 if (dataBufSize > 0)
4785                         bufsize = min(echoBufSize, dataBufSize);
4786                 else
4787                         bufsize = echoBufSize;
4788         } else if (dataBufSize == 0)
4789                 goto target_done;
4790
4791         ddvprintk((MYIOC_s_INFO_FMT "%s Buffer Capacity %d\n", ioc->name,
4792                 (iocmd.flags & MPT_ICFLAG_ECHO) ? "Echo" : " ", bufsize));
4793
4794         /* Data buffers for write-read-compare test max 1K.
4795          */
4796         sz = min(bufsize, 1024);
4797
4798         /* --- loop ----
4799          * On first pass, always issue a reserve.
4800          * On additional loops, only if a reset has occurred.
4801          * iocmd.flags indicates if echo or regular buffer
4802          */
4803         for (patt = 0; patt < 4; patt++) {
4804                 ddvprintk(("Pattern %d\n", patt));
4805                 if ((iocmd.flags & MPT_ICFLAG_RESERVED) && (iocmd.flags & MPT_ICFLAG_DID_RESET)) {
4806                         iocmd.cmd = TEST_UNIT_READY;
4807                         iocmd.data_dma = -1;
4808                         iocmd.data = NULL;
4809                         iocmd.size = 0;
4810                         if (mptscsih_do_cmd(hd, &iocmd) < 0)
4811                                 goto target_done;
4812
4813                         iocmd.cmd = RELEASE;
4814                         iocmd.data_dma = -1;
4815                         iocmd.data = NULL;
4816                         iocmd.size = 0;
4817                         if (mptscsih_do_cmd(hd, &iocmd) < 0)
4818                                 goto target_done;
4819                         else if (hd->pLocal == NULL)
4820                                 goto target_done;
4821                         else {
4822                                 rc = hd->pLocal->completion;
4823                                 ddvprintk(("Release rc %d\n", rc));
4824                                 if (rc == MPT_SCANDV_GOOD)
4825                                         iocmd.flags &= ~MPT_ICFLAG_RESERVED;
4826                                 else
4827                                         goto target_done;
4828                         }
4829                         iocmd.flags &= ~MPT_ICFLAG_RESERVED;
4830                 }
4831                 iocmd.flags &= ~MPT_ICFLAG_DID_RESET;
4832
4833                 if (iocmd.flags & MPT_ICFLAG_EBOS)
4834                         goto skip_Reserve;
4835
4836                 repeat = 5;
4837                 while (repeat && (!(iocmd.flags & MPT_ICFLAG_RESERVED))) {
4838                         iocmd.cmd = RESERVE;
4839                         iocmd.data_dma = -1;
4840                         iocmd.data = NULL;
4841                         iocmd.size = 0;
4842                         if (mptscsih_do_cmd(hd, &iocmd) < 0)
4843                                 goto target_done;
4844                         else if (hd->pLocal == NULL)
4845                                 goto target_done;
4846                         else {
4847                                 rc = hd->pLocal->completion;
4848                                 if (rc == MPT_SCANDV_GOOD) {
4849                                         iocmd.flags |= MPT_ICFLAG_RESERVED;
4850                                 } else if (rc == MPT_SCANDV_SENSE) {
4851                                         /* Wait if coming ready
4852                                          */
4853                                         u8 skey = hd->pLocal->sense[2] & 0x0F;
4854                                         u8 asc = hd->pLocal->sense[12];
4855                                         u8 ascq = hd->pLocal->sense[13];
4856                                         ddvprintk((MYIOC_s_INFO_FMT
4857                                                 "DV: Reserve Failed: ", ioc->name));
4858                                         ddvprintk(("SenseKey:ASC:ASCQ = (%x:%02x:%02x)\n",
4859                                                         skey, asc, ascq));
4860
4861                                         if ((skey == NOT_READY) && (asc == 0x04)&&
4862                                                                         (ascq == 0x01)) {
4863                                                 /* wait then repeat */
4864                                                 mdelay (2000);
4865                                                 notDone++;
4866                                         } else {
4867                                                 ddvprintk((MYIOC_s_INFO_FMT
4868                                                         "DV: Reserved Failed.", ioc->name));
4869                                                 goto target_done;
4870                                         }
4871                                 } else {
4872                                         ddvprintk((MYIOC_s_INFO_FMT "DV: Reserved Failed.",
4873                                                          ioc->name));
4874                                         goto target_done;
4875                                 }
4876                         }
4877                 }
4878
4879 skip_Reserve:
4880                 mptscsih_fillbuf(pbuf1, sz, patt, 1);
4881                 iocmd.cmd = WRITE_BUFFER;
4882                 iocmd.data_dma = buf1_dma;
4883                 iocmd.data = pbuf1;
4884                 iocmd.size = sz;
4885                 if (mptscsih_do_cmd(hd, &iocmd) < 0)
4886                         goto target_done;
4887                 else if (hd->pLocal == NULL)
4888                         goto target_done;
4889                 else {
4890                         rc = hd->pLocal->completion;
4891                         if (rc == MPT_SCANDV_GOOD)
4892                                 ;               /* Issue read buffer */
4893                         else if (rc == MPT_SCANDV_DID_RESET) {
4894                                 /* If using echo buffers, reset to data buffers.
4895                                  * Else do Fallback and restart
4896                                  * this test (re-issue reserve
4897                                  * because of bus reset).
4898                                  */
4899                                 if ((iocmd.flags & MPT_ICFLAG_ECHO) && (dataBufSize >= bufsize)) {
4900                                         iocmd.flags &= ~MPT_ICFLAG_ECHO;
4901                                 } else {
4902                                         dv.cmd = MPT_FALLBACK;
4903                                         mptscsih_dv_parms(hd, &dv, (void *)pcfg1Data);
4904
4905                                         if (mpt_config(hd->ioc, &cfg) != 0)
4906                                                 goto target_done;
4907
4908                                         if ((!dv.now.width) && (!dv.now.offset))
4909                                                 goto target_done;
4910                                 }
4911
4912                                 iocmd.flags |= MPT_ICFLAG_DID_RESET;
4913                                 patt = -1;
4914                                 continue;
4915                         } else if (rc == MPT_SCANDV_SENSE) {
4916                                 /* Restart data test if UA, else quit.
4917                                  */
4918                                 u8 skey = hd->pLocal->sense[2] & 0x0F;
4919                                 ddvprintk((MYIOC_s_INFO_FMT
4920                                         "SenseKey:ASC:ASCQ = (%x:%02x:%02x)\n", ioc->name, skey,
4921                                         hd->pLocal->sense[12], hd->pLocal->sense[13]));
4922                                 if (skey == UNIT_ATTENTION) {
4923                                         patt = -1;
4924                                         continue;
4925                                 } else if (skey == ILLEGAL_REQUEST) {
4926                                         if (iocmd.flags & MPT_ICFLAG_ECHO) {
4927                                                 if (dataBufSize >= bufsize) {
4928                                                         iocmd.flags &= ~MPT_ICFLAG_ECHO;
4929                                                         patt = -1;
4930                                                         continue;
4931                                                 }
4932                                         }
4933                                         goto target_done;
4934                                 }
4935                                 else
4936                                         goto target_done;
4937                         } else {
4938                                 /* fatal error */
4939                                 goto target_done;
4940                         }
4941                 }
4942
4943                 iocmd.cmd = READ_BUFFER;
4944                 iocmd.data_dma = buf2_dma;
4945                 iocmd.data = pbuf2;
4946                 iocmd.size = sz;
4947                 if (mptscsih_do_cmd(hd, &iocmd) < 0)
4948                         goto target_done;
4949                 else if (hd->pLocal == NULL)
4950                         goto target_done;
4951                 else {
4952                         rc = hd->pLocal->completion;
4953                         if (rc == MPT_SCANDV_GOOD) {
4954                                  /* If buffers compare,
4955                                   * go to next pattern,
4956                                   * else, do a fallback and restart
4957                                   * data transfer test.
4958                                   */
4959                                 if (memcmp (pbuf1, pbuf2, sz) == 0) {
4960                                         ; /* goto next pattern */
4961                                 } else {
4962                                         /* Miscompare with Echo buffer, go to data buffer,
4963                                          * if that buffer exists.
4964                                          * Miscompare with Data buffer, check first 4 bytes,
4965                                          * some devices return capacity. Exit in this case.
4966                                          */
4967                                         if (iocmd.flags & MPT_ICFLAG_ECHO) {
4968                                                 if (dataBufSize >= bufsize)
4969                                                         iocmd.flags &= ~MPT_ICFLAG_ECHO;
4970                                                 else
4971                                                         goto target_done;
4972                                         } else {
4973                                                 if (dataBufSize == (pbuf2[1]<<16 | pbuf2[2]<<8 | pbuf2[3])) {
4974                                                         /* Argh. Device returning wrong data.
4975                                                          * Quit DV for this device.
4976                                                          */
4977                                                         goto target_done;
4978                                                 }
4979
4980                                                 /* Had an actual miscompare. Slow down.*/
4981                                                 dv.cmd = MPT_FALLBACK;
4982                                                 mptscsih_dv_parms(hd, &dv, (void *)pcfg1Data);
4983
4984                                                 if (mpt_config(hd->ioc, &cfg) != 0)
4985                                                         goto target_done;
4986
4987                                                 if ((!dv.now.width) && (!dv.now.offset))
4988                                                         goto target_done;
4989                                         }
4990
4991                                         patt = -1;
4992                                         continue;
4993                                 }
4994                         } else if (rc == MPT_SCANDV_DID_RESET) {
4995                                 /* Do Fallback and restart
4996                                  * this test (re-issue reserve
4997                                  * because of bus reset).
4998                                  */
4999                                 dv.cmd = MPT_FALLBACK;
5000                                 mptscsih_dv_parms(hd, &dv, (void *)pcfg1Data);
5001
5002                                 if (mpt_config(hd->ioc, &cfg) != 0)
5003                                          goto target_done;
5004
5005                                 if ((!dv.now.width) && (!dv.now.offset))
5006                                         goto target_done;
5007
5008                                 iocmd.flags |= MPT_ICFLAG_DID_RESET;
5009                                 patt = -1;
5010                                 continue;
5011                         } else if (rc == MPT_SCANDV_SENSE) {
5012                                 /* Restart data test if UA, else quit.
5013                                  */
5014                                 u8 skey = hd->pLocal->sense[2] & 0x0F;
5015                                 ddvprintk((MYIOC_s_INFO_FMT
5016                                         "SenseKey:ASC:ASCQ = (%x:%02x:%02x)\n", ioc->name, skey,
5017                                         hd->pLocal->sense[12], hd->pLocal->sense[13]));
5018                                 if (skey == UNIT_ATTENTION) {
5019                                         patt = -1;
5020                                         continue;
5021                                 }
5022                                 else
5023                                         goto target_done;
5024                         } else {
5025                                 /* fatal error */
5026                                 goto target_done;
5027                         }
5028                 }
5029
5030         } /* --- end of patt loop ---- */
5031
5032 target_done:
5033         if (iocmd.flags & MPT_ICFLAG_RESERVED) {
5034                 iocmd.cmd = RELEASE;
5035                 iocmd.data_dma = -1;
5036                 iocmd.data = NULL;
5037                 iocmd.size = 0;
5038                 if (mptscsih_do_cmd(hd, &iocmd) < 0)
5039                         printk(MYIOC_s_INFO_FMT "DV: Release failed. id %d",
5040                                         ioc->name, id);
5041                 else if (hd->pLocal) {
5042                         if (hd->pLocal->completion == MPT_SCANDV_GOOD)
5043                                 iocmd.flags &= ~MPT_ICFLAG_RESERVED;
5044                 } else {
5045                         printk(MYIOC_s_INFO_FMT "DV: Release failed. id %d",
5046                                                 ioc->name, id);
5047                 }
5048         }
5049
5050
5051         /* Set if cfg1_dma_addr contents is valid
5052          */
5053         if ((cfg.cfghdr.hdr != NULL) && (retcode == 0)){
5054                 /* If disk, not U320, disable QAS
5055                  */
5056                 if ((inq0 == 0) && (dv.now.factor > MPT_ULTRA320)) {
5057                         hd->ioc->spi_data.noQas = MPT_TARGET_NO_NEGO_QAS;
5058                         ddvprintk((MYIOC_s_NOTE_FMT
5059                             "noQas set due to id=%d has factor=%x\n", ioc->name, id, dv.now.factor));
5060                 }
5061
5062                 dv.cmd = MPT_SAVE;
5063                 mptscsih_dv_parms(hd, &dv, (void *)pcfg1Data);
5064
5065                 /* Double writes to SDP1 can cause problems,
5066                  * skip save of the final negotiated settings to
5067                  * SCSI device page 1.
5068                  *
5069                 cfg.cfghdr.hdr = &header1;
5070                 cfg.physAddr = cfg1_dma_addr;
5071                 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
5072                 cfg.dir = 1;
5073                 mpt_config(hd->ioc, &cfg);
5074                  */
5075         }
5076
5077         /* If this is a RAID Passthrough, enable internal IOs
5078          */
5079         if (iocmd.flags & MPT_ICFLAG_PHYS_DISK) {
5080                 if (mptscsih_do_raid(hd, MPI_RAID_ACTION_ENABLE_PHYS_IO, &iocmd) < 0)
5081                         ddvprintk((MYIOC_s_ERR_FMT "RAID Enable FAILED!\n", ioc->name));
5082         }
5083
5084         /* Done with the DV scan of the current target
5085          */
5086         if (pDvBuf)
5087                 pci_free_consistent(ioc->pcidev, dv_alloc, pDvBuf, dvbuf_dma);
5088
5089         ddvtprintk((MYIOC_s_INFO_FMT "DV Done id=%d\n",
5090                         ioc->name, id));
5091
5092         return retcode;
5093 }
5094
5095 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5096 /*      mptscsih_dv_parms - perform a variety of operations on the
5097  *      parameters used for negotiation.
5098  *      @hd: Pointer to a SCSI host.
5099  *      @dv: Pointer to a structure that contains the maximum and current
5100  *              negotiated parameters.
5101  */
5102 static void
5103 mptscsih_dv_parms(MPT_SCSI_HOST *hd, DVPARAMETERS *dv,void *pPage)
5104 {
5105         VirtTarget              *vtarget;
5106         SCSIDevicePage0_t       *pPage0;
5107         SCSIDevicePage1_t       *pPage1;
5108         int                     val = 0, data, configuration;
5109         u8                      width = 0;
5110         u8                      offset = 0;
5111         u8                      factor = 0;
5112         u8                      negoFlags = 0;
5113         u8                      cmd = dv->cmd;
5114         u8                      id = dv->id;
5115
5116         switch (cmd) {
5117         case MPT_GET_NVRAM_VALS:
5118                 ddvprintk((MYIOC_s_NOTE_FMT "Getting NVRAM: ",
5119                                                          hd->ioc->name));
5120                 /* Get the NVRAM values and save in tmax
5121                  * If not an LVD bus, the adapter minSyncFactor has been
5122                  * already throttled back.
5123                  */
5124                 negoFlags = hd->ioc->spi_data.noQas;
5125                 if ((hd->Targets)&&((vtarget = hd->Targets[(int)id]) != NULL) && !vtarget->raidVolume) {
5126                         width = vtarget->maxWidth;
5127                         offset = vtarget->maxOffset;
5128                         factor = vtarget->minSyncFactor;
5129                         negoFlags |= vtarget->negoFlags;
5130                 } else {
5131                         if (hd->ioc->spi_data.nvram && (hd->ioc->spi_data.nvram[id] != MPT_HOST_NVRAM_INVALID)) {
5132                                 data = hd->ioc->spi_data.nvram[id];
5133                                 width = data & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
5134                                 if ((offset = hd->ioc->spi_data.maxSyncOffset) == 0)
5135                                         factor = MPT_ASYNC;
5136                                 else {
5137                                         factor = (data & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
5138                                         if ((factor == 0) || (factor == MPT_ASYNC)){
5139                                                 factor = MPT_ASYNC;
5140                                                 offset = 0;
5141                                         }
5142                                 }
5143                         } else {
5144                                 width = MPT_NARROW;
5145                                 offset = 0;
5146                                 factor = MPT_ASYNC;
5147                         }
5148
5149                         /* Set the negotiation flags */
5150                         if (!width)
5151                                 negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
5152
5153                         if (!offset)
5154                                 negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
5155                 }
5156
5157                 /* limit by adapter capabilities */
5158                 width = min(width, hd->ioc->spi_data.maxBusWidth);
5159                 offset = min(offset, hd->ioc->spi_data.maxSyncOffset);
5160                 factor = max(factor, hd->ioc->spi_data.minSyncFactor);
5161
5162                 /* Check Consistency */
5163                 if (offset && (factor < MPT_ULTRA2) && !width)
5164                         factor = MPT_ULTRA2;
5165
5166                 dv->max.width = width;
5167                 dv->max.offset = offset;
5168                 dv->max.factor = factor;
5169                 dv->max.flags = negoFlags;
5170                 ddvprintk((" id=%d width=%d factor=%x offset=%x flags=%x\n",
5171                                 id, width, factor, offset, negoFlags));
5172                 break;
5173
5174         case MPT_UPDATE_MAX:
5175                 ddvprintk((MYIOC_s_NOTE_FMT
5176                         "Updating with SDP0 Data: ", hd->ioc->name));
5177                 /* Update tmax values with those from Device Page 0.*/
5178                 pPage0 = (SCSIDevicePage0_t *) pPage;
5179                 if (pPage0) {
5180                         val = le32_to_cpu(pPage0->NegotiatedParameters);
5181                         dv->max.width = val & MPI_SCSIDEVPAGE0_NP_WIDE ? 1 : 0;
5182                         dv->max.offset = (val&MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> 16;
5183                         dv->max.factor = (val&MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> 8;
5184                 }
5185
5186                 dv->now.width = dv->max.width;
5187                 dv->now.offset = dv->max.offset;
5188                 dv->now.factor = dv->max.factor;
5189                 ddvprintk(("id=%d width=%d factor=%x offset=%x flags=%x\n",
5190                                 id, dv->now.width, dv->now.factor, dv->now.offset, dv->now.flags));
5191                 break;
5192
5193         case MPT_SET_MAX:
5194                 ddvprintk((MYIOC_s_NOTE_FMT "Setting Max: ",
5195                                                                 hd->ioc->name));
5196                 /* Set current to the max values. Update the config page.*/
5197                 dv->now.width = dv->max.width;
5198                 dv->now.offset = dv->max.offset;
5199                 dv->now.factor = dv->max.factor;
5200                 dv->now.flags = dv->max.flags;
5201
5202                 pPage1 = (SCSIDevicePage1_t *)pPage;
5203                 if (pPage1) {
5204                         mptscsih_setDevicePage1Flags (dv->now.width, dv->now.factor,
5205                                 dv->now.offset, &val, &configuration, dv->now.flags);
5206                         dnegoprintk(("Setting Max: id=%d width=%d factor=%x offset=%x negoFlags=%x request=%x config=%x\n",
5207                                 id, dv->now.width, dv->now.factor, dv->now.offset, dv->now.flags, val, configuration));
5208                         pPage1->RequestedParameters = cpu_to_le32(val);
5209                         pPage1->Reserved = 0;
5210                         pPage1->Configuration = cpu_to_le32(configuration);
5211                 }
5212
5213                 ddvprintk(("id=%d width=%d factor=%x offset=%x negoFlags=%x request=%x configuration=%x\n",
5214                                 id, dv->now.width, dv->now.factor, dv->now.offset, dv->now.flags, val, configuration));
5215                 break;
5216
5217         case MPT_SET_MIN:
5218                 ddvprintk((MYIOC_s_NOTE_FMT "Setting Min: ",
5219                                                                 hd->ioc->name));
5220                 /* Set page to asynchronous and narrow
5221                  * Do not update now, breaks fallback routine. */
5222                 width = MPT_NARROW;
5223                 offset = 0;
5224                 factor = MPT_ASYNC;
5225                 negoFlags = dv->max.flags;
5226
5227                 pPage1 = (SCSIDevicePage1_t *)pPage;
5228                 if (pPage1) {
5229                         mptscsih_setDevicePage1Flags (width, factor,
5230                                 offset, &val, &configuration, negoFlags);
5231                         dnegoprintk(("Setting Min: id=%d width=%d factor=%x offset=%x negoFlags=%x request=%x config=%x\n",
5232                                 id, width, factor, offset, negoFlags, val, configuration));
5233                         pPage1->RequestedParameters = cpu_to_le32(val);
5234                         pPage1->Reserved = 0;
5235                         pPage1->Configuration = cpu_to_le32(configuration);
5236                 }
5237                 ddvprintk(("id=%d width=%d factor=%x offset=%x request=%x config=%x negoFlags=%x\n",
5238                                 id, width, factor, offset, val, configuration, negoFlags));
5239                 break;
5240
5241         case MPT_FALLBACK:
5242                 ddvprintk((MYIOC_s_NOTE_FMT
5243                         "Fallback: Start: offset %d, factor %x, width %d \n",
5244                                 hd->ioc->name, dv->now.offset,
5245                                 dv->now.factor, dv->now.width));
5246                 width = dv->now.width;
5247                 offset = dv->now.offset;
5248                 factor = dv->now.factor;
5249                 if ((offset) && (dv->max.width)) {
5250                         if (factor < MPT_ULTRA160)
5251                                 factor = MPT_ULTRA160;
5252                         else if (factor < MPT_ULTRA2) {
5253                                 factor = MPT_ULTRA2;
5254                                 width = MPT_WIDE;
5255                         } else if ((factor == MPT_ULTRA2) && width) {
5256                                 factor = MPT_ULTRA2;
5257                                 width = MPT_NARROW;
5258                         } else if (factor < MPT_ULTRA) {
5259                                 factor = MPT_ULTRA;
5260                                 width = MPT_WIDE;
5261                         } else if ((factor == MPT_ULTRA) && width) {
5262                                 width = MPT_NARROW;
5263                         } else if (factor < MPT_FAST) {
5264                                 factor = MPT_FAST;
5265                                 width = MPT_WIDE;
5266                         } else if ((factor == MPT_FAST) && width) {
5267                                 factor = MPT_FAST;
5268                                 width = MPT_NARROW;
5269                         } else if (factor < MPT_SCSI) {
5270                                 factor = MPT_SCSI;
5271                                 width = MPT_WIDE;
5272                         } else if ((factor == MPT_SCSI) && width) {
5273                                 factor = MPT_SCSI;
5274                                 width = MPT_NARROW;
5275                         } else {
5276                                 factor = MPT_ASYNC;
5277                                 offset = 0;
5278                         }
5279
5280                 } else if (offset) {
5281                         width = MPT_NARROW;
5282                         if (factor < MPT_ULTRA)
5283                                 factor = MPT_ULTRA;
5284                         else if (factor < MPT_FAST)
5285                                 factor = MPT_FAST;
5286                         else if (factor < MPT_SCSI)
5287                                 factor = MPT_SCSI;
5288                         else {
5289                                 factor = MPT_ASYNC;
5290                                 offset = 0;
5291                         }
5292
5293                 } else {
5294                         width = MPT_NARROW;
5295                         factor = MPT_ASYNC;
5296                 }
5297                 dv->max.flags |= MPT_TARGET_NO_NEGO_QAS;
5298                 dv->max.flags &= ~MPT_TAPE_NEGO_IDP;
5299
5300                 dv->now.width = width;
5301                 dv->now.offset = offset;
5302                 dv->now.factor = factor;
5303                 dv->now.flags = dv->max.flags;
5304
5305                 pPage1 = (SCSIDevicePage1_t *)pPage;
5306                 if (pPage1) {
5307                         mptscsih_setDevicePage1Flags (width, factor, offset, &val,
5308                                                 &configuration, dv->now.flags);
5309                         dnegoprintk(("Finish: id=%d width=%d offset=%d factor=%x negoFlags=%x request=%x config=%x\n",
5310                              id, width, offset, factor, dv->now.flags, val, configuration));
5311
5312                         pPage1->RequestedParameters = cpu_to_le32(val);
5313                         pPage1->Reserved = 0;
5314                         pPage1->Configuration = cpu_to_le32(configuration);
5315                 }
5316
5317                 ddvprintk(("Finish: id=%d offset=%d factor=%x width=%d request=%x config=%x\n",
5318                              id, dv->now.offset, dv->now.factor, dv->now.width, val, configuration));
5319                 break;
5320
5321         case MPT_SAVE:
5322                 ddvprintk((MYIOC_s_NOTE_FMT
5323                         "Saving to Target structure: ", hd->ioc->name));
5324                 ddvprintk(("id=%d width=%x factor=%x offset=%d flags=%x\n",
5325                              id, dv->now.width, dv->now.factor, dv->now.offset, dv->now.flags));
5326
5327                 /* Save these values to target structures
5328                  * or overwrite nvram (phys disks only).
5329                  */
5330
5331                 if ((hd->Targets)&&((vtarget = hd->Targets[(int)id]) != NULL) && !vtarget->raidVolume ) {
5332                         vtarget->maxWidth = dv->now.width;
5333                         vtarget->maxOffset = dv->now.offset;
5334                         vtarget->minSyncFactor = dv->now.factor;
5335                         vtarget->negoFlags = dv->now.flags;
5336                 } else {
5337                         /* Preserv all flags, use
5338                          * read-modify-write algorithm
5339                          */
5340                         if (hd->ioc->spi_data.nvram) {
5341                                 data = hd->ioc->spi_data.nvram[id];
5342
5343                                 if (dv->now.width)
5344                                         data &= ~MPT_NVRAM_WIDE_DISABLE;
5345                                 else
5346                                         data |= MPT_NVRAM_WIDE_DISABLE;
5347
5348                                 if (!dv->now.offset)
5349                                         factor = MPT_ASYNC;
5350
5351                                 data &= ~MPT_NVRAM_SYNC_MASK;
5352                                 data |= (dv->now.factor << MPT_NVRAM_SYNC_SHIFT) & MPT_NVRAM_SYNC_MASK;
5353
5354                                 hd->ioc->spi_data.nvram[id] = data;
5355                         }
5356                 }
5357                 break;
5358         }
5359 }
5360
5361 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5362 /*      mptscsih_fillbuf - fill a buffer with a special data pattern
5363  *              cleanup. For bus scan only.
5364  *
5365  *      @buffer: Pointer to data buffer to be filled.
5366  *      @size: Number of bytes to fill
5367  *      @index: Pattern index
5368  *      @width: bus width, 0 (8 bits) or 1 (16 bits)
5369  */
5370 static void
5371 mptscsih_fillbuf(char *buffer, int size, int index, int width)
5372 {
5373         char *ptr = buffer;
5374         int ii;
5375         char byte;
5376         short val;
5377
5378         switch (index) {
5379         case 0:
5380
5381                 if (width) {
5382                         /* Pattern:  0000 FFFF 0000 FFFF
5383                          */
5384                         for (ii=0; ii < size; ii++, ptr++) {
5385                                 if (ii & 0x02)
5386                                         *ptr = 0xFF;
5387                                 else
5388                                         *ptr = 0x00;
5389                         }
5390                 } else {
5391                         /* Pattern:  00 FF 00 FF
5392                          */
5393                         for (ii=0; ii < size; ii++, ptr++) {
5394                                 if (ii & 0x01)
5395                                         *ptr = 0xFF;
5396                                 else
5397                                         *ptr = 0x00;
5398                         }
5399                 }
5400                 break;
5401
5402         case 1:
5403                 if (width) {
5404                         /* Pattern:  5555 AAAA 5555 AAAA 5555
5405                          */
5406                         for (ii=0; ii < size; ii++, ptr++) {
5407                                 if (ii & 0x02)
5408                                         *ptr = 0xAA;
5409                                 else
5410                                         *ptr = 0x55;
5411                         }
5412                 } else {
5413                         /* Pattern:  55 AA 55 AA 55
5414                          */
5415                         for (ii=0; ii < size; ii++, ptr++) {
5416                                 if (ii & 0x01)
5417                                         *ptr = 0xAA;
5418                                 else
5419                                         *ptr = 0x55;
5420                         }
5421                 }
5422                 break;
5423
5424         case 2:
5425                 /* Pattern:  00 01 02 03 04 05
5426                  * ... FE FF 00 01..
5427                  */
5428                 for (ii=0; ii < size; ii++, ptr++)
5429                         *ptr = (char) ii;
5430                 break;
5431
5432         case 3:
5433                 if (width) {
5434                         /* Wide Pattern:  FFFE 0001 FFFD 0002
5435                          * ...  4000 DFFF 8000 EFFF
5436                          */
5437                         byte = 0;
5438                         for (ii=0; ii < size/2; ii++) {
5439                                 /* Create the base pattern
5440                                  */
5441                                 val = (1 << byte);
5442                                 /* every 64 (0x40) bytes flip the pattern
5443                                  * since we fill 2 bytes / iteration,
5444                                  * test for ii = 0x20
5445                                  */
5446                                 if (ii & 0x20)
5447                                         val = ~(val);
5448
5449                                 if (ii & 0x01) {
5450                                         *ptr = (char)( (val & 0xFF00) >> 8);
5451                                         ptr++;
5452                                         *ptr = (char)(val & 0xFF);
5453                                         byte++;
5454                                         byte &= 0x0F;
5455                                 } else {
5456                                         val = ~val;
5457                                         *ptr = (char)( (val & 0xFF00) >> 8);
5458                                         ptr++;
5459                                         *ptr = (char)(val & 0xFF);
5460                                 }
5461
5462                                 ptr++;
5463                         }
5464                 } else {
5465                         /* Narrow Pattern:  FE 01 FD 02 FB 04
5466                          * .. 7F 80 01 FE 02 FD ...  80 7F
5467                          */
5468                         byte = 0;
5469                         for (ii=0; ii < size; ii++, ptr++) {
5470                                 /* Base pattern - first 32 bytes
5471                                  */
5472                                 if (ii & 0x01) {
5473                                         *ptr = (1 << byte);
5474                                         byte++;
5475                                         byte &= 0x07;
5476                                 } else {
5477                                         *ptr = (char) (~(1 << byte));
5478                                 }
5479
5480                                 /* Flip the pattern every 32 bytes
5481                                  */
5482                                 if (ii & 0x20)
5483                                         *ptr = ~(*ptr);
5484                         }
5485                 }
5486                 break;
5487         }
5488 }
5489
5490 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5491 /* If DV disabled (negoNvram set to USE_NVARM) or if not LUN 0, return.
5492  * Else set the NEED_DV flag after Read Capacity Issued (disks)
5493  * or Mode Sense (cdroms).
5494  *
5495  * Tapes, initTarget will set this flag on completion of Inquiry command.
5496  * Called only if DV_NOT_DONE flag is set
5497  */
5498 static void
5499 mptscsih_set_dvflags(MPT_SCSI_HOST *hd, struct scsi_cmnd *sc)
5500 {
5501         MPT_ADAPTER     *ioc = hd->ioc;
5502         u8 cmd;
5503         SpiCfgData      *pSpi;
5504
5505         ddvtprintk((MYIOC_s_NOTE_FMT
5506                 " set_dvflags: id=%d lun=%d negoNvram=%x cmd=%x\n",
5507                 hd->ioc->name, sc->device->id, sc->device->lun , hd->negoNvram, sc->cmnd[0]));
5508
5509         if ((sc->device->lun != 0) || (hd->negoNvram != 0))
5510                 return;
5511
5512         cmd = sc->cmnd[0];
5513
5514         if ((cmd == READ_CAPACITY) || (cmd == MODE_SENSE)) {
5515                 pSpi = &ioc->spi_data;
5516                 if ((ioc->raid_data.isRaid & (1 << sc->device->id)) && ioc->raid_data.pIocPg3) {
5517                         /* Set NEED_DV for all hidden disks
5518                          */
5519                         Ioc3PhysDisk_t *pPDisk =  ioc->raid_data.pIocPg3->PhysDisk;
5520                         int             numPDisk = ioc->raid_data.pIocPg3->NumPhysDisks;
5521
5522                         while (numPDisk) {
5523                                 pSpi->dvStatus[pPDisk->PhysDiskID] |= MPT_SCSICFG_NEED_DV;
5524                                 ddvtprintk(("NEED_DV set for phys disk id %d\n", pPDisk->PhysDiskID));
5525                                 pPDisk++;
5526                                 numPDisk--;
5527                         }
5528                 }
5529                 pSpi->dvStatus[sc->device->id] |= MPT_SCSICFG_NEED_DV;
5530                 ddvtprintk(("NEED_DV set for visible disk id %d\n", sc->device->id));
5531         }
5532 }
5533
5534 /* mptscsih_raid_set_dv_flags()
5535  *
5536  * New or replaced disk. Set DV flag and schedule DV.
5537  */
5538 static void
5539 mptscsih_set_dvflags_raid(MPT_SCSI_HOST *hd, int id)
5540 {
5541         MPT_ADAPTER     *ioc = hd->ioc;
5542         SpiCfgData      *pSpi = &ioc->spi_data;
5543         Ioc3PhysDisk_t  *pPDisk;
5544         int              numPDisk;
5545
5546         if (hd->negoNvram != 0)
5547                 return;
5548
5549         ddvtprintk(("DV requested for phys disk id %d\n", id));
5550         if (ioc->raid_data.pIocPg3) {
5551                 pPDisk =  ioc->raid_data.pIocPg3->PhysDisk;
5552                 numPDisk = ioc->raid_data.pIocPg3->NumPhysDisks;
5553                 while (numPDisk) {
5554                         if (id == pPDisk->PhysDiskNum) {
5555                                 pSpi->dvStatus[pPDisk->PhysDiskID] =
5556                                     (MPT_SCSICFG_NEED_DV | MPT_SCSICFG_DV_NOT_DONE);
5557                                 pSpi->forceDv = MPT_SCSICFG_NEED_DV;
5558                                 ddvtprintk(("NEED_DV set for phys disk id %d\n",
5559                                     pPDisk->PhysDiskID));
5560                                 break;
5561                         }
5562                         pPDisk++;
5563                         numPDisk--;
5564                 }
5565
5566                 if (numPDisk == 0) {
5567                         /* The physical disk that needs DV was not found
5568                          * in the stored IOC Page 3. The driver must reload
5569                          * this page. DV routine will set the NEED_DV flag for
5570                          * all phys disks that have DV_NOT_DONE set.
5571                          */
5572                         pSpi->forceDv = MPT_SCSICFG_NEED_DV | MPT_SCSICFG_RELOAD_IOC_PG3;
5573                         ddvtprintk(("phys disk %d not found. Setting reload IOC Pg3 Flag\n",id));
5574                 }
5575         }
5576 }
5577 #endif /* ~MPTSCSIH_ENABLE_DOMAIN_VALIDATION */
5578
5579 EXPORT_SYMBOL(mptscsih_remove);
5580 EXPORT_SYMBOL(mptscsih_shutdown);
5581 #ifdef CONFIG_PM
5582 EXPORT_SYMBOL(mptscsih_suspend);
5583 EXPORT_SYMBOL(mptscsih_resume);
5584 #endif
5585 EXPORT_SYMBOL(mptscsih_proc_info);
5586 EXPORT_SYMBOL(mptscsih_info);
5587 EXPORT_SYMBOL(mptscsih_qcmd);
5588 EXPORT_SYMBOL(mptscsih_target_alloc);
5589 EXPORT_SYMBOL(mptscsih_slave_alloc);
5590 EXPORT_SYMBOL(mptscsih_target_destroy);
5591 EXPORT_SYMBOL(mptscsih_slave_destroy);
5592 EXPORT_SYMBOL(mptscsih_slave_configure);
5593 EXPORT_SYMBOL(mptscsih_abort);
5594 EXPORT_SYMBOL(mptscsih_dev_reset);
5595 EXPORT_SYMBOL(mptscsih_bus_reset);
5596 EXPORT_SYMBOL(mptscsih_host_reset);
5597 EXPORT_SYMBOL(mptscsih_bios_param);
5598 EXPORT_SYMBOL(mptscsih_io_done);
5599 EXPORT_SYMBOL(mptscsih_taskmgmt_complete);
5600 EXPORT_SYMBOL(mptscsih_scandv_complete);
5601 EXPORT_SYMBOL(mptscsih_event_process);
5602 EXPORT_SYMBOL(mptscsih_ioc_reset);
5603 EXPORT_SYMBOL(mptscsih_change_queue_depth);
5604 EXPORT_SYMBOL(mptscsih_timer_expired);
5605
5606 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/