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