SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/message/fusion/mptspi.c

   1 /*
   2  *  linux/drivers/message/fusion/mptspi.c
   3  *      For use with LSI PCI chip/adapter(s)
   4  *      running LSI Fusion MPT (Message Passing Technology) firmware.
   5  *
   6  *  Copyright (c) 1999-2008 LSI Corporation
   7  *  (mailto:DL-MPTFusionLinux@lsi.com)
   8  *
   9  */
  10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  11 /*
  12     This program is free software; you can redistribute it and/or modify
  13     it under the terms of the GNU General Public License as published by
  14     the Free Software Foundation; version 2 of the License.
  15
  16     This program is distributed in the hope that it will be useful,
  17     but WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19     GNU General Public License for more details.
  20
  21     NO WARRANTY
  22     THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  23     CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  24     LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  25     MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  26     solely responsible for determining the appropriateness of using and
  27     distributing the Program and assumes all risks associated with its
  28     exercise of rights under this Agreement, including but not limited to
  29     the risks and costs of program errors, damage to or loss of data,
  30     programs or equipment, and unavailability or interruption of operations.
  31
  32     DISCLAIMER OF LIABILITY
  33     NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  34     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  35     DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  36     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  37     TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  38     USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  39     HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  40
  41     You should have received a copy of the GNU General Public License
  42     along with this program; if not, write to the Free Software
  43     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  44 */
  45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  46
  47 #include <linux/module.h>
  48 #include <linux/kernel.h>
  49 #include <linux/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         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         if (starget->hostdata)
 460                 kfree(starget->hostdata);
 461         starget->hostdata = NULL;
 462 }
 463
 464 /**
 465  *      mptspi_print_write_nego - negotiation parameters debug info that is being sent
 466  *      @hd: Pointer to a SCSI HOST structure
 467  *      @starget: SCSI target
 468  *      @ii: negotiation parameters
 469  *
 470  */
 471 static void
 472 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
 473 {
 474         ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x"
 475             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
 476             hd->ioc->name, starget->id, ii,
 477             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
 478             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
 479             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
 480             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
 481             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
 482             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
 483             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
 484             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
 485             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
 486             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
 487 }
 488
 489 /**
 490  *      mptspi_print_read_nego - negotiation parameters debug info that is being read
 491  *      @hd: Pointer to a SCSI HOST structure
 492  *      @starget: SCSI target
 493  *      @ii: negotiation parameters
 494  *
 495  */
 496 static void
 497 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
 498 {
 499         ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x"
 500             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
 501             hd->ioc->name, starget->id, ii,
 502             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
 503             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
 504             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
 505             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
 506             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
 507             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
 508             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
 509             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
 510             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
 511             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
 512 }
 513
 514 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
 515                              struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
 516 {
 517         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 518         struct _MPT_SCSI_HOST *hd = shost_priv(shost);
 519         struct _MPT_ADAPTER *ioc = hd->ioc;
 520         struct _CONFIG_PAGE_SCSI_DEVICE_0 *spi_dev_pg0;
 521         dma_addr_t spi_dev_pg0_dma;
 522         int size;
 523         struct _x_config_parms cfg;
 524         struct _CONFIG_PAGE_HEADER hdr;
 525         int err = -EBUSY;
 526
 527         /* No SPI parameters for RAID devices */
 528         if (starget->channel == 0 &&
 529             mptspi_is_raid(hd, starget->id))
 530                 return -1;
 531
 532         size = ioc->spi_data.sdp0length * 4;
 533         /*
 534         if (ioc->spi_data.sdp0length & 1)
 535                 size += size + 4;
 536         size += 2048;
 537         */
 538
 539         spi_dev_pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &spi_dev_pg0_dma, GFP_KERNEL);
 540         if (spi_dev_pg0 == NULL) {
 541                 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
 542                     "dma_alloc_coherent for parameters failed\n", ioc->name);
 543                 return -EINVAL;
 544         }
 545
 546         memset(&hdr, 0, sizeof(hdr));
 547
 548         hdr.PageVersion = ioc->spi_data.sdp0version;
 549         hdr.PageLength = ioc->spi_data.sdp0length;
 550         hdr.PageNumber = 0;
 551         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 552
 553         memset(&cfg, 0, sizeof(cfg));
 554
 555         cfg.cfghdr.hdr = &hdr;
 556         cfg.physAddr = spi_dev_pg0_dma;
 557         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 558         cfg.dir = 0;
 559         cfg.pageAddr = starget->id;
 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 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_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
 778 {
 779         struct _MPT_SCSI_HOST *hd = shost_priv(SCpnt->device->host);
 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                 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                 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,done);
 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 struct scsi_host_template mptspi_driver_template = {
 824         .module                         = THIS_MODULE,
 825         .proc_name                      = "mptspi",
 826         .proc_info                      = mptscsih_proc_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         .use_clustering                 = ENABLE_CLUSTERING,
 847         .shost_attrs                    = mptscsih_host_attrs,
 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
 863         /* don't allow updating nego parameters on RAID devices */
 864         if (starget->channel == 0 &&
 865             mptspi_is_raid(hd, starget->id))
 866                 return -1;
 867
 868         size = ioc->spi_data.sdp1length * 4;
 869
 870         pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
 871         if (pg1 == NULL) {
 872                 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
 873                     "dma_alloc_coherent for parameters failed\n", ioc->name);
 874                 return -EINVAL;
 875         }
 876
 877         memset(&hdr, 0, sizeof(hdr));
 878
 879         hdr.PageVersion = ioc->spi_data.sdp1version;
 880         hdr.PageLength = ioc->spi_data.sdp1length;
 881         hdr.PageNumber = 1;
 882         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 883
 884         memset(&cfg, 0, sizeof(cfg));
 885
 886         cfg.cfghdr.hdr = &hdr;
 887         cfg.physAddr = pg1_dma;
 888         cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 889         cfg.dir = 1;
 890         cfg.pageAddr = starget->id;
 891
 892         memcpy(pg1, pass_pg1, size);
 893
 894         pg1->Header.PageVersion = hdr.PageVersion;
 895         pg1->Header.PageLength = hdr.PageLength;
 896         pg1->Header.PageNumber = hdr.PageNumber;
 897         pg1->Header.PageType = hdr.PageType;
 898
 899         mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
 900
 901         if (mpt_config(ioc, &cfg)) {
 902                 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
 903                     "mpt_config failed\n", ioc->name);
 904                 goto out_free;
 905         }
 906         err = 0;
 907
 908  out_free:
 909         dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
 910         return err;
 911 }
 912
 913 static void mptspi_write_offset(struct scsi_target *starget, int offset)
 914 {
 915         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 916         u32 nego;
 917
 918         if (offset < 0)
 919                 offset = 0;
 920
 921         if (offset > 255)
 922                 offset = 255;
 923
 924         if (spi_offset(starget) == -1)
 925                 mptspi_read_parameters(starget);
 926
 927         spi_offset(starget) = offset;
 928
 929         nego = mptspi_getRP(starget);
 930
 931         pg1.RequestedParameters = cpu_to_le32(nego);
 932         pg1.Reserved = 0;
 933         pg1.Configuration = 0;
 934
 935         mptspi_write_spi_device_pg1(starget, &pg1);
 936 }
 937
 938 static void mptspi_write_period(struct scsi_target *starget, int period)
 939 {
 940         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 941         u32 nego;
 942
 943         if (period < 8)
 944                 period = 8;
 945
 946         if (period > 255)
 947                 period = 255;
 948
 949         if (spi_period(starget) == -1)
 950                 mptspi_read_parameters(starget);
 951
 952         if (period == 8) {
 953                 spi_iu(starget) = 1;
 954                 spi_dt(starget) = 1;
 955         } else if (period == 9) {
 956                 spi_dt(starget) = 1;
 957         }
 958
 959         spi_period(starget) = period;
 960
 961         nego = mptspi_getRP(starget);
 962
 963         pg1.RequestedParameters = cpu_to_le32(nego);
 964         pg1.Reserved = 0;
 965         pg1.Configuration = 0;
 966
 967         mptspi_write_spi_device_pg1(starget, &pg1);
 968 }
 969
 970 static void mptspi_write_dt(struct scsi_target *starget, int dt)
 971 {
 972         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 973         u32 nego;
 974
 975         if (spi_period(starget) == -1)
 976                 mptspi_read_parameters(starget);
 977
 978         if (!dt && spi_period(starget) < 10)
 979                 spi_period(starget) = 10;
 980
 981         spi_dt(starget) = dt;
 982
 983         nego = mptspi_getRP(starget);
 984
 985
 986         pg1.RequestedParameters = cpu_to_le32(nego);
 987         pg1.Reserved = 0;
 988         pg1.Configuration = 0;
 989
 990         mptspi_write_spi_device_pg1(starget, &pg1);
 991 }
 992
 993 static void mptspi_write_iu(struct scsi_target *starget, int iu)
 994 {
 995         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 996         u32 nego;
 997
 998         if (spi_period(starget) == -1)
 999                 mptspi_read_parameters(starget);
1000
1001         if (!iu && spi_period(starget) < 9)
1002                 spi_period(starget) = 9;
1003
1004         spi_iu(starget) = iu;
1005
1006         nego = mptspi_getRP(starget);
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 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm)                              \
1016 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1017 {                                                                       \
1018         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;                          \
1019         u32 nego;                                                       \
1020                                                                         \
1021         spi_##parm(starget) = parm;                                     \
1022                                                                         \
1023         nego = mptspi_getRP(starget);                                   \
1024                                                                         \
1025         pg1.RequestedParameters = cpu_to_le32(nego);                    \
1026         pg1.Reserved = 0;                                               \
1027         pg1.Configuration = 0;                                          \
1028                                                                         \
1029         mptspi_write_spi_device_pg1(starget, &pg1);                             \
1030 }
1031
1032 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1033 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1034 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1035 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1036 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1037
1038 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1039 {
1040         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1041         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1042         struct _MPT_SCSI_HOST *hd = shost_priv(shost);
1043         VirtTarget *vtarget = starget->hostdata;
1044         u32 nego;
1045
1046         if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1047             hd->ioc->spi_data.noQas)
1048                 spi_qas(starget) = 0;
1049         else
1050                 spi_qas(starget) = qas;
1051
1052         nego = mptspi_getRP(starget);
1053
1054         pg1.RequestedParameters = cpu_to_le32(nego);
1055         pg1.Reserved = 0;
1056         pg1.Configuration = 0;
1057
1058         mptspi_write_spi_device_pg1(starget, &pg1);
1059 }
1060
1061 static void mptspi_write_width(struct scsi_target *starget, int width)
1062 {
1063         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1064         u32 nego;
1065
1066         if (!width) {
1067                 spi_dt(starget) = 0;
1068                 if (spi_period(starget) < 10)
1069                         spi_period(starget) = 10;
1070         }
1071
1072         spi_width(starget) = width;
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 struct work_queue_wrapper {
1084         struct work_struct      work;
1085         struct _MPT_SCSI_HOST   *hd;
1086         int                     disk;
1087 };
1088
1089 static void mpt_work_wrapper(struct work_struct *work)
1090 {
1091         struct work_queue_wrapper *wqw =
1092                 container_of(work, struct work_queue_wrapper, work);
1093         struct _MPT_SCSI_HOST *hd = wqw->hd;
1094         MPT_ADAPTER *ioc = hd->ioc;
1095         struct Scsi_Host *shost = ioc->sh;
1096         struct scsi_device *sdev;
1097         int disk = wqw->disk;
1098         struct _CONFIG_PAGE_IOC_3 *pg3;
1099
1100         kfree(wqw);
1101
1102         mpt_findImVolumes(ioc);
1103         pg3 = ioc->raid_data.pIocPg3;
1104         if (!pg3)
1105                 return;
1106
1107         shost_for_each_device(sdev,shost) {
1108                 struct scsi_target *starget = scsi_target(sdev);
1109                 VirtTarget *vtarget = starget->hostdata;
1110
1111                 /* only want to search RAID components */
1112                 if (sdev->channel != 1)
1113                         continue;
1114
1115                 /* The id is the raid PhysDiskNum, even if
1116                  * starget->id is the actual target address */
1117                 if(vtarget->id != disk)
1118                         continue;
1119
1120                 starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1121                     "Integrated RAID requests DV of new device\n", ioc->name);
1122                 mptspi_dv_device(hd, sdev);
1123         }
1124         shost_printk(KERN_INFO, shost, MYIOC_s_FMT
1125             "Integrated RAID detects new device %d\n", ioc->name, disk);
1126         scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, 1);
1127 }
1128
1129
1130 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1131 {
1132         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1133         MPT_ADAPTER *ioc = hd->ioc;
1134
1135         if (!wqw) {
1136                 shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
1137                     "Failed to act on RAID event for physical disk %d\n",
1138                     ioc->name, disk);
1139                 return;
1140         }
1141         INIT_WORK(&wqw->work, mpt_work_wrapper);
1142         wqw->hd = hd;
1143         wqw->disk = disk;
1144
1145         schedule_work(&wqw->work);
1146 }
1147
1148 static int
1149 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1150 {
1151         u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1152         struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1153
1154         if (hd && event ==  MPI_EVENT_INTEGRATED_RAID) {
1155                 int reason
1156                         = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1157
1158                 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1159                         int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1160                         mpt_dv_raid(hd, disk);
1161                 }
1162         }
1163         return mptscsih_event_process(ioc, pEvReply);
1164 }
1165
1166 static int
1167 mptspi_deny_binding(struct scsi_target *starget)
1168 {
1169         struct _MPT_SCSI_HOST *hd =
1170                 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1171         return ((mptspi_is_raid(hd, starget->id)) &&
1172                 starget->channel == 0) ? 1 : 0;
1173 }
1174
1175 static struct spi_function_template mptspi_transport_functions = {
1176         .get_offset     = mptspi_read_parameters,
1177         .set_offset     = mptspi_write_offset,
1178         .show_offset    = 1,
1179         .get_period     = mptspi_read_parameters,
1180         .set_period     = mptspi_write_period,
1181         .show_period    = 1,
1182         .get_width      = mptspi_read_parameters,
1183         .set_width      = mptspi_write_width,
1184         .show_width     = 1,
1185         .get_iu         = mptspi_read_parameters,
1186         .set_iu         = mptspi_write_iu,
1187         .show_iu        = 1,
1188         .get_dt         = mptspi_read_parameters,
1189         .set_dt         = mptspi_write_dt,
1190         .show_dt        = 1,
1191         .get_qas        = mptspi_read_parameters,
1192         .set_qas        = mptspi_write_qas,
1193         .show_qas       = 1,
1194         .get_wr_flow    = mptspi_read_parameters,
1195         .set_wr_flow    = mptspi_write_wr_flow,
1196         .show_wr_flow   = 1,
1197         .get_rd_strm    = mptspi_read_parameters,
1198         .set_rd_strm    = mptspi_write_rd_strm,
1199         .show_rd_strm   = 1,
1200         .get_rti        = mptspi_read_parameters,
1201         .set_rti        = mptspi_write_rti,
1202         .show_rti       = 1,
1203         .get_pcomp_en   = mptspi_read_parameters,
1204         .set_pcomp_en   = mptspi_write_pcomp_en,
1205         .show_pcomp_en  = 1,
1206         .get_hold_mcs   = mptspi_read_parameters,
1207         .set_hold_mcs   = mptspi_write_hold_mcs,
1208         .show_hold_mcs  = 1,
1209         .deny_binding   = mptspi_deny_binding,
1210 };
1211
1212 /****************************************************************************
1213  * Supported hardware
1214  */
1215
1216 static struct pci_device_id mptspi_pci_table[] = {
1217         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1218                 PCI_ANY_ID, PCI_ANY_ID },
1219         { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1220                 PCI_ANY_ID, PCI_ANY_ID },
1221         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1222                 PCI_ANY_ID, PCI_ANY_ID },
1223         {0}     /* Terminating entry */
1224 };
1225 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1226
1227
1228 /*
1229  * renegotiate for a given target
1230  */
1231 static void
1232 mptspi_dv_renegotiate_work(struct work_struct *work)
1233 {
1234         struct work_queue_wrapper *wqw =
1235                 container_of(work, struct work_queue_wrapper, work);
1236         struct _MPT_SCSI_HOST *hd = wqw->hd;
1237         struct scsi_device *sdev;
1238         struct scsi_target *starget;
1239         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1240         u32 nego;
1241         MPT_ADAPTER *ioc = hd->ioc;
1242
1243         kfree(wqw);
1244
1245         if (hd->spi_pending) {
1246                 shost_for_each_device(sdev, ioc->sh) {
1247                         if  (hd->spi_pending & (1 << sdev->id))
1248                                 continue;
1249                         starget = scsi_target(sdev);
1250                         nego = mptspi_getRP(starget);
1251                         pg1.RequestedParameters = cpu_to_le32(nego);
1252                         pg1.Reserved = 0;
1253                         pg1.Configuration = 0;
1254                         mptspi_write_spi_device_pg1(starget, &pg1);
1255                 }
1256         } else {
1257                 shost_for_each_device(sdev, ioc->sh)
1258                         mptspi_dv_device(hd, sdev);
1259         }
1260 }
1261
1262 static void
1263 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1264 {
1265         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1266
1267         if (!wqw)
1268                 return;
1269
1270         INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1271         wqw->hd = hd;
1272
1273         schedule_work(&wqw->work);
1274 }
1275
1276 /*
1277  * spi module reset handler
1278  */
1279 static int
1280 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1281 {
1282         int rc;
1283
1284         rc = mptscsih_ioc_reset(ioc, reset_phase);
1285
1286         /* only try to do a renegotiation if we're properly set up
1287          * if we get an ioc fault on bringup, ioc->sh will be NULL */
1288         if (reset_phase == MPT_IOC_POST_RESET &&
1289             ioc->sh) {
1290                 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1291
1292                 mptspi_dv_renegotiate(hd);
1293         }
1294
1295         return rc;
1296 }
1297
1298 #ifdef CONFIG_PM
1299 /*
1300  * spi module resume handler
1301  */
1302 static int
1303 mptspi_resume(struct pci_dev *pdev)
1304 {
1305         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1306         struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1307         int rc;
1308
1309         rc = mptscsih_resume(pdev);
1310         mptspi_dv_renegotiate(hd);
1311
1312         return rc;
1313 }
1314 #endif
1315
1316 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1317 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1318 /*
1319  *      mptspi_probe - Installs scsi devices per bus.
1320  *      @pdev: Pointer to pci_dev structure
1321  *
1322  *      Returns 0 for success, non-zero for failure.
1323  *
1324  */
1325 static int
1326 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1327 {
1328         struct Scsi_Host        *sh;
1329         MPT_SCSI_HOST           *hd;
1330         MPT_ADAPTER             *ioc;
1331         unsigned long            flags;
1332         int                      ii;
1333         int                      numSGE = 0;
1334         int                      scale;
1335         int                      ioc_cap;
1336         int                     error=0;
1337         int                     r;
1338
1339         if ((r = mpt_attach(pdev,id)) != 0)
1340                 return r;
1341
1342         ioc = pci_get_drvdata(pdev);
1343         ioc->DoneCtx = mptspiDoneCtx;
1344         ioc->TaskCtx = mptspiTaskCtx;
1345         ioc->InternalCtx = mptspiInternalCtx;
1346
1347         /*  Added sanity check on readiness of the MPT adapter.
1348          */
1349         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1350                 printk(MYIOC_s_WARN_FMT
1351                   "Skipping because it's not operational!\n",
1352                   ioc->name);
1353                 error = -ENODEV;
1354                 goto out_mptspi_probe;
1355         }
1356
1357         if (!ioc->active) {
1358                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1359                   ioc->name);
1360                 error = -ENODEV;
1361                 goto out_mptspi_probe;
1362         }
1363
1364         /*  Sanity check - ensure at least 1 port is INITIATOR capable
1365          */
1366         ioc_cap = 0;
1367         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1368                 if (ioc->pfacts[ii].ProtocolFlags &
1369                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
1370                         ioc_cap ++;
1371         }
1372
1373         if (!ioc_cap) {
1374                 printk(MYIOC_s_WARN_FMT
1375                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1376                         ioc->name, ioc);
1377                 return 0;
1378         }
1379
1380         sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1381
1382         if (!sh) {
1383                 printk(MYIOC_s_WARN_FMT
1384                         "Unable to register controller with SCSI subsystem\n",
1385                         ioc->name);
1386                 error = -1;
1387                 goto out_mptspi_probe;
1388         }
1389
1390         spin_lock_irqsave(&ioc->FreeQlock, flags);
1391
1392         /* Attach the SCSI Host to the IOC structure
1393          */
1394         ioc->sh = sh;
1395
1396         sh->io_port = 0;
1397         sh->n_io_port = 0;
1398         sh->irq = 0;
1399
1400         /* set 16 byte cdb's */
1401         sh->max_cmd_len = 16;
1402
1403         /* Yikes!  This is important!
1404          * Otherwise, by default, linux
1405          * only scans target IDs 0-7!
1406          * pfactsN->MaxDevices unreliable
1407          * (not supported in early
1408          *      versions of the FW).
1409          * max_id = 1 + actual max id,
1410          * max_lun = 1 + actual last lun,
1411          *      see hosts.h :o(
1412          */
1413         sh->max_id = ioc->devices_per_bus;
1414
1415         sh->max_lun = MPT_LAST_LUN + 1;
1416         /*
1417          * If RAID Firmware Detected, setup virtual channel
1418          */
1419         if (ioc->ir_firmware)
1420                 sh->max_channel = 1;
1421         else
1422                 sh->max_channel = 0;
1423         sh->this_id = ioc->pfacts[0].PortSCSIID;
1424
1425         /* Required entry.
1426          */
1427         sh->unique_id = ioc->id;
1428
1429         /* Verify that we won't exceed the maximum
1430          * number of chain buffers
1431          * We can optimize:  ZZ = req_sz/sizeof(SGE)
1432          * For 32bit SGE's:
1433          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1434          *               + (req_sz - 64)/sizeof(SGE)
1435          * A slightly different algorithm is required for
1436          * 64bit SGEs.
1437          */
1438         scale = ioc->req_sz/ioc->SGE_size;
1439         if (ioc->sg_addr_size == sizeof(u64)) {
1440                 numSGE = (scale - 1) *
1441                   (ioc->facts.MaxChainDepth-1) + scale +
1442                   (ioc->req_sz - 60) / ioc->SGE_size;
1443         } else {
1444                 numSGE = 1 + (scale - 1) *
1445                   (ioc->facts.MaxChainDepth-1) + scale +
1446                   (ioc->req_sz - 64) / ioc->SGE_size;
1447         }
1448
1449         if (numSGE < sh->sg_tablesize) {
1450                 /* Reset this value */
1451                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1452                   "Resetting sg_tablesize to %d from %d\n",
1453                   ioc->name, numSGE, sh->sg_tablesize));
1454                 sh->sg_tablesize = numSGE;
1455         }
1456
1457         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1458
1459         hd = shost_priv(sh);
1460         hd->ioc = ioc;
1461
1462         /* SCSI needs scsi_cmnd lookup table!
1463          * (with size equal to req_depth*PtrSz!)
1464          */
1465         ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1466         if (!ioc->ScsiLookup) {
1467                 error = -ENOMEM;
1468                 goto out_mptspi_probe;
1469         }
1470         spin_lock_init(&ioc->scsi_lookup_lock);
1471
1472         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1473                  ioc->name, ioc->ScsiLookup));
1474
1475         /* Clear the TM flags
1476          */
1477         hd->tmPending = 0;
1478         hd->tmState = TM_STATE_NONE;
1479         hd->resetPending = 0;
1480         hd->abortSCpnt = NULL;
1481
1482         /* Clear the pointer used to store
1483          * single-threaded commands, i.e., those
1484          * issued during a bus scan, dv and
1485          * configuration pages.
1486          */
1487         hd->cmdPtr = NULL;
1488
1489         /* Initialize this SCSI Hosts' timers
1490          * To use, set the timer expires field
1491          * and add_timer
1492          */
1493         init_timer(&hd->timer);
1494         hd->timer.data = (unsigned long) hd;
1495         hd->timer.function = mptscsih_timer_expired;
1496
1497         ioc->spi_data.Saf_Te = mpt_saf_te;
1498
1499         hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1500         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1501                 "saf_te %x\n",
1502                 ioc->name,
1503                 mpt_saf_te));
1504         ioc->spi_data.noQas = 0;
1505
1506         hd->last_queue_full = 0;
1507         hd->spi_pending = 0;
1508
1509         /* Some versions of the firmware don't support page 0; without
1510          * that we can't get the parameters */
1511         if (ioc->spi_data.sdp0length != 0)
1512                 sh->transportt = mptspi_transport_template;
1513
1514         error = scsi_add_host (sh, &ioc->pcidev->dev);
1515         if(error) {
1516                 dprintk(ioc, printk(MYIOC_s_ERR_FMT
1517                   "scsi_add_host failed\n", ioc->name));
1518                 goto out_mptspi_probe;
1519         }
1520
1521         /*
1522          * issue internal bus reset
1523          */
1524         if (ioc->spi_data.bus_reset)
1525                 mptscsih_IssueTaskMgmt(hd,
1526                     MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1527                     0, 0, 0, 0, 5);
1528
1529         scsi_scan_host(sh);
1530         return 0;
1531
1532 out_mptspi_probe:
1533
1534         mptscsih_remove(pdev);
1535         return error;
1536 }
1537
1538 static struct pci_driver mptspi_driver = {
1539         .name           = "mptspi",
1540         .id_table       = mptspi_pci_table,
1541         .probe          = mptspi_probe,
1542         .remove         = __devexit_p(mptscsih_remove),
1543         .shutdown       = mptscsih_shutdown,
1544 #ifdef CONFIG_PM
1545         .suspend        = mptscsih_suspend,
1546         .resume         = mptspi_resume,
1547 #endif
1548 };
1549
1550 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1551 /**
1552  *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1553  *
1554  *      Returns 0 for success, non-zero for failure.
1555  */
1556 static int __init
1557 mptspi_init(void)
1558 {
1559         int error;
1560
1561         show_mptmod_ver(my_NAME, my_VERSION);
1562
1563         mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1564         if (!mptspi_transport_template)
1565                 return -ENODEV;
1566
1567         mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1568         mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1569         mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1570
1571         mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1572         mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1573
1574         error = pci_register_driver(&mptspi_driver);
1575         if (error)
1576                 spi_release_transport(mptspi_transport_template);
1577
1578         return error;
1579 }
1580
1581 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1582 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1583 /**
1584  *      mptspi_exit - Unregisters MPT adapter(s)
1585  */
1586 static void __exit
1587 mptspi_exit(void)
1588 {
1589         pci_unregister_driver(&mptspi_driver);
1590
1591         mpt_reset_deregister(mptspiDoneCtx);
1592         mpt_event_deregister(mptspiDoneCtx);
1593
1594         mpt_deregister(mptspiInternalCtx);
1595         mpt_deregister(mptspiTaskCtx);
1596         mpt_deregister(mptspiDoneCtx);
1597         spi_release_transport(mptspi_transport_template);
1598 }
1599
1600 module_init(mptspi_init);
1601 module_exit(mptspi_exit);