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;
 730
 731         mptspi_initTarget(hd, vtarget, sdev);
 732
 733         ret = mptscsih_slave_configure(sdev);
 734
 735         if (ret)
 736                 return ret;
 737
 738         ddvprintk((MYIOC_s_INFO_FMT "id=%d min_period=0x%02x"
 739                 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
 740                 sdev->id, spi_min_period(scsi_target(sdev)),
 741                 spi_max_offset(scsi_target(sdev)),
 742                 spi_max_width(scsi_target(sdev))));
 743
 744         if ((sdev->channel == 1 ||
 745              !(mptspi_is_raid(hd, sdev->id))) &&
 746             !spi_initial_dv(sdev->sdev_target))
 747                 mptspi_dv_device(hd, sdev);
 748
 749         return 0;
 750 }
 751
 752 static int
 753 mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
 754 {
 755         struct _MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata;
 756         VirtDevice      *vdev = SCpnt->device->hostdata;
 757
 758         if (!vdev || !vdev->vtarget) {
 759                 SCpnt->result = DID_NO_CONNECT << 16;
 760                 done(SCpnt);
 761                 return 0;
 762         }
 763
 764         if (SCpnt->device->channel == 1 &&
 765                 mptscsih_is_phys_disk(hd->ioc, 0, SCpnt->device->id) == 0) {
 766                 SCpnt->result = DID_NO_CONNECT << 16;
 767                 done(SCpnt);
 768                 return 0;
 769         }
 770
 771 #ifdef MPT_DEBUG_DV
 772         if (spi_dv_pending(scsi_target(SCpnt->device)))
 773                 scsi_print_command(SCpnt);
 774 #endif
 775
 776         return mptscsih_qcmd(SCpnt,done);
 777 }
 778
 779 static void mptspi_slave_destroy(struct scsi_device *sdev)
 780 {
 781         struct scsi_target *starget = scsi_target(sdev);
 782         VirtTarget *vtarget = starget->hostdata;
 783         VirtDevice *vdevice = sdev->hostdata;
 784
 785         /* Will this be the last lun on a non-raid device? */
 786         if (vtarget->num_luns == 1 && vdevice->configured_lun) {
 787                 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 788
 789                 /* Async Narrow */
 790                 pg1.RequestedParameters = 0;
 791                 pg1.Reserved = 0;
 792                 pg1.Configuration = 0;
 793
 794                 mptspi_write_spi_device_pg1(starget, &pg1);
 795         }
 796
 797         mptscsih_slave_destroy(sdev);
 798 }
 799
 800 static struct scsi_host_template mptspi_driver_template = {
 801         .module                         = THIS_MODULE,
 802         .proc_name                      = "mptspi",
 803         .proc_info                      = mptscsih_proc_info,
 804         .name                           = "MPT SPI Host",
 805         .info                           = mptscsih_info,
 806         .queuecommand                   = mptspi_qcmd,
 807         .target_alloc                   = mptspi_target_alloc,
 808         .slave_alloc                    = mptspi_slave_alloc,
 809         .slave_configure                = mptspi_slave_configure,
 810         .target_destroy                 = mptspi_target_destroy,
 811         .slave_destroy                  = mptspi_slave_destroy,
 812         .change_queue_depth             = mptscsih_change_queue_depth,
 813         .eh_abort_handler               = mptscsih_abort,
 814         .eh_device_reset_handler        = mptscsih_dev_reset,
 815         .eh_bus_reset_handler           = mptscsih_bus_reset,
 816         .eh_host_reset_handler          = mptscsih_host_reset,
 817         .bios_param                     = mptscsih_bios_param,
 818         .can_queue                      = MPT_SCSI_CAN_QUEUE,
 819         .this_id                        = -1,
 820         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
 821         .max_sectors                    = 8192,
 822         .cmd_per_lun                    = 7,
 823         .use_clustering                 = ENABLE_CLUSTERING,
 824 };
 825
 826 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
 827                                struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
 828 {
 829         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 830         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
 831         struct _MPT_ADAPTER *ioc = hd->ioc;
 832         struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
 833         dma_addr_t pg1_dma;
 834         int size;
 835         struct _x_config_parms cfg;
 836         struct _CONFIG_PAGE_HEADER hdr;
 837         int err = -EBUSY;
 838
 839         /* don't allow updating nego parameters on RAID devices */
 840         if (starget->channel == 0 &&
 841             mptspi_is_raid(hd, starget->id))
 842                 return -1;
 843
 844         size = ioc->spi_data.sdp1length * 4;
 845
 846         pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
 847         if (pg1 == NULL) {
 848                 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
 849                 return -EINVAL;
 850         }
 851
 852         memset(&hdr, 0, sizeof(hdr));
 853
 854         hdr.PageVersion = ioc->spi_data.sdp1version;
 855         hdr.PageLength = ioc->spi_data.sdp1length;
 856         hdr.PageNumber = 1;
 857         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 858
 859         memset(&cfg, 0, sizeof(cfg));
 860
 861         cfg.cfghdr.hdr = &hdr;
 862         cfg.physAddr = pg1_dma;
 863         cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 864         cfg.dir = 1;
 865         cfg.pageAddr = starget->id;
 866
 867         memcpy(pg1, pass_pg1, size);
 868
 869         pg1->Header.PageVersion = hdr.PageVersion;
 870         pg1->Header.PageLength = hdr.PageLength;
 871         pg1->Header.PageNumber = hdr.PageNumber;
 872         pg1->Header.PageType = hdr.PageType;
 873
 874         mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
 875
 876         if (mpt_config(ioc, &cfg)) {
 877                 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
 878                 goto out_free;
 879         }
 880         err = 0;
 881
 882  out_free:
 883         dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
 884         return err;
 885 }
 886
 887 static void mptspi_write_offset(struct scsi_target *starget, int offset)
 888 {
 889         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 890         u32 nego;
 891
 892         if (offset < 0)
 893                 offset = 0;
 894
 895         if (offset > 255)
 896                 offset = 255;
 897
 898         if (spi_offset(starget) == -1)
 899                 mptspi_read_parameters(starget);
 900
 901         spi_offset(starget) = offset;
 902
 903         nego = mptspi_getRP(starget);
 904
 905         pg1.RequestedParameters = cpu_to_le32(nego);
 906         pg1.Reserved = 0;
 907         pg1.Configuration = 0;
 908
 909         mptspi_write_spi_device_pg1(starget, &pg1);
 910 }
 911
 912 static void mptspi_write_period(struct scsi_target *starget, int period)
 913 {
 914         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 915         u32 nego;
 916
 917         if (period < 8)
 918                 period = 8;
 919
 920         if (period > 255)
 921                 period = 255;
 922
 923         if (spi_period(starget) == -1)
 924                 mptspi_read_parameters(starget);
 925
 926         if (period == 8) {
 927                 spi_iu(starget) = 1;
 928                 spi_dt(starget) = 1;
 929         } else if (period == 9) {
 930                 spi_dt(starget) = 1;
 931         }
 932
 933         spi_period(starget) = period;
 934
 935         nego = mptspi_getRP(starget);
 936
 937         pg1.RequestedParameters = cpu_to_le32(nego);
 938         pg1.Reserved = 0;
 939         pg1.Configuration = 0;
 940
 941         mptspi_write_spi_device_pg1(starget, &pg1);
 942 }
 943
 944 static void mptspi_write_dt(struct scsi_target *starget, int dt)
 945 {
 946         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 947         u32 nego;
 948
 949         if (spi_period(starget) == -1)
 950                 mptspi_read_parameters(starget);
 951
 952         if (!dt && spi_period(starget) < 10)
 953                 spi_period(starget) = 10;
 954
 955         spi_dt(starget) = dt;
 956
 957         nego = mptspi_getRP(starget);
 958
 959
 960         pg1.RequestedParameters = cpu_to_le32(nego);
 961         pg1.Reserved = 0;
 962         pg1.Configuration = 0;
 963
 964         mptspi_write_spi_device_pg1(starget, &pg1);
 965 }
 966
 967 static void mptspi_write_iu(struct scsi_target *starget, int iu)
 968 {
 969         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 970         u32 nego;
 971
 972         if (spi_period(starget) == -1)
 973                 mptspi_read_parameters(starget);
 974
 975         if (!iu && spi_period(starget) < 9)
 976                 spi_period(starget) = 9;
 977
 978         spi_iu(starget) = iu;
 979
 980         nego = mptspi_getRP(starget);
 981
 982         pg1.RequestedParameters = cpu_to_le32(nego);
 983         pg1.Reserved = 0;
 984         pg1.Configuration = 0;
 985
 986         mptspi_write_spi_device_pg1(starget, &pg1);
 987 }
 988
 989 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm)                              \
 990 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
 991 {                                                                       \
 992         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;                          \
 993         u32 nego;                                                       \
 994                                                                         \
 995         spi_##parm(starget) = parm;                                     \
 996                                                                         \
 997         nego = mptspi_getRP(starget);                                   \
 998                                                                         \
 999         pg1.RequestedParameters = cpu_to_le32(nego);                    \
1000         pg1.Reserved = 0;                                               \
1001         pg1.Configuration = 0;                                          \
1002                                                                         \
1003         mptspi_write_spi_device_pg1(starget, &pg1);                             \
1004 }
1005
1006 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1007 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1008 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1009 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1010 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1011
1012 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1013 {
1014         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1015         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1016         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
1017         VirtTarget *vtarget = starget->hostdata;
1018         u32 nego;
1019
1020         if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1021             hd->ioc->spi_data.noQas)
1022                 spi_qas(starget) = 0;
1023         else
1024                 spi_qas(starget) = qas;
1025
1026         nego = mptspi_getRP(starget);
1027
1028         pg1.RequestedParameters = cpu_to_le32(nego);
1029         pg1.Reserved = 0;
1030         pg1.Configuration = 0;
1031
1032         mptspi_write_spi_device_pg1(starget, &pg1);
1033 }
1034
1035 static void mptspi_write_width(struct scsi_target *starget, int width)
1036 {
1037         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1038         u32 nego;
1039
1040         if (!width) {
1041                 spi_dt(starget) = 0;
1042                 if (spi_period(starget) < 10)
1043                         spi_period(starget) = 10;
1044         }
1045
1046         spi_width(starget) = width;
1047
1048         nego = mptspi_getRP(starget);
1049
1050         pg1.RequestedParameters = cpu_to_le32(nego);
1051         pg1.Reserved = 0;
1052         pg1.Configuration = 0;
1053
1054         mptspi_write_spi_device_pg1(starget, &pg1);
1055 }
1056
1057 struct work_queue_wrapper {
1058         struct work_struct      work;
1059         struct _MPT_SCSI_HOST   *hd;
1060         int                     disk;
1061 };
1062
1063 static void mpt_work_wrapper(struct work_struct *work)
1064 {
1065         struct work_queue_wrapper *wqw =
1066                 container_of(work, struct work_queue_wrapper, work);
1067         struct _MPT_SCSI_HOST *hd = wqw->hd;
1068         struct Scsi_Host *shost = hd->ioc->sh;
1069         struct scsi_device *sdev;
1070         int disk = wqw->disk;
1071         struct _CONFIG_PAGE_IOC_3 *pg3;
1072
1073         kfree(wqw);
1074
1075         mpt_findImVolumes(hd->ioc);
1076         pg3 = hd->ioc->raid_data.pIocPg3;
1077         if (!pg3)
1078                 return;
1079
1080         shost_for_each_device(sdev,shost) {
1081                 struct scsi_target *starget = scsi_target(sdev);
1082                 VirtTarget *vtarget = starget->hostdata;
1083
1084                 /* only want to search RAID components */
1085                 if (sdev->channel != 1)
1086                         continue;
1087
1088                 /* The id is the raid PhysDiskNum, even if
1089                  * starget->id is the actual target address */
1090                 if(vtarget->id != disk)
1091                         continue;
1092
1093                 starget_printk(KERN_INFO, vtarget->starget,
1094                                "Integrated RAID requests DV of new device\n");
1095                 mptspi_dv_device(hd, sdev);
1096         }
1097         shost_printk(KERN_INFO, shost,
1098                      "Integrated RAID detects new device %d\n", disk);
1099         scsi_scan_target(&hd->ioc->sh->shost_gendev, 1, disk, 0, 1);
1100 }
1101
1102
1103 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1104 {
1105         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1106
1107         if (!wqw) {
1108                 shost_printk(KERN_ERR, hd->ioc->sh,
1109                              "Failed to act on RAID event for physical disk %d\n",
1110                            disk);
1111                 return;
1112         }
1113         INIT_WORK(&wqw->work, mpt_work_wrapper);
1114         wqw->hd = hd;
1115         wqw->disk = disk;
1116
1117         schedule_work(&wqw->work);
1118 }
1119
1120 static int
1121 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1122 {
1123         u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1124         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1125
1126         if (hd && event ==  MPI_EVENT_INTEGRATED_RAID) {
1127                 int reason
1128                         = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1129
1130                 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1131                         int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1132                         mpt_dv_raid(hd, disk);
1133                 }
1134         }
1135         return mptscsih_event_process(ioc, pEvReply);
1136 }
1137
1138 static int
1139 mptspi_deny_binding(struct scsi_target *starget)
1140 {
1141         struct _MPT_SCSI_HOST *hd =
1142                 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1143         return ((mptspi_is_raid(hd, starget->id)) &&
1144                 starget->channel == 0) ? 1 : 0;
1145 }
1146
1147 static struct spi_function_template mptspi_transport_functions = {
1148         .get_offset     = mptspi_read_parameters,
1149         .set_offset     = mptspi_write_offset,
1150         .show_offset    = 1,
1151         .get_period     = mptspi_read_parameters,
1152         .set_period     = mptspi_write_period,
1153         .show_period    = 1,
1154         .get_width      = mptspi_read_parameters,
1155         .set_width      = mptspi_write_width,
1156         .show_width     = 1,
1157         .get_iu         = mptspi_read_parameters,
1158         .set_iu         = mptspi_write_iu,
1159         .show_iu        = 1,
1160         .get_dt         = mptspi_read_parameters,
1161         .set_dt         = mptspi_write_dt,
1162         .show_dt        = 1,
1163         .get_qas        = mptspi_read_parameters,
1164         .set_qas        = mptspi_write_qas,
1165         .show_qas       = 1,
1166         .get_wr_flow    = mptspi_read_parameters,
1167         .set_wr_flow    = mptspi_write_wr_flow,
1168         .show_wr_flow   = 1,
1169         .get_rd_strm    = mptspi_read_parameters,
1170         .set_rd_strm    = mptspi_write_rd_strm,
1171         .show_rd_strm   = 1,
1172         .get_rti        = mptspi_read_parameters,
1173         .set_rti        = mptspi_write_rti,
1174         .show_rti       = 1,
1175         .get_pcomp_en   = mptspi_read_parameters,
1176         .set_pcomp_en   = mptspi_write_pcomp_en,
1177         .show_pcomp_en  = 1,
1178         .get_hold_mcs   = mptspi_read_parameters,
1179         .set_hold_mcs   = mptspi_write_hold_mcs,
1180         .show_hold_mcs  = 1,
1181         .deny_binding   = mptspi_deny_binding,
1182 };
1183
1184 /****************************************************************************
1185  * Supported hardware
1186  */
1187
1188 static struct pci_device_id mptspi_pci_table[] = {
1189         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1190                 PCI_ANY_ID, PCI_ANY_ID },
1191         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1192                 PCI_ANY_ID, PCI_ANY_ID },
1193         {0}     /* Terminating entry */
1194 };
1195 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1196
1197
1198 /*
1199  * renegotiate for a given target
1200  */
1201 static void
1202 mptspi_dv_renegotiate_work(struct work_struct *work)
1203 {
1204         struct work_queue_wrapper *wqw =
1205                 container_of(work, struct work_queue_wrapper, work);
1206         struct _MPT_SCSI_HOST *hd = wqw->hd;
1207         struct scsi_device *sdev;
1208         struct scsi_target *starget;
1209         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1210         u32 nego;
1211
1212         kfree(wqw);
1213
1214         if (hd->spi_pending) {
1215                 shost_for_each_device(sdev, hd->ioc->sh) {
1216                         if  (hd->spi_pending & (1 << sdev->id))
1217                                 continue;
1218                         starget = scsi_target(sdev);
1219                         nego = mptspi_getRP(starget);
1220                         pg1.RequestedParameters = cpu_to_le32(nego);
1221                         pg1.Reserved = 0;
1222                         pg1.Configuration = 0;
1223                         mptspi_write_spi_device_pg1(starget, &pg1);
1224                 }
1225         } else {
1226                 shost_for_each_device(sdev, hd->ioc->sh)
1227                         mptspi_dv_device(hd, sdev);
1228         }
1229 }
1230
1231 static void
1232 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1233 {
1234         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1235
1236         if (!wqw)
1237                 return;
1238
1239         INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1240         wqw->hd = hd;
1241
1242         schedule_work(&wqw->work);
1243 }
1244
1245 /*
1246  * spi module reset handler
1247  */
1248 static int
1249 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1250 {
1251         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1252         int rc;
1253
1254         rc = mptscsih_ioc_reset(ioc, reset_phase);
1255
1256         if (reset_phase == MPT_IOC_POST_RESET)
1257                 mptspi_dv_renegotiate(hd);
1258
1259         return rc;
1260 }
1261
1262 #ifdef CONFIG_PM
1263 /*
1264  * spi module resume handler
1265  */
1266 static int
1267 mptspi_resume(struct pci_dev *pdev)
1268 {
1269         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1270         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1271         int rc;
1272
1273         rc = mptscsih_resume(pdev);
1274         mptspi_dv_renegotiate(hd);
1275
1276         return rc;
1277 }
1278 #endif
1279
1280 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1281 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1282 /*
1283  *      mptspi_probe - Installs scsi devices per bus.
1284  *      @pdev: Pointer to pci_dev structure
1285  *
1286  *      Returns 0 for success, non-zero for failure.
1287  *
1288  */
1289 static int
1290 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1291 {
1292         struct Scsi_Host        *sh;
1293         MPT_SCSI_HOST           *hd;
1294         MPT_ADAPTER             *ioc;
1295         unsigned long            flags;
1296         int                      ii;
1297         int                      numSGE = 0;
1298         int                      scale;
1299         int                      ioc_cap;
1300         int                     error=0;
1301         int                     r;
1302
1303         if ((r = mpt_attach(pdev,id)) != 0)
1304                 return r;
1305
1306         ioc = pci_get_drvdata(pdev);
1307         ioc->DoneCtx = mptspiDoneCtx;
1308         ioc->TaskCtx = mptspiTaskCtx;
1309         ioc->InternalCtx = mptspiInternalCtx;
1310
1311         /*  Added sanity check on readiness of the MPT adapter.
1312          */
1313         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1314                 printk(MYIOC_s_WARN_FMT
1315                   "Skipping because it's not operational!\n",
1316                   ioc->name);
1317                 error = -ENODEV;
1318                 goto out_mptspi_probe;
1319         }
1320
1321         if (!ioc->active) {
1322                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1323                   ioc->name);
1324                 error = -ENODEV;
1325                 goto out_mptspi_probe;
1326         }
1327
1328         /*  Sanity check - ensure at least 1 port is INITIATOR capable
1329          */
1330         ioc_cap = 0;
1331         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1332                 if (ioc->pfacts[ii].ProtocolFlags &
1333                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
1334                         ioc_cap ++;
1335         }
1336
1337         if (!ioc_cap) {
1338                 printk(MYIOC_s_WARN_FMT
1339                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1340                         ioc->name, ioc);
1341                 return 0;
1342         }
1343
1344         sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1345
1346         if (!sh) {
1347                 printk(MYIOC_s_WARN_FMT
1348                         "Unable to register controller with SCSI subsystem\n",
1349                         ioc->name);
1350                 error = -1;
1351                 goto out_mptspi_probe;
1352         }
1353
1354         spin_lock_irqsave(&ioc->FreeQlock, flags);
1355
1356         /* Attach the SCSI Host to the IOC structure
1357          */
1358         ioc->sh = sh;
1359
1360         sh->io_port = 0;
1361         sh->n_io_port = 0;
1362         sh->irq = 0;
1363
1364         /* set 16 byte cdb's */
1365         sh->max_cmd_len = 16;
1366
1367         /* Yikes!  This is important!
1368          * Otherwise, by default, linux
1369          * only scans target IDs 0-7!
1370          * pfactsN->MaxDevices unreliable
1371          * (not supported in early
1372          *      versions of the FW).
1373          * max_id = 1 + actual max id,
1374          * max_lun = 1 + actual last lun,
1375          *      see hosts.h :o(
1376          */
1377         sh->max_id = ioc->devices_per_bus;
1378
1379         sh->max_lun = MPT_LAST_LUN + 1;
1380         /*
1381          * If RAID Firmware Detected, setup virtual channel
1382          */
1383         if (ioc->ir_firmware)
1384                 sh->max_channel = 1;
1385         else
1386                 sh->max_channel = 0;
1387         sh->this_id = ioc->pfacts[0].PortSCSIID;
1388
1389         /* Required entry.
1390          */
1391         sh->unique_id = ioc->id;
1392
1393         /* Verify that we won't exceed the maximum
1394          * number of chain buffers
1395          * We can optimize:  ZZ = req_sz/sizeof(SGE)
1396          * For 32bit SGE's:
1397          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1398          *               + (req_sz - 64)/sizeof(SGE)
1399          * A slightly different algorithm is required for
1400          * 64bit SGEs.
1401          */
1402         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1403         if (sizeof(dma_addr_t) == sizeof(u64)) {
1404                 numSGE = (scale - 1) *
1405                   (ioc->facts.MaxChainDepth-1) + scale +
1406                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1407                   sizeof(u32));
1408         } else {
1409                 numSGE = 1 + (scale - 1) *
1410                   (ioc->facts.MaxChainDepth-1) + scale +
1411                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1412                   sizeof(u32));
1413         }
1414
1415         if (numSGE < sh->sg_tablesize) {
1416                 /* Reset this value */
1417                 dprintk((MYIOC_s_INFO_FMT
1418                   "Resetting sg_tablesize to %d from %d\n",
1419                   ioc->name, numSGE, sh->sg_tablesize));
1420                 sh->sg_tablesize = numSGE;
1421         }
1422
1423         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1424
1425         hd = (MPT_SCSI_HOST *) sh->hostdata;
1426         hd->ioc = ioc;
1427
1428         /* SCSI needs scsi_cmnd lookup table!
1429          * (with size equal to req_depth*PtrSz!)
1430          */
1431         hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1432         if (!hd->ScsiLookup) {
1433                 error = -ENOMEM;
1434                 goto out_mptspi_probe;
1435         }
1436
1437         dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
1438                  ioc->name, hd->ScsiLookup));
1439
1440         /* Clear the TM flags
1441          */
1442         hd->tmPending = 0;
1443         hd->tmState = TM_STATE_NONE;
1444         hd->resetPending = 0;
1445         hd->abortSCpnt = NULL;
1446
1447         /* Clear the pointer used to store
1448          * single-threaded commands, i.e., those
1449          * issued during a bus scan, dv and
1450          * configuration pages.
1451          */
1452         hd->cmdPtr = NULL;
1453
1454         /* Initialize this SCSI Hosts' timers
1455          * To use, set the timer expires field
1456          * and add_timer
1457          */
1458         init_timer(&hd->timer);
1459         hd->timer.data = (unsigned long) hd;
1460         hd->timer.function = mptscsih_timer_expired;
1461
1462         ioc->spi_data.Saf_Te = mpt_saf_te;
1463
1464         hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1465         ddvprintk((MYIOC_s_INFO_FMT
1466                 "saf_te %x\n",
1467                 ioc->name,
1468                 mpt_saf_te));
1469         ioc->spi_data.noQas = 0;
1470
1471         init_waitqueue_head(&hd->scandv_waitq);
1472         hd->scandv_wait_done = 0;
1473         hd->last_queue_full = 0;
1474         hd->spi_pending = 0;
1475
1476         /* Some versions of the firmware don't support page 0; without
1477          * that we can't get the parameters */
1478         if (hd->ioc->spi_data.sdp0length != 0)
1479                 sh->transportt = mptspi_transport_template;
1480
1481         error = scsi_add_host (sh, &ioc->pcidev->dev);
1482         if(error) {
1483                 dprintk((KERN_ERR MYNAM
1484                   "scsi_add_host failed\n"));
1485                 goto out_mptspi_probe;
1486         }
1487
1488         /*
1489          * issue internal bus reset
1490          */
1491         if (ioc->spi_data.bus_reset)
1492                 mptscsih_TMHandler(hd,
1493                     MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1494                     0, 0, 0, 0, 5);
1495
1496         scsi_scan_host(sh);
1497         return 0;
1498
1499 out_mptspi_probe:
1500
1501         mptscsih_remove(pdev);
1502         return error;
1503 }
1504
1505 static struct pci_driver mptspi_driver = {
1506         .name           = "mptspi",
1507         .id_table       = mptspi_pci_table,
1508         .probe          = mptspi_probe,
1509         .remove         = __devexit_p(mptscsih_remove),
1510         .shutdown       = mptscsih_shutdown,
1511 #ifdef CONFIG_PM
1512         .suspend        = mptscsih_suspend,
1513         .resume         = mptspi_resume,
1514 #endif
1515 };
1516
1517 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1518 /**
1519  *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1520  *
1521  *      Returns 0 for success, non-zero for failure.
1522  */
1523 static int __init
1524 mptspi_init(void)
1525 {
1526         show_mptmod_ver(my_NAME, my_VERSION);
1527
1528         mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1529         if (!mptspi_transport_template)
1530                 return -ENODEV;
1531
1532         mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1533         mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1534         mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1535
1536         if (mpt_event_register(mptspiDoneCtx, mptspi_event_process) == 0) {
1537                 devtverboseprintk((KERN_INFO MYNAM
1538                   ": Registered for IOC event notifications\n"));
1539         }
1540
1541         if (mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset) == 0) {
1542                 dprintk((KERN_INFO MYNAM
1543                   ": Registered for IOC reset notifications\n"));
1544         }
1545
1546         return pci_register_driver(&mptspi_driver);
1547 }
1548
1549 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1550 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1551 /**
1552  *      mptspi_exit - Unregisters MPT adapter(s)
1553  */
1554 static void __exit
1555 mptspi_exit(void)
1556 {
1557         pci_unregister_driver(&mptspi_driver);
1558
1559         mpt_reset_deregister(mptspiDoneCtx);
1560         dprintk((KERN_INFO MYNAM
1561           ": Deregistered for IOC reset notifications\n"));
1562
1563         mpt_event_deregister(mptspiDoneCtx);
1564         dprintk((KERN_INFO MYNAM
1565           ": Deregistered for IOC event notifications\n"));
1566
1567         mpt_deregister(mptspiInternalCtx);
1568         mpt_deregister(mptspiTaskCtx);
1569         mpt_deregister(mptspiDoneCtx);
1570         spi_release_transport(mptspi_transport_template);
1571 }
1572
1573 module_init(mptspi_init);
1574 module_exit(mptspi_exit);