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