err.no Git - linux-2.6/blob - drivers/message/fusion/mptspi.c

   1 /*
   2  *  linux/drivers/message/fusion/mptspi.c
   3  *      For use with LSI Logic PCI chip/adapter(s)
   4  *      running LSI Logic Fusion MPT (Message Passing Technology) firmware.
   5  *
   6  *  Copyright (c) 1999-2007 LSI Logic Corporation
   7  *  (mailto:DL-MPTFusionLinux@lsi.com)
   8  *
   9  */
  10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  11 /*
  12     This program is free software; you can redistribute it and/or modify
  13     it under the terms of the GNU General Public License as published by
  14     the Free Software Foundation; version 2 of the License.
  15
  16     This program is distributed in the hope that it will be useful,
  17     but WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19     GNU General Public License for more details.
  20
  21     NO WARRANTY
  22     THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  23     CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  24     LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  25     MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  26     solely responsible for determining the appropriateness of using and
  27     distributing the Program and assumes all risks associated with its
  28     exercise of rights under this Agreement, including but not limited to
  29     the risks and costs of program errors, damage to or loss of data,
  30     programs or equipment, and unavailability or interruption of operations.
  31
  32     DISCLAIMER OF LIABILITY
  33     NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  34     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  35     DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  36     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  37     TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  38     USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  39     HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  40
  41     You should have received a copy of the GNU General Public License
  42     along with this program; if not, write to the Free Software
  43     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  44 */
  45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  46
  47 #include <linux/module.h>
  48 #include <linux/kernel.h>
  49 #include <linux/init.h>
  50 #include <linux/errno.h>
  51 #include <linux/kdev_t.h>
  52 #include <linux/blkdev.h>
  53 #include <linux/delay.h>        /* for mdelay */
  54 #include <linux/interrupt.h>    /* needed for in_interrupt() proto */
  55 #include <linux/reboot.h>       /* notifier code */
  56 #include <linux/workqueue.h>
  57 #include <linux/raid_class.h>
  58
  59 #include <scsi/scsi.h>
  60 #include <scsi/scsi_cmnd.h>
  61 #include <scsi/scsi_device.h>
  62 #include <scsi/scsi_host.h>
  63 #include <scsi/scsi_tcq.h>
  64 #include <scsi/scsi_transport.h>
  65 #include <scsi/scsi_transport_spi.h>
  66 #include <scsi/scsi_dbg.h>
  67
  68 #include "mptbase.h"
  69 #include "mptscsih.h"
  70
  71 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  72 #define my_NAME         "Fusion MPT SPI Host driver"
  73 #define my_VERSION      MPT_LINUX_VERSION_COMMON
  74 #define MYNAM           "mptspi"
  75
  76 MODULE_AUTHOR(MODULEAUTHOR);
  77 MODULE_DESCRIPTION(my_NAME);
  78 MODULE_LICENSE("GPL");
  79 MODULE_VERSION(my_VERSION);
  80
  81 /* Command line args */
  82 static int mpt_saf_te = MPTSCSIH_SAF_TE;
  83 module_param(mpt_saf_te, int, 0);
  84 MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1  (default=MPTSCSIH_SAF_TE=0)");
  85
  86 static void mptspi_write_offset(struct scsi_target *, int);
  87 static void mptspi_write_width(struct scsi_target *, int);
  88 static int mptspi_write_spi_device_pg1(struct scsi_target *,
  89                                        struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
  90
  91 static struct scsi_transport_template *mptspi_transport_template = NULL;
  92
  93 static int      mptspiDoneCtx = -1;
  94 static int      mptspiTaskCtx = -1;
  95 static int      mptspiInternalCtx = -1; /* Used only for internal commands */
  96
  97 /**
  98  *      mptspi_setTargetNegoParms  - Update the target negotiation parameters
  99  *      @hd: Pointer to a SCSI Host Structure
 100  *      @target: per target private data
 101  *      @sdev: SCSI device
 102  *
 103  *      Update the target negotiation parameters based on the the Inquiry
 104  *      data, adapter capabilities, and NVRAM settings.
 105  **/
 106 static void
 107 mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
 108                             struct scsi_device *sdev)
 109 {
 110         SpiCfgData *pspi_data = &hd->ioc->spi_data;
 111         int  id = (int) target->id;
 112         int  nvram;
 113         u8 width = MPT_NARROW;
 114         u8 factor = MPT_ASYNC;
 115         u8 offset = 0;
 116         u8 nfactor;
 117         u8 noQas = 1;
 118
 119         target->negoFlags = pspi_data->noQas;
 120
 121         if (sdev->scsi_level < SCSI_2) {
 122                 width = 0;
 123                 factor = MPT_ULTRA2;
 124                 offset = pspi_data->maxSyncOffset;
 125                 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
 126         } else {
 127                 if (scsi_device_wide(sdev))
 128                         width = 1;
 129
 130                 if (scsi_device_sync(sdev)) {
 131                         factor = pspi_data->minSyncFactor;
 132                         if (!scsi_device_dt(sdev))
 133                                         factor = MPT_ULTRA2;
 134                         else {
 135                                 if (!scsi_device_ius(sdev) &&
 136                                     !scsi_device_qas(sdev))
 137                                         factor = MPT_ULTRA160;
 138                                 else {
 139                                         factor = MPT_ULTRA320;
 140                                         if (scsi_device_qas(sdev)) {
 141                                                 ddvprintk((KERN_INFO "Enabling QAS due to byte56=%02x on id=%d!\n", scsi_device_qas(sdev), id));
 142                                                 noQas = 0;
 143                                         }
 144                                         if (sdev->type == TYPE_TAPE &&
 145                                             scsi_device_ius(sdev))
 146                                                 target->negoFlags |= MPT_TAPE_NEGO_IDP;
 147                                 }
 148                         }
 149                         offset = pspi_data->maxSyncOffset;
 150
 151                         /* If RAID, never disable QAS
 152                          * else if non RAID, do not disable
 153                          *   QAS if bit 1 is set
 154                          * bit 1 QAS support, non-raid only
 155                          * bit 0 IU support
 156                          */
 157                         if (target->raidVolume == 1)
 158                                 noQas = 0;
 159                 } else {
 160                         factor = MPT_ASYNC;
 161                         offset = 0;
 162                 }
 163         }
 164
 165         if (!sdev->tagged_supported)
 166                 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
 167
 168         /* Update tflags based on NVRAM settings. (SCSI only)
 169          */
 170         if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
 171                 nvram = pspi_data->nvram[id];
 172                 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
 173
 174                 if (width)
 175                         width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
 176
 177                 if (offset > 0) {
 178                         /* Ensure factor is set to the
 179                          * maximum of: adapter, nvram, inquiry
 180                          */
 181                         if (nfactor) {
 182                                 if (nfactor < pspi_data->minSyncFactor )
 183                                         nfactor = pspi_data->minSyncFactor;
 184
 185                                 factor = max(factor, nfactor);
 186                                 if (factor == MPT_ASYNC)
 187                                         offset = 0;
 188                         } else {
 189                                 offset = 0;
 190                                 factor = MPT_ASYNC;
 191                 }
 192                 } else {
 193                         factor = MPT_ASYNC;
 194                 }
 195         }
 196
 197         /* Make sure data is consistent
 198          */
 199         if ((!width) && (factor < MPT_ULTRA2))
 200                 factor = MPT_ULTRA2;
 201
 202         /* Save the data to the target structure.
 203          */
 204         target->minSyncFactor = factor;
 205         target->maxOffset = offset;
 206         target->maxWidth = width;
 207
 208         target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
 209
 210         /* Disable unused features.
 211          */
 212         if (!width)
 213                 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
 214
 215         if (!offset)
 216                 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
 217
 218         if ( factor > MPT_ULTRA320 )
 219                 noQas = 0;
 220
 221         if (noQas && (pspi_data->noQas == 0)) {
 222                 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
 223                 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
 224
 225                 /* Disable QAS in a mixed configuration case
 226                  */
 227
 228                 ddvprintk((KERN_INFO "Disabling QAS due to noQas=%02x on id=%d!\n", noQas, id));
 229         }
 230 }
 231
 232 /**
 233  *      mptspi_writeIOCPage4  - write IOC Page 4
 234  *      @hd: Pointer to a SCSI Host Structure
 235  *      @channel: channel number
 236  *      @id: write IOC Page4 for this ID & Bus
 237  *
 238  *      Return: -EAGAIN if unable to obtain a Message Frame
 239  *              or 0 if success.
 240  *
 241  *      Remark: We do not wait for a return, write pages sequentially.
 242  **/
 243 static int
 244 mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
 245 {
 246         MPT_ADAPTER             *ioc = hd->ioc;
 247         Config_t                *pReq;
 248         IOCPage4_t              *IOCPage4Ptr;
 249         MPT_FRAME_HDR           *mf;
 250         dma_addr_t               dataDma;
 251         u16                      req_idx;
 252         u32                      frameOffset;
 253         u32                      flagsLength;
 254         int                      ii;
 255
 256         /* Get a MF for this command.
 257          */
 258         if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
 259                 dfailprintk((MYIOC_s_WARN_FMT "writeIOCPage4 : no msg frames!\n",
 260                                         ioc->name));
 261                 return -EAGAIN;
 262         }
 263
 264         /* Set the request and the data pointers.
 265          * Place data at end of MF.
 266          */
 267         pReq = (Config_t *)mf;
 268
 269         req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
 270         frameOffset = ioc->req_sz - sizeof(IOCPage4_t);
 271
 272         /* Complete the request frame (same for all requests).
 273          */
 274         pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 275         pReq->Reserved = 0;
 276         pReq->ChainOffset = 0;
 277         pReq->Function = MPI_FUNCTION_CONFIG;
 278         pReq->ExtPageLength = 0;
 279         pReq->ExtPageType = 0;
 280         pReq->MsgFlags = 0;
 281         for (ii=0; ii < 8; ii++) {
 282                 pReq->Reserved2[ii] = 0;
 283         }
 284
 285         IOCPage4Ptr = ioc->spi_data.pIocPg4;
 286         dataDma = ioc->spi_data.IocPg4_dma;
 287         ii = IOCPage4Ptr->ActiveSEP++;
 288         IOCPage4Ptr->SEP[ii].SEPTargetID = id;
 289         IOCPage4Ptr->SEP[ii].SEPBus = channel;
 290         pReq->Header = IOCPage4Ptr->Header;
 291         pReq->PageAddress = cpu_to_le32(id | (channel << 8 ));
 292
 293         /* Add a SGE to the config request.
 294          */
 295         flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
 296                 (IOCPage4Ptr->Header.PageLength + ii) * 4;
 297
 298         mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
 299
 300         ddvprintk((MYIOC_s_INFO_FMT
 301                 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
 302                         ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
 303
 304         mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
 305
 306         return 0;
 307 }
 308
 309 /**
 310  *      mptspi_initTarget - Target, LUN alloc/free functionality.
 311  *      @hd: Pointer to MPT_SCSI_HOST structure
 312  *      @vtarget: per target private data
 313  *      @sdev: SCSI device
 314  *
 315  *      NOTE: It's only SAFE to call this routine if data points to
 316  *      sane & valid STANDARD INQUIRY data!
 317  *
 318  *      Allocate and initialize memory for this target.
 319  *      Save inquiry data.
 320  *
 321  **/
 322 static void
 323 mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
 324                     struct scsi_device *sdev)
 325 {
 326
 327         /* Is LUN supported? If so, upper 2 bits will be 0
 328         * in first byte of inquiry data.
 329         */
 330         if (sdev->inq_periph_qual != 0)
 331                 return;
 332
 333         if (vtarget == NULL)
 334                 return;
 335
 336         vtarget->type = sdev->type;
 337
 338         if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
 339                 /* Treat all Processors as SAF-TE if
 340                  * command line option is set */
 341                 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
 342                 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
 343         }else if ((sdev->type == TYPE_PROCESSOR) &&
 344                 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
 345                 if (sdev->inquiry_len > 49 ) {
 346                         if (sdev->inquiry[44] == 'S' &&
 347                             sdev->inquiry[45] == 'A' &&
 348                             sdev->inquiry[46] == 'F' &&
 349                             sdev->inquiry[47] == '-' &&
 350                             sdev->inquiry[48] == 'T' &&
 351                             sdev->inquiry[49] == 'E' ) {
 352                                 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
 353                                 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
 354                         }
 355                 }
 356         }
 357         mptspi_setTargetNegoParms(hd, vtarget, sdev);
 358 }
 359
 360 /**
 361  *      mptspi_is_raid - Determines whether target is belonging to volume
 362  *      @hd: Pointer to a SCSI HOST structure
 363  *      @id: target device id
 364  *
 365  *      Return:
 366  *              non-zero = true
 367  *              zero = false
 368  *
 369  */
 370 static int
 371 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
 372 {
 373         int i, rc = 0;
 374
 375         if (!hd->ioc->raid_data.pIocPg2)
 376                 goto out;
 377
 378         if (!hd->ioc->raid_data.pIocPg2->NumActiveVolumes)
 379                 goto out;
 380         for (i=0; i < hd->ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
 381                 if (hd->ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
 382                         rc = 1;
 383                         goto out;
 384                 }
 385         }
 386
 387  out:
 388         return rc;
 389 }
 390
 391 static int mptspi_target_alloc(struct scsi_target *starget)
 392 {
 393         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 394         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
 395         VirtTarget              *vtarget;
 396
 397         if (hd == NULL)
 398                 return -ENODEV;
 399
 400         vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
 401         if (!vtarget)
 402                 return -ENOMEM;
 403
 404         vtarget->ioc_id = hd->ioc->id;
 405         vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
 406         vtarget->id = (u8)starget->id;
 407         vtarget->channel = (u8)starget->channel;
 408         vtarget->starget = starget;
 409         starget->hostdata = vtarget;
 410
 411         if (starget->channel == 1) {
 412                 if (mptscsih_is_phys_disk(hd->ioc, 0, starget->id) == 0)
 413                         return 0;
 414                 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
 415                 /* The real channel for this device is zero */
 416                 vtarget->channel = 0;
 417                 /* The actual physdisknum (for RAID passthrough) */
 418                 vtarget->id = mptscsih_raid_id_to_num(hd->ioc, 0,
 419                     starget->id);
 420         }
 421
 422         if (starget->channel == 0 &&
 423             mptspi_is_raid(hd, starget->id)) {
 424                 vtarget->raidVolume = 1;
 425                 ddvprintk((KERN_INFO
 426                     "RAID Volume @ channel=%d id=%d\n", starget->channel,
 427                     starget->id));
 428         }
 429
 430         if (hd->ioc->spi_data.nvram &&
 431             hd->ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
 432                 u32 nvram = hd->ioc->spi_data.nvram[starget->id];
 433                 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
 434                 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
 435         } else {
 436                 spi_min_period(starget) = hd->ioc->spi_data.minSyncFactor;
 437                 spi_max_width(starget) = hd->ioc->spi_data.maxBusWidth;
 438         }
 439         spi_max_offset(starget) = hd->ioc->spi_data.maxSyncOffset;
 440
 441         spi_offset(starget) = 0;
 442         mptspi_write_width(starget, 0);
 443
 444         return 0;
 445 }
 446
 447 static void
 448 mptspi_target_destroy(struct scsi_target *starget)
 449 {
 450         if (starget->hostdata)
 451                 kfree(starget->hostdata);
 452         starget->hostdata = NULL;
 453 }
 454
 455 /**
 456  *      mptspi_print_write_nego - negotiation parameters debug info that is being sent
 457  *      @hd: Pointer to a SCSI HOST structure
 458  *      @starget: SCSI target
 459  *      @ii: negotiation parameters
 460  *
 461  */
 462 static void
 463 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
 464 {
 465         ddvprintk((MYIOC_s_INFO_FMT "id=%d Requested = 0x%08x"
 466             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
 467             hd->ioc->name, starget->id, ii,
 468             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
 469             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
 470             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
 471             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
 472             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
 473             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
 474             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
 475             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
 476             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
 477             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
 478 }
 479
 480 /**
 481  *      mptspi_print_read_nego - negotiation parameters debug info that is being read
 482  *      @hd: Pointer to a SCSI HOST structure
 483  *      @starget: SCSI target
 484  *      @ii: negotiation parameters
 485  *
 486  */
 487 static void
 488 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
 489 {
 490         ddvprintk((MYIOC_s_INFO_FMT "id=%d Read = 0x%08x"
 491             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
 492             hd->ioc->name, starget->id, ii,
 493             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
 494             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
 495             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
 496             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
 497             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
 498             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
 499             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
 500             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
 501             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
 502             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
 503 }
 504
 505 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
 506                              struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
 507 {
 508         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 509         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
 510         struct _MPT_ADAPTER *ioc = hd->ioc;
 511         struct _CONFIG_PAGE_SCSI_DEVICE_0 *pg0;
 512         dma_addr_t pg0_dma;
 513         int size;
 514         struct _x_config_parms cfg;
 515         struct _CONFIG_PAGE_HEADER hdr;
 516         int err = -EBUSY;
 517
 518         /* No SPI parameters for RAID devices */
 519         if (starget->channel == 0 &&
 520             mptspi_is_raid(hd, starget->id))
 521                 return -1;
 522
 523         size = ioc->spi_data.sdp0length * 4;
 524         /*
 525         if (ioc->spi_data.sdp0length & 1)
 526                 size += size + 4;
 527         size += 2048;
 528         */
 529
 530         pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg0_dma, GFP_KERNEL);
 531         if (pg0 == NULL) {
 532                 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
 533                 return -EINVAL;
 534         }
 535
 536         memset(&hdr, 0, sizeof(hdr));
 537
 538         hdr.PageVersion = ioc->spi_data.sdp0version;
 539         hdr.PageLength = ioc->spi_data.sdp0length;
 540         hdr.PageNumber = 0;
 541         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 542
 543         memset(&cfg, 0, sizeof(cfg));
 544
 545         cfg.cfghdr.hdr = &hdr;
 546         cfg.physAddr = pg0_dma;
 547         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 548         cfg.dir = 0;
 549         cfg.pageAddr = starget->id;
 550
 551         if (mpt_config(ioc, &cfg)) {
 552                 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
 553                 goto out_free;
 554         }
 555         err = 0;
 556         memcpy(pass_pg0, pg0, size);
 557
 558         mptspi_print_read_nego(hd, starget, le32_to_cpu(pg0->NegotiatedParameters));
 559
 560  out_free:
 561         dma_free_coherent(&ioc->pcidev->dev, size, pg0, pg0_dma);
 562         return err;
 563 }
 564
 565 static u32 mptspi_getRP(struct scsi_target *starget)
 566 {
 567         u32 nego = 0;
 568
 569         nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
 570         nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
 571         nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
 572         nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
 573         nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
 574         nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
 575         nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
 576         nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
 577
 578         nego |= (spi_period(starget) <<  MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
 579         nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
 580         nego |= spi_width(starget) ?  MPI_SCSIDEVPAGE1_RP_WIDE : 0;
 581
 582         return nego;
 583 }
 584
 585 static void mptspi_read_parameters(struct scsi_target *starget)
 586 {
 587         int nego;
 588         struct _CONFIG_PAGE_SCSI_DEVICE_0 pg0;
 589
 590         mptspi_read_spi_device_pg0(starget, &pg0);
 591
 592         nego = le32_to_cpu(pg0.NegotiatedParameters);
 593
 594         spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
 595         spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
 596         spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
 597         spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
 598         spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
 599         spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
 600         spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
 601         spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
 602         spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
 603         spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
 604         spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
 605 }
 606
 607 static int
 608 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
 609 {
 610         MpiRaidActionRequest_t  *pReq;
 611         MPT_FRAME_HDR           *mf;
 612
 613         /* Get and Populate a free Frame
 614          */
 615         if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
 616                 ddvprintk((MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
 617                                         hd->ioc->name));
 618                 return -EAGAIN;
 619         }
 620         pReq = (MpiRaidActionRequest_t *)mf;
 621         if (quiesce)
 622                 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
 623         else
 624                 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
 625         pReq->Reserved1 = 0;
 626         pReq->ChainOffset = 0;
 627         pReq->Function = MPI_FUNCTION_RAID_ACTION;
 628         pReq->VolumeID = id;
 629         pReq->VolumeBus = channel;
 630         pReq->PhysDiskNum = 0;
 631         pReq->MsgFlags = 0;
 632         pReq->Reserved2 = 0;
 633         pReq->ActionDataWord = 0; /* Reserved for this action */
 634
 635         mpt_add_sge((char *)&pReq->ActionDataSGE,
 636                 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
 637
 638         ddvprintk((MYIOC_s_INFO_FMT "RAID Volume action=%x channel=%d id=%d\n",
 639                         hd->ioc->name, pReq->Action, channel, id));
 640
 641         hd->pLocal = NULL;
 642         hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
 643         hd->scandv_wait_done = 0;
 644
 645         /* Save cmd pointer, for resource free if timeout or
 646          * FW reload occurs
 647          */
 648         hd->cmdPtr = mf;
 649
 650         add_timer(&hd->timer);
 651         mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
 652         wait_event(hd->scandv_waitq, hd->scandv_wait_done);
 653
 654         if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
 655                 return -1;
 656
 657         return 0;
 658 }
 659
 660 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
 661                              struct scsi_device *sdev)
 662 {
 663         VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 664
 665         /* no DV on RAID devices */
 666         if (sdev->channel == 0 &&
 667             mptspi_is_raid(hd, sdev->id))
 668                 return;
 669
 670         /* If this is a piece of a RAID, then quiesce first */
 671         if (sdev->channel == 1 &&
 672             mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
 673                 starget_printk(KERN_ERR, scsi_target(sdev),
 674                                "Integrated RAID quiesce failed\n");
 675                 return;
 676         }
 677
 678         hd->spi_pending |= (1 << sdev->id);
 679         spi_dv_device(sdev);
 680         hd->spi_pending &= ~(1 << sdev->id);
 681
 682         if (sdev->channel == 1 &&
 683             mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
 684                 starget_printk(KERN_ERR, scsi_target(sdev),
 685                                "Integrated RAID resume failed\n");
 686
 687         mptspi_read_parameters(sdev->sdev_target);
 688         spi_display_xfer_agreement(sdev->sdev_target);
 689         mptspi_read_parameters(sdev->sdev_target);
 690 }
 691
 692 static int mptspi_slave_alloc(struct scsi_device *sdev)
 693 {
 694         MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
 695         VirtTarget              *vtarget;
 696         VirtDevice              *vdev;
 697         struct scsi_target      *starget;
 698
 699         if (sdev->channel == 1 &&
 700                 mptscsih_is_phys_disk(hd->ioc, 0, sdev->id) == 0)
 701                         return -ENXIO;
 702
 703         vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
 704         if (!vdev) {
 705                 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
 706                                 hd->ioc->name, sizeof(VirtDevice));
 707                 return -ENOMEM;
 708         }
 709
 710         vdev->lun = sdev->lun;
 711         sdev->hostdata = vdev;
 712
 713         starget = scsi_target(sdev);
 714         vtarget = starget->hostdata;
 715         vdev->vtarget = vtarget;
 716         vtarget->num_luns++;
 717
 718         if (sdev->channel == 1)
 719                 sdev->no_uld_attach = 1;
 720
 721         return 0;
 722 }
 723
 724 static int mptspi_slave_configure(struct scsi_device *sdev)
 725 {
 726         struct _MPT_SCSI_HOST *hd =
 727                 (struct _MPT_SCSI_HOST *)sdev->host->hostdata;
 728         VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 729         int ret = mptscsih_slave_configure(sdev);
 730
 731         if (ret)
 732                 return ret;
 733
 734         mptspi_initTarget(hd, vtarget, sdev);
 735
 736         ddvprintk((MYIOC_s_INFO_FMT "id=%d min_period=0x%02x"
 737                 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
 738                 sdev->id, spi_min_period(scsi_target(sdev)),
 739                 spi_max_offset(scsi_target(sdev)),
 740                 spi_max_width(scsi_target(sdev))));
 741
 742         if ((sdev->channel == 1 ||
 743              !(mptspi_is_raid(hd, sdev->id))) &&
 744             !spi_initial_dv(sdev->sdev_target))
 745                 mptspi_dv_device(hd, sdev);
 746
 747         return 0;
 748 }
 749
 750 static int
 751 mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
 752 {
 753         struct _MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata;
 754         VirtDevice      *vdev = SCpnt->device->hostdata;
 755
 756         if (!vdev || !vdev->vtarget) {
 757                 SCpnt->result = DID_NO_CONNECT << 16;
 758                 done(SCpnt);
 759                 return 0;
 760         }
 761
 762         if (SCpnt->device->channel == 1 &&
 763                 mptscsih_is_phys_disk(hd->ioc, 0, SCpnt->device->id) == 0) {
 764                 SCpnt->result = DID_NO_CONNECT << 16;
 765                 done(SCpnt);
 766                 return 0;
 767         }
 768
 769 #ifdef MPT_DEBUG_DV
 770         if (spi_dv_pending(scsi_target(SCpnt->device)))
 771                 scsi_print_command(SCpnt);
 772 #endif
 773
 774         return mptscsih_qcmd(SCpnt,done);
 775 }
 776
 777 static void mptspi_slave_destroy(struct scsi_device *sdev)
 778 {
 779         struct scsi_target *starget = scsi_target(sdev);
 780         VirtTarget *vtarget = starget->hostdata;
 781         VirtDevice *vdevice = sdev->hostdata;
 782
 783         /* Will this be the last lun on a non-raid device? */
 784         if (vtarget->num_luns == 1 && vdevice->configured_lun) {
 785                 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 786
 787                 /* Async Narrow */
 788                 pg1.RequestedParameters = 0;
 789                 pg1.Reserved = 0;
 790                 pg1.Configuration = 0;
 791
 792                 mptspi_write_spi_device_pg1(starget, &pg1);
 793         }
 794
 795         mptscsih_slave_destroy(sdev);
 796 }
 797
 798 static struct scsi_host_template mptspi_driver_template = {
 799         .module                         = THIS_MODULE,
 800         .proc_name                      = "mptspi",
 801         .proc_info                      = mptscsih_proc_info,
 802         .name                           = "MPT SPI Host",
 803         .info                           = mptscsih_info,
 804         .queuecommand                   = mptspi_qcmd,
 805         .target_alloc                   = mptspi_target_alloc,
 806         .slave_alloc                    = mptspi_slave_alloc,
 807         .slave_configure                = mptspi_slave_configure,
 808         .target_destroy                 = mptspi_target_destroy,
 809         .slave_destroy                  = mptspi_slave_destroy,
 810         .change_queue_depth             = mptscsih_change_queue_depth,
 811         .eh_abort_handler               = mptscsih_abort,
 812         .eh_device_reset_handler        = mptscsih_dev_reset,
 813         .eh_bus_reset_handler           = mptscsih_bus_reset,
 814         .eh_host_reset_handler          = mptscsih_host_reset,
 815         .bios_param                     = mptscsih_bios_param,
 816         .can_queue                      = MPT_SCSI_CAN_QUEUE,
 817         .this_id                        = -1,
 818         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
 819         .max_sectors                    = 8192,
 820         .cmd_per_lun                    = 7,
 821         .use_clustering                 = ENABLE_CLUSTERING,
 822 };
 823
 824 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
 825                                struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
 826 {
 827         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 828         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
 829         struct _MPT_ADAPTER *ioc = hd->ioc;
 830         struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
 831         dma_addr_t pg1_dma;
 832         int size;
 833         struct _x_config_parms cfg;
 834         struct _CONFIG_PAGE_HEADER hdr;
 835         int err = -EBUSY;
 836
 837         /* don't allow updating nego parameters on RAID devices */
 838         if (starget->channel == 0 &&
 839             mptspi_is_raid(hd, starget->id))
 840                 return -1;
 841
 842         size = ioc->spi_data.sdp1length * 4;
 843
 844         pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
 845         if (pg1 == NULL) {
 846                 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
 847                 return -EINVAL;
 848         }
 849
 850         memset(&hdr, 0, sizeof(hdr));
 851
 852         hdr.PageVersion = ioc->spi_data.sdp1version;
 853         hdr.PageLength = ioc->spi_data.sdp1length;
 854         hdr.PageNumber = 1;
 855         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 856
 857         memset(&cfg, 0, sizeof(cfg));
 858
 859         cfg.cfghdr.hdr = &hdr;
 860         cfg.physAddr = pg1_dma;
 861         cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 862         cfg.dir = 1;
 863         cfg.pageAddr = starget->id;
 864
 865         memcpy(pg1, pass_pg1, size);
 866
 867         pg1->Header.PageVersion = hdr.PageVersion;
 868         pg1->Header.PageLength = hdr.PageLength;
 869         pg1->Header.PageNumber = hdr.PageNumber;
 870         pg1->Header.PageType = hdr.PageType;
 871
 872         mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
 873
 874         if (mpt_config(ioc, &cfg)) {
 875                 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
 876                 goto out_free;
 877         }
 878         err = 0;
 879
 880  out_free:
 881         dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
 882         return err;
 883 }
 884
 885 static void mptspi_write_offset(struct scsi_target *starget, int offset)
 886 {
 887         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 888         u32 nego;
 889
 890         if (offset < 0)
 891                 offset = 0;
 892
 893         if (offset > 255)
 894                 offset = 255;
 895
 896         if (spi_offset(starget) == -1)
 897                 mptspi_read_parameters(starget);
 898
 899         spi_offset(starget) = offset;
 900
 901         nego = mptspi_getRP(starget);
 902
 903         pg1.RequestedParameters = cpu_to_le32(nego);
 904         pg1.Reserved = 0;
 905         pg1.Configuration = 0;
 906
 907         mptspi_write_spi_device_pg1(starget, &pg1);
 908 }
 909
 910 static void mptspi_write_period(struct scsi_target *starget, int period)
 911 {
 912         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 913         u32 nego;
 914
 915         if (period < 8)
 916                 period = 8;
 917
 918         if (period > 255)
 919                 period = 255;
 920
 921         if (spi_period(starget) == -1)
 922                 mptspi_read_parameters(starget);
 923
 924         if (period == 8) {
 925                 spi_iu(starget) = 1;
 926                 spi_dt(starget) = 1;
 927         } else if (period == 9) {
 928                 spi_dt(starget) = 1;
 929         }
 930
 931         spi_period(starget) = period;
 932
 933         nego = mptspi_getRP(starget);
 934
 935         pg1.RequestedParameters = cpu_to_le32(nego);
 936         pg1.Reserved = 0;
 937         pg1.Configuration = 0;
 938
 939         mptspi_write_spi_device_pg1(starget, &pg1);
 940 }
 941
 942 static void mptspi_write_dt(struct scsi_target *starget, int dt)
 943 {
 944         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 945         u32 nego;
 946
 947         if (spi_period(starget) == -1)
 948                 mptspi_read_parameters(starget);
 949
 950         if (!dt && spi_period(starget) < 10)
 951                 spi_period(starget) = 10;
 952
 953         spi_dt(starget) = dt;
 954
 955         nego = mptspi_getRP(starget);
 956
 957
 958         pg1.RequestedParameters = cpu_to_le32(nego);
 959         pg1.Reserved = 0;
 960         pg1.Configuration = 0;
 961
 962         mptspi_write_spi_device_pg1(starget, &pg1);
 963 }
 964
 965 static void mptspi_write_iu(struct scsi_target *starget, int iu)
 966 {
 967         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 968         u32 nego;
 969
 970         if (spi_period(starget) == -1)
 971                 mptspi_read_parameters(starget);
 972
 973         if (!iu && spi_period(starget) < 9)
 974                 spi_period(starget) = 9;
 975
 976         spi_iu(starget) = iu;
 977
 978         nego = mptspi_getRP(starget);
 979
 980         pg1.RequestedParameters = cpu_to_le32(nego);
 981         pg1.Reserved = 0;
 982         pg1.Configuration = 0;
 983
 984         mptspi_write_spi_device_pg1(starget, &pg1);
 985 }
 986
 987 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm)                              \
 988 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
 989 {                                                                       \
 990         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;                          \
 991         u32 nego;                                                       \
 992                                                                         \
 993         spi_##parm(starget) = parm;                                     \
 994                                                                         \
 995         nego = mptspi_getRP(starget);                                   \
 996                                                                         \
 997         pg1.RequestedParameters = cpu_to_le32(nego);                    \
 998         pg1.Reserved = 0;                                               \
 999         pg1.Configuration = 0;                                          \
1000                                                                         \
1001         mptspi_write_spi_device_pg1(starget, &pg1);                             \
1002 }
1003
1004 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1005 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1006 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1007 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1008 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1009
1010 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1011 {
1012         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1013         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1014         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
1015         VirtTarget *vtarget = starget->hostdata;
1016         u32 nego;
1017
1018         if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1019             hd->ioc->spi_data.noQas)
1020                 spi_qas(starget) = 0;
1021         else
1022                 spi_qas(starget) = qas;
1023
1024         nego = mptspi_getRP(starget);
1025
1026         pg1.RequestedParameters = cpu_to_le32(nego);
1027         pg1.Reserved = 0;
1028         pg1.Configuration = 0;
1029
1030         mptspi_write_spi_device_pg1(starget, &pg1);
1031 }
1032
1033 static void mptspi_write_width(struct scsi_target *starget, int width)
1034 {
1035         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1036         u32 nego;
1037
1038         if (!width) {
1039                 spi_dt(starget) = 0;
1040                 if (spi_period(starget) < 10)
1041                         spi_period(starget) = 10;
1042         }
1043
1044         spi_width(starget) = width;
1045
1046         nego = mptspi_getRP(starget);
1047
1048         pg1.RequestedParameters = cpu_to_le32(nego);
1049         pg1.Reserved = 0;
1050         pg1.Configuration = 0;
1051
1052         mptspi_write_spi_device_pg1(starget, &pg1);
1053 }
1054
1055 struct work_queue_wrapper {
1056         struct work_struct      work;
1057         struct _MPT_SCSI_HOST   *hd;
1058         int                     disk;
1059 };
1060
1061 static void mpt_work_wrapper(struct work_struct *work)
1062 {
1063         struct work_queue_wrapper *wqw =
1064                 container_of(work, struct work_queue_wrapper, work);
1065         struct _MPT_SCSI_HOST *hd = wqw->hd;
1066         struct Scsi_Host *shost = hd->ioc->sh;
1067         struct scsi_device *sdev;
1068         int disk = wqw->disk;
1069         struct _CONFIG_PAGE_IOC_3 *pg3;
1070
1071         kfree(wqw);
1072
1073         mpt_findImVolumes(hd->ioc);
1074         pg3 = hd->ioc->raid_data.pIocPg3;
1075         if (!pg3)
1076                 return;
1077
1078         shost_for_each_device(sdev,shost) {
1079                 struct scsi_target *starget = scsi_target(sdev);
1080                 VirtTarget *vtarget = starget->hostdata;
1081
1082                 /* only want to search RAID components */
1083                 if (sdev->channel != 1)
1084                         continue;
1085
1086                 /* The id is the raid PhysDiskNum, even if
1087                  * starget->id is the actual target address */
1088                 if(vtarget->id != disk)
1089                         continue;
1090
1091                 starget_printk(KERN_INFO, vtarget->starget,
1092                                "Integrated RAID requests DV of new device\n");
1093                 mptspi_dv_device(hd, sdev);
1094         }
1095         shost_printk(KERN_INFO, shost,
1096                      "Integrated RAID detects new device %d\n", disk);
1097         scsi_scan_target(&hd->ioc->sh->shost_gendev, 1, disk, 0, 1);
1098 }
1099
1100
1101 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1102 {
1103         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1104
1105         if (!wqw) {
1106                 shost_printk(KERN_ERR, hd->ioc->sh,
1107                              "Failed to act on RAID event for physical disk %d\n",
1108                            disk);
1109                 return;
1110         }
1111         INIT_WORK(&wqw->work, mpt_work_wrapper);
1112         wqw->hd = hd;
1113         wqw->disk = disk;
1114
1115         schedule_work(&wqw->work);
1116 }
1117
1118 static int
1119 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1120 {
1121         u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1122         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1123
1124         if (hd && event ==  MPI_EVENT_INTEGRATED_RAID) {
1125                 int reason
1126                         = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1127
1128                 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1129                         int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1130                         mpt_dv_raid(hd, disk);
1131                 }
1132         }
1133         return mptscsih_event_process(ioc, pEvReply);
1134 }
1135
1136 static int
1137 mptspi_deny_binding(struct scsi_target *starget)
1138 {
1139         struct _MPT_SCSI_HOST *hd =
1140                 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1141         return ((mptspi_is_raid(hd, starget->id)) &&
1142                 starget->channel == 0) ? 1 : 0;
1143 }
1144
1145 static struct spi_function_template mptspi_transport_functions = {
1146         .get_offset     = mptspi_read_parameters,
1147         .set_offset     = mptspi_write_offset,
1148         .show_offset    = 1,
1149         .get_period     = mptspi_read_parameters,
1150         .set_period     = mptspi_write_period,
1151         .show_period    = 1,
1152         .get_width      = mptspi_read_parameters,
1153         .set_width      = mptspi_write_width,
1154         .show_width     = 1,
1155         .get_iu         = mptspi_read_parameters,
1156         .set_iu         = mptspi_write_iu,
1157         .show_iu        = 1,
1158         .get_dt         = mptspi_read_parameters,
1159         .set_dt         = mptspi_write_dt,
1160         .show_dt        = 1,
1161         .get_qas        = mptspi_read_parameters,
1162         .set_qas        = mptspi_write_qas,
1163         .show_qas       = 1,
1164         .get_wr_flow    = mptspi_read_parameters,
1165         .set_wr_flow    = mptspi_write_wr_flow,
1166         .show_wr_flow   = 1,
1167         .get_rd_strm    = mptspi_read_parameters,
1168         .set_rd_strm    = mptspi_write_rd_strm,
1169         .show_rd_strm   = 1,
1170         .get_rti        = mptspi_read_parameters,
1171         .set_rti        = mptspi_write_rti,
1172         .show_rti       = 1,
1173         .get_pcomp_en   = mptspi_read_parameters,
1174         .set_pcomp_en   = mptspi_write_pcomp_en,
1175         .show_pcomp_en  = 1,
1176         .get_hold_mcs   = mptspi_read_parameters,
1177         .set_hold_mcs   = mptspi_write_hold_mcs,
1178         .show_hold_mcs  = 1,
1179         .deny_binding   = mptspi_deny_binding,
1180 };
1181
1182 /****************************************************************************
1183  * Supported hardware
1184  */
1185
1186 static struct pci_device_id mptspi_pci_table[] = {
1187         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1188                 PCI_ANY_ID, PCI_ANY_ID },
1189         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1190                 PCI_ANY_ID, PCI_ANY_ID },
1191         {0}     /* Terminating entry */
1192 };
1193 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1194
1195
1196 /*
1197  * renegotiate for a given target
1198  */
1199 static void
1200 mptspi_dv_renegotiate_work(struct work_struct *work)
1201 {
1202         struct work_queue_wrapper *wqw =
1203                 container_of(work, struct work_queue_wrapper, work);
1204         struct _MPT_SCSI_HOST *hd = wqw->hd;
1205         struct scsi_device *sdev;
1206         struct scsi_target *starget;
1207         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1208         u32 nego;
1209
1210         kfree(wqw);
1211
1212         if (hd->spi_pending) {
1213                 shost_for_each_device(sdev, hd->ioc->sh) {
1214                         if  (hd->spi_pending & (1 << sdev->id))
1215                                 continue;
1216                         starget = scsi_target(sdev);
1217                         nego = mptspi_getRP(starget);
1218                         pg1.RequestedParameters = cpu_to_le32(nego);
1219                         pg1.Reserved = 0;
1220                         pg1.Configuration = 0;
1221                         mptspi_write_spi_device_pg1(starget, &pg1);
1222                 }
1223         } else {
1224                 shost_for_each_device(sdev, hd->ioc->sh)
1225                         mptspi_dv_device(hd, sdev);
1226         }
1227 }
1228
1229 static void
1230 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1231 {
1232         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1233
1234         if (!wqw)
1235                 return;
1236
1237         INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1238         wqw->hd = hd;
1239
1240         schedule_work(&wqw->work);
1241 }
1242
1243 /*
1244  * spi module reset handler
1245  */
1246 static int
1247 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1248 {
1249         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1250         int rc;
1251
1252         rc = mptscsih_ioc_reset(ioc, reset_phase);
1253
1254         if (reset_phase == MPT_IOC_POST_RESET)
1255                 mptspi_dv_renegotiate(hd);
1256
1257         return rc;
1258 }
1259
1260 #ifdef CONFIG_PM
1261 /*
1262  * spi module resume handler
1263  */
1264 static int
1265 mptspi_resume(struct pci_dev *pdev)
1266 {
1267         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1268         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1269         int rc;
1270
1271         rc = mptscsih_resume(pdev);
1272         mptspi_dv_renegotiate(hd);
1273
1274         return rc;
1275 }
1276 #endif
1277
1278 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1279 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1280 /*
1281  *      mptspi_probe - Installs scsi devices per bus.
1282  *      @pdev: Pointer to pci_dev structure
1283  *
1284  *      Returns 0 for success, non-zero for failure.
1285  *
1286  */
1287 static int
1288 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1289 {
1290         struct Scsi_Host        *sh;
1291         MPT_SCSI_HOST           *hd;
1292         MPT_ADAPTER             *ioc;
1293         unsigned long            flags;
1294         int                      ii;
1295         int                      numSGE = 0;
1296         int                      scale;
1297         int                      ioc_cap;
1298         int                     error=0;
1299         int                     r;
1300
1301         if ((r = mpt_attach(pdev,id)) != 0)
1302                 return r;
1303
1304         ioc = pci_get_drvdata(pdev);
1305         ioc->DoneCtx = mptspiDoneCtx;
1306         ioc->TaskCtx = mptspiTaskCtx;
1307         ioc->InternalCtx = mptspiInternalCtx;
1308
1309         /*  Added sanity check on readiness of the MPT adapter.
1310          */
1311         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1312                 printk(MYIOC_s_WARN_FMT
1313                   "Skipping because it's not operational!\n",
1314                   ioc->name);
1315                 error = -ENODEV;
1316                 goto out_mptspi_probe;
1317         }
1318
1319         if (!ioc->active) {
1320                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1321                   ioc->name);
1322                 error = -ENODEV;
1323                 goto out_mptspi_probe;
1324         }
1325
1326         /*  Sanity check - ensure at least 1 port is INITIATOR capable
1327          */
1328         ioc_cap = 0;
1329         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1330                 if (ioc->pfacts[ii].ProtocolFlags &
1331                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
1332                         ioc_cap ++;
1333         }
1334
1335         if (!ioc_cap) {
1336                 printk(MYIOC_s_WARN_FMT
1337                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1338                         ioc->name, ioc);
1339                 return 0;
1340         }
1341
1342         sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1343
1344         if (!sh) {
1345                 printk(MYIOC_s_WARN_FMT
1346                         "Unable to register controller with SCSI subsystem\n",
1347                         ioc->name);
1348                 error = -1;
1349                 goto out_mptspi_probe;
1350         }
1351
1352         spin_lock_irqsave(&ioc->FreeQlock, flags);
1353
1354         /* Attach the SCSI Host to the IOC structure
1355          */
1356         ioc->sh = sh;
1357
1358         sh->io_port = 0;
1359         sh->n_io_port = 0;
1360         sh->irq = 0;
1361
1362         /* set 16 byte cdb's */
1363         sh->max_cmd_len = 16;
1364
1365         /* Yikes!  This is important!
1366          * Otherwise, by default, linux
1367          * only scans target IDs 0-7!
1368          * pfactsN->MaxDevices unreliable
1369          * (not supported in early
1370          *      versions of the FW).
1371          * max_id = 1 + actual max id,
1372          * max_lun = 1 + actual last lun,
1373          *      see hosts.h :o(
1374          */
1375         sh->max_id = ioc->devices_per_bus;
1376
1377         sh->max_lun = MPT_LAST_LUN + 1;
1378         /*
1379          * If RAID Firmware Detected, setup virtual channel
1380          */
1381         if (ioc->ir_firmware)
1382                 sh->max_channel = 1;
1383         else
1384                 sh->max_channel = 0;
1385         sh->this_id = ioc->pfacts[0].PortSCSIID;
1386
1387         /* Required entry.
1388          */
1389         sh->unique_id = ioc->id;
1390
1391         /* Verify that we won't exceed the maximum
1392          * number of chain buffers
1393          * We can optimize:  ZZ = req_sz/sizeof(SGE)
1394          * For 32bit SGE's:
1395          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1396          *               + (req_sz - 64)/sizeof(SGE)
1397          * A slightly different algorithm is required for
1398          * 64bit SGEs.
1399          */
1400         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1401         if (sizeof(dma_addr_t) == sizeof(u64)) {
1402                 numSGE = (scale - 1) *
1403                   (ioc->facts.MaxChainDepth-1) + scale +
1404                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1405                   sizeof(u32));
1406         } else {
1407                 numSGE = 1 + (scale - 1) *
1408                   (ioc->facts.MaxChainDepth-1) + scale +
1409                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1410                   sizeof(u32));
1411         }
1412
1413         if (numSGE < sh->sg_tablesize) {
1414                 /* Reset this value */
1415                 dprintk((MYIOC_s_INFO_FMT
1416                   "Resetting sg_tablesize to %d from %d\n",
1417                   ioc->name, numSGE, sh->sg_tablesize));
1418                 sh->sg_tablesize = numSGE;
1419         }
1420
1421         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1422
1423         hd = (MPT_SCSI_HOST *) sh->hostdata;
1424         hd->ioc = ioc;
1425
1426         /* SCSI needs scsi_cmnd lookup table!
1427          * (with size equal to req_depth*PtrSz!)
1428          */
1429         hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1430         if (!hd->ScsiLookup) {
1431                 error = -ENOMEM;
1432                 goto out_mptspi_probe;
1433         }
1434
1435         dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
1436                  ioc->name, hd->ScsiLookup));
1437
1438         /* Clear the TM flags
1439          */
1440         hd->tmPending = 0;
1441         hd->tmState = TM_STATE_NONE;
1442         hd->resetPending = 0;
1443         hd->abortSCpnt = NULL;
1444
1445         /* Clear the pointer used to store
1446          * single-threaded commands, i.e., those
1447          * issued during a bus scan, dv and
1448          * configuration pages.
1449          */
1450         hd->cmdPtr = NULL;
1451
1452         /* Initialize this SCSI Hosts' timers
1453          * To use, set the timer expires field
1454          * and add_timer
1455          */
1456         init_timer(&hd->timer);
1457         hd->timer.data = (unsigned long) hd;
1458         hd->timer.function = mptscsih_timer_expired;
1459
1460         ioc->spi_data.Saf_Te = mpt_saf_te;
1461
1462         hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1463         ddvprintk((MYIOC_s_INFO_FMT
1464                 "saf_te %x\n",
1465                 ioc->name,
1466                 mpt_saf_te));
1467         ioc->spi_data.noQas = 0;
1468
1469         init_waitqueue_head(&hd->scandv_waitq);
1470         hd->scandv_wait_done = 0;
1471         hd->last_queue_full = 0;
1472         hd->spi_pending = 0;
1473
1474         /* Some versions of the firmware don't support page 0; without
1475          * that we can't get the parameters */
1476         if (hd->ioc->spi_data.sdp0length != 0)
1477                 sh->transportt = mptspi_transport_template;
1478
1479         error = scsi_add_host (sh, &ioc->pcidev->dev);
1480         if(error) {
1481                 dprintk((KERN_ERR MYNAM
1482                   "scsi_add_host failed\n"));
1483                 goto out_mptspi_probe;
1484         }
1485
1486         /*
1487          * issue internal bus reset
1488          */
1489         if (ioc->spi_data.bus_reset)
1490                 mptscsih_TMHandler(hd,
1491                     MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1492                     0, 0, 0, 0, 5);
1493
1494         scsi_scan_host(sh);
1495         return 0;
1496
1497 out_mptspi_probe:
1498
1499         mptscsih_remove(pdev);
1500         return error;
1501 }
1502
1503 static struct pci_driver mptspi_driver = {
1504         .name           = "mptspi",
1505         .id_table       = mptspi_pci_table,
1506         .probe          = mptspi_probe,
1507         .remove         = __devexit_p(mptscsih_remove),
1508         .shutdown       = mptscsih_shutdown,
1509 #ifdef CONFIG_PM
1510         .suspend        = mptscsih_suspend,
1511         .resume         = mptspi_resume,
1512 #endif
1513 };
1514
1515 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1516 /**
1517  *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1518  *
1519  *      Returns 0 for success, non-zero for failure.
1520  */
1521 static int __init
1522 mptspi_init(void)
1523 {
1524         show_mptmod_ver(my_NAME, my_VERSION);
1525
1526         mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1527         if (!mptspi_transport_template)
1528                 return -ENODEV;
1529
1530         mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1531         mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1532         mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1533
1534         if (mpt_event_register(mptspiDoneCtx, mptspi_event_process) == 0) {
1535                 devtverboseprintk((KERN_INFO MYNAM
1536                   ": Registered for IOC event notifications\n"));
1537         }
1538
1539         if (mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset) == 0) {
1540                 dprintk((KERN_INFO MYNAM
1541                   ": Registered for IOC reset notifications\n"));
1542         }
1543
1544         return pci_register_driver(&mptspi_driver);
1545 }
1546
1547 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1548 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1549 /**
1550  *      mptspi_exit - Unregisters MPT adapter(s)
1551  */
1552 static void __exit
1553 mptspi_exit(void)
1554 {
1555         pci_unregister_driver(&mptspi_driver);
1556
1557         mpt_reset_deregister(mptspiDoneCtx);
1558         dprintk((KERN_INFO MYNAM
1559           ": Deregistered for IOC reset notifications\n"));
1560
1561         mpt_event_deregister(mptspiDoneCtx);
1562         dprintk((KERN_INFO MYNAM
1563           ": Deregistered for IOC event notifications\n"));
1564
1565         mpt_deregister(mptspiInternalCtx);
1566         mpt_deregister(mptspiTaskCtx);
1567         mpt_deregister(mptspiDoneCtx);
1568         spi_release_transport(mptspi_transport_template);
1569 }
1570
1571 module_init(mptspi_init);
1572 module_exit(mptspi_exit);