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