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         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 = 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 static int
 618 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
 619 {
 620         MpiRaidActionRequest_t  *pReq;
 621         MPT_FRAME_HDR           *mf;
 622         MPT_ADAPTER *ioc = hd->ioc;
 623
 624         /* Get and Populate a free Frame
 625          */
 626         if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
 627                 ddvprintk(ioc, printk(MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
 628                                         ioc->name));
 629                 return -EAGAIN;
 630         }
 631         pReq = (MpiRaidActionRequest_t *)mf;
 632         if (quiesce)
 633                 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
 634         else
 635                 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
 636         pReq->Reserved1 = 0;
 637         pReq->ChainOffset = 0;
 638         pReq->Function = MPI_FUNCTION_RAID_ACTION;
 639         pReq->VolumeID = id;
 640         pReq->VolumeBus = channel;
 641         pReq->PhysDiskNum = 0;
 642         pReq->MsgFlags = 0;
 643         pReq->Reserved2 = 0;
 644         pReq->ActionDataWord = 0; /* Reserved for this action */
 645
 646         mpt_add_sge((char *)&pReq->ActionDataSGE,
 647                 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
 648
 649         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
 650                         ioc->name, pReq->Action, channel, id));
 651
 652         hd->pLocal = NULL;
 653         hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
 654         hd->scandv_wait_done = 0;
 655
 656         /* Save cmd pointer, for resource free if timeout or
 657          * FW reload occurs
 658          */
 659         hd->cmdPtr = mf;
 660
 661         add_timer(&hd->timer);
 662         mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
 663         wait_event(hd->scandv_waitq, hd->scandv_wait_done);
 664
 665         if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
 666                 return -1;
 667
 668         return 0;
 669 }
 670
 671 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
 672                              struct scsi_device *sdev)
 673 {
 674         VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 675         MPT_ADAPTER *ioc = hd->ioc;
 676
 677         /* no DV on RAID devices */
 678         if (sdev->channel == 0 &&
 679             mptspi_is_raid(hd, sdev->id))
 680                 return;
 681
 682         /* If this is a piece of a RAID, then quiesce first */
 683         if (sdev->channel == 1 &&
 684             mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
 685                 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
 686                     "Integrated RAID quiesce failed\n", ioc->name);
 687                 return;
 688         }
 689
 690         hd->spi_pending |= (1 << sdev->id);
 691         spi_dv_device(sdev);
 692         hd->spi_pending &= ~(1 << sdev->id);
 693
 694         if (sdev->channel == 1 &&
 695             mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
 696                 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
 697                     "Integrated RAID resume failed\n", ioc->name);
 698
 699         mptspi_read_parameters(sdev->sdev_target);
 700         spi_display_xfer_agreement(sdev->sdev_target);
 701         mptspi_read_parameters(sdev->sdev_target);
 702 }
 703
 704 static int mptspi_slave_alloc(struct scsi_device *sdev)
 705 {
 706         MPT_SCSI_HOST *hd = shost_priv(sdev->host);
 707         VirtTarget              *vtarget;
 708         VirtDevice              *vdevice;
 709         struct scsi_target      *starget;
 710         MPT_ADAPTER *ioc = hd->ioc;
 711
 712         if (sdev->channel == 1 &&
 713                 mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0)
 714                         return -ENXIO;
 715
 716         vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
 717         if (!vdevice) {
 718                 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
 719                                 ioc->name, sizeof(VirtDevice));
 720                 return -ENOMEM;
 721         }
 722
 723         vdevice->lun = sdev->lun;
 724         sdev->hostdata = vdevice;
 725
 726         starget = scsi_target(sdev);
 727         vtarget = starget->hostdata;
 728         vdevice->vtarget = vtarget;
 729         vtarget->num_luns++;
 730
 731         if (sdev->channel == 1)
 732                 sdev->no_uld_attach = 1;
 733
 734         return 0;
 735 }
 736
 737 static int mptspi_slave_configure(struct scsi_device *sdev)
 738 {
 739         struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
 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 = shost_priv(SCpnt->device->host);
 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 = shost_priv(shost);
 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(KERN_ERR, starget, MYIOC_s_FMT
 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(KERN_ERR, starget, MYIOC_s_FMT
 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 = shost_priv(shost);
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(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1109                     "Integrated RAID requests DV of new device\n", ioc->name);
1110                 mptspi_dv_device(hd, sdev);
1111         }
1112         shost_printk(KERN_INFO, shost, MYIOC_s_FMT
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(KERN_ERR, ioc->sh, MYIOC_s_FMT
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 = shost_priv(ioc->sh);
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         int rc;
1271
1272         rc = mptscsih_ioc_reset(ioc, reset_phase);
1273
1274         /* only try to do a renegotiation if we're properly set up
1275          * if we get an ioc fault on bringup, ioc->sh will be NULL */
1276         if (reset_phase == MPT_IOC_POST_RESET &&
1277             ioc->sh) {
1278                 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1279
1280                 mptspi_dv_renegotiate(hd);
1281         }
1282
1283         return rc;
1284 }
1285
1286 #ifdef CONFIG_PM
1287 /*
1288  * spi module resume handler
1289  */
1290 static int
1291 mptspi_resume(struct pci_dev *pdev)
1292 {
1293         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1294         struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1295         int rc;
1296
1297         rc = mptscsih_resume(pdev);
1298         mptspi_dv_renegotiate(hd);
1299
1300         return rc;
1301 }
1302 #endif
1303
1304 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1305 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1306 /*
1307  *      mptspi_probe - Installs scsi devices per bus.
1308  *      @pdev: Pointer to pci_dev structure
1309  *
1310  *      Returns 0 for success, non-zero for failure.
1311  *
1312  */
1313 static int
1314 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1315 {
1316         struct Scsi_Host        *sh;
1317         MPT_SCSI_HOST           *hd;
1318         MPT_ADAPTER             *ioc;
1319         unsigned long            flags;
1320         int                      ii;
1321         int                      numSGE = 0;
1322         int                      scale;
1323         int                      ioc_cap;
1324         int                     error=0;
1325         int                     r;
1326
1327         if ((r = mpt_attach(pdev,id)) != 0)
1328                 return r;
1329
1330         ioc = pci_get_drvdata(pdev);
1331         ioc->DoneCtx = mptspiDoneCtx;
1332         ioc->TaskCtx = mptspiTaskCtx;
1333         ioc->InternalCtx = mptspiInternalCtx;
1334
1335         /*  Added sanity check on readiness of the MPT adapter.
1336          */
1337         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1338                 printk(MYIOC_s_WARN_FMT
1339                   "Skipping because it's not operational!\n",
1340                   ioc->name);
1341                 error = -ENODEV;
1342                 goto out_mptspi_probe;
1343         }
1344
1345         if (!ioc->active) {
1346                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1347                   ioc->name);
1348                 error = -ENODEV;
1349                 goto out_mptspi_probe;
1350         }
1351
1352         /*  Sanity check - ensure at least 1 port is INITIATOR capable
1353          */
1354         ioc_cap = 0;
1355         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1356                 if (ioc->pfacts[ii].ProtocolFlags &
1357                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
1358                         ioc_cap ++;
1359         }
1360
1361         if (!ioc_cap) {
1362                 printk(MYIOC_s_WARN_FMT
1363                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1364                         ioc->name, ioc);
1365                 return 0;
1366         }
1367
1368         sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1369
1370         if (!sh) {
1371                 printk(MYIOC_s_WARN_FMT
1372                         "Unable to register controller with SCSI subsystem\n",
1373                         ioc->name);
1374                 error = -1;
1375                 goto out_mptspi_probe;
1376         }
1377
1378         spin_lock_irqsave(&ioc->FreeQlock, flags);
1379
1380         /* Attach the SCSI Host to the IOC structure
1381          */
1382         ioc->sh = sh;
1383
1384         sh->io_port = 0;
1385         sh->n_io_port = 0;
1386         sh->irq = 0;
1387
1388         /* set 16 byte cdb's */
1389         sh->max_cmd_len = 16;
1390
1391         /* Yikes!  This is important!
1392          * Otherwise, by default, linux
1393          * only scans target IDs 0-7!
1394          * pfactsN->MaxDevices unreliable
1395          * (not supported in early
1396          *      versions of the FW).
1397          * max_id = 1 + actual max id,
1398          * max_lun = 1 + actual last lun,
1399          *      see hosts.h :o(
1400          */
1401         sh->max_id = ioc->devices_per_bus;
1402
1403         sh->max_lun = MPT_LAST_LUN + 1;
1404         /*
1405          * If RAID Firmware Detected, setup virtual channel
1406          */
1407         if (ioc->ir_firmware)
1408                 sh->max_channel = 1;
1409         else
1410                 sh->max_channel = 0;
1411         sh->this_id = ioc->pfacts[0].PortSCSIID;
1412
1413         /* Required entry.
1414          */
1415         sh->unique_id = ioc->id;
1416
1417         /* Verify that we won't exceed the maximum
1418          * number of chain buffers
1419          * We can optimize:  ZZ = req_sz/sizeof(SGE)
1420          * For 32bit SGE's:
1421          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1422          *               + (req_sz - 64)/sizeof(SGE)
1423          * A slightly different algorithm is required for
1424          * 64bit SGEs.
1425          */
1426         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1427         if (sizeof(dma_addr_t) == sizeof(u64)) {
1428                 numSGE = (scale - 1) *
1429                   (ioc->facts.MaxChainDepth-1) + scale +
1430                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1431                   sizeof(u32));
1432         } else {
1433                 numSGE = 1 + (scale - 1) *
1434                   (ioc->facts.MaxChainDepth-1) + scale +
1435                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1436                   sizeof(u32));
1437         }
1438
1439         if (numSGE < sh->sg_tablesize) {
1440                 /* Reset this value */
1441                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1442                   "Resetting sg_tablesize to %d from %d\n",
1443                   ioc->name, numSGE, sh->sg_tablesize));
1444                 sh->sg_tablesize = numSGE;
1445         }
1446
1447         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1448
1449         hd = shost_priv(sh);
1450         hd->ioc = ioc;
1451
1452         /* SCSI needs scsi_cmnd lookup table!
1453          * (with size equal to req_depth*PtrSz!)
1454          */
1455         ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1456         if (!ioc->ScsiLookup) {
1457                 error = -ENOMEM;
1458                 goto out_mptspi_probe;
1459         }
1460         spin_lock_init(&ioc->scsi_lookup_lock);
1461
1462         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1463                  ioc->name, ioc->ScsiLookup));
1464
1465         /* Clear the TM flags
1466          */
1467         hd->tmPending = 0;
1468         hd->tmState = TM_STATE_NONE;
1469         hd->resetPending = 0;
1470         hd->abortSCpnt = NULL;
1471
1472         /* Clear the pointer used to store
1473          * single-threaded commands, i.e., those
1474          * issued during a bus scan, dv and
1475          * configuration pages.
1476          */
1477         hd->cmdPtr = NULL;
1478
1479         /* Initialize this SCSI Hosts' timers
1480          * To use, set the timer expires field
1481          * and add_timer
1482          */
1483         init_timer(&hd->timer);
1484         hd->timer.data = (unsigned long) hd;
1485         hd->timer.function = mptscsih_timer_expired;
1486
1487         ioc->spi_data.Saf_Te = mpt_saf_te;
1488
1489         hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1490         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1491                 "saf_te %x\n",
1492                 ioc->name,
1493                 mpt_saf_te));
1494         ioc->spi_data.noQas = 0;
1495
1496         init_waitqueue_head(&hd->scandv_waitq);
1497         hd->scandv_wait_done = 0;
1498         hd->last_queue_full = 0;
1499         hd->spi_pending = 0;
1500
1501         /* Some versions of the firmware don't support page 0; without
1502          * that we can't get the parameters */
1503         if (ioc->spi_data.sdp0length != 0)
1504                 sh->transportt = mptspi_transport_template;
1505
1506         error = scsi_add_host (sh, &ioc->pcidev->dev);
1507         if(error) {
1508                 dprintk(ioc, printk(MYIOC_s_ERR_FMT
1509                   "scsi_add_host failed\n", ioc->name));
1510                 goto out_mptspi_probe;
1511         }
1512
1513         /*
1514          * issue internal bus reset
1515          */
1516         if (ioc->spi_data.bus_reset)
1517                 mptscsih_TMHandler(hd,
1518                     MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1519                     0, 0, 0, 0, 5);
1520
1521         scsi_scan_host(sh);
1522         return 0;
1523
1524 out_mptspi_probe:
1525
1526         mptscsih_remove(pdev);
1527         return error;
1528 }
1529
1530 static struct pci_driver mptspi_driver = {
1531         .name           = "mptspi",
1532         .id_table       = mptspi_pci_table,
1533         .probe          = mptspi_probe,
1534         .remove         = __devexit_p(mptscsih_remove),
1535         .shutdown       = mptscsih_shutdown,
1536 #ifdef CONFIG_PM
1537         .suspend        = mptscsih_suspend,
1538         .resume         = mptspi_resume,
1539 #endif
1540 };
1541
1542 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1543 /**
1544  *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1545  *
1546  *      Returns 0 for success, non-zero for failure.
1547  */
1548 static int __init
1549 mptspi_init(void)
1550 {
1551         int error;
1552
1553         show_mptmod_ver(my_NAME, my_VERSION);
1554
1555         mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1556         if (!mptspi_transport_template)
1557                 return -ENODEV;
1558
1559         mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1560         mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1561         mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1562
1563         mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1564         mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1565
1566         error = pci_register_driver(&mptspi_driver);
1567         if (error)
1568                 spi_release_transport(mptspi_transport_template);
1569
1570         return error;
1571 }
1572
1573 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1574 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1575 /**
1576  *      mptspi_exit - Unregisters MPT adapter(s)
1577  */
1578 static void __exit
1579 mptspi_exit(void)
1580 {
1581         pci_unregister_driver(&mptspi_driver);
1582
1583         mpt_reset_deregister(mptspiDoneCtx);
1584         mpt_event_deregister(mptspiDoneCtx);
1585
1586         mpt_deregister(mptspiInternalCtx);
1587         mpt_deregister(mptspiTaskCtx);
1588         mpt_deregister(mptspiDoneCtx);
1589         spi_release_transport(mptspi_transport_template);
1590 }
1591
1592 module_init(mptspi_init);
1593 module_exit(mptspi_exit);