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