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