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