git.oblomov.eu Git - linux-2.6/blob - drivers/message/fusion/mptspi.c

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