kernel/drivers/message/fusion/mptspi.c

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