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

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