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-2007 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/init.h>
  50 #include <linux/errno.h>
  51 #include <linux/kdev_t.h>
  52 #include <linux/blkdev.h>
  53 #include <linux/delay.h>        /* for mdelay */
  54 #include <linux/interrupt.h>    /* needed for in_interrupt() proto */
  55 #include <linux/reboot.h>       /* notifier code */
  56 #include <linux/workqueue.h>
  57 #include <linux/raid_class.h>
  58
  59 #include <scsi/scsi.h>
  60 #include <scsi/scsi_cmnd.h>
  61 #include <scsi/scsi_device.h>
  62 #include <scsi/scsi_host.h>
  63 #include <scsi/scsi_tcq.h>
  64 #include <scsi/scsi_transport.h>
  65 #include <scsi/scsi_transport_spi.h>
  66 #include <scsi/scsi_dbg.h>
  67
  68 #include "mptbase.h"
  69 #include "mptscsih.h"
  70
  71 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  72 #define my_NAME         "Fusion MPT SPI Host driver"
  73 #define my_VERSION      MPT_LINUX_VERSION_COMMON
  74 #define MYNAM           "mptspi"
  75
  76 MODULE_AUTHOR(MODULEAUTHOR);
  77 MODULE_DESCRIPTION(my_NAME);
  78 MODULE_LICENSE("GPL");
  79 MODULE_VERSION(my_VERSION);
  80
  81 /* Command line args */
  82 static int mpt_saf_te = MPTSCSIH_SAF_TE;
  83 module_param(mpt_saf_te, int, 0);
  84 MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1  (default=MPTSCSIH_SAF_TE=0)");
  85
  86 static void mptspi_write_offset(struct scsi_target *, int);
  87 static void mptspi_write_width(struct scsi_target *, int);
  88 static int mptspi_write_spi_device_pg1(struct scsi_target *,
  89                                        struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
  90
  91 static struct scsi_transport_template *mptspi_transport_template = NULL;
  92
  93 static u8       mptspiDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
  94 static u8       mptspiTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
  95 static u8       mptspiInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */
  96
  97 /**
  98  *      mptspi_setTargetNegoParms  - Update the target negotiation parameters
  99  *      @hd: Pointer to a SCSI Host Structure
 100  *      @target: per target private data
 101  *      @sdev: SCSI device
 102  *
 103  *      Update the target negotiation parameters based on the the Inquiry
 104  *      data, adapter capabilities, and NVRAM settings.
 105  **/
 106 static void
 107 mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
 108                             struct scsi_device *sdev)
 109 {
 110         MPT_ADAPTER *ioc = hd->ioc;
 111         SpiCfgData *pspi_data = &ioc->spi_data;
 112         int  id = (int) target->id;
 113         int  nvram;
 114         u8 width = MPT_NARROW;
 115         u8 factor = MPT_ASYNC;
 116         u8 offset = 0;
 117         u8 nfactor;
 118         u8 noQas = 1;
 119
 120         target->negoFlags = pspi_data->noQas;
 121
 122         if (sdev->scsi_level < SCSI_2) {
 123                 width = 0;
 124                 factor = MPT_ULTRA2;
 125                 offset = pspi_data->maxSyncOffset;
 126                 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
 127         } else {
 128                 if (scsi_device_wide(sdev))
 129                         width = 1;
 130
 131                 if (scsi_device_sync(sdev)) {
 132                         factor = pspi_data->minSyncFactor;
 133                         if (!scsi_device_dt(sdev))
 134                                         factor = MPT_ULTRA2;
 135                         else {
 136                                 if (!scsi_device_ius(sdev) &&
 137                                     !scsi_device_qas(sdev))
 138                                         factor = MPT_ULTRA160;
 139                                 else {
 140                                         factor = MPT_ULTRA320;
 141                                         if (scsi_device_qas(sdev)) {
 142                                                 ddvprintk(ioc,
 143                                                 printk(MYIOC_s_DEBUG_FMT "Enabling QAS due to "
 144                                                 "byte56=%02x on id=%d!\n", ioc->name,
 145                                                 scsi_device_qas(sdev), id));
 146                                                 noQas = 0;
 147                                         }
 148                                         if (sdev->type == TYPE_TAPE &&
 149                                             scsi_device_ius(sdev))
 150                                                 target->negoFlags |= MPT_TAPE_NEGO_IDP;
 151                                 }
 152                         }
 153                         offset = pspi_data->maxSyncOffset;
 154
 155                         /* If RAID, never disable QAS
 156                          * else if non RAID, do not disable
 157                          *   QAS if bit 1 is set
 158                          * bit 1 QAS support, non-raid only
 159                          * bit 0 IU support
 160                          */
 161                         if (target->raidVolume == 1)
 162                                 noQas = 0;
 163                 } else {
 164                         factor = MPT_ASYNC;
 165                         offset = 0;
 166                 }
 167         }
 168
 169         if (!sdev->tagged_supported)
 170                 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
 171
 172         /* Update tflags based on NVRAM settings. (SCSI only)
 173          */
 174         if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
 175                 nvram = pspi_data->nvram[id];
 176                 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
 177
 178                 if (width)
 179                         width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
 180
 181                 if (offset > 0) {
 182                         /* Ensure factor is set to the
 183                          * maximum of: adapter, nvram, inquiry
 184                          */
 185                         if (nfactor) {
 186                                 if (nfactor < pspi_data->minSyncFactor )
 187                                         nfactor = pspi_data->minSyncFactor;
 188
 189                                 factor = max(factor, nfactor);
 190                                 if (factor == MPT_ASYNC)
 191                                         offset = 0;
 192                         } else {
 193                                 offset = 0;
 194                                 factor = MPT_ASYNC;
 195                 }
 196                 } else {
 197                         factor = MPT_ASYNC;
 198                 }
 199         }
 200
 201         /* Make sure data is consistent
 202          */
 203         if ((!width) && (factor < MPT_ULTRA2))
 204                 factor = MPT_ULTRA2;
 205
 206         /* Save the data to the target structure.
 207          */
 208         target->minSyncFactor = factor;
 209         target->maxOffset = offset;
 210         target->maxWidth = width;
 211
 212         target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
 213
 214         /* Disable unused features.
 215          */
 216         if (!width)
 217                 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
 218
 219         if (!offset)
 220                 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
 221
 222         if ( factor > MPT_ULTRA320 )
 223                 noQas = 0;
 224
 225         if (noQas && (pspi_data->noQas == 0)) {
 226                 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
 227                 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
 228
 229                 /* Disable QAS in a mixed configuration case
 230                  */
 231
 232                 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 233                         "Disabling QAS due to noQas=%02x on id=%d!\n", ioc->name, noQas, id));
 234         }
 235 }
 236
 237 /**
 238  *      mptspi_writeIOCPage4  - write IOC Page 4
 239  *      @hd: Pointer to a SCSI Host Structure
 240  *      @channel: channel number
 241  *      @id: write IOC Page4 for this ID & Bus
 242  *
 243  *      Return: -EAGAIN if unable to obtain a Message Frame
 244  *              or 0 if success.
 245  *
 246  *      Remark: We do not wait for a return, write pages sequentially.
 247  **/
 248 static int
 249 mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
 250 {
 251         MPT_ADAPTER             *ioc = hd->ioc;
 252         Config_t                *pReq;
 253         IOCPage4_t              *IOCPage4Ptr;
 254         MPT_FRAME_HDR           *mf;
 255         dma_addr_t               dataDma;
 256         u16                      req_idx;
 257         u32                      frameOffset;
 258         u32                      flagsLength;
 259         int                      ii;
 260
 261         /* Get a MF for this command.
 262          */
 263         if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
 264                 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
 265                                 "writeIOCPage4 : no msg frames!\n",ioc->name));
 266                 return -EAGAIN;
 267         }
 268
 269         /* Set the request and the data pointers.
 270          * Place data at end of MF.
 271          */
 272         pReq = (Config_t *)mf;
 273
 274         req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
 275         frameOffset = ioc->req_sz - sizeof(IOCPage4_t);
 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         mpt_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 = (struct _MPT_SCSI_HOST *)shost->hostdata;
 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         mptspi_write_width(starget, 0);
 451
 452         return 0;
 453 }
 454
 455 static void
 456 mptspi_target_destroy(struct scsi_target *starget)
 457 {
 458         if (starget->hostdata)
 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 = (struct _MPT_SCSI_HOST *)shost->hostdata;
 518         struct _MPT_ADAPTER *ioc = hd->ioc;
 519         struct _CONFIG_PAGE_SCSI_DEVICE_0 *pg0;
 520         dma_addr_t 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         pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg0_dma, GFP_KERNEL);
 539         if (pg0 == NULL) {
 540                 starget_printk(MYIOC_s_ERR_FMT, starget,
 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 = pg0_dma;
 556         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 557         cfg.dir = 0;
 558         cfg.pageAddr = starget->id;
 559
 560         if (mpt_config(ioc, &cfg)) {
 561                 starget_printk(MYIOC_s_ERR_FMT, starget, "mpt_config failed\n", ioc->name);
 562                 goto out_free;
 563         }
 564         err = 0;
 565         memcpy(pass_pg0, pg0, size);
 566
 567         mptspi_print_read_nego(hd, starget, le32_to_cpu(pg0->NegotiatedParameters));
 568
 569  out_free:
 570         dma_free_coherent(&ioc->pcidev->dev, size, pg0, pg0_dma);
 571         return err;
 572 }
 573
 574 static u32 mptspi_getRP(struct scsi_target *starget)
 575 {
 576         u32 nego = 0;
 577
 578         nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
 579         nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
 580         nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
 581         nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
 582         nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
 583         nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
 584         nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
 585         nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
 586
 587         nego |= (spi_period(starget) <<  MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
 588         nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
 589         nego |= spi_width(starget) ?  MPI_SCSIDEVPAGE1_RP_WIDE : 0;
 590
 591         return nego;
 592 }
 593
 594 static void mptspi_read_parameters(struct scsi_target *starget)
 595 {
 596         int nego;
 597         struct _CONFIG_PAGE_SCSI_DEVICE_0 pg0;
 598
 599         mptspi_read_spi_device_pg0(starget, &pg0);
 600
 601         nego = le32_to_cpu(pg0.NegotiatedParameters);
 602
 603         spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
 604         spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
 605         spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
 606         spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
 607         spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
 608         spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
 609         spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
 610         spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
 611         spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
 612         spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
 613         spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
 614 }
 615
 616 static int
 617 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
 618 {
 619         MpiRaidActionRequest_t  *pReq;
 620         MPT_FRAME_HDR           *mf;
 621         MPT_ADAPTER *ioc = hd->ioc;
 622
 623         /* Get and Populate a free Frame
 624          */
 625         if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
 626                 ddvprintk(ioc, printk(MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
 627                                         ioc->name));
 628                 return -EAGAIN;
 629         }
 630         pReq = (MpiRaidActionRequest_t *)mf;
 631         if (quiesce)
 632                 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
 633         else
 634                 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
 635         pReq->Reserved1 = 0;
 636         pReq->ChainOffset = 0;
 637         pReq->Function = MPI_FUNCTION_RAID_ACTION;
 638         pReq->VolumeID = id;
 639         pReq->VolumeBus = channel;
 640         pReq->PhysDiskNum = 0;
 641         pReq->MsgFlags = 0;
 642         pReq->Reserved2 = 0;
 643         pReq->ActionDataWord = 0; /* Reserved for this action */
 644
 645         mpt_add_sge((char *)&pReq->ActionDataSGE,
 646                 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
 647
 648         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
 649                         ioc->name, pReq->Action, channel, id));
 650
 651         hd->pLocal = NULL;
 652         hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
 653         hd->scandv_wait_done = 0;
 654
 655         /* Save cmd pointer, for resource free if timeout or
 656          * FW reload occurs
 657          */
 658         hd->cmdPtr = mf;
 659
 660         add_timer(&hd->timer);
 661         mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
 662         wait_event(hd->scandv_waitq, hd->scandv_wait_done);
 663
 664         if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
 665                 return -1;
 666
 667         return 0;
 668 }
 669
 670 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
 671                              struct scsi_device *sdev)
 672 {
 673         VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 674         MPT_ADAPTER *ioc = hd->ioc;
 675
 676         /* no DV on RAID devices */
 677         if (sdev->channel == 0 &&
 678             mptspi_is_raid(hd, sdev->id))
 679                 return;
 680
 681         /* If this is a piece of a RAID, then quiesce first */
 682         if (sdev->channel == 1 &&
 683             mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
 684                 starget_printk(MYIOC_s_ERR_FMT, scsi_target(sdev),
 685                     "Integrated RAID quiesce failed\n", ioc->name);
 686                 return;
 687         }
 688
 689         hd->spi_pending |= (1 << sdev->id);
 690         spi_dv_device(sdev);
 691         hd->spi_pending &= ~(1 << sdev->id);
 692
 693         if (sdev->channel == 1 &&
 694             mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
 695                 starget_printk(MYIOC_s_ERR_FMT, scsi_target(sdev),
 696                     "Integrated RAID resume failed\n", ioc->name);
 697
 698         mptspi_read_parameters(sdev->sdev_target);
 699         spi_display_xfer_agreement(sdev->sdev_target);
 700         mptspi_read_parameters(sdev->sdev_target);
 701 }
 702
 703 static int mptspi_slave_alloc(struct scsi_device *sdev)
 704 {
 705         MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
 706         VirtTarget              *vtarget;
 707         VirtDevice              *vdevice;
 708         struct scsi_target      *starget;
 709         MPT_ADAPTER *ioc = hd->ioc;
 710
 711         if (sdev->channel == 1 &&
 712                 mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0)
 713                         return -ENXIO;
 714
 715         vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
 716         if (!vdevice) {
 717                 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
 718                                 ioc->name, sizeof(VirtDevice));
 719                 return -ENOMEM;
 720         }
 721
 722         vdevice->lun = sdev->lun;
 723         sdev->hostdata = vdevice;
 724
 725         starget = scsi_target(sdev);
 726         vtarget = starget->hostdata;
 727         vdevice->vtarget = vtarget;
 728         vtarget->num_luns++;
 729
 730         if (sdev->channel == 1)
 731                 sdev->no_uld_attach = 1;
 732
 733         return 0;
 734 }
 735
 736 static int mptspi_slave_configure(struct scsi_device *sdev)
 737 {
 738         struct _MPT_SCSI_HOST *hd =
 739                 (struct _MPT_SCSI_HOST *)sdev->host->hostdata;
 740         VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 741         int ret;
 742
 743         mptspi_initTarget(hd, vtarget, sdev);
 744
 745         ret = mptscsih_slave_configure(sdev);
 746
 747         if (ret)
 748                 return ret;
 749
 750         ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
 751                 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
 752                 sdev->id, spi_min_period(scsi_target(sdev)),
 753                 spi_max_offset(scsi_target(sdev)),
 754                 spi_max_width(scsi_target(sdev))));
 755
 756         if ((sdev->channel == 1 ||
 757              !(mptspi_is_raid(hd, sdev->id))) &&
 758             !spi_initial_dv(sdev->sdev_target))
 759                 mptspi_dv_device(hd, sdev);
 760
 761         return 0;
 762 }
 763
 764 static int
 765 mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
 766 {
 767         struct _MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata;
 768         VirtDevice      *vdevice = SCpnt->device->hostdata;
 769         MPT_ADAPTER *ioc = hd->ioc;
 770
 771         if (!vdevice || !vdevice->vtarget) {
 772                 SCpnt->result = DID_NO_CONNECT << 16;
 773                 done(SCpnt);
 774                 return 0;
 775         }
 776
 777         if (SCpnt->device->channel == 1 &&
 778                 mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) {
 779                 SCpnt->result = DID_NO_CONNECT << 16;
 780                 done(SCpnt);
 781                 return 0;
 782         }
 783
 784         if (spi_dv_pending(scsi_target(SCpnt->device)))
 785                 ddvprintk(ioc, scsi_print_command(SCpnt));
 786
 787         return mptscsih_qcmd(SCpnt,done);
 788 }
 789
 790 static void mptspi_slave_destroy(struct scsi_device *sdev)
 791 {
 792         struct scsi_target *starget = scsi_target(sdev);
 793         VirtTarget *vtarget = starget->hostdata;
 794         VirtDevice *vdevice = sdev->hostdata;
 795
 796         /* Will this be the last lun on a non-raid device? */
 797         if (vtarget->num_luns == 1 && vdevice->configured_lun) {
 798                 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 799
 800                 /* Async Narrow */
 801                 pg1.RequestedParameters = 0;
 802                 pg1.Reserved = 0;
 803                 pg1.Configuration = 0;
 804
 805                 mptspi_write_spi_device_pg1(starget, &pg1);
 806         }
 807
 808         mptscsih_slave_destroy(sdev);
 809 }
 810
 811 static struct scsi_host_template mptspi_driver_template = {
 812         .module                         = THIS_MODULE,
 813         .proc_name                      = "mptspi",
 814         .proc_info                      = mptscsih_proc_info,
 815         .name                           = "MPT SPI Host",
 816         .info                           = mptscsih_info,
 817         .queuecommand                   = mptspi_qcmd,
 818         .target_alloc                   = mptspi_target_alloc,
 819         .slave_alloc                    = mptspi_slave_alloc,
 820         .slave_configure                = mptspi_slave_configure,
 821         .target_destroy                 = mptspi_target_destroy,
 822         .slave_destroy                  = mptspi_slave_destroy,
 823         .change_queue_depth             = mptscsih_change_queue_depth,
 824         .eh_abort_handler               = mptscsih_abort,
 825         .eh_device_reset_handler        = mptscsih_dev_reset,
 826         .eh_bus_reset_handler           = mptscsih_bus_reset,
 827         .eh_host_reset_handler          = mptscsih_host_reset,
 828         .bios_param                     = mptscsih_bios_param,
 829         .can_queue                      = MPT_SCSI_CAN_QUEUE,
 830         .this_id                        = -1,
 831         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
 832         .max_sectors                    = 8192,
 833         .cmd_per_lun                    = 7,
 834         .use_clustering                 = ENABLE_CLUSTERING,
 835         .shost_attrs                    = mptscsih_host_attrs,
 836 };
 837
 838 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
 839                                struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
 840 {
 841         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 842         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
 843         struct _MPT_ADAPTER *ioc = hd->ioc;
 844         struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
 845         dma_addr_t pg1_dma;
 846         int size;
 847         struct _x_config_parms cfg;
 848         struct _CONFIG_PAGE_HEADER hdr;
 849         int err = -EBUSY;
 850
 851         /* don't allow updating nego parameters on RAID devices */
 852         if (starget->channel == 0 &&
 853             mptspi_is_raid(hd, starget->id))
 854                 return -1;
 855
 856         size = ioc->spi_data.sdp1length * 4;
 857
 858         pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
 859         if (pg1 == NULL) {
 860                 starget_printk(MYIOC_s_ERR_FMT, starget,
 861                     "dma_alloc_coherent for parameters failed\n", ioc->name);
 862                 return -EINVAL;
 863         }
 864
 865         memset(&hdr, 0, sizeof(hdr));
 866
 867         hdr.PageVersion = ioc->spi_data.sdp1version;
 868         hdr.PageLength = ioc->spi_data.sdp1length;
 869         hdr.PageNumber = 1;
 870         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 871
 872         memset(&cfg, 0, sizeof(cfg));
 873
 874         cfg.cfghdr.hdr = &hdr;
 875         cfg.physAddr = pg1_dma;
 876         cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 877         cfg.dir = 1;
 878         cfg.pageAddr = starget->id;
 879
 880         memcpy(pg1, pass_pg1, size);
 881
 882         pg1->Header.PageVersion = hdr.PageVersion;
 883         pg1->Header.PageLength = hdr.PageLength;
 884         pg1->Header.PageNumber = hdr.PageNumber;
 885         pg1->Header.PageType = hdr.PageType;
 886
 887         mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
 888
 889         if (mpt_config(ioc, &cfg)) {
 890                 starget_printk(MYIOC_s_ERR_FMT, starget,
 891                     "mpt_config failed\n", ioc->name);
 892                 goto out_free;
 893         }
 894         err = 0;
 895
 896  out_free:
 897         dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
 898         return err;
 899 }
 900
 901 static void mptspi_write_offset(struct scsi_target *starget, int offset)
 902 {
 903         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 904         u32 nego;
 905
 906         if (offset < 0)
 907                 offset = 0;
 908
 909         if (offset > 255)
 910                 offset = 255;
 911
 912         if (spi_offset(starget) == -1)
 913                 mptspi_read_parameters(starget);
 914
 915         spi_offset(starget) = offset;
 916
 917         nego = mptspi_getRP(starget);
 918
 919         pg1.RequestedParameters = cpu_to_le32(nego);
 920         pg1.Reserved = 0;
 921         pg1.Configuration = 0;
 922
 923         mptspi_write_spi_device_pg1(starget, &pg1);
 924 }
 925
 926 static void mptspi_write_period(struct scsi_target *starget, int period)
 927 {
 928         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 929         u32 nego;
 930
 931         if (period < 8)
 932                 period = 8;
 933
 934         if (period > 255)
 935                 period = 255;
 936
 937         if (spi_period(starget) == -1)
 938                 mptspi_read_parameters(starget);
 939
 940         if (period == 8) {
 941                 spi_iu(starget) = 1;
 942                 spi_dt(starget) = 1;
 943         } else if (period == 9) {
 944                 spi_dt(starget) = 1;
 945         }
 946
 947         spi_period(starget) = period;
 948
 949         nego = mptspi_getRP(starget);
 950
 951         pg1.RequestedParameters = cpu_to_le32(nego);
 952         pg1.Reserved = 0;
 953         pg1.Configuration = 0;
 954
 955         mptspi_write_spi_device_pg1(starget, &pg1);
 956 }
 957
 958 static void mptspi_write_dt(struct scsi_target *starget, int dt)
 959 {
 960         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 961         u32 nego;
 962
 963         if (spi_period(starget) == -1)
 964                 mptspi_read_parameters(starget);
 965
 966         if (!dt && spi_period(starget) < 10)
 967                 spi_period(starget) = 10;
 968
 969         spi_dt(starget) = dt;
 970
 971         nego = mptspi_getRP(starget);
 972
 973
 974         pg1.RequestedParameters = cpu_to_le32(nego);
 975         pg1.Reserved = 0;
 976         pg1.Configuration = 0;
 977
 978         mptspi_write_spi_device_pg1(starget, &pg1);
 979 }
 980
 981 static void mptspi_write_iu(struct scsi_target *starget, int iu)
 982 {
 983         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 984         u32 nego;
 985
 986         if (spi_period(starget) == -1)
 987                 mptspi_read_parameters(starget);
 988
 989         if (!iu && spi_period(starget) < 9)
 990                 spi_period(starget) = 9;
 991
 992         spi_iu(starget) = iu;
 993
 994         nego = mptspi_getRP(starget);
 995
 996         pg1.RequestedParameters = cpu_to_le32(nego);
 997         pg1.Reserved = 0;
 998         pg1.Configuration = 0;
 999
1000         mptspi_write_spi_device_pg1(starget, &pg1);
1001 }
1002
1003 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm)                              \
1004 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1005 {                                                                       \
1006         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;                          \
1007         u32 nego;                                                       \
1008                                                                         \
1009         spi_##parm(starget) = parm;                                     \
1010                                                                         \
1011         nego = mptspi_getRP(starget);                                   \
1012                                                                         \
1013         pg1.RequestedParameters = cpu_to_le32(nego);                    \
1014         pg1.Reserved = 0;                                               \
1015         pg1.Configuration = 0;                                          \
1016                                                                         \
1017         mptspi_write_spi_device_pg1(starget, &pg1);                             \
1018 }
1019
1020 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1021 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1022 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1023 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1024 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1025
1026 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1027 {
1028         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1029         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1030         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
1031         VirtTarget *vtarget = starget->hostdata;
1032         u32 nego;
1033
1034         if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1035             hd->ioc->spi_data.noQas)
1036                 spi_qas(starget) = 0;
1037         else
1038                 spi_qas(starget) = qas;
1039
1040         nego = mptspi_getRP(starget);
1041
1042         pg1.RequestedParameters = cpu_to_le32(nego);
1043         pg1.Reserved = 0;
1044         pg1.Configuration = 0;
1045
1046         mptspi_write_spi_device_pg1(starget, &pg1);
1047 }
1048
1049 static void mptspi_write_width(struct scsi_target *starget, int width)
1050 {
1051         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1052         u32 nego;
1053
1054         if (!width) {
1055                 spi_dt(starget) = 0;
1056                 if (spi_period(starget) < 10)
1057                         spi_period(starget) = 10;
1058         }
1059
1060         spi_width(starget) = width;
1061
1062         nego = mptspi_getRP(starget);
1063
1064         pg1.RequestedParameters = cpu_to_le32(nego);
1065         pg1.Reserved = 0;
1066         pg1.Configuration = 0;
1067
1068         mptspi_write_spi_device_pg1(starget, &pg1);
1069 }
1070
1071 struct work_queue_wrapper {
1072         struct work_struct      work;
1073         struct _MPT_SCSI_HOST   *hd;
1074         int                     disk;
1075 };
1076
1077 static void mpt_work_wrapper(struct work_struct *work)
1078 {
1079         struct work_queue_wrapper *wqw =
1080                 container_of(work, struct work_queue_wrapper, work);
1081         struct _MPT_SCSI_HOST *hd = wqw->hd;
1082         MPT_ADAPTER *ioc = hd->ioc;
1083         struct Scsi_Host *shost = ioc->sh;
1084         struct scsi_device *sdev;
1085         int disk = wqw->disk;
1086         struct _CONFIG_PAGE_IOC_3 *pg3;
1087
1088         kfree(wqw);
1089
1090         mpt_findImVolumes(ioc);
1091         pg3 = ioc->raid_data.pIocPg3;
1092         if (!pg3)
1093                 return;
1094
1095         shost_for_each_device(sdev,shost) {
1096                 struct scsi_target *starget = scsi_target(sdev);
1097                 VirtTarget *vtarget = starget->hostdata;
1098
1099                 /* only want to search RAID components */
1100                 if (sdev->channel != 1)
1101                         continue;
1102
1103                 /* The id is the raid PhysDiskNum, even if
1104                  * starget->id is the actual target address */
1105                 if(vtarget->id != disk)
1106                         continue;
1107
1108                 starget_printk(MYIOC_s_INFO_FMT, vtarget->starget,
1109                     "Integrated RAID requests DV of new device\n", ioc->name);
1110                 mptspi_dv_device(hd, sdev);
1111         }
1112         shost_printk(MYIOC_s_INFO_FMT, shost,
1113             "Integrated RAID detects new device %d\n", ioc->name, disk);
1114         scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, 1);
1115 }
1116
1117
1118 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1119 {
1120         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1121         MPT_ADAPTER *ioc = hd->ioc;
1122
1123         if (!wqw) {
1124                 shost_printk(MYIOC_s_ERR_FMT, ioc->sh,
1125                     "Failed to act on RAID event for physical disk %d\n",
1126                     ioc->name, disk);
1127                 return;
1128         }
1129         INIT_WORK(&wqw->work, mpt_work_wrapper);
1130         wqw->hd = hd;
1131         wqw->disk = disk;
1132
1133         schedule_work(&wqw->work);
1134 }
1135
1136 static int
1137 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1138 {
1139         u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1140         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1141
1142         if (hd && event ==  MPI_EVENT_INTEGRATED_RAID) {
1143                 int reason
1144                         = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1145
1146                 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1147                         int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1148                         mpt_dv_raid(hd, disk);
1149                 }
1150         }
1151         return mptscsih_event_process(ioc, pEvReply);
1152 }
1153
1154 static int
1155 mptspi_deny_binding(struct scsi_target *starget)
1156 {
1157         struct _MPT_SCSI_HOST *hd =
1158                 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1159         return ((mptspi_is_raid(hd, starget->id)) &&
1160                 starget->channel == 0) ? 1 : 0;
1161 }
1162
1163 static struct spi_function_template mptspi_transport_functions = {
1164         .get_offset     = mptspi_read_parameters,
1165         .set_offset     = mptspi_write_offset,
1166         .show_offset    = 1,
1167         .get_period     = mptspi_read_parameters,
1168         .set_period     = mptspi_write_period,
1169         .show_period    = 1,
1170         .get_width      = mptspi_read_parameters,
1171         .set_width      = mptspi_write_width,
1172         .show_width     = 1,
1173         .get_iu         = mptspi_read_parameters,
1174         .set_iu         = mptspi_write_iu,
1175         .show_iu        = 1,
1176         .get_dt         = mptspi_read_parameters,
1177         .set_dt         = mptspi_write_dt,
1178         .show_dt        = 1,
1179         .get_qas        = mptspi_read_parameters,
1180         .set_qas        = mptspi_write_qas,
1181         .show_qas       = 1,
1182         .get_wr_flow    = mptspi_read_parameters,
1183         .set_wr_flow    = mptspi_write_wr_flow,
1184         .show_wr_flow   = 1,
1185         .get_rd_strm    = mptspi_read_parameters,
1186         .set_rd_strm    = mptspi_write_rd_strm,
1187         .show_rd_strm   = 1,
1188         .get_rti        = mptspi_read_parameters,
1189         .set_rti        = mptspi_write_rti,
1190         .show_rti       = 1,
1191         .get_pcomp_en   = mptspi_read_parameters,
1192         .set_pcomp_en   = mptspi_write_pcomp_en,
1193         .show_pcomp_en  = 1,
1194         .get_hold_mcs   = mptspi_read_parameters,
1195         .set_hold_mcs   = mptspi_write_hold_mcs,
1196         .show_hold_mcs  = 1,
1197         .deny_binding   = mptspi_deny_binding,
1198 };
1199
1200 /****************************************************************************
1201  * Supported hardware
1202  */
1203
1204 static struct pci_device_id mptspi_pci_table[] = {
1205         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1206                 PCI_ANY_ID, PCI_ANY_ID },
1207         { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1208                 PCI_ANY_ID, PCI_ANY_ID },
1209         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1210                 PCI_ANY_ID, PCI_ANY_ID },
1211         {0}     /* Terminating entry */
1212 };
1213 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1214
1215
1216 /*
1217  * renegotiate for a given target
1218  */
1219 static void
1220 mptspi_dv_renegotiate_work(struct work_struct *work)
1221 {
1222         struct work_queue_wrapper *wqw =
1223                 container_of(work, struct work_queue_wrapper, work);
1224         struct _MPT_SCSI_HOST *hd = wqw->hd;
1225         struct scsi_device *sdev;
1226         struct scsi_target *starget;
1227         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1228         u32 nego;
1229         MPT_ADAPTER *ioc = hd->ioc;
1230
1231         kfree(wqw);
1232
1233         if (hd->spi_pending) {
1234                 shost_for_each_device(sdev, ioc->sh) {
1235                         if  (hd->spi_pending & (1 << sdev->id))
1236                                 continue;
1237                         starget = scsi_target(sdev);
1238                         nego = mptspi_getRP(starget);
1239                         pg1.RequestedParameters = cpu_to_le32(nego);
1240                         pg1.Reserved = 0;
1241                         pg1.Configuration = 0;
1242                         mptspi_write_spi_device_pg1(starget, &pg1);
1243                 }
1244         } else {
1245                 shost_for_each_device(sdev, ioc->sh)
1246                         mptspi_dv_device(hd, sdev);
1247         }
1248 }
1249
1250 static void
1251 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1252 {
1253         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1254
1255         if (!wqw)
1256                 return;
1257
1258         INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1259         wqw->hd = hd;
1260
1261         schedule_work(&wqw->work);
1262 }
1263
1264 /*
1265  * spi module reset handler
1266  */
1267 static int
1268 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1269 {
1270         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1271         int rc;
1272
1273         rc = mptscsih_ioc_reset(ioc, reset_phase);
1274
1275         if (reset_phase == MPT_IOC_POST_RESET)
1276                 mptspi_dv_renegotiate(hd);
1277
1278         return rc;
1279 }
1280
1281 #ifdef CONFIG_PM
1282 /*
1283  * spi module resume handler
1284  */
1285 static int
1286 mptspi_resume(struct pci_dev *pdev)
1287 {
1288         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1289         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1290         int rc;
1291
1292         rc = mptscsih_resume(pdev);
1293         mptspi_dv_renegotiate(hd);
1294
1295         return rc;
1296 }
1297 #endif
1298
1299 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1300 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1301 /*
1302  *      mptspi_probe - Installs scsi devices per bus.
1303  *      @pdev: Pointer to pci_dev structure
1304  *
1305  *      Returns 0 for success, non-zero for failure.
1306  *
1307  */
1308 static int
1309 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1310 {
1311         struct Scsi_Host        *sh;
1312         MPT_SCSI_HOST           *hd;
1313         MPT_ADAPTER             *ioc;
1314         unsigned long            flags;
1315         int                      ii;
1316         int                      numSGE = 0;
1317         int                      scale;
1318         int                      ioc_cap;
1319         int                     error=0;
1320         int                     r;
1321
1322         if ((r = mpt_attach(pdev,id)) != 0)
1323                 return r;
1324
1325         ioc = pci_get_drvdata(pdev);
1326         ioc->DoneCtx = mptspiDoneCtx;
1327         ioc->TaskCtx = mptspiTaskCtx;
1328         ioc->InternalCtx = mptspiInternalCtx;
1329
1330         /*  Added sanity check on readiness of the MPT adapter.
1331          */
1332         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1333                 printk(MYIOC_s_WARN_FMT
1334                   "Skipping because it's not operational!\n",
1335                   ioc->name);
1336                 error = -ENODEV;
1337                 goto out_mptspi_probe;
1338         }
1339
1340         if (!ioc->active) {
1341                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1342                   ioc->name);
1343                 error = -ENODEV;
1344                 goto out_mptspi_probe;
1345         }
1346
1347         /*  Sanity check - ensure at least 1 port is INITIATOR capable
1348          */
1349         ioc_cap = 0;
1350         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1351                 if (ioc->pfacts[ii].ProtocolFlags &
1352                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
1353                         ioc_cap ++;
1354         }
1355
1356         if (!ioc_cap) {
1357                 printk(MYIOC_s_WARN_FMT
1358                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1359                         ioc->name, ioc);
1360                 return 0;
1361         }
1362
1363         sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1364
1365         if (!sh) {
1366                 printk(MYIOC_s_WARN_FMT
1367                         "Unable to register controller with SCSI subsystem\n",
1368                         ioc->name);
1369                 error = -1;
1370                 goto out_mptspi_probe;
1371         }
1372
1373         spin_lock_irqsave(&ioc->FreeQlock, flags);
1374
1375         /* Attach the SCSI Host to the IOC structure
1376          */
1377         ioc->sh = sh;
1378
1379         sh->io_port = 0;
1380         sh->n_io_port = 0;
1381         sh->irq = 0;
1382
1383         /* set 16 byte cdb's */
1384         sh->max_cmd_len = 16;
1385
1386         /* Yikes!  This is important!
1387          * Otherwise, by default, linux
1388          * only scans target IDs 0-7!
1389          * pfactsN->MaxDevices unreliable
1390          * (not supported in early
1391          *      versions of the FW).
1392          * max_id = 1 + actual max id,
1393          * max_lun = 1 + actual last lun,
1394          *      see hosts.h :o(
1395          */
1396         sh->max_id = ioc->devices_per_bus;
1397
1398         sh->max_lun = MPT_LAST_LUN + 1;
1399         /*
1400          * If RAID Firmware Detected, setup virtual channel
1401          */
1402         if (ioc->ir_firmware)
1403                 sh->max_channel = 1;
1404         else
1405                 sh->max_channel = 0;
1406         sh->this_id = ioc->pfacts[0].PortSCSIID;
1407
1408         /* Required entry.
1409          */
1410         sh->unique_id = ioc->id;
1411
1412         /* Verify that we won't exceed the maximum
1413          * number of chain buffers
1414          * We can optimize:  ZZ = req_sz/sizeof(SGE)
1415          * For 32bit SGE's:
1416          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1417          *               + (req_sz - 64)/sizeof(SGE)
1418          * A slightly different algorithm is required for
1419          * 64bit SGEs.
1420          */
1421         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1422         if (sizeof(dma_addr_t) == sizeof(u64)) {
1423                 numSGE = (scale - 1) *
1424                   (ioc->facts.MaxChainDepth-1) + scale +
1425                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1426                   sizeof(u32));
1427         } else {
1428                 numSGE = 1 + (scale - 1) *
1429                   (ioc->facts.MaxChainDepth-1) + scale +
1430                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1431                   sizeof(u32));
1432         }
1433
1434         if (numSGE < sh->sg_tablesize) {
1435                 /* Reset this value */
1436                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1437                   "Resetting sg_tablesize to %d from %d\n",
1438                   ioc->name, numSGE, sh->sg_tablesize));
1439                 sh->sg_tablesize = numSGE;
1440         }
1441
1442         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1443
1444         hd = (MPT_SCSI_HOST *) sh->hostdata;
1445         hd->ioc = ioc;
1446
1447         /* SCSI needs scsi_cmnd lookup table!
1448          * (with size equal to req_depth*PtrSz!)
1449          */
1450         hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1451         if (!hd->ScsiLookup) {
1452                 error = -ENOMEM;
1453                 goto out_mptspi_probe;
1454         }
1455
1456         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1457                  ioc->name, hd->ScsiLookup));
1458
1459         /* Clear the TM flags
1460          */
1461         hd->tmPending = 0;
1462         hd->tmState = TM_STATE_NONE;
1463         hd->resetPending = 0;
1464         hd->abortSCpnt = NULL;
1465
1466         /* Clear the pointer used to store
1467          * single-threaded commands, i.e., those
1468          * issued during a bus scan, dv and
1469          * configuration pages.
1470          */
1471         hd->cmdPtr = NULL;
1472
1473         /* Initialize this SCSI Hosts' timers
1474          * To use, set the timer expires field
1475          * and add_timer
1476          */
1477         init_timer(&hd->timer);
1478         hd->timer.data = (unsigned long) hd;
1479         hd->timer.function = mptscsih_timer_expired;
1480
1481         ioc->spi_data.Saf_Te = mpt_saf_te;
1482
1483         hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1484         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1485                 "saf_te %x\n",
1486                 ioc->name,
1487                 mpt_saf_te));
1488         ioc->spi_data.noQas = 0;
1489
1490         init_waitqueue_head(&hd->scandv_waitq);
1491         hd->scandv_wait_done = 0;
1492         hd->last_queue_full = 0;
1493         hd->spi_pending = 0;
1494
1495         /* Some versions of the firmware don't support page 0; without
1496          * that we can't get the parameters */
1497         if (ioc->spi_data.sdp0length != 0)
1498                 sh->transportt = mptspi_transport_template;
1499
1500         error = scsi_add_host (sh, &ioc->pcidev->dev);
1501         if(error) {
1502                 dprintk(ioc, printk(MYIOC_s_ERR_FMT
1503                   "scsi_add_host failed\n", ioc->name));
1504                 goto out_mptspi_probe;
1505         }
1506
1507         /*
1508          * issue internal bus reset
1509          */
1510         if (ioc->spi_data.bus_reset)
1511                 mptscsih_TMHandler(hd,
1512                     MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1513                     0, 0, 0, 0, 5);
1514
1515         scsi_scan_host(sh);
1516         return 0;
1517
1518 out_mptspi_probe:
1519
1520         mptscsih_remove(pdev);
1521         return error;
1522 }
1523
1524 static struct pci_driver mptspi_driver = {
1525         .name           = "mptspi",
1526         .id_table       = mptspi_pci_table,
1527         .probe          = mptspi_probe,
1528         .remove         = __devexit_p(mptscsih_remove),
1529         .shutdown       = mptscsih_shutdown,
1530 #ifdef CONFIG_PM
1531         .suspend        = mptscsih_suspend,
1532         .resume         = mptspi_resume,
1533 #endif
1534 };
1535
1536 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1537 /**
1538  *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1539  *
1540  *      Returns 0 for success, non-zero for failure.
1541  */
1542 static int __init
1543 mptspi_init(void)
1544 {
1545         int error;
1546
1547         show_mptmod_ver(my_NAME, my_VERSION);
1548
1549         mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1550         if (!mptspi_transport_template)
1551                 return -ENODEV;
1552
1553         mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1554         mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1555         mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1556
1557         mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1558         mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1559
1560         error = pci_register_driver(&mptspi_driver);
1561         if (error)
1562                 spi_release_transport(mptspi_transport_template);
1563
1564         return error;
1565 }
1566
1567 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1568 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1569 /**
1570  *      mptspi_exit - Unregisters MPT adapter(s)
1571  */
1572 static void __exit
1573 mptspi_exit(void)
1574 {
1575         pci_unregister_driver(&mptspi_driver);
1576
1577         mpt_reset_deregister(mptspiDoneCtx);
1578         mpt_event_deregister(mptspiDoneCtx);
1579
1580         mpt_deregister(mptspiInternalCtx);
1581         mpt_deregister(mptspiTaskCtx);
1582         mpt_deregister(mptspiDoneCtx);
1583         spi_release_transport(mptspi_transport_template);
1584 }
1585
1586 module_init(mptspi_init);
1587 module_exit(mptspi_exit);