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

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