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