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         if (starget->hostdata)
 465                 kfree(starget->hostdata);
 466         starget->hostdata = NULL;
 467 }
 468
 469 /**
 470  *      mptspi_print_write_nego - negotiation parameters debug info that is being sent
 471  *      @hd: Pointer to a SCSI HOST structure
 472  *      @starget: SCSI target
 473  *      @ii: negotiation parameters
 474  *
 475  */
 476 static void
 477 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
 478 {
 479         ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x"
 480             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
 481             hd->ioc->name, starget->id, ii,
 482             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
 483             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
 484             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
 485             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
 486             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
 487             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
 488             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
 489             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
 490             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
 491             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
 492 }
 493
 494 /**
 495  *      mptspi_print_read_nego - negotiation parameters debug info that is being read
 496  *      @hd: Pointer to a SCSI HOST structure
 497  *      @starget: SCSI target
 498  *      @ii: negotiation parameters
 499  *
 500  */
 501 static void
 502 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
 503 {
 504         ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x"
 505             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
 506             hd->ioc->name, starget->id, ii,
 507             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
 508             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
 509             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
 510             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
 511             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
 512             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
 513             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
 514             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
 515             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
 516             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
 517 }
 518
 519 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
 520                              struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
 521 {
 522         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 523         struct _MPT_SCSI_HOST *hd = shost_priv(shost);
 524         struct _MPT_ADAPTER *ioc = hd->ioc;
 525         struct _CONFIG_PAGE_SCSI_DEVICE_0 *spi_dev_pg0;
 526         dma_addr_t spi_dev_pg0_dma;
 527         int size;
 528         struct _x_config_parms cfg;
 529         struct _CONFIG_PAGE_HEADER hdr;
 530         int err = -EBUSY;
 531
 532         /* No SPI parameters for RAID devices */
 533         if (starget->channel == 0 &&
 534             mptspi_is_raid(hd, starget->id))
 535                 return -1;
 536
 537         size = ioc->spi_data.sdp0length * 4;
 538         /*
 539         if (ioc->spi_data.sdp0length & 1)
 540                 size += size + 4;
 541         size += 2048;
 542         */
 543
 544         spi_dev_pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &spi_dev_pg0_dma, GFP_KERNEL);
 545         if (spi_dev_pg0 == NULL) {
 546                 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
 547                     "dma_alloc_coherent for parameters failed\n", ioc->name);
 548                 return -EINVAL;
 549         }
 550
 551         memset(&hdr, 0, sizeof(hdr));
 552
 553         hdr.PageVersion = ioc->spi_data.sdp0version;
 554         hdr.PageLength = ioc->spi_data.sdp0length;
 555         hdr.PageNumber = 0;
 556         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 557
 558         memset(&cfg, 0, sizeof(cfg));
 559
 560         cfg.cfghdr.hdr = &hdr;
 561         cfg.physAddr = spi_dev_pg0_dma;
 562         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 563         cfg.dir = 0;
 564         cfg.pageAddr = starget->id;
 565         cfg.timeout = 60;
 566
 567         if (mpt_config(ioc, &cfg)) {
 568                 starget_printk(KERN_ERR, starget, MYIOC_s_FMT "mpt_config failed\n", ioc->name);
 569                 goto out_free;
 570         }
 571         err = 0;
 572         memcpy(pass_pg0, spi_dev_pg0, size);
 573
 574         mptspi_print_read_nego(hd, starget, le32_to_cpu(spi_dev_pg0->NegotiatedParameters));
 575
 576  out_free:
 577         dma_free_coherent(&ioc->pcidev->dev, size, spi_dev_pg0, spi_dev_pg0_dma);
 578         return err;
 579 }
 580
 581 static u32 mptspi_getRP(struct scsi_target *starget)
 582 {
 583         u32 nego = 0;
 584
 585         nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
 586         nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
 587         nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
 588         nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
 589         nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
 590         nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
 591         nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
 592         nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
 593
 594         nego |= (spi_period(starget) <<  MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
 595         nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
 596         nego |= spi_width(starget) ?  MPI_SCSIDEVPAGE1_RP_WIDE : 0;
 597
 598         return nego;
 599 }
 600
 601 static void mptspi_read_parameters(struct scsi_target *starget)
 602 {
 603         int nego;
 604         struct _CONFIG_PAGE_SCSI_DEVICE_0 spi_dev_pg0;
 605
 606         mptspi_read_spi_device_pg0(starget, &spi_dev_pg0);
 607
 608         nego = le32_to_cpu(spi_dev_pg0.NegotiatedParameters);
 609
 610         spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
 611         spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
 612         spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
 613         spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
 614         spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
 615         spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
 616         spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
 617         spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
 618         spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
 619         spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
 620         spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
 621 }
 622
 623 int
 624 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
 625 {
 626         MPT_ADAPTER     *ioc = hd->ioc;
 627         MpiRaidActionRequest_t  *pReq;
 628         MPT_FRAME_HDR           *mf;
 629         int                     ret;
 630         unsigned long           timeleft;
 631
 632         mutex_lock(&ioc->internal_cmds.mutex);
 633
 634         /* Get and Populate a free Frame
 635          */
 636         if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
 637                 dfailprintk(hd->ioc, printk(MYIOC_s_WARN_FMT
 638                         "%s: no msg frames!\n", ioc->name, __func__));
 639                 ret = -EAGAIN;
 640                 goto out;
 641         }
 642         pReq = (MpiRaidActionRequest_t *)mf;
 643         if (quiesce)
 644                 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
 645         else
 646                 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
 647         pReq->Reserved1 = 0;
 648         pReq->ChainOffset = 0;
 649         pReq->Function = MPI_FUNCTION_RAID_ACTION;
 650         pReq->VolumeID = id;
 651         pReq->VolumeBus = channel;
 652         pReq->PhysDiskNum = 0;
 653         pReq->MsgFlags = 0;
 654         pReq->Reserved2 = 0;
 655         pReq->ActionDataWord = 0; /* Reserved for this action */
 656
 657         ioc->add_sge((char *)&pReq->ActionDataSGE,
 658                 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
 659
 660         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
 661                         ioc->name, pReq->Action, channel, id));
 662
 663         INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
 664         mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
 665         timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done, 10*HZ);
 666         if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
 667                 ret = -ETIME;
 668                 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: TIMED OUT!\n",
 669                     ioc->name, __func__));
 670                 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
 671                         goto out;
 672                 if (!timeleft) {
 673                         printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
 674                             ioc->name, __func__);
 675                         mpt_HardResetHandler(ioc, CAN_SLEEP);
 676                         mpt_free_msg_frame(ioc, mf);
 677                 }
 678                 goto out;
 679         }
 680
 681         ret = ioc->internal_cmds.completion_code;
 682
 683  out:
 684         CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
 685         mutex_unlock(&ioc->internal_cmds.mutex);
 686         return ret;
 687 }
 688
 689 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
 690                              struct scsi_device *sdev)
 691 {
 692         VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 693         MPT_ADAPTER *ioc = hd->ioc;
 694
 695         /* no DV on RAID devices */
 696         if (sdev->channel == 0 &&
 697             mptspi_is_raid(hd, sdev->id))
 698                 return;
 699
 700         /* If this is a piece of a RAID, then quiesce first */
 701         if (sdev->channel == 1 &&
 702             mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
 703                 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
 704                     "Integrated RAID quiesce failed\n", ioc->name);
 705                 return;
 706         }
 707
 708         hd->spi_pending |= (1 << sdev->id);
 709         spi_dv_device(sdev);
 710         hd->spi_pending &= ~(1 << sdev->id);
 711
 712         if (sdev->channel == 1 &&
 713             mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
 714                 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
 715                     "Integrated RAID resume failed\n", ioc->name);
 716
 717         mptspi_read_parameters(sdev->sdev_target);
 718         spi_display_xfer_agreement(sdev->sdev_target);
 719         mptspi_read_parameters(sdev->sdev_target);
 720 }
 721
 722 static int mptspi_slave_alloc(struct scsi_device *sdev)
 723 {
 724         MPT_SCSI_HOST *hd = shost_priv(sdev->host);
 725         VirtTarget              *vtarget;
 726         VirtDevice              *vdevice;
 727         struct scsi_target      *starget;
 728         MPT_ADAPTER *ioc = hd->ioc;
 729
 730         if (sdev->channel == 1 &&
 731                 mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0)
 732                         return -ENXIO;
 733
 734         vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
 735         if (!vdevice) {
 736                 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
 737                                 ioc->name, sizeof(VirtDevice));
 738                 return -ENOMEM;
 739         }
 740
 741         vdevice->lun = sdev->lun;
 742         sdev->hostdata = vdevice;
 743
 744         starget = scsi_target(sdev);
 745         vtarget = starget->hostdata;
 746         vdevice->vtarget = vtarget;
 747         vtarget->num_luns++;
 748
 749         if (sdev->channel == 1)
 750                 sdev->no_uld_attach = 1;
 751
 752         return 0;
 753 }
 754
 755 static int mptspi_slave_configure(struct scsi_device *sdev)
 756 {
 757         struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
 758         VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 759         int ret;
 760
 761         mptspi_initTarget(hd, vtarget, sdev);
 762
 763         ret = mptscsih_slave_configure(sdev);
 764
 765         if (ret)
 766                 return ret;
 767
 768         ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
 769                 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
 770                 sdev->id, spi_min_period(scsi_target(sdev)),
 771                 spi_max_offset(scsi_target(sdev)),
 772                 spi_max_width(scsi_target(sdev))));
 773
 774         if ((sdev->channel == 1 ||
 775              !(mptspi_is_raid(hd, sdev->id))) &&
 776             !spi_initial_dv(sdev->sdev_target))
 777                 mptspi_dv_device(hd, sdev);
 778
 779         return 0;
 780 }
 781
 782 static int
 783 mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
 784 {
 785         struct _MPT_SCSI_HOST *hd = shost_priv(SCpnt->device->host);
 786         VirtDevice      *vdevice = SCpnt->device->hostdata;
 787         MPT_ADAPTER *ioc = hd->ioc;
 788
 789         if (!vdevice || !vdevice->vtarget) {
 790                 SCpnt->result = DID_NO_CONNECT << 16;
 791                 done(SCpnt);
 792                 return 0;
 793         }
 794
 795         if (SCpnt->device->channel == 1 &&
 796                 mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) {
 797                 SCpnt->result = DID_NO_CONNECT << 16;
 798                 done(SCpnt);
 799                 return 0;
 800         }
 801
 802         if (spi_dv_pending(scsi_target(SCpnt->device)))
 803                 ddvprintk(ioc, scsi_print_command(SCpnt));
 804
 805         return mptscsih_qcmd(SCpnt,done);
 806 }
 807
 808 static void mptspi_slave_destroy(struct scsi_device *sdev)
 809 {
 810         struct scsi_target *starget = scsi_target(sdev);
 811         VirtTarget *vtarget = starget->hostdata;
 812         VirtDevice *vdevice = sdev->hostdata;
 813
 814         /* Will this be the last lun on a non-raid device? */
 815         if (vtarget->num_luns == 1 && vdevice->configured_lun) {
 816                 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 817
 818                 /* Async Narrow */
 819                 pg1.RequestedParameters = 0;
 820                 pg1.Reserved = 0;
 821                 pg1.Configuration = 0;
 822
 823                 mptspi_write_spi_device_pg1(starget, &pg1);
 824         }
 825
 826         mptscsih_slave_destroy(sdev);
 827 }
 828
 829 static struct scsi_host_template mptspi_driver_template = {
 830         .module                         = THIS_MODULE,
 831         .proc_name                      = "mptspi",
 832         .proc_info                      = mptscsih_proc_info,
 833         .name                           = "MPT SPI Host",
 834         .info                           = mptscsih_info,
 835         .queuecommand                   = mptspi_qcmd,
 836         .target_alloc                   = mptspi_target_alloc,
 837         .slave_alloc                    = mptspi_slave_alloc,
 838         .slave_configure                = mptspi_slave_configure,
 839         .target_destroy                 = mptspi_target_destroy,
 840         .slave_destroy                  = mptspi_slave_destroy,
 841         .change_queue_depth             = mptscsih_change_queue_depth,
 842         .eh_abort_handler               = mptscsih_abort,
 843         .eh_device_reset_handler        = mptscsih_dev_reset,
 844         .eh_bus_reset_handler           = mptscsih_bus_reset,
 845         .eh_host_reset_handler          = mptscsih_host_reset,
 846         .bios_param                     = mptscsih_bios_param,
 847         .can_queue                      = MPT_SCSI_CAN_QUEUE,
 848         .this_id                        = -1,
 849         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
 850         .max_sectors                    = 8192,
 851         .cmd_per_lun                    = 7,
 852         .use_clustering                 = ENABLE_CLUSTERING,
 853         .shost_attrs                    = mptscsih_host_attrs,
 854 };
 855
 856 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
 857                                struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
 858 {
 859         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 860         struct _MPT_SCSI_HOST *hd = shost_priv(shost);
 861         struct _MPT_ADAPTER *ioc = hd->ioc;
 862         struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
 863         dma_addr_t pg1_dma;
 864         int size;
 865         struct _x_config_parms cfg;
 866         struct _CONFIG_PAGE_HEADER hdr;
 867         int err = -EBUSY;
 868
 869         /* don't allow updating nego parameters on RAID devices */
 870         if (starget->channel == 0 &&
 871             mptspi_is_raid(hd, starget->id))
 872                 return -1;
 873
 874         size = ioc->spi_data.sdp1length * 4;
 875
 876         pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
 877         if (pg1 == NULL) {
 878                 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
 879                     "dma_alloc_coherent for parameters failed\n", ioc->name);
 880                 return -EINVAL;
 881         }
 882
 883         memset(&hdr, 0, sizeof(hdr));
 884
 885         hdr.PageVersion = ioc->spi_data.sdp1version;
 886         hdr.PageLength = ioc->spi_data.sdp1length;
 887         hdr.PageNumber = 1;
 888         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 889
 890         memset(&cfg, 0, sizeof(cfg));
 891
 892         cfg.cfghdr.hdr = &hdr;
 893         cfg.physAddr = pg1_dma;
 894         cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 895         cfg.dir = 1;
 896         cfg.pageAddr = starget->id;
 897
 898         memcpy(pg1, pass_pg1, size);
 899
 900         pg1->Header.PageVersion = hdr.PageVersion;
 901         pg1->Header.PageLength = hdr.PageLength;
 902         pg1->Header.PageNumber = hdr.PageNumber;
 903         pg1->Header.PageType = hdr.PageType;
 904
 905         mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
 906
 907         if (mpt_config(ioc, &cfg)) {
 908                 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
 909                     "mpt_config failed\n", ioc->name);
 910                 goto out_free;
 911         }
 912         err = 0;
 913
 914  out_free:
 915         dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
 916         return err;
 917 }
 918
 919 static void mptspi_write_offset(struct scsi_target *starget, int offset)
 920 {
 921         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 922         u32 nego;
 923
 924         if (offset < 0)
 925                 offset = 0;
 926
 927         if (offset > 255)
 928                 offset = 255;
 929
 930         if (spi_offset(starget) == -1)
 931                 mptspi_read_parameters(starget);
 932
 933         spi_offset(starget) = offset;
 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_period(struct scsi_target *starget, int period)
 945 {
 946         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 947         u32 nego;
 948
 949         if (period < 8)
 950                 period = 8;
 951
 952         if (period > 255)
 953                 period = 255;
 954
 955         if (spi_period(starget) == -1)
 956                 mptspi_read_parameters(starget);
 957
 958         if (period == 8) {
 959                 spi_iu(starget) = 1;
 960                 spi_dt(starget) = 1;
 961         } else if (period == 9) {
 962                 spi_dt(starget) = 1;
 963         }
 964
 965         spi_period(starget) = period;
 966
 967         nego = mptspi_getRP(starget);
 968
 969         pg1.RequestedParameters = cpu_to_le32(nego);
 970         pg1.Reserved = 0;
 971         pg1.Configuration = 0;
 972
 973         mptspi_write_spi_device_pg1(starget, &pg1);
 974 }
 975
 976 static void mptspi_write_dt(struct scsi_target *starget, int dt)
 977 {
 978         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 979         u32 nego;
 980
 981         if (spi_period(starget) == -1)
 982                 mptspi_read_parameters(starget);
 983
 984         if (!dt && spi_period(starget) < 10)
 985                 spi_period(starget) = 10;
 986
 987         spi_dt(starget) = dt;
 988
 989         nego = mptspi_getRP(starget);
 990
 991
 992         pg1.RequestedParameters = cpu_to_le32(nego);
 993         pg1.Reserved = 0;
 994         pg1.Configuration = 0;
 995
 996         mptspi_write_spi_device_pg1(starget, &pg1);
 997 }
 998
 999 static void mptspi_write_iu(struct scsi_target *starget, int iu)
1000 {
1001         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1002         u32 nego;
1003
1004         if (spi_period(starget) == -1)
1005                 mptspi_read_parameters(starget);
1006
1007         if (!iu && spi_period(starget) < 9)
1008                 spi_period(starget) = 9;
1009
1010         spi_iu(starget) = iu;
1011
1012         nego = mptspi_getRP(starget);
1013
1014         pg1.RequestedParameters = cpu_to_le32(nego);
1015         pg1.Reserved = 0;
1016         pg1.Configuration = 0;
1017
1018         mptspi_write_spi_device_pg1(starget, &pg1);
1019 }
1020
1021 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm)                              \
1022 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1023 {                                                                       \
1024         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;                          \
1025         u32 nego;                                                       \
1026                                                                         \
1027         spi_##parm(starget) = parm;                                     \
1028                                                                         \
1029         nego = mptspi_getRP(starget);                                   \
1030                                                                         \
1031         pg1.RequestedParameters = cpu_to_le32(nego);                    \
1032         pg1.Reserved = 0;                                               \
1033         pg1.Configuration = 0;                                          \
1034                                                                         \
1035         mptspi_write_spi_device_pg1(starget, &pg1);                             \
1036 }
1037
1038 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1039 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1040 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1041 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1042 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1043
1044 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1045 {
1046         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1047         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1048         struct _MPT_SCSI_HOST *hd = shost_priv(shost);
1049         VirtTarget *vtarget = starget->hostdata;
1050         u32 nego;
1051
1052         if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1053             hd->ioc->spi_data.noQas)
1054                 spi_qas(starget) = 0;
1055         else
1056                 spi_qas(starget) = qas;
1057
1058         nego = mptspi_getRP(starget);
1059
1060         pg1.RequestedParameters = cpu_to_le32(nego);
1061         pg1.Reserved = 0;
1062         pg1.Configuration = 0;
1063
1064         mptspi_write_spi_device_pg1(starget, &pg1);
1065 }
1066
1067 static void mptspi_write_width(struct scsi_target *starget, int width)
1068 {
1069         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1070         u32 nego;
1071
1072         if (!width) {
1073                 spi_dt(starget) = 0;
1074                 if (spi_period(starget) < 10)
1075                         spi_period(starget) = 10;
1076         }
1077
1078         spi_width(starget) = width;
1079
1080         nego = mptspi_getRP(starget);
1081
1082         pg1.RequestedParameters = cpu_to_le32(nego);
1083         pg1.Reserved = 0;
1084         pg1.Configuration = 0;
1085
1086         mptspi_write_spi_device_pg1(starget, &pg1);
1087 }
1088
1089 struct work_queue_wrapper {
1090         struct work_struct      work;
1091         struct _MPT_SCSI_HOST   *hd;
1092         int                     disk;
1093 };
1094
1095 static void mpt_work_wrapper(struct work_struct *work)
1096 {
1097         struct work_queue_wrapper *wqw =
1098                 container_of(work, struct work_queue_wrapper, work);
1099         struct _MPT_SCSI_HOST *hd = wqw->hd;
1100         MPT_ADAPTER *ioc = hd->ioc;
1101         struct Scsi_Host *shost = ioc->sh;
1102         struct scsi_device *sdev;
1103         int disk = wqw->disk;
1104         struct _CONFIG_PAGE_IOC_3 *pg3;
1105
1106         kfree(wqw);
1107
1108         mpt_findImVolumes(ioc);
1109         pg3 = ioc->raid_data.pIocPg3;
1110         if (!pg3)
1111                 return;
1112
1113         shost_for_each_device(sdev,shost) {
1114                 struct scsi_target *starget = scsi_target(sdev);
1115                 VirtTarget *vtarget = starget->hostdata;
1116
1117                 /* only want to search RAID components */
1118                 if (sdev->channel != 1)
1119                         continue;
1120
1121                 /* The id is the raid PhysDiskNum, even if
1122                  * starget->id is the actual target address */
1123                 if(vtarget->id != disk)
1124                         continue;
1125
1126                 starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1127                     "Integrated RAID requests DV of new device\n", ioc->name);
1128                 mptspi_dv_device(hd, sdev);
1129         }
1130         shost_printk(KERN_INFO, shost, MYIOC_s_FMT
1131             "Integrated RAID detects new device %d\n", ioc->name, disk);
1132         scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, 1);
1133 }
1134
1135
1136 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1137 {
1138         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1139         MPT_ADAPTER *ioc = hd->ioc;
1140
1141         if (!wqw) {
1142                 shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
1143                     "Failed to act on RAID event for physical disk %d\n",
1144                     ioc->name, disk);
1145                 return;
1146         }
1147         INIT_WORK(&wqw->work, mpt_work_wrapper);
1148         wqw->hd = hd;
1149         wqw->disk = disk;
1150
1151         schedule_work(&wqw->work);
1152 }
1153
1154 static int
1155 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1156 {
1157         u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1158         struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1159
1160         if (ioc->bus_type != SPI)
1161                 return 0;
1162
1163         if (hd && event ==  MPI_EVENT_INTEGRATED_RAID) {
1164                 int reason
1165                         = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1166
1167                 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1168                         int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1169                         mpt_dv_raid(hd, disk);
1170                 }
1171         }
1172         return mptscsih_event_process(ioc, pEvReply);
1173 }
1174
1175 static int
1176 mptspi_deny_binding(struct scsi_target *starget)
1177 {
1178         struct _MPT_SCSI_HOST *hd =
1179                 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1180         return ((mptspi_is_raid(hd, starget->id)) &&
1181                 starget->channel == 0) ? 1 : 0;
1182 }
1183
1184 static struct spi_function_template mptspi_transport_functions = {
1185         .get_offset     = mptspi_read_parameters,
1186         .set_offset     = mptspi_write_offset,
1187         .show_offset    = 1,
1188         .get_period     = mptspi_read_parameters,
1189         .set_period     = mptspi_write_period,
1190         .show_period    = 1,
1191         .get_width      = mptspi_read_parameters,
1192         .set_width      = mptspi_write_width,
1193         .show_width     = 1,
1194         .get_iu         = mptspi_read_parameters,
1195         .set_iu         = mptspi_write_iu,
1196         .show_iu        = 1,
1197         .get_dt         = mptspi_read_parameters,
1198         .set_dt         = mptspi_write_dt,
1199         .show_dt        = 1,
1200         .get_qas        = mptspi_read_parameters,
1201         .set_qas        = mptspi_write_qas,
1202         .show_qas       = 1,
1203         .get_wr_flow    = mptspi_read_parameters,
1204         .set_wr_flow    = mptspi_write_wr_flow,
1205         .show_wr_flow   = 1,
1206         .get_rd_strm    = mptspi_read_parameters,
1207         .set_rd_strm    = mptspi_write_rd_strm,
1208         .show_rd_strm   = 1,
1209         .get_rti        = mptspi_read_parameters,
1210         .set_rti        = mptspi_write_rti,
1211         .show_rti       = 1,
1212         .get_pcomp_en   = mptspi_read_parameters,
1213         .set_pcomp_en   = mptspi_write_pcomp_en,
1214         .show_pcomp_en  = 1,
1215         .get_hold_mcs   = mptspi_read_parameters,
1216         .set_hold_mcs   = mptspi_write_hold_mcs,
1217         .show_hold_mcs  = 1,
1218         .deny_binding   = mptspi_deny_binding,
1219 };
1220
1221 /****************************************************************************
1222  * Supported hardware
1223  */
1224
1225 static struct pci_device_id mptspi_pci_table[] = {
1226         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1227                 PCI_ANY_ID, PCI_ANY_ID },
1228         { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1229                 PCI_ANY_ID, PCI_ANY_ID },
1230         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1231                 PCI_ANY_ID, PCI_ANY_ID },
1232         {0}     /* Terminating entry */
1233 };
1234 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1235
1236
1237 /*
1238  * renegotiate for a given target
1239  */
1240 static void
1241 mptspi_dv_renegotiate_work(struct work_struct *work)
1242 {
1243         struct work_queue_wrapper *wqw =
1244                 container_of(work, struct work_queue_wrapper, work);
1245         struct _MPT_SCSI_HOST *hd = wqw->hd;
1246         struct scsi_device *sdev;
1247         struct scsi_target *starget;
1248         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1249         u32 nego;
1250         MPT_ADAPTER *ioc = hd->ioc;
1251
1252         kfree(wqw);
1253
1254         if (hd->spi_pending) {
1255                 shost_for_each_device(sdev, ioc->sh) {
1256                         if  (hd->spi_pending & (1 << sdev->id))
1257                                 continue;
1258                         starget = scsi_target(sdev);
1259                         nego = mptspi_getRP(starget);
1260                         pg1.RequestedParameters = cpu_to_le32(nego);
1261                         pg1.Reserved = 0;
1262                         pg1.Configuration = 0;
1263                         mptspi_write_spi_device_pg1(starget, &pg1);
1264                 }
1265         } else {
1266                 shost_for_each_device(sdev, ioc->sh)
1267                         mptspi_dv_device(hd, sdev);
1268         }
1269 }
1270
1271 static void
1272 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1273 {
1274         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1275
1276         if (!wqw)
1277                 return;
1278
1279         INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1280         wqw->hd = hd;
1281
1282         schedule_work(&wqw->work);
1283 }
1284
1285 /*
1286  * spi module reset handler
1287  */
1288 static int
1289 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1290 {
1291         int rc;
1292
1293         rc = mptscsih_ioc_reset(ioc, reset_phase);
1294         if ((ioc->bus_type != SPI) || (!rc))
1295                 return rc;
1296
1297         /* only try to do a renegotiation if we're properly set up
1298          * if we get an ioc fault on bringup, ioc->sh will be NULL */
1299         if (reset_phase == MPT_IOC_POST_RESET &&
1300             ioc->sh) {
1301                 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1302
1303                 mptspi_dv_renegotiate(hd);
1304         }
1305
1306         return rc;
1307 }
1308
1309 #ifdef CONFIG_PM
1310 /*
1311  * spi module resume handler
1312  */
1313 static int
1314 mptspi_resume(struct pci_dev *pdev)
1315 {
1316         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1317         struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1318         int rc;
1319
1320         rc = mptscsih_resume(pdev);
1321         mptspi_dv_renegotiate(hd);
1322
1323         return rc;
1324 }
1325 #endif
1326
1327 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1328 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1329 /*
1330  *      mptspi_probe - Installs scsi devices per bus.
1331  *      @pdev: Pointer to pci_dev structure
1332  *
1333  *      Returns 0 for success, non-zero for failure.
1334  *
1335  */
1336 static int
1337 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1338 {
1339         struct Scsi_Host        *sh;
1340         MPT_SCSI_HOST           *hd;
1341         MPT_ADAPTER             *ioc;
1342         unsigned long            flags;
1343         int                      ii;
1344         int                      numSGE = 0;
1345         int                      scale;
1346         int                      ioc_cap;
1347         int                     error=0;
1348         int                     r;
1349
1350         if ((r = mpt_attach(pdev,id)) != 0)
1351                 return r;
1352
1353         ioc = pci_get_drvdata(pdev);
1354         ioc->DoneCtx = mptspiDoneCtx;
1355         ioc->TaskCtx = mptspiTaskCtx;
1356         ioc->InternalCtx = mptspiInternalCtx;
1357
1358         /*  Added sanity check on readiness of the MPT adapter.
1359          */
1360         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1361                 printk(MYIOC_s_WARN_FMT
1362                   "Skipping because it's not operational!\n",
1363                   ioc->name);
1364                 error = -ENODEV;
1365                 goto out_mptspi_probe;
1366         }
1367
1368         if (!ioc->active) {
1369                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1370                   ioc->name);
1371                 error = -ENODEV;
1372                 goto out_mptspi_probe;
1373         }
1374
1375         /*  Sanity check - ensure at least 1 port is INITIATOR capable
1376          */
1377         ioc_cap = 0;
1378         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1379                 if (ioc->pfacts[ii].ProtocolFlags &
1380                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
1381                         ioc_cap ++;
1382         }
1383
1384         if (!ioc_cap) {
1385                 printk(MYIOC_s_WARN_FMT
1386                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1387                         ioc->name, ioc);
1388                 return 0;
1389         }
1390
1391         sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1392
1393         if (!sh) {
1394                 printk(MYIOC_s_WARN_FMT
1395                         "Unable to register controller with SCSI subsystem\n",
1396                         ioc->name);
1397                 error = -1;
1398                 goto out_mptspi_probe;
1399         }
1400
1401         spin_lock_irqsave(&ioc->FreeQlock, flags);
1402
1403         /* Attach the SCSI Host to the IOC structure
1404          */
1405         ioc->sh = sh;
1406
1407         sh->io_port = 0;
1408         sh->n_io_port = 0;
1409         sh->irq = 0;
1410
1411         /* set 16 byte cdb's */
1412         sh->max_cmd_len = 16;
1413
1414         /* Yikes!  This is important!
1415          * Otherwise, by default, linux
1416          * only scans target IDs 0-7!
1417          * pfactsN->MaxDevices unreliable
1418          * (not supported in early
1419          *      versions of the FW).
1420          * max_id = 1 + actual max id,
1421          * max_lun = 1 + actual last lun,
1422          *      see hosts.h :o(
1423          */
1424         sh->max_id = ioc->devices_per_bus;
1425
1426         sh->max_lun = MPT_LAST_LUN + 1;
1427         /*
1428          * If RAID Firmware Detected, setup virtual channel
1429          */
1430         if (ioc->ir_firmware)
1431                 sh->max_channel = 1;
1432         else
1433                 sh->max_channel = 0;
1434         sh->this_id = ioc->pfacts[0].PortSCSIID;
1435
1436         /* Required entry.
1437          */
1438         sh->unique_id = ioc->id;
1439
1440         /* Verify that we won't exceed the maximum
1441          * number of chain buffers
1442          * We can optimize:  ZZ = req_sz/sizeof(SGE)
1443          * For 32bit SGE's:
1444          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1445          *               + (req_sz - 64)/sizeof(SGE)
1446          * A slightly different algorithm is required for
1447          * 64bit SGEs.
1448          */
1449         scale = ioc->req_sz/ioc->SGE_size;
1450         if (ioc->sg_addr_size == sizeof(u64)) {
1451                 numSGE = (scale - 1) *
1452                   (ioc->facts.MaxChainDepth-1) + scale +
1453                   (ioc->req_sz - 60) / ioc->SGE_size;
1454         } else {
1455                 numSGE = 1 + (scale - 1) *
1456                   (ioc->facts.MaxChainDepth-1) + scale +
1457                   (ioc->req_sz - 64) / ioc->SGE_size;
1458         }
1459
1460         if (numSGE < sh->sg_tablesize) {
1461                 /* Reset this value */
1462                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1463                   "Resetting sg_tablesize to %d from %d\n",
1464                   ioc->name, numSGE, sh->sg_tablesize));
1465                 sh->sg_tablesize = numSGE;
1466         }
1467
1468         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1469
1470         hd = shost_priv(sh);
1471         hd->ioc = ioc;
1472
1473         /* SCSI needs scsi_cmnd lookup table!
1474          * (with size equal to req_depth*PtrSz!)
1475          */
1476         ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1477         if (!ioc->ScsiLookup) {
1478                 error = -ENOMEM;
1479                 goto out_mptspi_probe;
1480         }
1481         spin_lock_init(&ioc->scsi_lookup_lock);
1482
1483         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1484                  ioc->name, ioc->ScsiLookup));
1485
1486         ioc->spi_data.Saf_Te = mpt_saf_te;
1487         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1488                 "saf_te %x\n",
1489                 ioc->name,
1490                 mpt_saf_te));
1491         ioc->spi_data.noQas = 0;
1492
1493         hd->last_queue_full = 0;
1494         hd->spi_pending = 0;
1495
1496         /* Some versions of the firmware don't support page 0; without
1497          * that we can't get the parameters */
1498         if (ioc->spi_data.sdp0length != 0)
1499                 sh->transportt = mptspi_transport_template;
1500
1501         error = scsi_add_host (sh, &ioc->pcidev->dev);
1502         if(error) {
1503                 dprintk(ioc, printk(MYIOC_s_ERR_FMT
1504                   "scsi_add_host failed\n", ioc->name));
1505                 goto out_mptspi_probe;
1506         }
1507
1508         /*
1509          * issue internal bus reset
1510          */
1511         if (ioc->spi_data.bus_reset)
1512                 mptscsih_IssueTaskMgmt(hd,
1513                     MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1514                     0, 0, 0, 0, 5);
1515
1516         scsi_scan_host(sh);
1517         return 0;
1518
1519 out_mptspi_probe:
1520
1521         mptscsih_remove(pdev);
1522         return error;
1523 }
1524
1525 static struct pci_driver mptspi_driver = {
1526         .name           = "mptspi",
1527         .id_table       = mptspi_pci_table,
1528         .probe          = mptspi_probe,
1529         .remove         = __devexit_p(mptscsih_remove),
1530         .shutdown       = mptscsih_shutdown,
1531 #ifdef CONFIG_PM
1532         .suspend        = mptscsih_suspend,
1533         .resume         = mptspi_resume,
1534 #endif
1535 };
1536
1537 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1538 /**
1539  *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1540  *
1541  *      Returns 0 for success, non-zero for failure.
1542  */
1543 static int __init
1544 mptspi_init(void)
1545 {
1546         int error;
1547
1548         show_mptmod_ver(my_NAME, my_VERSION);
1549
1550         mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1551         if (!mptspi_transport_template)
1552                 return -ENODEV;
1553
1554         mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1555         mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1556         mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1557
1558         mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1559         mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1560
1561         error = pci_register_driver(&mptspi_driver);
1562         if (error)
1563                 spi_release_transport(mptspi_transport_template);
1564
1565         return error;
1566 }
1567
1568 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1569 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1570 /**
1571  *      mptspi_exit - Unregisters MPT adapter(s)
1572  */
1573 static void __exit
1574 mptspi_exit(void)
1575 {
1576         pci_unregister_driver(&mptspi_driver);
1577
1578         mpt_reset_deregister(mptspiDoneCtx);
1579         mpt_event_deregister(mptspiDoneCtx);
1580
1581         mpt_deregister(mptspiInternalCtx);
1582         mpt_deregister(mptspiTaskCtx);
1583         mpt_deregister(mptspiDoneCtx);
1584         spi_release_transport(mptspi_transport_template);
1585 }
1586
1587 module_init(mptspi_init);
1588 module_exit(mptspi_exit);