drivers/message/fusion/mptscsih.c

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