git.oblomov.eu Git - 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-2007 LSI Corporation
   7  *  (mailto:DL-MPTFusionLinux@lsi.com)
   8  *
   9  */
  10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  11 /*
  12     This program is free software; you can redistribute it and/or modify
  13     it under the terms of the GNU General Public License as published by
  14     the Free Software Foundation; version 2 of the License.
  15
  16     This program is distributed in the hope that it will be useful,
  17     but WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19     GNU General Public License for more details.
  20
  21     NO WARRANTY
  22     THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  23     CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  24     LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  25     MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  26     solely responsible for determining the appropriateness of using and
  27     distributing the Program and assumes all risks associated with its
  28     exercise of rights under this Agreement, including but not limited to
  29     the risks and costs of program errors, damage to or loss of data,
  30     programs or equipment, and unavailability or interruption of operations.
  31
  32     DISCLAIMER OF LIABILITY
  33     NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  34     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  35     DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  36     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  37     TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  38     USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  39     HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  40
  41     You should have received a copy of the GNU General Public License
  42     along with this program; if not, write to the Free Software
  43     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  44 */
  45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  46
  47 #include <linux/module.h>
  48 #include <linux/kernel.h>
  49 #include <linux/init.h>
  50 #include <linux/errno.h>
  51 #include <linux/kdev_t.h>
  52 #include <linux/blkdev.h>
  53 #include <linux/delay.h>        /* for mdelay */
  54 #include <linux/interrupt.h>    /* needed for in_interrupt() proto */
  55 #include <linux/reboot.h>       /* notifier code */
  56 #include <linux/workqueue.h>
  57 #include <linux/raid_class.h>
  58
  59 #include <scsi/scsi.h>
  60 #include <scsi/scsi_cmnd.h>
  61 #include <scsi/scsi_device.h>
  62 #include <scsi/scsi_host.h>
  63 #include <scsi/scsi_tcq.h>
  64 #include <scsi/scsi_transport.h>
  65 #include <scsi/scsi_transport_spi.h>
  66 #include <scsi/scsi_dbg.h>
  67
  68 #include "mptbase.h"
  69 #include "mptscsih.h"
  70
  71 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  72 #define my_NAME         "Fusion MPT SPI Host driver"
  73 #define my_VERSION      MPT_LINUX_VERSION_COMMON
  74 #define MYNAM           "mptspi"
  75
  76 MODULE_AUTHOR(MODULEAUTHOR);
  77 MODULE_DESCRIPTION(my_NAME);
  78 MODULE_LICENSE("GPL");
  79 MODULE_VERSION(my_VERSION);
  80
  81 /* Command line args */
  82 static int mpt_saf_te = MPTSCSIH_SAF_TE;
  83 module_param(mpt_saf_te, int, 0);
  84 MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1  (default=MPTSCSIH_SAF_TE=0)");
  85
  86 static void mptspi_write_offset(struct scsi_target *, int);
  87 static void mptspi_write_width(struct scsi_target *, int);
  88 static int mptspi_write_spi_device_pg1(struct scsi_target *,
  89                                        struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
  90
  91 static struct scsi_transport_template *mptspi_transport_template = NULL;
  92
  93 static u8       mptspiDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
  94 static u8       mptspiTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
  95 static u8       mptspiInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */
  96
  97 /**
  98  *      mptspi_setTargetNegoParms  - Update the target negotiation parameters
  99  *      @hd: Pointer to a SCSI Host Structure
 100  *      @target: per target private data
 101  *      @sdev: SCSI device
 102  *
 103  *      Update the target negotiation parameters based on the the Inquiry
 104  *      data, adapter capabilities, and NVRAM settings.
 105  **/
 106 static void
 107 mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
 108                             struct scsi_device *sdev)
 109 {
 110         SpiCfgData *pspi_data = &hd->ioc->spi_data;
 111         int  id = (int) target->id;
 112         int  nvram;
 113         u8 width = MPT_NARROW;
 114         u8 factor = MPT_ASYNC;
 115         u8 offset = 0;
 116         u8 nfactor;
 117         u8 noQas = 1;
 118
 119         target->negoFlags = pspi_data->noQas;
 120
 121         if (sdev->scsi_level < SCSI_2) {
 122                 width = 0;
 123                 factor = MPT_ULTRA2;
 124                 offset = pspi_data->maxSyncOffset;
 125                 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
 126         } else {
 127                 if (scsi_device_wide(sdev))
 128                         width = 1;
 129
 130                 if (scsi_device_sync(sdev)) {
 131                         factor = pspi_data->minSyncFactor;
 132                         if (!scsi_device_dt(sdev))
 133                                         factor = MPT_ULTRA2;
 134                         else {
 135                                 if (!scsi_device_ius(sdev) &&
 136                                     !scsi_device_qas(sdev))
 137                                         factor = MPT_ULTRA160;
 138                                 else {
 139                                         factor = MPT_ULTRA320;
 140                                         if (scsi_device_qas(sdev)) {
 141                                                 ddvprintk(hd->ioc,
 142                                                 printk(KERN_DEBUG "Enabling QAS due to "
 143                                                 "byte56=%02x on id=%d!\n", scsi_device_qas(sdev), id));
 144                                                 noQas = 0;
 145                                         }
 146                                         if (sdev->type == TYPE_TAPE &&
 147                                             scsi_device_ius(sdev))
 148                                                 target->negoFlags |= MPT_TAPE_NEGO_IDP;
 149                                 }
 150                         }
 151                         offset = pspi_data->maxSyncOffset;
 152
 153                         /* If RAID, never disable QAS
 154                          * else if non RAID, do not disable
 155                          *   QAS if bit 1 is set
 156                          * bit 1 QAS support, non-raid only
 157                          * bit 0 IU support
 158                          */
 159                         if (target->raidVolume == 1)
 160                                 noQas = 0;
 161                 } else {
 162                         factor = MPT_ASYNC;
 163                         offset = 0;
 164                 }
 165         }
 166
 167         if (!sdev->tagged_supported)
 168                 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
 169
 170         /* Update tflags based on NVRAM settings. (SCSI only)
 171          */
 172         if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
 173                 nvram = pspi_data->nvram[id];
 174                 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
 175
 176                 if (width)
 177                         width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
 178
 179                 if (offset > 0) {
 180                         /* Ensure factor is set to the
 181                          * maximum of: adapter, nvram, inquiry
 182                          */
 183                         if (nfactor) {
 184                                 if (nfactor < pspi_data->minSyncFactor )
 185                                         nfactor = pspi_data->minSyncFactor;
 186
 187                                 factor = max(factor, nfactor);
 188                                 if (factor == MPT_ASYNC)
 189                                         offset = 0;
 190                         } else {
 191                                 offset = 0;
 192                                 factor = MPT_ASYNC;
 193                 }
 194                 } else {
 195                         factor = MPT_ASYNC;
 196                 }
 197         }
 198
 199         /* Make sure data is consistent
 200          */
 201         if ((!width) && (factor < MPT_ULTRA2))
 202                 factor = MPT_ULTRA2;
 203
 204         /* Save the data to the target structure.
 205          */
 206         target->minSyncFactor = factor;
 207         target->maxOffset = offset;
 208         target->maxWidth = width;
 209
 210         target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
 211
 212         /* Disable unused features.
 213          */
 214         if (!width)
 215                 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
 216
 217         if (!offset)
 218                 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
 219
 220         if ( factor > MPT_ULTRA320 )
 221                 noQas = 0;
 222
 223         if (noQas && (pspi_data->noQas == 0)) {
 224                 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
 225                 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
 226
 227                 /* Disable QAS in a mixed configuration case
 228                  */
 229
 230                 ddvprintk(hd->ioc, printk(KERN_DEBUG
 231                         "Disabling QAS due to noQas=%02x on id=%d!\n", noQas, id));
 232         }
 233 }
 234
 235 /**
 236  *      mptspi_writeIOCPage4  - write IOC Page 4
 237  *      @hd: Pointer to a SCSI Host Structure
 238  *      @channel: channel number
 239  *      @id: write IOC Page4 for this ID & Bus
 240  *
 241  *      Return: -EAGAIN if unable to obtain a Message Frame
 242  *              or 0 if success.
 243  *
 244  *      Remark: We do not wait for a return, write pages sequentially.
 245  **/
 246 static int
 247 mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
 248 {
 249         MPT_ADAPTER             *ioc = hd->ioc;
 250         Config_t                *pReq;
 251         IOCPage4_t              *IOCPage4Ptr;
 252         MPT_FRAME_HDR           *mf;
 253         dma_addr_t               dataDma;
 254         u16                      req_idx;
 255         u32                      frameOffset;
 256         u32                      flagsLength;
 257         int                      ii;
 258
 259         /* Get a MF for this command.
 260          */
 261         if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
 262                 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
 263                                 "writeIOCPage4 : no msg frames!\n",ioc->name));
 264                 return -EAGAIN;
 265         }
 266
 267         /* Set the request and the data pointers.
 268          * Place data at end of MF.
 269          */
 270         pReq = (Config_t *)mf;
 271
 272         req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
 273         frameOffset = ioc->req_sz - sizeof(IOCPage4_t);
 274
 275         /* Complete the request frame (same for all requests).
 276          */
 277         pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 278         pReq->Reserved = 0;
 279         pReq->ChainOffset = 0;
 280         pReq->Function = MPI_FUNCTION_CONFIG;
 281         pReq->ExtPageLength = 0;
 282         pReq->ExtPageType = 0;
 283         pReq->MsgFlags = 0;
 284         for (ii=0; ii < 8; ii++) {
 285                 pReq->Reserved2[ii] = 0;
 286         }
 287
 288         IOCPage4Ptr = ioc->spi_data.pIocPg4;
 289         dataDma = ioc->spi_data.IocPg4_dma;
 290         ii = IOCPage4Ptr->ActiveSEP++;
 291         IOCPage4Ptr->SEP[ii].SEPTargetID = id;
 292         IOCPage4Ptr->SEP[ii].SEPBus = channel;
 293         pReq->Header = IOCPage4Ptr->Header;
 294         pReq->PageAddress = cpu_to_le32(id | (channel << 8 ));
 295
 296         /* Add a SGE to the config request.
 297          */
 298         flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
 299                 (IOCPage4Ptr->Header.PageLength + ii) * 4;
 300
 301         mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
 302
 303         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 304                 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
 305                         ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
 306
 307         mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
 308
 309         return 0;
 310 }
 311
 312 /**
 313  *      mptspi_initTarget - Target, LUN alloc/free functionality.
 314  *      @hd: Pointer to MPT_SCSI_HOST structure
 315  *      @vtarget: per target private data
 316  *      @sdev: SCSI device
 317  *
 318  *      NOTE: It's only SAFE to call this routine if data points to
 319  *      sane & valid STANDARD INQUIRY data!
 320  *
 321  *      Allocate and initialize memory for this target.
 322  *      Save inquiry data.
 323  *
 324  **/
 325 static void
 326 mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
 327                     struct scsi_device *sdev)
 328 {
 329
 330         /* Is LUN supported? If so, upper 2 bits will be 0
 331         * in first byte of inquiry data.
 332         */
 333         if (sdev->inq_periph_qual != 0)
 334                 return;
 335
 336         if (vtarget == NULL)
 337                 return;
 338
 339         vtarget->type = sdev->type;
 340
 341         if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
 342                 /* Treat all Processors as SAF-TE if
 343                  * command line option is set */
 344                 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
 345                 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
 346         }else if ((sdev->type == TYPE_PROCESSOR) &&
 347                 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
 348                 if (sdev->inquiry_len > 49 ) {
 349                         if (sdev->inquiry[44] == 'S' &&
 350                             sdev->inquiry[45] == 'A' &&
 351                             sdev->inquiry[46] == 'F' &&
 352                             sdev->inquiry[47] == '-' &&
 353                             sdev->inquiry[48] == 'T' &&
 354                             sdev->inquiry[49] == 'E' ) {
 355                                 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
 356                                 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
 357                         }
 358                 }
 359         }
 360         mptspi_setTargetNegoParms(hd, vtarget, sdev);
 361 }
 362
 363 /**
 364  *      mptspi_is_raid - Determines whether target is belonging to volume
 365  *      @hd: Pointer to a SCSI HOST structure
 366  *      @id: target device id
 367  *
 368  *      Return:
 369  *              non-zero = true
 370  *              zero = false
 371  *
 372  */
 373 static int
 374 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
 375 {
 376         int i, rc = 0;
 377
 378         if (!hd->ioc->raid_data.pIocPg2)
 379                 goto out;
 380
 381         if (!hd->ioc->raid_data.pIocPg2->NumActiveVolumes)
 382                 goto out;
 383         for (i=0; i < hd->ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
 384                 if (hd->ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
 385                         rc = 1;
 386                         goto out;
 387                 }
 388         }
 389
 390  out:
 391         return rc;
 392 }
 393
 394 static int mptspi_target_alloc(struct scsi_target *starget)
 395 {
 396         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 397         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
 398         VirtTarget              *vtarget;
 399
 400         if (hd == NULL)
 401                 return -ENODEV;
 402
 403         vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
 404         if (!vtarget)
 405                 return -ENOMEM;
 406
 407         vtarget->ioc_id = hd->ioc->id;
 408         vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
 409         vtarget->id = (u8)starget->id;
 410         vtarget->channel = (u8)starget->channel;
 411         vtarget->starget = starget;
 412         starget->hostdata = vtarget;
 413
 414         if (starget->channel == 1) {
 415                 if (mptscsih_is_phys_disk(hd->ioc, 0, starget->id) == 0)
 416                         return 0;
 417                 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
 418                 /* The real channel for this device is zero */
 419                 vtarget->channel = 0;
 420                 /* The actual physdisknum (for RAID passthrough) */
 421                 vtarget->id = mptscsih_raid_id_to_num(hd->ioc, 0,
 422                     starget->id);
 423         }
 424
 425         if (starget->channel == 0 &&
 426             mptspi_is_raid(hd, starget->id)) {
 427                 vtarget->raidVolume = 1;
 428                 ddvprintk(hd->ioc, printk(KERN_DEBUG
 429                     "RAID Volume @ channel=%d id=%d\n", starget->channel,
 430                     starget->id));
 431         }
 432
 433         if (hd->ioc->spi_data.nvram &&
 434             hd->ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
 435                 u32 nvram = hd->ioc->spi_data.nvram[starget->id];
 436                 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
 437                 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
 438         } else {
 439                 spi_min_period(starget) = hd->ioc->spi_data.minSyncFactor;
 440                 spi_max_width(starget) = hd->ioc->spi_data.maxBusWidth;
 441         }
 442         spi_max_offset(starget) = hd->ioc->spi_data.maxSyncOffset;
 443
 444         spi_offset(starget) = 0;
 445         mptspi_write_width(starget, 0);
 446
 447         return 0;
 448 }
 449
 450 static void
 451 mptspi_target_destroy(struct scsi_target *starget)
 452 {
 453         if (starget->hostdata)
 454                 kfree(starget->hostdata);
 455         starget->hostdata = NULL;
 456 }
 457
 458 /**
 459  *      mptspi_print_write_nego - negotiation parameters debug info that is being sent
 460  *      @hd: Pointer to a SCSI HOST structure
 461  *      @starget: SCSI target
 462  *      @ii: negotiation parameters
 463  *
 464  */
 465 static void
 466 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
 467 {
 468         ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x"
 469             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
 470             hd->ioc->name, starget->id, ii,
 471             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
 472             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
 473             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
 474             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
 475             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
 476             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
 477             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
 478             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
 479             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
 480             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
 481 }
 482
 483 /**
 484  *      mptspi_print_read_nego - negotiation parameters debug info that is being read
 485  *      @hd: Pointer to a SCSI HOST structure
 486  *      @starget: SCSI target
 487  *      @ii: negotiation parameters
 488  *
 489  */
 490 static void
 491 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
 492 {
 493         ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x"
 494             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
 495             hd->ioc->name, starget->id, ii,
 496             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
 497             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
 498             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
 499             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
 500             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
 501             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
 502             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
 503             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
 504             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
 505             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
 506 }
 507
 508 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
 509                              struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
 510 {
 511         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 512         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
 513         struct _MPT_ADAPTER *ioc = hd->ioc;
 514         struct _CONFIG_PAGE_SCSI_DEVICE_0 *pg0;
 515         dma_addr_t pg0_dma;
 516         int size;
 517         struct _x_config_parms cfg;
 518         struct _CONFIG_PAGE_HEADER hdr;
 519         int err = -EBUSY;
 520
 521         /* No SPI parameters for RAID devices */
 522         if (starget->channel == 0 &&
 523             mptspi_is_raid(hd, starget->id))
 524                 return -1;
 525
 526         size = ioc->spi_data.sdp0length * 4;
 527         /*
 528         if (ioc->spi_data.sdp0length & 1)
 529                 size += size + 4;
 530         size += 2048;
 531         */
 532
 533         pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg0_dma, GFP_KERNEL);
 534         if (pg0 == NULL) {
 535                 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
 536                 return -EINVAL;
 537         }
 538
 539         memset(&hdr, 0, sizeof(hdr));
 540
 541         hdr.PageVersion = ioc->spi_data.sdp0version;
 542         hdr.PageLength = ioc->spi_data.sdp0length;
 543         hdr.PageNumber = 0;
 544         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 545
 546         memset(&cfg, 0, sizeof(cfg));
 547
 548         cfg.cfghdr.hdr = &hdr;
 549         cfg.physAddr = pg0_dma;
 550         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 551         cfg.dir = 0;
 552         cfg.pageAddr = starget->id;
 553
 554         if (mpt_config(ioc, &cfg)) {
 555                 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
 556                 goto out_free;
 557         }
 558         err = 0;
 559         memcpy(pass_pg0, pg0, size);
 560
 561         mptspi_print_read_nego(hd, starget, le32_to_cpu(pg0->NegotiatedParameters));
 562
 563  out_free:
 564         dma_free_coherent(&ioc->pcidev->dev, size, pg0, pg0_dma);
 565         return err;
 566 }
 567
 568 static u32 mptspi_getRP(struct scsi_target *starget)
 569 {
 570         u32 nego = 0;
 571
 572         nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
 573         nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
 574         nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
 575         nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
 576         nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
 577         nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
 578         nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
 579         nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
 580
 581         nego |= (spi_period(starget) <<  MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
 582         nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
 583         nego |= spi_width(starget) ?  MPI_SCSIDEVPAGE1_RP_WIDE : 0;
 584
 585         return nego;
 586 }
 587
 588 static void mptspi_read_parameters(struct scsi_target *starget)
 589 {
 590         int nego;
 591         struct _CONFIG_PAGE_SCSI_DEVICE_0 pg0;
 592
 593         mptspi_read_spi_device_pg0(starget, &pg0);
 594
 595         nego = le32_to_cpu(pg0.NegotiatedParameters);
 596
 597         spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
 598         spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
 599         spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
 600         spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
 601         spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
 602         spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
 603         spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
 604         spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
 605         spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
 606         spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
 607         spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
 608 }
 609
 610 static int
 611 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
 612 {
 613         MpiRaidActionRequest_t  *pReq;
 614         MPT_FRAME_HDR           *mf;
 615
 616         /* Get and Populate a free Frame
 617          */
 618         if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
 619                 ddvprintk(hd->ioc, printk(MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
 620                                         hd->ioc->name));
 621                 return -EAGAIN;
 622         }
 623         pReq = (MpiRaidActionRequest_t *)mf;
 624         if (quiesce)
 625                 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
 626         else
 627                 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
 628         pReq->Reserved1 = 0;
 629         pReq->ChainOffset = 0;
 630         pReq->Function = MPI_FUNCTION_RAID_ACTION;
 631         pReq->VolumeID = id;
 632         pReq->VolumeBus = channel;
 633         pReq->PhysDiskNum = 0;
 634         pReq->MsgFlags = 0;
 635         pReq->Reserved2 = 0;
 636         pReq->ActionDataWord = 0; /* Reserved for this action */
 637
 638         mpt_add_sge((char *)&pReq->ActionDataSGE,
 639                 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
 640
 641         ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
 642                         hd->ioc->name, pReq->Action, channel, id));
 643
 644         hd->pLocal = NULL;
 645         hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
 646         hd->scandv_wait_done = 0;
 647
 648         /* Save cmd pointer, for resource free if timeout or
 649          * FW reload occurs
 650          */
 651         hd->cmdPtr = mf;
 652
 653         add_timer(&hd->timer);
 654         mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
 655         wait_event(hd->scandv_waitq, hd->scandv_wait_done);
 656
 657         if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
 658                 return -1;
 659
 660         return 0;
 661 }
 662
 663 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
 664                              struct scsi_device *sdev)
 665 {
 666         VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 667
 668         /* no DV on RAID devices */
 669         if (sdev->channel == 0 &&
 670             mptspi_is_raid(hd, sdev->id))
 671                 return;
 672
 673         /* If this is a piece of a RAID, then quiesce first */
 674         if (sdev->channel == 1 &&
 675             mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
 676                 starget_printk(KERN_ERR, scsi_target(sdev),
 677                                "Integrated RAID quiesce failed\n");
 678                 return;
 679         }
 680
 681         hd->spi_pending |= (1 << sdev->id);
 682         spi_dv_device(sdev);
 683         hd->spi_pending &= ~(1 << sdev->id);
 684
 685         if (sdev->channel == 1 &&
 686             mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
 687                 starget_printk(KERN_ERR, scsi_target(sdev),
 688                                "Integrated RAID resume failed\n");
 689
 690         mptspi_read_parameters(sdev->sdev_target);
 691         spi_display_xfer_agreement(sdev->sdev_target);
 692         mptspi_read_parameters(sdev->sdev_target);
 693 }
 694
 695 static int mptspi_slave_alloc(struct scsi_device *sdev)
 696 {
 697         MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
 698         VirtTarget              *vtarget;
 699         VirtDevice              *vdev;
 700         struct scsi_target      *starget;
 701
 702         if (sdev->channel == 1 &&
 703                 mptscsih_is_phys_disk(hd->ioc, 0, sdev->id) == 0)
 704                         return -ENXIO;
 705
 706         vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
 707         if (!vdev) {
 708                 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
 709                                 hd->ioc->name, sizeof(VirtDevice));
 710                 return -ENOMEM;
 711         }
 712
 713         vdev->lun = sdev->lun;
 714         sdev->hostdata = vdev;
 715
 716         starget = scsi_target(sdev);
 717         vtarget = starget->hostdata;
 718         vdev->vtarget = vtarget;
 719         vtarget->num_luns++;
 720
 721         if (sdev->channel == 1)
 722                 sdev->no_uld_attach = 1;
 723
 724         return 0;
 725 }
 726
 727 static int mptspi_slave_configure(struct scsi_device *sdev)
 728 {
 729         struct _MPT_SCSI_HOST *hd =
 730                 (struct _MPT_SCSI_HOST *)sdev->host->hostdata;
 731         VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 732         int ret;
 733
 734         mptspi_initTarget(hd, vtarget, sdev);
 735
 736         ret = mptscsih_slave_configure(sdev);
 737
 738         if (ret)
 739                 return ret;
 740
 741         ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
 742                 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
 743                 sdev->id, spi_min_period(scsi_target(sdev)),
 744                 spi_max_offset(scsi_target(sdev)),
 745                 spi_max_width(scsi_target(sdev))));
 746
 747         if ((sdev->channel == 1 ||
 748              !(mptspi_is_raid(hd, sdev->id))) &&
 749             !spi_initial_dv(sdev->sdev_target))
 750                 mptspi_dv_device(hd, sdev);
 751
 752         return 0;
 753 }
 754
 755 static int
 756 mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
 757 {
 758         struct _MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata;
 759         VirtDevice      *vdev = SCpnt->device->hostdata;
 760
 761         if (!vdev || !vdev->vtarget) {
 762                 SCpnt->result = DID_NO_CONNECT << 16;
 763                 done(SCpnt);
 764                 return 0;
 765         }
 766
 767         if (SCpnt->device->channel == 1 &&
 768                 mptscsih_is_phys_disk(hd->ioc, 0, SCpnt->device->id) == 0) {
 769                 SCpnt->result = DID_NO_CONNECT << 16;
 770                 done(SCpnt);
 771                 return 0;
 772         }
 773
 774         if (spi_dv_pending(scsi_target(SCpnt->device)))
 775                 ddvprintk(hd->ioc, scsi_print_command(SCpnt));
 776
 777         return mptscsih_qcmd(SCpnt,done);
 778 }
 779
 780 static void mptspi_slave_destroy(struct scsi_device *sdev)
 781 {
 782         struct scsi_target *starget = scsi_target(sdev);
 783         VirtTarget *vtarget = starget->hostdata;
 784         VirtDevice *vdevice = sdev->hostdata;
 785
 786         /* Will this be the last lun on a non-raid device? */
 787         if (vtarget->num_luns == 1 && vdevice->configured_lun) {
 788                 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 789
 790                 /* Async Narrow */
 791                 pg1.RequestedParameters = 0;
 792                 pg1.Reserved = 0;
 793                 pg1.Configuration = 0;
 794
 795                 mptspi_write_spi_device_pg1(starget, &pg1);
 796         }
 797
 798         mptscsih_slave_destroy(sdev);
 799 }
 800
 801 static struct scsi_host_template mptspi_driver_template = {
 802         .module                         = THIS_MODULE,
 803         .proc_name                      = "mptspi",
 804         .proc_info                      = mptscsih_proc_info,
 805         .name                           = "MPT SPI Host",
 806         .info                           = mptscsih_info,
 807         .queuecommand                   = mptspi_qcmd,
 808         .target_alloc                   = mptspi_target_alloc,
 809         .slave_alloc                    = mptspi_slave_alloc,
 810         .slave_configure                = mptspi_slave_configure,
 811         .target_destroy                 = mptspi_target_destroy,
 812         .slave_destroy                  = mptspi_slave_destroy,
 813         .change_queue_depth             = mptscsih_change_queue_depth,
 814         .eh_abort_handler               = mptscsih_abort,
 815         .eh_device_reset_handler        = mptscsih_dev_reset,
 816         .eh_bus_reset_handler           = mptscsih_bus_reset,
 817         .eh_host_reset_handler          = mptscsih_host_reset,
 818         .bios_param                     = mptscsih_bios_param,
 819         .can_queue                      = MPT_SCSI_CAN_QUEUE,
 820         .this_id                        = -1,
 821         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
 822         .max_sectors                    = 8192,
 823         .cmd_per_lun                    = 7,
 824         .use_clustering                 = ENABLE_CLUSTERING,
 825         .shost_attrs                    = mptscsih_host_attrs,
 826 };
 827
 828 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
 829                                struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
 830 {
 831         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 832         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
 833         struct _MPT_ADAPTER *ioc = hd->ioc;
 834         struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
 835         dma_addr_t pg1_dma;
 836         int size;
 837         struct _x_config_parms cfg;
 838         struct _CONFIG_PAGE_HEADER hdr;
 839         int err = -EBUSY;
 840
 841         /* don't allow updating nego parameters on RAID devices */
 842         if (starget->channel == 0 &&
 843             mptspi_is_raid(hd, starget->id))
 844                 return -1;
 845
 846         size = ioc->spi_data.sdp1length * 4;
 847
 848         pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
 849         if (pg1 == NULL) {
 850                 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
 851                 return -EINVAL;
 852         }
 853
 854         memset(&hdr, 0, sizeof(hdr));
 855
 856         hdr.PageVersion = ioc->spi_data.sdp1version;
 857         hdr.PageLength = ioc->spi_data.sdp1length;
 858         hdr.PageNumber = 1;
 859         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 860
 861         memset(&cfg, 0, sizeof(cfg));
 862
 863         cfg.cfghdr.hdr = &hdr;
 864         cfg.physAddr = pg1_dma;
 865         cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 866         cfg.dir = 1;
 867         cfg.pageAddr = starget->id;
 868
 869         memcpy(pg1, pass_pg1, size);
 870
 871         pg1->Header.PageVersion = hdr.PageVersion;
 872         pg1->Header.PageLength = hdr.PageLength;
 873         pg1->Header.PageNumber = hdr.PageNumber;
 874         pg1->Header.PageType = hdr.PageType;
 875
 876         mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
 877
 878         if (mpt_config(ioc, &cfg)) {
 879                 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
 880                 goto out_free;
 881         }
 882         err = 0;
 883
 884  out_free:
 885         dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
 886         return err;
 887 }
 888
 889 static void mptspi_write_offset(struct scsi_target *starget, int offset)
 890 {
 891         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 892         u32 nego;
 893
 894         if (offset < 0)
 895                 offset = 0;
 896
 897         if (offset > 255)
 898                 offset = 255;
 899
 900         if (spi_offset(starget) == -1)
 901                 mptspi_read_parameters(starget);
 902
 903         spi_offset(starget) = offset;
 904
 905         nego = mptspi_getRP(starget);
 906
 907         pg1.RequestedParameters = cpu_to_le32(nego);
 908         pg1.Reserved = 0;
 909         pg1.Configuration = 0;
 910
 911         mptspi_write_spi_device_pg1(starget, &pg1);
 912 }
 913
 914 static void mptspi_write_period(struct scsi_target *starget, int period)
 915 {
 916         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 917         u32 nego;
 918
 919         if (period < 8)
 920                 period = 8;
 921
 922         if (period > 255)
 923                 period = 255;
 924
 925         if (spi_period(starget) == -1)
 926                 mptspi_read_parameters(starget);
 927
 928         if (period == 8) {
 929                 spi_iu(starget) = 1;
 930                 spi_dt(starget) = 1;
 931         } else if (period == 9) {
 932                 spi_dt(starget) = 1;
 933         }
 934
 935         spi_period(starget) = period;
 936
 937         nego = mptspi_getRP(starget);
 938
 939         pg1.RequestedParameters = cpu_to_le32(nego);
 940         pg1.Reserved = 0;
 941         pg1.Configuration = 0;
 942
 943         mptspi_write_spi_device_pg1(starget, &pg1);
 944 }
 945
 946 static void mptspi_write_dt(struct scsi_target *starget, int dt)
 947 {
 948         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 949         u32 nego;
 950
 951         if (spi_period(starget) == -1)
 952                 mptspi_read_parameters(starget);
 953
 954         if (!dt && spi_period(starget) < 10)
 955                 spi_period(starget) = 10;
 956
 957         spi_dt(starget) = dt;
 958
 959         nego = mptspi_getRP(starget);
 960
 961
 962         pg1.RequestedParameters = cpu_to_le32(nego);
 963         pg1.Reserved = 0;
 964         pg1.Configuration = 0;
 965
 966         mptspi_write_spi_device_pg1(starget, &pg1);
 967 }
 968
 969 static void mptspi_write_iu(struct scsi_target *starget, int iu)
 970 {
 971         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 972         u32 nego;
 973
 974         if (spi_period(starget) == -1)
 975                 mptspi_read_parameters(starget);
 976
 977         if (!iu && spi_period(starget) < 9)
 978                 spi_period(starget) = 9;
 979
 980         spi_iu(starget) = iu;
 981
 982         nego = mptspi_getRP(starget);
 983
 984         pg1.RequestedParameters = cpu_to_le32(nego);
 985         pg1.Reserved = 0;
 986         pg1.Configuration = 0;
 987
 988         mptspi_write_spi_device_pg1(starget, &pg1);
 989 }
 990
 991 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm)                              \
 992 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
 993 {                                                                       \
 994         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;                          \
 995         u32 nego;                                                       \
 996                                                                         \
 997         spi_##parm(starget) = parm;                                     \
 998                                                                         \
 999         nego = mptspi_getRP(starget);                                   \
1000                                                                         \
1001         pg1.RequestedParameters = cpu_to_le32(nego);                    \
1002         pg1.Reserved = 0;                                               \
1003         pg1.Configuration = 0;                                          \
1004                                                                         \
1005         mptspi_write_spi_device_pg1(starget, &pg1);                             \
1006 }
1007
1008 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1009 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1010 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1011 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1012 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1013
1014 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1015 {
1016         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1017         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1018         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
1019         VirtTarget *vtarget = starget->hostdata;
1020         u32 nego;
1021
1022         if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1023             hd->ioc->spi_data.noQas)
1024                 spi_qas(starget) = 0;
1025         else
1026                 spi_qas(starget) = qas;
1027
1028         nego = mptspi_getRP(starget);
1029
1030         pg1.RequestedParameters = cpu_to_le32(nego);
1031         pg1.Reserved = 0;
1032         pg1.Configuration = 0;
1033
1034         mptspi_write_spi_device_pg1(starget, &pg1);
1035 }
1036
1037 static void mptspi_write_width(struct scsi_target *starget, int width)
1038 {
1039         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1040         u32 nego;
1041
1042         if (!width) {
1043                 spi_dt(starget) = 0;
1044                 if (spi_period(starget) < 10)
1045                         spi_period(starget) = 10;
1046         }
1047
1048         spi_width(starget) = width;
1049
1050         nego = mptspi_getRP(starget);
1051
1052         pg1.RequestedParameters = cpu_to_le32(nego);
1053         pg1.Reserved = 0;
1054         pg1.Configuration = 0;
1055
1056         mptspi_write_spi_device_pg1(starget, &pg1);
1057 }
1058
1059 struct work_queue_wrapper {
1060         struct work_struct      work;
1061         struct _MPT_SCSI_HOST   *hd;
1062         int                     disk;
1063 };
1064
1065 static void mpt_work_wrapper(struct work_struct *work)
1066 {
1067         struct work_queue_wrapper *wqw =
1068                 container_of(work, struct work_queue_wrapper, work);
1069         struct _MPT_SCSI_HOST *hd = wqw->hd;
1070         struct Scsi_Host *shost = hd->ioc->sh;
1071         struct scsi_device *sdev;
1072         int disk = wqw->disk;
1073         struct _CONFIG_PAGE_IOC_3 *pg3;
1074
1075         kfree(wqw);
1076
1077         mpt_findImVolumes(hd->ioc);
1078         pg3 = hd->ioc->raid_data.pIocPg3;
1079         if (!pg3)
1080                 return;
1081
1082         shost_for_each_device(sdev,shost) {
1083                 struct scsi_target *starget = scsi_target(sdev);
1084                 VirtTarget *vtarget = starget->hostdata;
1085
1086                 /* only want to search RAID components */
1087                 if (sdev->channel != 1)
1088                         continue;
1089
1090                 /* The id is the raid PhysDiskNum, even if
1091                  * starget->id is the actual target address */
1092                 if(vtarget->id != disk)
1093                         continue;
1094
1095                 starget_printk(KERN_INFO, vtarget->starget,
1096                                "Integrated RAID requests DV of new device\n");
1097                 mptspi_dv_device(hd, sdev);
1098         }
1099         shost_printk(KERN_INFO, shost,
1100                      "Integrated RAID detects new device %d\n", disk);
1101         scsi_scan_target(&hd->ioc->sh->shost_gendev, 1, disk, 0, 1);
1102 }
1103
1104
1105 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1106 {
1107         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1108
1109         if (!wqw) {
1110                 shost_printk(KERN_ERR, hd->ioc->sh,
1111                              "Failed to act on RAID event for physical disk %d\n",
1112                            disk);
1113                 return;
1114         }
1115         INIT_WORK(&wqw->work, mpt_work_wrapper);
1116         wqw->hd = hd;
1117         wqw->disk = disk;
1118
1119         schedule_work(&wqw->work);
1120 }
1121
1122 static int
1123 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1124 {
1125         u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1126         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1127
1128         if (hd && event ==  MPI_EVENT_INTEGRATED_RAID) {
1129                 int reason
1130                         = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1131
1132                 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1133                         int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1134                         mpt_dv_raid(hd, disk);
1135                 }
1136         }
1137         return mptscsih_event_process(ioc, pEvReply);
1138 }
1139
1140 static int
1141 mptspi_deny_binding(struct scsi_target *starget)
1142 {
1143         struct _MPT_SCSI_HOST *hd =
1144                 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1145         return ((mptspi_is_raid(hd, starget->id)) &&
1146                 starget->channel == 0) ? 1 : 0;
1147 }
1148
1149 static struct spi_function_template mptspi_transport_functions = {
1150         .get_offset     = mptspi_read_parameters,
1151         .set_offset     = mptspi_write_offset,
1152         .show_offset    = 1,
1153         .get_period     = mptspi_read_parameters,
1154         .set_period     = mptspi_write_period,
1155         .show_period    = 1,
1156         .get_width      = mptspi_read_parameters,
1157         .set_width      = mptspi_write_width,
1158         .show_width     = 1,
1159         .get_iu         = mptspi_read_parameters,
1160         .set_iu         = mptspi_write_iu,
1161         .show_iu        = 1,
1162         .get_dt         = mptspi_read_parameters,
1163         .set_dt         = mptspi_write_dt,
1164         .show_dt        = 1,
1165         .get_qas        = mptspi_read_parameters,
1166         .set_qas        = mptspi_write_qas,
1167         .show_qas       = 1,
1168         .get_wr_flow    = mptspi_read_parameters,
1169         .set_wr_flow    = mptspi_write_wr_flow,
1170         .show_wr_flow   = 1,
1171         .get_rd_strm    = mptspi_read_parameters,
1172         .set_rd_strm    = mptspi_write_rd_strm,
1173         .show_rd_strm   = 1,
1174         .get_rti        = mptspi_read_parameters,
1175         .set_rti        = mptspi_write_rti,
1176         .show_rti       = 1,
1177         .get_pcomp_en   = mptspi_read_parameters,
1178         .set_pcomp_en   = mptspi_write_pcomp_en,
1179         .show_pcomp_en  = 1,
1180         .get_hold_mcs   = mptspi_read_parameters,
1181         .set_hold_mcs   = mptspi_write_hold_mcs,
1182         .show_hold_mcs  = 1,
1183         .deny_binding   = mptspi_deny_binding,
1184 };
1185
1186 /****************************************************************************
1187  * Supported hardware
1188  */
1189
1190 static struct pci_device_id mptspi_pci_table[] = {
1191         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1192                 PCI_ANY_ID, PCI_ANY_ID },
1193         { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1194                 PCI_ANY_ID, PCI_ANY_ID },
1195         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1196                 PCI_ANY_ID, PCI_ANY_ID },
1197         {0}     /* Terminating entry */
1198 };
1199 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1200
1201
1202 /*
1203  * renegotiate for a given target
1204  */
1205 static void
1206 mptspi_dv_renegotiate_work(struct work_struct *work)
1207 {
1208         struct work_queue_wrapper *wqw =
1209                 container_of(work, struct work_queue_wrapper, work);
1210         struct _MPT_SCSI_HOST *hd = wqw->hd;
1211         struct scsi_device *sdev;
1212         struct scsi_target *starget;
1213         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1214         u32 nego;
1215
1216         kfree(wqw);
1217
1218         if (hd->spi_pending) {
1219                 shost_for_each_device(sdev, hd->ioc->sh) {
1220                         if  (hd->spi_pending & (1 << sdev->id))
1221                                 continue;
1222                         starget = scsi_target(sdev);
1223                         nego = mptspi_getRP(starget);
1224                         pg1.RequestedParameters = cpu_to_le32(nego);
1225                         pg1.Reserved = 0;
1226                         pg1.Configuration = 0;
1227                         mptspi_write_spi_device_pg1(starget, &pg1);
1228                 }
1229         } else {
1230                 shost_for_each_device(sdev, hd->ioc->sh)
1231                         mptspi_dv_device(hd, sdev);
1232         }
1233 }
1234
1235 static void
1236 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1237 {
1238         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1239
1240         if (!wqw)
1241                 return;
1242
1243         INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1244         wqw->hd = hd;
1245
1246         schedule_work(&wqw->work);
1247 }
1248
1249 /*
1250  * spi module reset handler
1251  */
1252 static int
1253 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1254 {
1255         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1256         int rc;
1257
1258         rc = mptscsih_ioc_reset(ioc, reset_phase);
1259
1260         if (reset_phase == MPT_IOC_POST_RESET)
1261                 mptspi_dv_renegotiate(hd);
1262
1263         return rc;
1264 }
1265
1266 #ifdef CONFIG_PM
1267 /*
1268  * spi module resume handler
1269  */
1270 static int
1271 mptspi_resume(struct pci_dev *pdev)
1272 {
1273         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1274         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1275         int rc;
1276
1277         rc = mptscsih_resume(pdev);
1278         mptspi_dv_renegotiate(hd);
1279
1280         return rc;
1281 }
1282 #endif
1283
1284 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1285 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1286 /*
1287  *      mptspi_probe - Installs scsi devices per bus.
1288  *      @pdev: Pointer to pci_dev structure
1289  *
1290  *      Returns 0 for success, non-zero for failure.
1291  *
1292  */
1293 static int
1294 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1295 {
1296         struct Scsi_Host        *sh;
1297         MPT_SCSI_HOST           *hd;
1298         MPT_ADAPTER             *ioc;
1299         unsigned long            flags;
1300         int                      ii;
1301         int                      numSGE = 0;
1302         int                      scale;
1303         int                      ioc_cap;
1304         int                     error=0;
1305         int                     r;
1306
1307         if ((r = mpt_attach(pdev,id)) != 0)
1308                 return r;
1309
1310         ioc = pci_get_drvdata(pdev);
1311         ioc->DoneCtx = mptspiDoneCtx;
1312         ioc->TaskCtx = mptspiTaskCtx;
1313         ioc->InternalCtx = mptspiInternalCtx;
1314
1315         /*  Added sanity check on readiness of the MPT adapter.
1316          */
1317         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1318                 printk(MYIOC_s_WARN_FMT
1319                   "Skipping because it's not operational!\n",
1320                   ioc->name);
1321                 error = -ENODEV;
1322                 goto out_mptspi_probe;
1323         }
1324
1325         if (!ioc->active) {
1326                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1327                   ioc->name);
1328                 error = -ENODEV;
1329                 goto out_mptspi_probe;
1330         }
1331
1332         /*  Sanity check - ensure at least 1 port is INITIATOR capable
1333          */
1334         ioc_cap = 0;
1335         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1336                 if (ioc->pfacts[ii].ProtocolFlags &
1337                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
1338                         ioc_cap ++;
1339         }
1340
1341         if (!ioc_cap) {
1342                 printk(MYIOC_s_WARN_FMT
1343                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1344                         ioc->name, ioc);
1345                 return 0;
1346         }
1347
1348         sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1349
1350         if (!sh) {
1351                 printk(MYIOC_s_WARN_FMT
1352                         "Unable to register controller with SCSI subsystem\n",
1353                         ioc->name);
1354                 error = -1;
1355                 goto out_mptspi_probe;
1356         }
1357
1358         spin_lock_irqsave(&ioc->FreeQlock, flags);
1359
1360         /* Attach the SCSI Host to the IOC structure
1361          */
1362         ioc->sh = sh;
1363
1364         sh->io_port = 0;
1365         sh->n_io_port = 0;
1366         sh->irq = 0;
1367
1368         /* set 16 byte cdb's */
1369         sh->max_cmd_len = 16;
1370
1371         /* Yikes!  This is important!
1372          * Otherwise, by default, linux
1373          * only scans target IDs 0-7!
1374          * pfactsN->MaxDevices unreliable
1375          * (not supported in early
1376          *      versions of the FW).
1377          * max_id = 1 + actual max id,
1378          * max_lun = 1 + actual last lun,
1379          *      see hosts.h :o(
1380          */
1381         sh->max_id = ioc->devices_per_bus;
1382
1383         sh->max_lun = MPT_LAST_LUN + 1;
1384         /*
1385          * If RAID Firmware Detected, setup virtual channel
1386          */
1387         if (ioc->ir_firmware)
1388                 sh->max_channel = 1;
1389         else
1390                 sh->max_channel = 0;
1391         sh->this_id = ioc->pfacts[0].PortSCSIID;
1392
1393         /* Required entry.
1394          */
1395         sh->unique_id = ioc->id;
1396
1397         /* Verify that we won't exceed the maximum
1398          * number of chain buffers
1399          * We can optimize:  ZZ = req_sz/sizeof(SGE)
1400          * For 32bit SGE's:
1401          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1402          *               + (req_sz - 64)/sizeof(SGE)
1403          * A slightly different algorithm is required for
1404          * 64bit SGEs.
1405          */
1406         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1407         if (sizeof(dma_addr_t) == sizeof(u64)) {
1408                 numSGE = (scale - 1) *
1409                   (ioc->facts.MaxChainDepth-1) + scale +
1410                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1411                   sizeof(u32));
1412         } else {
1413                 numSGE = 1 + (scale - 1) *
1414                   (ioc->facts.MaxChainDepth-1) + scale +
1415                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1416                   sizeof(u32));
1417         }
1418
1419         if (numSGE < sh->sg_tablesize) {
1420                 /* Reset this value */
1421                 dprintk(ioc, printk(MYIOC_s_INFO_FMT
1422                   "Resetting sg_tablesize to %d from %d\n",
1423                   ioc->name, numSGE, sh->sg_tablesize));
1424                 sh->sg_tablesize = numSGE;
1425         }
1426
1427         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1428
1429         hd = (MPT_SCSI_HOST *) sh->hostdata;
1430         hd->ioc = ioc;
1431
1432         /* SCSI needs scsi_cmnd lookup table!
1433          * (with size equal to req_depth*PtrSz!)
1434          */
1435         hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1436         if (!hd->ScsiLookup) {
1437                 error = -ENOMEM;
1438                 goto out_mptspi_probe;
1439         }
1440
1441         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1442                  ioc->name, hd->ScsiLookup));
1443
1444         /* Clear the TM flags
1445          */
1446         hd->tmPending = 0;
1447         hd->tmState = TM_STATE_NONE;
1448         hd->resetPending = 0;
1449         hd->abortSCpnt = NULL;
1450
1451         /* Clear the pointer used to store
1452          * single-threaded commands, i.e., those
1453          * issued during a bus scan, dv and
1454          * configuration pages.
1455          */
1456         hd->cmdPtr = NULL;
1457
1458         /* Initialize this SCSI Hosts' timers
1459          * To use, set the timer expires field
1460          * and add_timer
1461          */
1462         init_timer(&hd->timer);
1463         hd->timer.data = (unsigned long) hd;
1464         hd->timer.function = mptscsih_timer_expired;
1465
1466         ioc->spi_data.Saf_Te = mpt_saf_te;
1467
1468         hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1469         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1470                 "saf_te %x\n",
1471                 ioc->name,
1472                 mpt_saf_te));
1473         ioc->spi_data.noQas = 0;
1474
1475         init_waitqueue_head(&hd->scandv_waitq);
1476         hd->scandv_wait_done = 0;
1477         hd->last_queue_full = 0;
1478         hd->spi_pending = 0;
1479
1480         /* Some versions of the firmware don't support page 0; without
1481          * that we can't get the parameters */
1482         if (hd->ioc->spi_data.sdp0length != 0)
1483                 sh->transportt = mptspi_transport_template;
1484
1485         error = scsi_add_host (sh, &ioc->pcidev->dev);
1486         if(error) {
1487                 dprintk(ioc, printk(KERN_ERR MYNAM
1488                   "scsi_add_host failed\n"));
1489                 goto out_mptspi_probe;
1490         }
1491
1492         /*
1493          * issue internal bus reset
1494          */
1495         if (ioc->spi_data.bus_reset)
1496                 mptscsih_TMHandler(hd,
1497                     MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1498                     0, 0, 0, 0, 5);
1499
1500         scsi_scan_host(sh);
1501         return 0;
1502
1503 out_mptspi_probe:
1504
1505         mptscsih_remove(pdev);
1506         return error;
1507 }
1508
1509 static struct pci_driver mptspi_driver = {
1510         .name           = "mptspi",
1511         .id_table       = mptspi_pci_table,
1512         .probe          = mptspi_probe,
1513         .remove         = __devexit_p(mptscsih_remove),
1514         .shutdown       = mptscsih_shutdown,
1515 #ifdef CONFIG_PM
1516         .suspend        = mptscsih_suspend,
1517         .resume         = mptspi_resume,
1518 #endif
1519 };
1520
1521 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1522 /**
1523  *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1524  *
1525  *      Returns 0 for success, non-zero for failure.
1526  */
1527 static int __init
1528 mptspi_init(void)
1529 {
1530         int error;
1531
1532         show_mptmod_ver(my_NAME, my_VERSION);
1533
1534         mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1535         if (!mptspi_transport_template)
1536                 return -ENODEV;
1537
1538         mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1539         mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1540         mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1541
1542         mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1543         mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1544
1545         error = pci_register_driver(&mptspi_driver);
1546         if (error)
1547                 spi_release_transport(mptspi_transport_template);
1548
1549         return error;
1550 }
1551
1552 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1553 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1554 /**
1555  *      mptspi_exit - Unregisters MPT adapter(s)
1556  */
1557 static void __exit
1558 mptspi_exit(void)
1559 {
1560         pci_unregister_driver(&mptspi_driver);
1561
1562         mpt_reset_deregister(mptspiDoneCtx);
1563         mpt_event_deregister(mptspiDoneCtx);
1564
1565         mpt_deregister(mptspiInternalCtx);
1566         mpt_deregister(mptspiTaskCtx);
1567         mpt_deregister(mptspiDoneCtx);
1568         spi_release_transport(mptspi_transport_template);
1569 }
1570
1571 module_init(mptspi_init);
1572 module_exit(mptspi_exit);