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        u32                      flagsLength;
 262        int                      ii;
 263
 264        /* Get a MF for this command.
 265         */
 266        if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
 267                dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
 268                                "writeIOCPage4 : no msg frames!\n",ioc->name));
 269                return -EAGAIN;
 270        }
 271
 272        /* Set the request and the data pointers.
 273         * Place data at end of MF.
 274         */
 275        pReq = (Config_t *)mf;
 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        ioc->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 **/
 327static void
 328mptspi_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 */
 375static int
 376mptspi_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
 397static 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        spi_period(starget) = 0xFF;
 451        mptspi_write_width(starget, 0);
 452
 453        return 0;
 454}
 455
 456static void
 457mptspi_target_destroy(struct scsi_target *starget)
 458{
 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 */
 470static void
 471mptspi_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 */
 495static void
 496mptspi_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
 513static 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        cfg.timeout = 60;
 560
 561        if (mpt_config(ioc, &cfg)) {
 562                starget_printk(KERN_ERR, starget, MYIOC_s_FMT "mpt_config failed\n", ioc->name);
 563                goto out_free;
 564        }
 565        err = 0;
 566        memcpy(pass_pg0, spi_dev_pg0, size);
 567
 568        mptspi_print_read_nego(hd, starget, le32_to_cpu(spi_dev_pg0->NegotiatedParameters));
 569
 570 out_free:
 571        dma_free_coherent(&ioc->pcidev->dev, size, spi_dev_pg0, spi_dev_pg0_dma);
 572        return err;
 573}
 574
 575static u32 mptspi_getRP(struct scsi_target *starget)
 576{
 577        u32 nego = 0;
 578
 579        nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
 580        nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
 581        nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
 582        nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
 583        nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
 584        nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
 585        nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
 586        nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
 587
 588        nego |= (spi_period(starget) <<  MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
 589        nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
 590        nego |= spi_width(starget) ?  MPI_SCSIDEVPAGE1_RP_WIDE : 0;
 591
 592        return nego;
 593}
 594
 595static void mptspi_read_parameters(struct scsi_target *starget)
 596{
 597        int nego;
 598        struct _CONFIG_PAGE_SCSI_DEVICE_0 spi_dev_pg0;
 599
 600        mptspi_read_spi_device_pg0(starget, &spi_dev_pg0);
 601
 602        nego = le32_to_cpu(spi_dev_pg0.NegotiatedParameters);
 603
 604        spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
 605        spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
 606        spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
 607        spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
 608        spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
 609        spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
 610        spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
 611        spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
 612        spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
 613        spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
 614        spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
 615}
 616
 617static int
 618mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
 619{
 620        MPT_ADAPTER     *ioc = hd->ioc;
 621        MpiRaidActionRequest_t  *pReq;
 622        MPT_FRAME_HDR           *mf;
 623        int                     ret;
 624        unsigned long           timeleft;
 625
 626        mutex_lock(&ioc->internal_cmds.mutex);
 627
 628        /* Get and Populate a free Frame
 629         */
 630        if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
 631                dfailprintk(hd->ioc, printk(MYIOC_s_WARN_FMT
 632                        "%s: no msg frames!\n", ioc->name, __func__));
 633                ret = -EAGAIN;
 634                goto out;
 635        }
 636        pReq = (MpiRaidActionRequest_t *)mf;
 637        if (quiesce)
 638                pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
 639        else
 640                pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
 641        pReq->Reserved1 = 0;
 642        pReq->ChainOffset = 0;
 643        pReq->Function = MPI_FUNCTION_RAID_ACTION;
 644        pReq->VolumeID = id;
 645        pReq->VolumeBus = channel;
 646        pReq->PhysDiskNum = 0;
 647        pReq->MsgFlags = 0;
 648        pReq->Reserved2 = 0;
 649        pReq->ActionDataWord = 0; /* Reserved for this action */
 650
 651        ioc->add_sge((char *)&pReq->ActionDataSGE,
 652                MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
 653
 654        ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
 655                        ioc->name, pReq->Action, channel, id));
 656
 657        INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
 658        mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
 659        timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done, 10*HZ);
 660        if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
 661                ret = -ETIME;
 662                dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: TIMED OUT!\n",
 663                    ioc->name, __func__));
 664                if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
 665                        goto out;
 666                if (!timeleft) {
 667                        printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
 668                            ioc->name, __func__);
 669                        mpt_HardResetHandler(ioc, CAN_SLEEP);
 670                        mpt_free_msg_frame(ioc, mf);
 671                }
 672                goto out;
 673        }
 674
 675        ret = ioc->internal_cmds.completion_code;
 676
 677 out:
 678        CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
 679        mutex_unlock(&ioc->internal_cmds.mutex);
 680        return ret;
 681}
 682
 683static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
 684                             struct scsi_device *sdev)
 685{
 686        VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 687        MPT_ADAPTER *ioc = hd->ioc;
 688
 689        /* no DV on RAID devices */
 690        if (sdev->channel == 0 &&
 691            mptspi_is_raid(hd, sdev->id))
 692                return;
 693
 694        /* If this is a piece of a RAID, then quiesce first */
 695        if (sdev->channel == 1 &&
 696            mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
 697                starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
 698                    "Integrated RAID quiesce failed\n", ioc->name);
 699                return;
 700        }
 701
 702        hd->spi_pending |= (1 << sdev->id);
 703        spi_dv_device(sdev);
 704        hd->spi_pending &= ~(1 << sdev->id);
 705
 706        if (sdev->channel == 1 &&
 707            mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
 708                starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
 709                    "Integrated RAID resume failed\n", ioc->name);
 710
 711        mptspi_read_parameters(sdev->sdev_target);
 712        spi_display_xfer_agreement(sdev->sdev_target);
 713        mptspi_read_parameters(sdev->sdev_target);
 714}
 715
 716static int mptspi_slave_alloc(struct scsi_device *sdev)
 717{
 718        MPT_SCSI_HOST *hd = shost_priv(sdev->host);
 719        VirtTarget              *vtarget;
 720        VirtDevice              *vdevice;
 721        struct scsi_target      *starget;
 722        MPT_ADAPTER *ioc = hd->ioc;
 723
 724        if (sdev->channel == 1 &&
 725                mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0)
 726                        return -ENXIO;
 727
 728        vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
 729        if (!vdevice) {
 730                printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
 731                                ioc->name, sizeof(VirtDevice));
 732                return -ENOMEM;
 733        }
 734
 735        vdevice->lun = sdev->lun;
 736        sdev->hostdata = vdevice;
 737
 738        starget = scsi_target(sdev);
 739        vtarget = starget->hostdata;
 740        vdevice->vtarget = vtarget;
 741        vtarget->num_luns++;
 742
 743        if (sdev->channel == 1)
 744                sdev->no_uld_attach = 1;
 745
 746        return 0;
 747}
 748
 749static int mptspi_slave_configure(struct scsi_device *sdev)
 750{
 751        struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
 752        VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 753        int ret;
 754
 755        mptspi_initTarget(hd, vtarget, sdev);
 756
 757        ret = mptscsih_slave_configure(sdev);
 758
 759        if (ret)
 760                return ret;
 761
 762        ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
 763                " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
 764                sdev->id, spi_min_period(scsi_target(sdev)),
 765                spi_max_offset(scsi_target(sdev)),
 766                spi_max_width(scsi_target(sdev))));
 767
 768        if ((sdev->channel == 1 ||
 769             !(mptspi_is_raid(hd, sdev->id))) &&
 770            !spi_initial_dv(sdev->sdev_target))
 771                mptspi_dv_device(hd, sdev);
 772
 773        return 0;
 774}
 775
 776static int
 777mptspi_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
 778{
 779        struct _MPT_SCSI_HOST *hd = shost_priv(shost);
 780        VirtDevice      *vdevice = SCpnt->device->hostdata;
 781        MPT_ADAPTER *ioc = hd->ioc;
 782
 783        if (!vdevice || !vdevice->vtarget) {
 784                SCpnt->result = DID_NO_CONNECT << 16;
 785                SCpnt->scsi_done(SCpnt);
 786                return 0;
 787        }
 788
 789        if (SCpnt->device->channel == 1 &&
 790                mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) {
 791                SCpnt->result = DID_NO_CONNECT << 16;
 792                SCpnt->scsi_done(SCpnt);
 793                return 0;
 794        }
 795
 796        if (spi_dv_pending(scsi_target(SCpnt->device)))
 797                ddvprintk(ioc, scsi_print_command(SCpnt));
 798
 799        return mptscsih_qcmd(SCpnt);
 800}
 801
 802static void mptspi_slave_destroy(struct scsi_device *sdev)
 803{
 804        struct scsi_target *starget = scsi_target(sdev);
 805        VirtTarget *vtarget = starget->hostdata;
 806        VirtDevice *vdevice = sdev->hostdata;
 807
 808        /* Will this be the last lun on a non-raid device? */
 809        if (vtarget->num_luns == 1 && vdevice->configured_lun) {
 810                struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 811
 812                /* Async Narrow */
 813                pg1.RequestedParameters = 0;
 814                pg1.Reserved = 0;
 815                pg1.Configuration = 0;
 816
 817                mptspi_write_spi_device_pg1(starget, &pg1);
 818        }
 819
 820        mptscsih_slave_destroy(sdev);
 821}
 822
 823static struct scsi_host_template mptspi_driver_template = {
 824        .module                         = THIS_MODULE,
 825        .proc_name                      = "mptspi",
 826        .show_info                      = mptscsih_show_info,
 827        .name                           = "MPT SPI Host",
 828        .info                           = mptscsih_info,
 829        .queuecommand                   = mptspi_qcmd,
 830        .target_alloc                   = mptspi_target_alloc,
 831        .slave_alloc                    = mptspi_slave_alloc,
 832        .slave_configure                = mptspi_slave_configure,
 833        .target_destroy                 = mptspi_target_destroy,
 834        .slave_destroy                  = mptspi_slave_destroy,
 835        .change_queue_depth             = mptscsih_change_queue_depth,
 836        .eh_abort_handler               = mptscsih_abort,
 837        .eh_device_reset_handler        = mptscsih_dev_reset,
 838        .eh_bus_reset_handler           = mptscsih_bus_reset,
 839        .eh_host_reset_handler          = mptscsih_host_reset,
 840        .bios_param                     = mptscsih_bios_param,
 841        .can_queue                      = MPT_SCSI_CAN_QUEUE,
 842        .this_id                        = -1,
 843        .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
 844        .max_sectors                    = 8192,
 845        .cmd_per_lun                    = 7,
 846        .shost_attrs                    = mptscsih_host_attrs,
 847};
 848
 849static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
 850                               struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
 851{
 852        struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 853        struct _MPT_SCSI_HOST *hd = shost_priv(shost);
 854        struct _MPT_ADAPTER *ioc = hd->ioc;
 855        struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
 856        dma_addr_t pg1_dma;
 857        int size;
 858        struct _x_config_parms cfg;
 859        struct _CONFIG_PAGE_HEADER hdr;
 860        int err = -EBUSY;
 861        u32 nego_parms;
 862        u32 period;
 863        struct scsi_device *sdev;
 864        int i;
 865
 866        /* don't allow updating nego parameters on RAID devices */
 867        if (starget->channel == 0 &&
 868            mptspi_is_raid(hd, starget->id))
 869                return -1;
 870
 871        size = ioc->spi_data.sdp1length * 4;
 872
 873        pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
 874        if (pg1 == NULL) {
 875                starget_printk(KERN_ERR, starget, MYIOC_s_FMT
 876                    "dma_alloc_coherent for parameters failed\n", ioc->name);
 877                return -EINVAL;
 878        }
 879
 880        memset(&hdr, 0, sizeof(hdr));
 881
 882        hdr.PageVersion = ioc->spi_data.sdp1version;
 883        hdr.PageLength = ioc->spi_data.sdp1length;
 884        hdr.PageNumber = 1;
 885        hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 886
 887        memset(&cfg, 0, sizeof(cfg));
 888
 889        cfg.cfghdr.hdr = &hdr;
 890        cfg.physAddr = pg1_dma;
 891        cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 892        cfg.dir = 1;
 893        cfg.pageAddr = starget->id;
 894
 895        memcpy(pg1, pass_pg1, size);
 896
 897        pg1->Header.PageVersion = hdr.PageVersion;
 898        pg1->Header.PageLength = hdr.PageLength;
 899        pg1->Header.PageNumber = hdr.PageNumber;
 900        pg1->Header.PageType = hdr.PageType;
 901
 902        nego_parms = le32_to_cpu(pg1->RequestedParameters);
 903        period = (nego_parms & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK) >>
 904                MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD;
 905        if (period == 8) {
 906                /* Turn on inline data padding for TAPE when running U320 */
 907                for (i = 0 ; i < 16; i++) {
 908                        sdev = scsi_device_lookup_by_target(starget, i);
 909                        if (sdev && sdev->type == TYPE_TAPE) {
 910                                sdev_printk(KERN_DEBUG, sdev, MYIOC_s_FMT
 911                                            "IDP:ON\n", ioc->name);
 912                                nego_parms |= MPI_SCSIDEVPAGE1_RP_IDP;
 913                                pg1->RequestedParameters =
 914                                    cpu_to_le32(nego_parms);
 915                                break;
 916                        }
 917                }
 918        }
 919
 920        mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
 921
 922        if (mpt_config(ioc, &cfg)) {
 923                starget_printk(KERN_ERR, starget, MYIOC_s_FMT
 924                    "mpt_config failed\n", ioc->name);
 925                goto out_free;
 926        }
 927        err = 0;
 928
 929 out_free:
 930        dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
 931        return err;
 932}
 933
 934static void mptspi_write_offset(struct scsi_target *starget, int offset)
 935{
 936        struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 937        u32 nego;
 938
 939        if (offset < 0)
 940                offset = 0;
 941
 942        if (offset > 255)
 943                offset = 255;
 944
 945        if (spi_offset(starget) == -1)
 946                mptspi_read_parameters(starget);
 947
 948        spi_offset(starget) = offset;
 949
 950        nego = mptspi_getRP(starget);
 951
 952        pg1.RequestedParameters = cpu_to_le32(nego);
 953        pg1.Reserved = 0;
 954        pg1.Configuration = 0;
 955
 956        mptspi_write_spi_device_pg1(starget, &pg1);
 957}
 958
 959static void mptspi_write_period(struct scsi_target *starget, int period)
 960{
 961        struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 962        u32 nego;
 963
 964        if (period < 8)
 965                period = 8;
 966
 967        if (period > 255)
 968                period = 255;
 969
 970        if (spi_period(starget) == -1)
 971                mptspi_read_parameters(starget);
 972
 973        if (period == 8) {
 974                spi_iu(starget) = 1;
 975                spi_dt(starget) = 1;
 976        } else if (period == 9) {
 977                spi_dt(starget) = 1;
 978        }
 979
 980        spi_period(starget) = period;
 981
 982        nego = mptspi_getRP(starget);
 983
 984        pg1.RequestedParameters = cpu_to_le32(nego);
 985        pg1.Reserved = 0;
 986        pg1.Configuration = 0;
 987
 988        mptspi_write_spi_device_pg1(starget, &pg1);
 989}
 990
 991static void mptspi_write_dt(struct scsi_target *starget, int dt)
 992{
 993        struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 994        u32 nego;
 995
 996        if (spi_period(starget) == -1)
 997                mptspi_read_parameters(starget);
 998
 999        if (!dt && spi_period(starget) < 10)
1000                spi_period(starget) = 10;
1001
1002        spi_dt(starget) = dt;
1003
1004        nego = mptspi_getRP(starget);
1005
1006
1007        pg1.RequestedParameters = cpu_to_le32(nego);
1008        pg1.Reserved = 0;
1009        pg1.Configuration = 0;
1010
1011        mptspi_write_spi_device_pg1(starget, &pg1);
1012}
1013
1014static void mptspi_write_iu(struct scsi_target *starget, int iu)
1015{
1016        struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1017        u32 nego;
1018
1019        if (spi_period(starget) == -1)
1020                mptspi_read_parameters(starget);
1021
1022        if (!iu && spi_period(starget) < 9)
1023                spi_period(starget) = 9;
1024
1025        spi_iu(starget) = iu;
1026
1027        nego = mptspi_getRP(starget);
1028
1029        pg1.RequestedParameters = cpu_to_le32(nego);
1030        pg1.Reserved = 0;
1031        pg1.Configuration = 0;
1032
1033        mptspi_write_spi_device_pg1(starget, &pg1);
1034}
1035
1036#define MPTSPI_SIMPLE_TRANSPORT_PARM(parm)                              \
1037static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1038{                                                                       \
1039        struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;                          \
1040        u32 nego;                                                       \
1041                                                                        \
1042        spi_##parm(starget) = parm;                                     \
1043                                                                        \
1044        nego = mptspi_getRP(starget);                                   \
1045                                                                        \
1046        pg1.RequestedParameters = cpu_to_le32(nego);                    \
1047        pg1.Reserved = 0;                                               \
1048        pg1.Configuration = 0;                                          \
1049                                                                        \
1050        mptspi_write_spi_device_pg1(starget, &pg1);                             \
1051}
1052
1053MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1054MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1055MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1056MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1057MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1058
1059static void mptspi_write_qas(struct scsi_target *starget, int qas)
1060{
1061        struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1062        struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1063        struct _MPT_SCSI_HOST *hd = shost_priv(shost);
1064        VirtTarget *vtarget = starget->hostdata;
1065        u32 nego;
1066
1067        if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1068            hd->ioc->spi_data.noQas)
1069                spi_qas(starget) = 0;
1070        else
1071                spi_qas(starget) = qas;
1072
1073        nego = mptspi_getRP(starget);
1074
1075        pg1.RequestedParameters = cpu_to_le32(nego);
1076        pg1.Reserved = 0;
1077        pg1.Configuration = 0;
1078
1079        mptspi_write_spi_device_pg1(starget, &pg1);
1080}
1081
1082static void mptspi_write_width(struct scsi_target *starget, int width)
1083{
1084        struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1085        u32 nego;
1086
1087        if (!width) {
1088                spi_dt(starget) = 0;
1089                if (spi_period(starget) < 10)
1090                        spi_period(starget) = 10;
1091        }
1092
1093        spi_width(starget) = width;
1094
1095        nego = mptspi_getRP(starget);
1096
1097        pg1.RequestedParameters = cpu_to_le32(nego);
1098        pg1.Reserved = 0;
1099        pg1.Configuration = 0;
1100
1101        mptspi_write_spi_device_pg1(starget, &pg1);
1102}
1103
1104struct work_queue_wrapper {
1105        struct work_struct      work;
1106        struct _MPT_SCSI_HOST   *hd;
1107        int                     disk;
1108};
1109
1110static void mpt_work_wrapper(struct work_struct *work)
1111{
1112        struct work_queue_wrapper *wqw =
1113                container_of(work, struct work_queue_wrapper, work);
1114        struct _MPT_SCSI_HOST *hd = wqw->hd;
1115        MPT_ADAPTER *ioc = hd->ioc;
1116        struct Scsi_Host *shost = ioc->sh;
1117        struct scsi_device *sdev;
1118        int disk = wqw->disk;
1119        struct _CONFIG_PAGE_IOC_3 *pg3;
1120
1121        kfree(wqw);
1122
1123        mpt_findImVolumes(ioc);
1124        pg3 = ioc->raid_data.pIocPg3;
1125        if (!pg3)
1126                return;
1127
1128        shost_for_each_device(sdev,shost) {
1129                struct scsi_target *starget = scsi_target(sdev);
1130                VirtTarget *vtarget = starget->hostdata;
1131
1132                /* only want to search RAID components */
1133                if (sdev->channel != 1)
1134                        continue;
1135
1136                /* The id is the raid PhysDiskNum, even if
1137                 * starget->id is the actual target address */
1138                if(vtarget->id != disk)
1139                        continue;
1140
1141                starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1142                    "Integrated RAID requests DV of new device\n", ioc->name);
1143                mptspi_dv_device(hd, sdev);
1144        }
1145        shost_printk(KERN_INFO, shost, MYIOC_s_FMT
1146            "Integrated RAID detects new device %d\n", ioc->name, disk);
1147        scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, SCSI_SCAN_RESCAN);
1148}
1149
1150
1151static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1152{
1153        struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1154        MPT_ADAPTER *ioc = hd->ioc;
1155
1156        if (!wqw) {
1157                shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
1158                    "Failed to act on RAID event for physical disk %d\n",
1159                    ioc->name, disk);
1160                return;
1161        }
1162        INIT_WORK(&wqw->work, mpt_work_wrapper);
1163        wqw->hd = hd;
1164        wqw->disk = disk;
1165
1166        schedule_work(&wqw->work);
1167}
1168
1169static int
1170mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1171{
1172        u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1173        struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1174
1175        if (ioc->bus_type != SPI)
1176                return 0;
1177
1178        if (hd && event ==  MPI_EVENT_INTEGRATED_RAID) {
1179                int reason
1180                        = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1181
1182                if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1183                        int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1184                        mpt_dv_raid(hd, disk);
1185                }
1186        }
1187        return mptscsih_event_process(ioc, pEvReply);
1188}
1189
1190static int
1191mptspi_deny_binding(struct scsi_target *starget)
1192{
1193        struct _MPT_SCSI_HOST *hd =
1194                (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1195        return ((mptspi_is_raid(hd, starget->id)) &&
1196                starget->channel == 0) ? 1 : 0;
1197}
1198
1199static struct spi_function_template mptspi_transport_functions = {
1200        .get_offset     = mptspi_read_parameters,
1201        .set_offset     = mptspi_write_offset,
1202        .show_offset    = 1,
1203        .get_period     = mptspi_read_parameters,
1204        .set_period     = mptspi_write_period,
1205        .show_period    = 1,
1206        .get_width      = mptspi_read_parameters,
1207        .set_width      = mptspi_write_width,
1208        .show_width     = 1,
1209        .get_iu         = mptspi_read_parameters,
1210        .set_iu         = mptspi_write_iu,
1211        .show_iu        = 1,
1212        .get_dt         = mptspi_read_parameters,
1213        .set_dt         = mptspi_write_dt,
1214        .show_dt        = 1,
1215        .get_qas        = mptspi_read_parameters,
1216        .set_qas        = mptspi_write_qas,
1217        .show_qas       = 1,
1218        .get_wr_flow    = mptspi_read_parameters,
1219        .set_wr_flow    = mptspi_write_wr_flow,
1220        .show_wr_flow   = 1,
1221        .get_rd_strm    = mptspi_read_parameters,
1222        .set_rd_strm    = mptspi_write_rd_strm,
1223        .show_rd_strm   = 1,
1224        .get_rti        = mptspi_read_parameters,
1225        .set_rti        = mptspi_write_rti,
1226        .show_rti       = 1,
1227        .get_pcomp_en   = mptspi_read_parameters,
1228        .set_pcomp_en   = mptspi_write_pcomp_en,
1229        .show_pcomp_en  = 1,
1230        .get_hold_mcs   = mptspi_read_parameters,
1231        .set_hold_mcs   = mptspi_write_hold_mcs,
1232        .show_hold_mcs  = 1,
1233        .deny_binding   = mptspi_deny_binding,
1234};
1235
1236/****************************************************************************
1237 * Supported hardware
1238 */
1239
1240static struct pci_device_id mptspi_pci_table[] = {
1241        { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1242                PCI_ANY_ID, PCI_ANY_ID },
1243        { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1244                PCI_ANY_ID, PCI_ANY_ID },
1245        { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1246                PCI_ANY_ID, PCI_ANY_ID },
1247        {0}     /* Terminating entry */
1248};
1249MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1250
1251
1252/*
1253 * renegotiate for a given target
1254 */
1255static void
1256mptspi_dv_renegotiate_work(struct work_struct *work)
1257{
1258        struct work_queue_wrapper *wqw =
1259                container_of(work, struct work_queue_wrapper, work);
1260        struct _MPT_SCSI_HOST *hd = wqw->hd;
1261        struct scsi_device *sdev;
1262        struct scsi_target *starget;
1263        struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1264        u32 nego;
1265        MPT_ADAPTER *ioc = hd->ioc;
1266
1267        kfree(wqw);
1268
1269        if (hd->spi_pending) {
1270                shost_for_each_device(sdev, ioc->sh) {
1271                        if  (hd->spi_pending & (1 << sdev->id))
1272                                continue;
1273                        starget = scsi_target(sdev);
1274                        nego = mptspi_getRP(starget);
1275                        pg1.RequestedParameters = cpu_to_le32(nego);
1276                        pg1.Reserved = 0;
1277                        pg1.Configuration = 0;
1278                        mptspi_write_spi_device_pg1(starget, &pg1);
1279                }
1280        } else {
1281                shost_for_each_device(sdev, ioc->sh)
1282                        mptspi_dv_device(hd, sdev);
1283        }
1284}
1285
1286static void
1287mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1288{
1289        struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1290
1291        if (!wqw)
1292                return;
1293
1294        INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1295        wqw->hd = hd;
1296
1297        schedule_work(&wqw->work);
1298}
1299
1300/*
1301 * spi module reset handler
1302 */
1303static int
1304mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1305{
1306        int rc;
1307
1308        rc = mptscsih_ioc_reset(ioc, reset_phase);
1309        if ((ioc->bus_type != SPI) || (!rc))
1310                return rc;
1311
1312        /* only try to do a renegotiation if we're properly set up
1313         * if we get an ioc fault on bringup, ioc->sh will be NULL */
1314        if (reset_phase == MPT_IOC_POST_RESET &&
1315            ioc->sh) {
1316                struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1317
1318                mptspi_dv_renegotiate(hd);
1319        }
1320
1321        return rc;
1322}
1323
1324#ifdef CONFIG_PM
1325/*
1326 * spi module resume handler
1327 */
1328static int
1329mptspi_resume(struct pci_dev *pdev)
1330{
1331        MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1332        struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1333        int rc;
1334
1335        rc = mptscsih_resume(pdev);
1336        mptspi_dv_renegotiate(hd);
1337
1338        return rc;
1339}
1340#endif
1341
1342/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1343/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1344/*
1345 *      mptspi_probe - Installs scsi devices per bus.
1346 *      @pdev: Pointer to pci_dev structure
1347 *
1348 *      Returns 0 for success, non-zero for failure.
1349 *
1350 */
1351static int
1352mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1353{
1354        struct Scsi_Host        *sh;
1355        MPT_SCSI_HOST           *hd;
1356        MPT_ADAPTER             *ioc;
1357        unsigned long            flags;
1358        int                      ii;
1359        int                      numSGE = 0;
1360        int                      scale;
1361        int                      ioc_cap;
1362        int                     error=0;
1363        int                     r;
1364
1365        if ((r = mpt_attach(pdev,id)) != 0)
1366                return r;
1367
1368        ioc = pci_get_drvdata(pdev);
1369        ioc->DoneCtx = mptspiDoneCtx;
1370        ioc->TaskCtx = mptspiTaskCtx;
1371        ioc->InternalCtx = mptspiInternalCtx;
1372
1373        /*  Added sanity check on readiness of the MPT adapter.
1374         */
1375        if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1376                printk(MYIOC_s_WARN_FMT
1377                  "Skipping because it's not operational!\n",
1378                  ioc->name);
1379                error = -ENODEV;
1380                goto out_mptspi_probe;
1381        }
1382
1383        if (!ioc->active) {
1384                printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1385                  ioc->name);
1386                error = -ENODEV;
1387                goto out_mptspi_probe;
1388        }
1389
1390        /*  Sanity check - ensure at least 1 port is INITIATOR capable
1391         */
1392        ioc_cap = 0;
1393        for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1394                if (ioc->pfacts[ii].ProtocolFlags &
1395                    MPI_PORTFACTS_PROTOCOL_INITIATOR)
1396                        ioc_cap ++;
1397        }
1398
1399        if (!ioc_cap) {
1400                printk(MYIOC_s_WARN_FMT
1401                        "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1402                        ioc->name, ioc);
1403                return 0;
1404        }
1405
1406        sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1407
1408        if (!sh) {
1409                printk(MYIOC_s_WARN_FMT
1410                        "Unable to register controller with SCSI subsystem\n",
1411                        ioc->name);
1412                error = -1;
1413                goto out_mptspi_probe;
1414        }
1415
1416        /* VMWare emulation doesn't properly implement WRITE_SAME
1417         */
1418        if (pdev->subsystem_vendor == 0x15AD)
1419                sh->no_write_same = 1;
1420
1421        spin_lock_irqsave(&ioc->FreeQlock, flags);
1422
1423        /* Attach the SCSI Host to the IOC structure
1424         */
1425        ioc->sh = sh;
1426
1427        sh->io_port = 0;
1428        sh->n_io_port = 0;
1429        sh->irq = 0;
1430
1431        /* set 16 byte cdb's */
1432        sh->max_cmd_len = 16;
1433
1434        /* Yikes!  This is important!
1435         * Otherwise, by default, linux
1436         * only scans target IDs 0-7!
1437         * pfactsN->MaxDevices unreliable
1438         * (not supported in early
1439         *      versions of the FW).
1440         * max_id = 1 + actual max id,
1441         * max_lun = 1 + actual last lun,
1442         *      see hosts.h :o(
1443         */
1444        sh->max_id = ioc->devices_per_bus;
1445
1446        sh->max_lun = MPT_LAST_LUN + 1;
1447        /*
1448         * If RAID Firmware Detected, setup virtual channel
1449         */
1450        if (ioc->ir_firmware)
1451                sh->max_channel = 1;
1452        else
1453                sh->max_channel = 0;
1454        sh->this_id = ioc->pfacts[0].PortSCSIID;
1455
1456        /* Required entry.
1457         */
1458        sh->unique_id = ioc->id;
1459
1460        /* Verify that we won't exceed the maximum
1461         * number of chain buffers
1462         * We can optimize:  ZZ = req_sz/sizeof(SGE)
1463         * For 32bit SGE's:
1464         *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1465         *               + (req_sz - 64)/sizeof(SGE)
1466         * A slightly different algorithm is required for
1467         * 64bit SGEs.
1468         */
1469        scale = ioc->req_sz/ioc->SGE_size;
1470        if (ioc->sg_addr_size == sizeof(u64)) {
1471                numSGE = (scale - 1) *
1472                  (ioc->facts.MaxChainDepth-1) + scale +
1473                  (ioc->req_sz - 60) / ioc->SGE_size;
1474        } else {
1475                numSGE = 1 + (scale - 1) *
1476                  (ioc->facts.MaxChainDepth-1) + scale +
1477                  (ioc->req_sz - 64) / ioc->SGE_size;
1478        }
1479
1480        if (numSGE < sh->sg_tablesize) {
1481                /* Reset this value */
1482                dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1483                  "Resetting sg_tablesize to %d from %d\n",
1484                  ioc->name, numSGE, sh->sg_tablesize));
1485                sh->sg_tablesize = numSGE;
1486        }
1487
1488        spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1489
1490        hd = shost_priv(sh);
1491        hd->ioc = ioc;
1492
1493        /* SCSI needs scsi_cmnd lookup table!
1494         * (with size equal to req_depth*PtrSz!)
1495         */
1496        ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1497        if (!ioc->ScsiLookup) {
1498                error = -ENOMEM;
1499                goto out_mptspi_probe;
1500        }
1501        spin_lock_init(&ioc->scsi_lookup_lock);
1502
1503        dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1504                 ioc->name, ioc->ScsiLookup));
1505
1506        ioc->spi_data.Saf_Te = mpt_saf_te;
1507        ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1508                "saf_te %x\n",
1509                ioc->name,
1510                mpt_saf_te));
1511        ioc->spi_data.noQas = 0;
1512
1513        hd->last_queue_full = 0;
1514        hd->spi_pending = 0;
1515
1516        /* Some versions of the firmware don't support page 0; without
1517         * that we can't get the parameters */
1518        if (ioc->spi_data.sdp0length != 0)
1519                sh->transportt = mptspi_transport_template;
1520
1521        error = scsi_add_host (sh, &ioc->pcidev->dev);
1522        if(error) {
1523                dprintk(ioc, printk(MYIOC_s_ERR_FMT
1524                  "scsi_add_host failed\n", ioc->name));
1525                goto out_mptspi_probe;
1526        }
1527
1528        /*
1529         * issue internal bus reset
1530         */
1531        if (ioc->spi_data.bus_reset)
1532                mptscsih_IssueTaskMgmt(hd,
1533                    MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1534                    0, 0, 0, 0, 5);
1535
1536        scsi_scan_host(sh);
1537        return 0;
1538
1539out_mptspi_probe:
1540
1541        mptscsih_remove(pdev);
1542        return error;
1543}
1544
1545static void mptspi_remove(struct pci_dev *pdev)
1546{
1547        MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1548
1549        scsi_remove_host(ioc->sh);
1550        mptscsih_remove(pdev);
1551}
1552
1553static struct pci_driver mptspi_driver = {
1554        .name           = "mptspi",
1555        .id_table       = mptspi_pci_table,
1556        .probe          = mptspi_probe,
1557        .remove         = mptspi_remove,
1558        .shutdown       = mptscsih_shutdown,
1559#ifdef CONFIG_PM
1560        .suspend        = mptscsih_suspend,
1561        .resume         = mptspi_resume,
1562#endif
1563};
1564
1565/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1566/**
1567 *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1568 *
1569 *      Returns 0 for success, non-zero for failure.
1570 */
1571static int __init
1572mptspi_init(void)
1573{
1574        int error;
1575
1576        show_mptmod_ver(my_NAME, my_VERSION);
1577
1578        mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1579        if (!mptspi_transport_template)
1580                return -ENODEV;
1581
1582        mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER,
1583            "mptscsih_io_done");
1584        mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER,
1585            "mptscsih_taskmgmt_complete");
1586        mptspiInternalCtx = mpt_register(mptscsih_scandv_complete,
1587            MPTSPI_DRIVER, "mptscsih_scandv_complete");
1588
1589        mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1590        mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1591
1592        error = pci_register_driver(&mptspi_driver);
1593        if (error)
1594                spi_release_transport(mptspi_transport_template);
1595
1596        return error;
1597}
1598
1599/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1600/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1601/**
1602 *      mptspi_exit - Unregisters MPT adapter(s)
1603 */
1604static void __exit
1605mptspi_exit(void)
1606{
1607        pci_unregister_driver(&mptspi_driver);
1608
1609        mpt_reset_deregister(mptspiDoneCtx);
1610        mpt_event_deregister(mptspiDoneCtx);
1611
1612        mpt_deregister(mptspiInternalCtx);
1613        mpt_deregister(mptspiTaskCtx);
1614        mpt_deregister(mptspiDoneCtx);
1615        spi_release_transport(mptspi_transport_template);
1616}
1617
1618module_init(mptspi_init);
1619module_exit(mptspi_exit);
1620