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 parameters
 100  *      @hd: Pointer to a SCSI Host Structure
 101  *      @target: per target private data
 102  *      @sdev: SCSI device
 103  *
 104  *      Update the target negotiation parameters based on the the Inquiry
 105  *      data, adapter capabilities, and NVRAM settings.
 106  **/
 107 static void
 108 mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
 109                             struct scsi_device *sdev)
 110 {
 111         SpiCfgData *pspi_data = &hd->ioc->spi_data;
 112         int  id = (int) target->id;
 113         int  nvram;
 114         u8 width = MPT_NARROW;
 115         u8 factor = MPT_ASYNC;
 116         u8 offset = 0;
 117         u8 nfactor;
 118         u8 noQas = 1;
 119
 120         target->negoFlags = pspi_data->noQas;
 121
 122         if (sdev->scsi_level < SCSI_2) {
 123                 width = 0;
 124                 factor = MPT_ULTRA2;
 125                 offset = pspi_data->maxSyncOffset;
 126                 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
 127         } else {
 128                 if (scsi_device_wide(sdev))
 129                         width = 1;
 130
 131                 if (scsi_device_sync(sdev)) {
 132                         factor = pspi_data->minSyncFactor;
 133                         if (!scsi_device_dt(sdev))
 134                                         factor = MPT_ULTRA2;
 135                         else {
 136                                 if (!scsi_device_ius(sdev) &&
 137                                     !scsi_device_qas(sdev))
 138                                         factor = MPT_ULTRA160;
 139                                 else {
 140                                         factor = MPT_ULTRA320;
 141                                         if (scsi_device_qas(sdev)) {
 142                                                 ddvprintk((KERN_INFO "Enabling QAS due to byte56=%02x on id=%d!\n", scsi_device_qas(sdev), id));
 143                                                 noQas = 0;
 144                                         }
 145                                         if (sdev->type == TYPE_TAPE &&
 146                                             scsi_device_ius(sdev))
 147                                                 target->negoFlags |= MPT_TAPE_NEGO_IDP;
 148                                 }
 149                         }
 150                         offset = pspi_data->maxSyncOffset;
 151
 152                         /* If RAID, never disable QAS
 153                          * else if non RAID, do not disable
 154                          *   QAS if bit 1 is set
 155                          * bit 1 QAS support, non-raid only
 156                          * bit 0 IU support
 157                          */
 158                         if (target->raidVolume == 1)
 159                                 noQas = 0;
 160                 } else {
 161                         factor = MPT_ASYNC;
 162                         offset = 0;
 163                 }
 164         }
 165
 166         if (!sdev->tagged_supported)
 167                 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
 168
 169         /* Update tflags based on NVRAM settings. (SCSI only)
 170          */
 171         if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
 172                 nvram = pspi_data->nvram[id];
 173                 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
 174
 175                 if (width)
 176                         width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
 177
 178                 if (offset > 0) {
 179                         /* Ensure factor is set to the
 180                          * maximum of: adapter, nvram, inquiry
 181                          */
 182                         if (nfactor) {
 183                                 if (nfactor < pspi_data->minSyncFactor )
 184                                         nfactor = pspi_data->minSyncFactor;
 185
 186                                 factor = max(factor, nfactor);
 187                                 if (factor == MPT_ASYNC)
 188                                         offset = 0;
 189                         } else {
 190                                 offset = 0;
 191                                 factor = MPT_ASYNC;
 192                 }
 193                 } else {
 194                         factor = MPT_ASYNC;
 195                 }
 196         }
 197
 198         /* Make sure data is consistent
 199          */
 200         if ((!width) && (factor < MPT_ULTRA2))
 201                 factor = MPT_ULTRA2;
 202
 203         /* Save the data to the target structure.
 204          */
 205         target->minSyncFactor = factor;
 206         target->maxOffset = offset;
 207         target->maxWidth = width;
 208
 209         target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
 210
 211         /* Disable unused features.
 212          */
 213         if (!width)
 214                 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
 215
 216         if (!offset)
 217                 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
 218
 219         if ( factor > MPT_ULTRA320 )
 220                 noQas = 0;
 221
 222         if (noQas && (pspi_data->noQas == 0)) {
 223                 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
 224                 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
 225
 226                 /* Disable QAS in a mixed configuration case
 227                  */
 228
 229                 ddvprintk((KERN_INFO "Disabling QAS due to noQas=%02x on id=%d!\n", noQas, id));
 230         }
 231 }
 232
 233 /**
 234  *      mptspi_writeIOCPage4  - write IOC Page 4
 235  *      @hd: Pointer to a SCSI Host Structure
 236  *      @channel: channel number
 237  *      @id: write IOC Page4 for this ID & Bus
 238  *
 239  *      Return: -EAGAIN if unable to obtain a Message Frame
 240  *              or 0 if success.
 241  *
 242  *      Remark: We do not wait for a return, write pages sequentially.
 243  **/
 244 static int
 245 mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
 246 {
 247         MPT_ADAPTER             *ioc = hd->ioc;
 248         Config_t                *pReq;
 249         IOCPage4_t              *IOCPage4Ptr;
 250         MPT_FRAME_HDR           *mf;
 251         dma_addr_t               dataDma;
 252         u16                      req_idx;
 253         u32                      frameOffset;
 254         u32                      flagsLength;
 255         int                      ii;
 256
 257         /* Get a MF for this command.
 258          */
 259         if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
 260                 dfailprintk((MYIOC_s_WARN_FMT "writeIOCPage4 : no msg frames!\n",
 261                                         ioc->name));
 262                 return -EAGAIN;
 263         }
 264
 265         /* Set the request and the data pointers.
 266          * Place data at end of MF.
 267          */
 268         pReq = (Config_t *)mf;
 269
 270         req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
 271         frameOffset = ioc->req_sz - sizeof(IOCPage4_t);
 272
 273         /* Complete the request frame (same for all requests).
 274          */
 275         pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 276         pReq->Reserved = 0;
 277         pReq->ChainOffset = 0;
 278         pReq->Function = MPI_FUNCTION_CONFIG;
 279         pReq->ExtPageLength = 0;
 280         pReq->ExtPageType = 0;
 281         pReq->MsgFlags = 0;
 282         for (ii=0; ii < 8; ii++) {
 283                 pReq->Reserved2[ii] = 0;
 284         }
 285
 286         IOCPage4Ptr = ioc->spi_data.pIocPg4;
 287         dataDma = ioc->spi_data.IocPg4_dma;
 288         ii = IOCPage4Ptr->ActiveSEP++;
 289         IOCPage4Ptr->SEP[ii].SEPTargetID = id;
 290         IOCPage4Ptr->SEP[ii].SEPBus = channel;
 291         pReq->Header = IOCPage4Ptr->Header;
 292         pReq->PageAddress = cpu_to_le32(id | (channel << 8 ));
 293
 294         /* Add a SGE to the config request.
 295          */
 296         flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
 297                 (IOCPage4Ptr->Header.PageLength + ii) * 4;
 298
 299         mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
 300
 301         ddvprintk((MYIOC_s_INFO_FMT
 302                 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
 303                         ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
 304
 305         mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
 306
 307         return 0;
 308 }
 309
 310 /**
 311  *      mptspi_initTarget - Target, LUN alloc/free functionality.
 312  *      @hd: Pointer to MPT_SCSI_HOST structure
 313  *      @vtarget: per target private data
 314  *      @sdev: SCSI device
 315  *
 316  *      NOTE: It's only SAFE to call this routine if data points to
 317  *      sane & valid STANDARD INQUIRY data!
 318  *
 319  *      Allocate and initialize memory for this target.
 320  *      Save inquiry data.
 321  *
 322  **/
 323 static void
 324 mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
 325                     struct scsi_device *sdev)
 326 {
 327
 328         /* Is LUN supported? If so, upper 2 bits will be 0
 329         * in first byte of inquiry data.
 330         */
 331         if (sdev->inq_periph_qual != 0)
 332                 return;
 333
 334         if (vtarget == NULL)
 335                 return;
 336
 337         vtarget->type = sdev->type;
 338
 339         if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
 340                 /* Treat all Processors as SAF-TE if
 341                  * command line option is set */
 342                 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
 343                 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
 344         }else if ((sdev->type == TYPE_PROCESSOR) &&
 345                 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
 346                 if (sdev->inquiry_len > 49 ) {
 347                         if (sdev->inquiry[44] == 'S' &&
 348                             sdev->inquiry[45] == 'A' &&
 349                             sdev->inquiry[46] == 'F' &&
 350                             sdev->inquiry[47] == '-' &&
 351                             sdev->inquiry[48] == 'T' &&
 352                             sdev->inquiry[49] == 'E' ) {
 353                                 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
 354                                 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
 355                         }
 356                 }
 357         }
 358         mptspi_setTargetNegoParms(hd, vtarget, sdev);
 359 }
 360
 361 /**
 362  *      mptspi_is_raid - Determines whether target is belonging to volume
 363  *      @hd: Pointer to a SCSI HOST structure
 364  *      @id: target device id
 365  *
 366  *      Return:
 367  *              non-zero = true
 368  *              zero = false
 369  *
 370  */
 371 static int
 372 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
 373 {
 374         int i, rc = 0;
 375
 376         if (!hd->ioc->raid_data.pIocPg2)
 377                 goto out;
 378
 379         if (!hd->ioc->raid_data.pIocPg2->NumActiveVolumes)
 380                 goto out;
 381         for (i=0; i < hd->ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
 382                 if (hd->ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
 383                         rc = 1;
 384                         goto out;
 385                 }
 386         }
 387
 388  out:
 389         return rc;
 390 }
 391
 392 static int mptspi_target_alloc(struct scsi_target *starget)
 393 {
 394         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 395         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
 396         VirtTarget              *vtarget;
 397
 398         if (hd == NULL)
 399                 return -ENODEV;
 400
 401         vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
 402         if (!vtarget)
 403                 return -ENOMEM;
 404
 405         vtarget->ioc_id = hd->ioc->id;
 406         vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
 407         vtarget->id = (u8)starget->id;
 408         vtarget->channel = (u8)starget->channel;
 409         vtarget->starget = starget;
 410         starget->hostdata = vtarget;
 411
 412         if (starget->channel == 1) {
 413                 if (mptscsih_is_phys_disk(hd->ioc, 0, starget->id) == 0)
 414                         return 0;
 415                 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
 416                 /* The real channel for this device is zero */
 417                 vtarget->channel = 0;
 418                 /* The actual physdisknum (for RAID passthrough) */
 419                 vtarget->id = mptscsih_raid_id_to_num(hd->ioc, 0,
 420                     starget->id);
 421         }
 422
 423         if (starget->channel == 0 &&
 424             mptspi_is_raid(hd, starget->id)) {
 425                 vtarget->raidVolume = 1;
 426                 ddvprintk((KERN_INFO
 427                     "RAID Volume @ channel=%d id=%d\n", starget->channel,
 428                     starget->id));
 429         }
 430
 431         if (hd->ioc->spi_data.nvram &&
 432             hd->ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
 433                 u32 nvram = hd->ioc->spi_data.nvram[starget->id];
 434                 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
 435                 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
 436         } else {
 437                 spi_min_period(starget) = hd->ioc->spi_data.minSyncFactor;
 438                 spi_max_width(starget) = hd->ioc->spi_data.maxBusWidth;
 439         }
 440         spi_max_offset(starget) = hd->ioc->spi_data.maxSyncOffset;
 441
 442         spi_offset(starget) = 0;
 443         mptspi_write_width(starget, 0);
 444
 445         return 0;
 446 }
 447
 448 static void
 449 mptspi_target_destroy(struct scsi_target *starget)
 450 {
 451         if (starget->hostdata)
 452                 kfree(starget->hostdata);
 453         starget->hostdata = NULL;
 454 }
 455
 456 /**
 457  *      mptspi_print_write_nego - negotiation parameters debug info that is being sent
 458  *      @hd: Pointer to a SCSI HOST structure
 459  *      @starget: SCSI target
 460  *      @ii: negotiation parameters
 461  *
 462  */
 463 static void
 464 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
 465 {
 466         ddvprintk((MYIOC_s_INFO_FMT "id=%d Requested = 0x%08x"
 467             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
 468             hd->ioc->name, starget->id, ii,
 469             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
 470             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
 471             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
 472             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
 473             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
 474             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
 475             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
 476             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
 477             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
 478             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
 479 }
 480
 481 /**
 482  *      mptspi_print_read_nego - negotiation parameters debug info that is being read
 483  *      @hd: Pointer to a SCSI HOST structure
 484  *      @starget: SCSI target
 485  *      @ii: negotiation parameters
 486  *
 487  */
 488 static void
 489 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
 490 {
 491         ddvprintk((MYIOC_s_INFO_FMT "id=%d Read = 0x%08x"
 492             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
 493             hd->ioc->name, starget->id, ii,
 494             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
 495             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
 496             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
 497             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
 498             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
 499             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
 500             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
 501             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
 502             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
 503             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
 504 }
 505
 506 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
 507                              struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
 508 {
 509         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 510         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
 511         struct _MPT_ADAPTER *ioc = hd->ioc;
 512         struct _CONFIG_PAGE_SCSI_DEVICE_0 *pg0;
 513         dma_addr_t pg0_dma;
 514         int size;
 515         struct _x_config_parms cfg;
 516         struct _CONFIG_PAGE_HEADER hdr;
 517         int err = -EBUSY;
 518
 519         /* No SPI parameters for RAID devices */
 520         if (starget->channel == 0 &&
 521             mptspi_is_raid(hd, starget->id))
 522                 return -1;
 523
 524         size = ioc->spi_data.sdp0length * 4;
 525         /*
 526         if (ioc->spi_data.sdp0length & 1)
 527                 size += size + 4;
 528         size += 2048;
 529         */
 530
 531         pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg0_dma, GFP_KERNEL);
 532         if (pg0 == NULL) {
 533                 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
 534                 return -EINVAL;
 535         }
 536
 537         memset(&hdr, 0, sizeof(hdr));
 538
 539         hdr.PageVersion = ioc->spi_data.sdp0version;
 540         hdr.PageLength = ioc->spi_data.sdp0length;
 541         hdr.PageNumber = 0;
 542         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 543
 544         memset(&cfg, 0, sizeof(cfg));
 545
 546         cfg.cfghdr.hdr = &hdr;
 547         cfg.physAddr = pg0_dma;
 548         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 549         cfg.dir = 0;
 550         cfg.pageAddr = starget->id;
 551
 552         if (mpt_config(ioc, &cfg)) {
 553                 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
 554                 goto out_free;
 555         }
 556         err = 0;
 557         memcpy(pass_pg0, pg0, size);
 558
 559         mptspi_print_read_nego(hd, starget, le32_to_cpu(pg0->NegotiatedParameters));
 560
 561  out_free:
 562         dma_free_coherent(&ioc->pcidev->dev, size, pg0, pg0_dma);
 563         return err;
 564 }
 565
 566 static u32 mptspi_getRP(struct scsi_target *starget)
 567 {
 568         u32 nego = 0;
 569
 570         nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
 571         nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
 572         nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
 573         nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
 574         nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
 575         nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
 576         nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
 577         nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
 578
 579         nego |= (spi_period(starget) <<  MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
 580         nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
 581         nego |= spi_width(starget) ?  MPI_SCSIDEVPAGE1_RP_WIDE : 0;
 582
 583         return nego;
 584 }
 585
 586 static void mptspi_read_parameters(struct scsi_target *starget)
 587 {
 588         int nego;
 589         struct _CONFIG_PAGE_SCSI_DEVICE_0 pg0;
 590
 591         mptspi_read_spi_device_pg0(starget, &pg0);
 592
 593         nego = le32_to_cpu(pg0.NegotiatedParameters);
 594
 595         spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
 596         spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
 597         spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
 598         spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
 599         spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
 600         spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
 601         spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
 602         spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
 603         spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
 604         spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
 605         spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
 606 }
 607
 608 static int
 609 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
 610 {
 611         MpiRaidActionRequest_t  *pReq;
 612         MPT_FRAME_HDR           *mf;
 613
 614         /* Get and Populate a free Frame
 615          */
 616         if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
 617                 ddvprintk((MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
 618                                         hd->ioc->name));
 619                 return -EAGAIN;
 620         }
 621         pReq = (MpiRaidActionRequest_t *)mf;
 622         if (quiesce)
 623                 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
 624         else
 625                 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
 626         pReq->Reserved1 = 0;
 627         pReq->ChainOffset = 0;
 628         pReq->Function = MPI_FUNCTION_RAID_ACTION;
 629         pReq->VolumeID = id;
 630         pReq->VolumeBus = channel;
 631         pReq->PhysDiskNum = 0;
 632         pReq->MsgFlags = 0;
 633         pReq->Reserved2 = 0;
 634         pReq->ActionDataWord = 0; /* Reserved for this action */
 635
 636         mpt_add_sge((char *)&pReq->ActionDataSGE,
 637                 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
 638
 639         ddvprintk((MYIOC_s_INFO_FMT "RAID Volume action=%x channel=%d id=%d\n",
 640                         hd->ioc->name, pReq->Action, channel, id));
 641
 642         hd->pLocal = NULL;
 643         hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
 644         hd->scandv_wait_done = 0;
 645
 646         /* Save cmd pointer, for resource free if timeout or
 647          * FW reload occurs
 648          */
 649         hd->cmdPtr = mf;
 650
 651         add_timer(&hd->timer);
 652         mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
 653         wait_event(hd->scandv_waitq, hd->scandv_wait_done);
 654
 655         if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
 656                 return -1;
 657
 658         return 0;
 659 }
 660
 661 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
 662                              struct scsi_device *sdev)
 663 {
 664         VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 665
 666         /* no DV on RAID devices */
 667         if (sdev->channel == 0 &&
 668             mptspi_is_raid(hd, sdev->id))
 669                 return;
 670
 671         /* If this is a piece of a RAID, then quiesce first */
 672         if (sdev->channel == 1 &&
 673             mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
 674                 starget_printk(KERN_ERR, scsi_target(sdev),
 675                                "Integrated RAID quiesce failed\n");
 676                 return;
 677         }
 678
 679         hd->spi_pending |= (1 << sdev->id);
 680         spi_dv_device(sdev);
 681         hd->spi_pending &= ~(1 << sdev->id);
 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         struct scsi_target *starget;
1208         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1209         u32 nego;
1210
1211         kfree(wqw);
1212
1213         if (hd->spi_pending) {
1214                 shost_for_each_device(sdev, hd->ioc->sh) {
1215                         if  (hd->spi_pending & (1 << sdev->id))
1216                                 continue;
1217                         starget = scsi_target(sdev);
1218                         nego = mptspi_getRP(starget);
1219                         pg1.RequestedParameters = cpu_to_le32(nego);
1220                         pg1.Reserved = 0;
1221                         pg1.Configuration = 0;
1222                         mptspi_write_spi_device_pg1(starget, &pg1);
1223                 }
1224         } else {
1225                 shost_for_each_device(sdev, hd->ioc->sh)
1226                         mptspi_dv_device(hd, sdev);
1227         }
1228 }
1229
1230 static void
1231 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1232 {
1233         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1234
1235         if (!wqw)
1236                 return;
1237
1238         INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1239         wqw->hd = hd;
1240
1241         schedule_work(&wqw->work);
1242 }
1243
1244 /*
1245  * spi module reset handler
1246  */
1247 static int
1248 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1249 {
1250         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1251         int rc;
1252
1253         rc = mptscsih_ioc_reset(ioc, reset_phase);
1254
1255         if (reset_phase == MPT_IOC_POST_RESET)
1256                 mptspi_dv_renegotiate(hd);
1257
1258         return rc;
1259 }
1260
1261 #ifdef CONFIG_PM
1262 /*
1263  * spi module resume handler
1264  */
1265 static int
1266 mptspi_resume(struct pci_dev *pdev)
1267 {
1268         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1269         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1270         int rc;
1271
1272         rc = mptscsih_resume(pdev);
1273         mptspi_dv_renegotiate(hd);
1274
1275         return rc;
1276 }
1277 #endif
1278
1279 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1280 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1281 /*
1282  *      mptspi_probe - Installs scsi devices per bus.
1283  *      @pdev: Pointer to pci_dev structure
1284  *
1285  *      Returns 0 for success, non-zero for failure.
1286  *
1287  */
1288 static int
1289 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1290 {
1291         struct Scsi_Host        *sh;
1292         MPT_SCSI_HOST           *hd;
1293         MPT_ADAPTER             *ioc;
1294         unsigned long            flags;
1295         int                      ii;
1296         int                      numSGE = 0;
1297         int                      scale;
1298         int                      ioc_cap;
1299         int                     error=0;
1300         int                     r;
1301
1302         if ((r = mpt_attach(pdev,id)) != 0)
1303                 return r;
1304
1305         ioc = pci_get_drvdata(pdev);
1306         ioc->DoneCtx = mptspiDoneCtx;
1307         ioc->TaskCtx = mptspiTaskCtx;
1308         ioc->InternalCtx = mptspiInternalCtx;
1309
1310         /*  Added sanity check on readiness of the MPT adapter.
1311          */
1312         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1313                 printk(MYIOC_s_WARN_FMT
1314                   "Skipping because it's not operational!\n",
1315                   ioc->name);
1316                 error = -ENODEV;
1317                 goto out_mptspi_probe;
1318         }
1319
1320         if (!ioc->active) {
1321                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1322                   ioc->name);
1323                 error = -ENODEV;
1324                 goto out_mptspi_probe;
1325         }
1326
1327         /*  Sanity check - ensure at least 1 port is INITIATOR capable
1328          */
1329         ioc_cap = 0;
1330         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1331                 if (ioc->pfacts[ii].ProtocolFlags &
1332                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
1333                         ioc_cap ++;
1334         }
1335
1336         if (!ioc_cap) {
1337                 printk(MYIOC_s_WARN_FMT
1338                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1339                         ioc->name, ioc);
1340                 return 0;
1341         }
1342
1343         sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1344
1345         if (!sh) {
1346                 printk(MYIOC_s_WARN_FMT
1347                         "Unable to register controller with SCSI subsystem\n",
1348                         ioc->name);
1349                 error = -1;
1350                 goto out_mptspi_probe;
1351         }
1352
1353         spin_lock_irqsave(&ioc->FreeQlock, flags);
1354
1355         /* Attach the SCSI Host to the IOC structure
1356          */
1357         ioc->sh = sh;
1358
1359         sh->io_port = 0;
1360         sh->n_io_port = 0;
1361         sh->irq = 0;
1362
1363         /* set 16 byte cdb's */
1364         sh->max_cmd_len = 16;
1365
1366         /* Yikes!  This is important!
1367          * Otherwise, by default, linux
1368          * only scans target IDs 0-7!
1369          * pfactsN->MaxDevices unreliable
1370          * (not supported in early
1371          *      versions of the FW).
1372          * max_id = 1 + actual max id,
1373          * max_lun = 1 + actual last lun,
1374          *      see hosts.h :o(
1375          */
1376         sh->max_id = ioc->devices_per_bus;
1377
1378         sh->max_lun = MPT_LAST_LUN + 1;
1379         /*
1380          * If RAID Firmware Detected, setup virtual channel
1381          */
1382         if (ioc->ir_firmware)
1383                 sh->max_channel = 1;
1384         else
1385                 sh->max_channel = 0;
1386         sh->this_id = ioc->pfacts[0].PortSCSIID;
1387
1388         /* Required entry.
1389          */
1390         sh->unique_id = ioc->id;
1391
1392         /* Verify that we won't exceed the maximum
1393          * number of chain buffers
1394          * We can optimize:  ZZ = req_sz/sizeof(SGE)
1395          * For 32bit SGE's:
1396          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1397          *               + (req_sz - 64)/sizeof(SGE)
1398          * A slightly different algorithm is required for
1399          * 64bit SGEs.
1400          */
1401         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1402         if (sizeof(dma_addr_t) == sizeof(u64)) {
1403                 numSGE = (scale - 1) *
1404                   (ioc->facts.MaxChainDepth-1) + scale +
1405                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1406                   sizeof(u32));
1407         } else {
1408                 numSGE = 1 + (scale - 1) *
1409                   (ioc->facts.MaxChainDepth-1) + scale +
1410                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1411                   sizeof(u32));
1412         }
1413
1414         if (numSGE < sh->sg_tablesize) {
1415                 /* Reset this value */
1416                 dprintk((MYIOC_s_INFO_FMT
1417                   "Resetting sg_tablesize to %d from %d\n",
1418                   ioc->name, numSGE, sh->sg_tablesize));
1419                 sh->sg_tablesize = numSGE;
1420         }
1421
1422         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1423
1424         hd = (MPT_SCSI_HOST *) sh->hostdata;
1425         hd->ioc = ioc;
1426
1427         /* SCSI needs scsi_cmnd lookup table!
1428          * (with size equal to req_depth*PtrSz!)
1429          */
1430         hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1431         if (!hd->ScsiLookup) {
1432                 error = -ENOMEM;
1433                 goto out_mptspi_probe;
1434         }
1435
1436         dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
1437                  ioc->name, hd->ScsiLookup));
1438
1439         /* Clear the TM flags
1440          */
1441         hd->tmPending = 0;
1442         hd->tmState = TM_STATE_NONE;
1443         hd->resetPending = 0;
1444         hd->abortSCpnt = NULL;
1445
1446         /* Clear the pointer used to store
1447          * single-threaded commands, i.e., those
1448          * issued during a bus scan, dv and
1449          * configuration pages.
1450          */
1451         hd->cmdPtr = NULL;
1452
1453         /* Initialize this SCSI Hosts' timers
1454          * To use, set the timer expires field
1455          * and add_timer
1456          */
1457         init_timer(&hd->timer);
1458         hd->timer.data = (unsigned long) hd;
1459         hd->timer.function = mptscsih_timer_expired;
1460
1461         ioc->spi_data.Saf_Te = mpt_saf_te;
1462
1463         hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1464         ddvprintk((MYIOC_s_INFO_FMT
1465                 "saf_te %x\n",
1466                 ioc->name,
1467                 mpt_saf_te));
1468         ioc->spi_data.noQas = 0;
1469
1470         init_waitqueue_head(&hd->scandv_waitq);
1471         hd->scandv_wait_done = 0;
1472         hd->last_queue_full = 0;
1473         hd->spi_pending = 0;
1474
1475         /* Some versions of the firmware don't support page 0; without
1476          * that we can't get the parameters */
1477         if (hd->ioc->spi_data.sdp0length != 0)
1478                 sh->transportt = mptspi_transport_template;
1479
1480         error = scsi_add_host (sh, &ioc->pcidev->dev);
1481         if(error) {
1482                 dprintk((KERN_ERR MYNAM
1483                   "scsi_add_host failed\n"));
1484                 goto out_mptspi_probe;
1485         }
1486
1487         /*
1488          * issue internal bus reset
1489          */
1490         if (ioc->spi_data.bus_reset)
1491                 mptscsih_TMHandler(hd,
1492                     MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1493                     0, 0, 0, 0, 5);
1494
1495         scsi_scan_host(sh);
1496         return 0;
1497
1498 out_mptspi_probe:
1499
1500         mptscsih_remove(pdev);
1501         return error;
1502 }
1503
1504 static struct pci_driver mptspi_driver = {
1505         .name           = "mptspi",
1506         .id_table       = mptspi_pci_table,
1507         .probe          = mptspi_probe,
1508         .remove         = __devexit_p(mptscsih_remove),
1509         .shutdown       = mptscsih_shutdown,
1510 #ifdef CONFIG_PM
1511         .suspend        = mptscsih_suspend,
1512         .resume         = mptspi_resume,
1513 #endif
1514 };
1515
1516 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1517 /**
1518  *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1519  *
1520  *      Returns 0 for success, non-zero for failure.
1521  */
1522 static int __init
1523 mptspi_init(void)
1524 {
1525         show_mptmod_ver(my_NAME, my_VERSION);
1526
1527         mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1528         if (!mptspi_transport_template)
1529                 return -ENODEV;
1530
1531         mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1532         mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1533         mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1534
1535         if (mpt_event_register(mptspiDoneCtx, mptspi_event_process) == 0) {
1536                 devtverboseprintk((KERN_INFO MYNAM
1537                   ": Registered for IOC event notifications\n"));
1538         }
1539
1540         if (mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset) == 0) {
1541                 dprintk((KERN_INFO MYNAM
1542                   ": Registered for IOC reset notifications\n"));
1543         }
1544
1545         return pci_register_driver(&mptspi_driver);
1546 }
1547
1548 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1549 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1550 /**
1551  *      mptspi_exit - Unregisters MPT adapter(s)
1552  */
1553 static void __exit
1554 mptspi_exit(void)
1555 {
1556         pci_unregister_driver(&mptspi_driver);
1557
1558         mpt_reset_deregister(mptspiDoneCtx);
1559         dprintk((KERN_INFO MYNAM
1560           ": Deregistered for IOC reset notifications\n"));
1561
1562         mpt_event_deregister(mptspiDoneCtx);
1563         dprintk((KERN_INFO MYNAM
1564           ": Deregistered for IOC event notifications\n"));
1565
1566         mpt_deregister(mptspiInternalCtx);
1567         mpt_deregister(mptspiTaskCtx);
1568         mpt_deregister(mptspiDoneCtx);
1569         spi_release_transport(mptspi_transport_template);
1570 }
1571
1572 module_init(mptspi_init);
1573 module_exit(mptspi_exit);