drivers/message/fusion/mptspi.c

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