Back to home page

OSCL-LXR

 
 

    


0001 /*
0002  *  linux/drivers/message/fusion/mptspi.c
0003  *      For use with LSI PCI chip/adapter(s)
0004  *      running LSI Fusion MPT (Message Passing Technology) firmware.
0005  *
0006  *  Copyright (c) 1999-2008 LSI Corporation
0007  *  (mailto:DL-MPTFusionLinux@lsi.com)
0008  *
0009  */
0010 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
0011 /*
0012     This program is free software; you can redistribute it and/or modify
0013     it under the terms of the GNU General Public License as published by
0014     the Free Software Foundation; version 2 of the License.
0015 
0016     This program is distributed in the hope that it will be useful,
0017     but WITHOUT ANY WARRANTY; without even the implied warranty of
0018     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
0019     GNU General Public License for more details.
0020 
0021     NO WARRANTY
0022     THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
0023     CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
0024     LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
0025     MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
0026     solely responsible for determining the appropriateness of using and
0027     distributing the Program and assumes all risks associated with its
0028     exercise of rights under this Agreement, including but not limited to
0029     the risks and costs of program errors, damage to or loss of data,
0030     programs or equipment, and unavailability or interruption of operations.
0031 
0032     DISCLAIMER OF LIABILITY
0033     NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
0034     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
0035     DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
0036     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
0037     TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
0038     USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
0039     HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
0040 
0041     You should have received a copy of the GNU General Public License
0042     along with this program; if not, write to the Free Software
0043     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
0044 */
0045 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
0046 
0047 #include <linux/module.h>
0048 #include <linux/kernel.h>
0049 #include <linux/slab.h>
0050 #include <linux/init.h>
0051 #include <linux/errno.h>
0052 #include <linux/kdev_t.h>
0053 #include <linux/blkdev.h>
0054 #include <linux/delay.h>    /* for mdelay */
0055 #include <linux/interrupt.h>
0056 #include <linux/reboot.h>   /* notifier code */
0057 #include <linux/workqueue.h>
0058 #include <linux/raid_class.h>
0059 
0060 #include <scsi/scsi.h>
0061 #include <scsi/scsi_cmnd.h>
0062 #include <scsi/scsi_device.h>
0063 #include <scsi/scsi_host.h>
0064 #include <scsi/scsi_tcq.h>
0065 #include <scsi/scsi_transport.h>
0066 #include <scsi/scsi_transport_spi.h>
0067 #include <scsi/scsi_dbg.h>
0068 
0069 #include "mptbase.h"
0070 #include "mptscsih.h"
0071 
0072 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
0073 #define my_NAME     "Fusion MPT SPI Host driver"
0074 #define my_VERSION  MPT_LINUX_VERSION_COMMON
0075 #define MYNAM       "mptspi"
0076 
0077 MODULE_AUTHOR(MODULEAUTHOR);
0078 MODULE_DESCRIPTION(my_NAME);
0079 MODULE_LICENSE("GPL");
0080 MODULE_VERSION(my_VERSION);
0081 
0082 /* Command line args */
0083 static int mpt_saf_te = MPTSCSIH_SAF_TE;
0084 module_param(mpt_saf_te, int, 0);
0085 MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1  (default=MPTSCSIH_SAF_TE=0)");
0086 
0087 static void mptspi_write_offset(struct scsi_target *, int);
0088 static void mptspi_write_width(struct scsi_target *, int);
0089 static int mptspi_write_spi_device_pg1(struct scsi_target *,
0090                        struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
0091 
0092 static struct scsi_transport_template *mptspi_transport_template = NULL;
0093 
0094 static u8   mptspiDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
0095 static u8   mptspiTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
0096 static u8   mptspiInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */
0097 
0098 /**
0099  *  mptspi_setTargetNegoParms  - Update the target negotiation parameters
0100  *  @hd: Pointer to a SCSI Host Structure
0101  *  @target: per target private data
0102  *  @sdev: SCSI device
0103  *
0104  *  Update the target negotiation parameters based on the Inquiry
0105  *  data, adapter capabilities, and NVRAM settings.
0106  **/
0107 static void
0108 mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
0109                 struct scsi_device *sdev)
0110 {
0111     MPT_ADAPTER *ioc = hd->ioc;
0112     SpiCfgData *pspi_data = &ioc->spi_data;
0113     int  id = (int) target->id;
0114     int  nvram;
0115     u8 width = MPT_NARROW;
0116     u8 factor = MPT_ASYNC;
0117     u8 offset = 0;
0118     u8 nfactor;
0119     u8 noQas = 1;
0120 
0121     target->negoFlags = pspi_data->noQas;
0122 
0123     if (sdev->scsi_level < SCSI_2) {
0124         width = 0;
0125         factor = MPT_ULTRA2;
0126         offset = pspi_data->maxSyncOffset;
0127         target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
0128     } else {
0129         if (scsi_device_wide(sdev))
0130             width = 1;
0131 
0132         if (scsi_device_sync(sdev)) {
0133             factor = pspi_data->minSyncFactor;
0134             if (!scsi_device_dt(sdev))
0135                     factor = MPT_ULTRA2;
0136             else {
0137                 if (!scsi_device_ius(sdev) &&
0138                     !scsi_device_qas(sdev))
0139                     factor = MPT_ULTRA160;
0140                 else {
0141                     factor = MPT_ULTRA320;
0142                     if (scsi_device_qas(sdev)) {
0143                         ddvprintk(ioc,
0144                         printk(MYIOC_s_DEBUG_FMT "Enabling QAS due to "
0145                         "byte56=%02x on id=%d!\n", ioc->name,
0146                         scsi_device_qas(sdev), id));
0147                         noQas = 0;
0148                     }
0149                     if (sdev->type == TYPE_TAPE &&
0150                         scsi_device_ius(sdev))
0151                         target->negoFlags |= MPT_TAPE_NEGO_IDP;
0152                 }
0153             }
0154             offset = pspi_data->maxSyncOffset;
0155 
0156             /* If RAID, never disable QAS
0157              * else if non RAID, do not disable
0158              *   QAS if bit 1 is set
0159              * bit 1 QAS support, non-raid only
0160              * bit 0 IU support
0161              */
0162             if (target->raidVolume == 1)
0163                 noQas = 0;
0164         } else {
0165             factor = MPT_ASYNC;
0166             offset = 0;
0167         }
0168     }
0169 
0170     if (!sdev->tagged_supported)
0171         target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
0172 
0173     /* Update tflags based on NVRAM settings. (SCSI only)
0174      */
0175     if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
0176         nvram = pspi_data->nvram[id];
0177         nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
0178 
0179         if (width)
0180             width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
0181 
0182         if (offset > 0) {
0183             /* Ensure factor is set to the
0184              * maximum of: adapter, nvram, inquiry
0185              */
0186             if (nfactor) {
0187                 if (nfactor < pspi_data->minSyncFactor )
0188                     nfactor = pspi_data->minSyncFactor;
0189 
0190                 factor = max(factor, nfactor);
0191                 if (factor == MPT_ASYNC)
0192                     offset = 0;
0193             } else {
0194                 offset = 0;
0195                 factor = MPT_ASYNC;
0196         }
0197         } else {
0198             factor = MPT_ASYNC;
0199         }
0200     }
0201 
0202     /* Make sure data is consistent
0203      */
0204     if ((!width) && (factor < MPT_ULTRA2))
0205         factor = MPT_ULTRA2;
0206 
0207     /* Save the data to the target structure.
0208      */
0209     target->minSyncFactor = factor;
0210     target->maxOffset = offset;
0211     target->maxWidth = width;
0212 
0213     spi_min_period(scsi_target(sdev)) = factor;
0214     spi_max_offset(scsi_target(sdev)) = offset;
0215     spi_max_width(scsi_target(sdev)) = width;
0216 
0217     target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
0218 
0219     /* Disable unused features.
0220      */
0221     if (!width)
0222         target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
0223 
0224     if (!offset)
0225         target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
0226 
0227     if ( factor > MPT_ULTRA320 )
0228         noQas = 0;
0229 
0230     if (noQas && (pspi_data->noQas == 0)) {
0231         pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
0232         target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
0233 
0234         /* Disable QAS in a mixed configuration case
0235          */
0236 
0237         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
0238             "Disabling QAS due to noQas=%02x on id=%d!\n", ioc->name, noQas, id));
0239     }
0240 }
0241 
0242 /**
0243  *  mptspi_writeIOCPage4  - write IOC Page 4
0244  *  @hd: Pointer to a SCSI Host Structure
0245  *  @channel: channel number
0246  *  @id: write IOC Page4 for this ID & Bus
0247  *
0248  *  Return: -EAGAIN if unable to obtain a Message Frame
0249  *      or 0 if success.
0250  *
0251  *  Remark: We do not wait for a return, write pages sequentially.
0252  **/
0253 static int
0254 mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
0255 {
0256     MPT_ADAPTER     *ioc = hd->ioc;
0257     Config_t        *pReq;
0258     IOCPage4_t      *IOCPage4Ptr;
0259     MPT_FRAME_HDR       *mf;
0260     dma_addr_t       dataDma;
0261     u32          flagsLength;
0262     int          ii;
0263 
0264     /* Get a MF for this command.
0265      */
0266     if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
0267         dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
0268                 "writeIOCPage4 : no msg frames!\n",ioc->name));
0269         return -EAGAIN;
0270     }
0271 
0272     /* Set the request and the data pointers.
0273      * Place data at end of MF.
0274      */
0275     pReq = (Config_t *)mf;
0276 
0277     /* Complete the request frame (same for all requests).
0278      */
0279     pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
0280     pReq->Reserved = 0;
0281     pReq->ChainOffset = 0;
0282     pReq->Function = MPI_FUNCTION_CONFIG;
0283     pReq->ExtPageLength = 0;
0284     pReq->ExtPageType = 0;
0285     pReq->MsgFlags = 0;
0286     for (ii=0; ii < 8; ii++) {
0287         pReq->Reserved2[ii] = 0;
0288     }
0289 
0290     IOCPage4Ptr = ioc->spi_data.pIocPg4;
0291     dataDma = ioc->spi_data.IocPg4_dma;
0292     ii = IOCPage4Ptr->ActiveSEP++;
0293     IOCPage4Ptr->SEP[ii].SEPTargetID = id;
0294     IOCPage4Ptr->SEP[ii].SEPBus = channel;
0295     pReq->Header = IOCPage4Ptr->Header;
0296     pReq->PageAddress = cpu_to_le32(id | (channel << 8 ));
0297 
0298     /* Add a SGE to the config request.
0299      */
0300     flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
0301         (IOCPage4Ptr->Header.PageLength + ii) * 4;
0302 
0303     ioc->add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
0304 
0305     ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
0306         "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
0307         ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
0308 
0309     mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
0310 
0311     return 0;
0312 }
0313 
0314 /**
0315  *  mptspi_initTarget - Target, LUN alloc/free functionality.
0316  *  @hd: Pointer to MPT_SCSI_HOST structure
0317  *  @vtarget: per target private data
0318  *  @sdev: SCSI device
0319  *
0320  *  NOTE: It's only SAFE to call this routine if data points to
0321  *  sane & valid STANDARD INQUIRY data!
0322  *
0323  *  Allocate and initialize memory for this target.
0324  *  Save inquiry data.
0325  *
0326  **/
0327 static void
0328 mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
0329             struct scsi_device *sdev)
0330 {
0331 
0332     /* Is LUN supported? If so, upper 2 bits will be 0
0333     * in first byte of inquiry data.
0334     */
0335     if (sdev->inq_periph_qual != 0)
0336         return;
0337 
0338     if (vtarget == NULL)
0339         return;
0340 
0341     vtarget->type = sdev->type;
0342 
0343     if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
0344         /* Treat all Processors as SAF-TE if
0345          * command line option is set */
0346         vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
0347         mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
0348     }else if ((sdev->type == TYPE_PROCESSOR) &&
0349         !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
0350         if (sdev->inquiry_len > 49 ) {
0351             if (sdev->inquiry[44] == 'S' &&
0352                 sdev->inquiry[45] == 'A' &&
0353                 sdev->inquiry[46] == 'F' &&
0354                 sdev->inquiry[47] == '-' &&
0355                 sdev->inquiry[48] == 'T' &&
0356                 sdev->inquiry[49] == 'E' ) {
0357                 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
0358                 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
0359             }
0360         }
0361     }
0362     mptspi_setTargetNegoParms(hd, vtarget, sdev);
0363 }
0364 
0365 /**
0366  *  mptspi_is_raid - Determines whether target is belonging to volume
0367  *  @hd: Pointer to a SCSI HOST structure
0368  *  @id: target device id
0369  *
0370  *  Return:
0371  *      non-zero = true
0372  *      zero = false
0373  *
0374  */
0375 static int
0376 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
0377 {
0378     int i, rc = 0;
0379     MPT_ADAPTER *ioc = hd->ioc;
0380 
0381     if (!ioc->raid_data.pIocPg2)
0382         goto out;
0383 
0384     if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
0385         goto out;
0386     for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
0387         if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
0388             rc = 1;
0389             goto out;
0390         }
0391     }
0392 
0393  out:
0394     return rc;
0395 }
0396 
0397 static int mptspi_target_alloc(struct scsi_target *starget)
0398 {
0399     struct Scsi_Host *shost = dev_to_shost(&starget->dev);
0400     struct _MPT_SCSI_HOST *hd = shost_priv(shost);
0401     VirtTarget      *vtarget;
0402     MPT_ADAPTER *ioc;
0403 
0404     if (hd == NULL)
0405         return -ENODEV;
0406 
0407     ioc = hd->ioc;
0408     vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
0409     if (!vtarget)
0410         return -ENOMEM;
0411 
0412     vtarget->ioc_id = ioc->id;
0413     vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
0414     vtarget->id = (u8)starget->id;
0415     vtarget->channel = (u8)starget->channel;
0416     vtarget->starget = starget;
0417     starget->hostdata = vtarget;
0418 
0419     if (starget->channel == 1) {
0420         if (mptscsih_is_phys_disk(ioc, 0, starget->id) == 0)
0421             return 0;
0422         vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
0423         /* The real channel for this device is zero */
0424         vtarget->channel = 0;
0425         /* The actual physdisknum (for RAID passthrough) */
0426         vtarget->id = mptscsih_raid_id_to_num(ioc, 0,
0427             starget->id);
0428     }
0429 
0430     if (starget->channel == 0 &&
0431         mptspi_is_raid(hd, starget->id)) {
0432         vtarget->raidVolume = 1;
0433         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
0434             "RAID Volume @ channel=%d id=%d\n", ioc->name, starget->channel,
0435             starget->id));
0436     }
0437 
0438     if (ioc->spi_data.nvram &&
0439         ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
0440         u32 nvram = ioc->spi_data.nvram[starget->id];
0441         spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
0442         spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
0443     } else {
0444         spi_min_period(starget) = ioc->spi_data.minSyncFactor;
0445         spi_max_width(starget) = ioc->spi_data.maxBusWidth;
0446     }
0447     spi_max_offset(starget) = ioc->spi_data.maxSyncOffset;
0448 
0449     spi_offset(starget) = 0;
0450     spi_period(starget) = 0xFF;
0451     mptspi_write_width(starget, 0);
0452 
0453     return 0;
0454 }
0455 
0456 static void
0457 mptspi_target_destroy(struct scsi_target *starget)
0458 {
0459     kfree(starget->hostdata);
0460     starget->hostdata = NULL;
0461 }
0462 
0463 /**
0464  *  mptspi_print_write_nego - negotiation parameters debug info that is being sent
0465  *  @hd: Pointer to a SCSI HOST structure
0466  *  @starget: SCSI target
0467  *  @ii: negotiation parameters
0468  *
0469  */
0470 static void
0471 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
0472 {
0473     ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x"
0474         " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
0475         hd->ioc->name, starget->id, ii,
0476         ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
0477         ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
0478         ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
0479         ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
0480         ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
0481         ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
0482         ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
0483         ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
0484         ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
0485         ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
0486 }
0487 
0488 /**
0489  *  mptspi_print_read_nego - negotiation parameters debug info that is being read
0490  *  @hd: Pointer to a SCSI HOST structure
0491  *  @starget: SCSI target
0492  *  @ii: negotiation parameters
0493  *
0494  */
0495 static void
0496 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
0497 {
0498     ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x"
0499         " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
0500         hd->ioc->name, starget->id, ii,
0501         ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
0502         ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
0503         ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
0504         ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
0505         ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
0506         ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
0507         ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
0508         ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
0509         ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
0510         ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
0511 }
0512 
0513 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
0514                  struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
0515 {
0516     struct Scsi_Host *shost = dev_to_shost(&starget->dev);
0517     struct _MPT_SCSI_HOST *hd = shost_priv(shost);
0518     struct _MPT_ADAPTER *ioc = hd->ioc;
0519     struct _CONFIG_PAGE_SCSI_DEVICE_0 *spi_dev_pg0;
0520     dma_addr_t spi_dev_pg0_dma;
0521     int size;
0522     struct _x_config_parms cfg;
0523     struct _CONFIG_PAGE_HEADER hdr;
0524     int err = -EBUSY;
0525 
0526     /* No SPI parameters for RAID devices */
0527     if (starget->channel == 0 &&
0528         mptspi_is_raid(hd, starget->id))
0529         return -1;
0530 
0531     size = ioc->spi_data.sdp0length * 4;
0532     /*
0533     if (ioc->spi_data.sdp0length & 1)
0534         size += size + 4;
0535     size += 2048;
0536     */
0537 
0538     spi_dev_pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &spi_dev_pg0_dma, GFP_KERNEL);
0539     if (spi_dev_pg0 == NULL) {
0540         starget_printk(KERN_ERR, starget, MYIOC_s_FMT
0541             "dma_alloc_coherent for parameters failed\n", ioc->name);
0542         return -EINVAL;
0543     }
0544 
0545     memset(&hdr, 0, sizeof(hdr));
0546 
0547     hdr.PageVersion = ioc->spi_data.sdp0version;
0548     hdr.PageLength = ioc->spi_data.sdp0length;
0549     hdr.PageNumber = 0;
0550     hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
0551 
0552     memset(&cfg, 0, sizeof(cfg));
0553 
0554     cfg.cfghdr.hdr = &hdr;
0555     cfg.physAddr = spi_dev_pg0_dma;
0556     cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
0557     cfg.dir = 0;
0558     cfg.pageAddr = starget->id;
0559     cfg.timeout = 60;
0560 
0561     if (mpt_config(ioc, &cfg)) {
0562         starget_printk(KERN_ERR, starget, MYIOC_s_FMT "mpt_config failed\n", ioc->name);
0563         goto out_free;
0564     }
0565     err = 0;
0566     memcpy(pass_pg0, spi_dev_pg0, size);
0567 
0568     mptspi_print_read_nego(hd, starget, le32_to_cpu(spi_dev_pg0->NegotiatedParameters));
0569 
0570  out_free:
0571     dma_free_coherent(&ioc->pcidev->dev, size, spi_dev_pg0, spi_dev_pg0_dma);
0572     return err;
0573 }
0574 
0575 static u32 mptspi_getRP(struct scsi_target *starget)
0576 {
0577     u32 nego = 0;
0578 
0579     nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
0580     nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
0581     nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
0582     nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
0583     nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
0584     nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
0585     nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
0586     nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
0587 
0588     nego |= (spi_period(starget) <<  MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
0589     nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
0590     nego |= spi_width(starget) ?  MPI_SCSIDEVPAGE1_RP_WIDE : 0;
0591 
0592     return nego;
0593 }
0594 
0595 static void mptspi_read_parameters(struct scsi_target *starget)
0596 {
0597     int nego;
0598     struct _CONFIG_PAGE_SCSI_DEVICE_0 spi_dev_pg0;
0599 
0600     mptspi_read_spi_device_pg0(starget, &spi_dev_pg0);
0601 
0602     nego = le32_to_cpu(spi_dev_pg0.NegotiatedParameters);
0603 
0604     spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
0605     spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
0606     spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
0607     spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
0608     spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
0609     spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
0610     spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
0611     spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
0612     spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
0613     spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
0614     spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
0615 }
0616 
0617 static int
0618 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
0619 {
0620     MPT_ADAPTER *ioc = hd->ioc;
0621     MpiRaidActionRequest_t  *pReq;
0622     MPT_FRAME_HDR       *mf;
0623     int         ret;
0624     unsigned long       timeleft;
0625 
0626     mutex_lock(&ioc->internal_cmds.mutex);
0627 
0628     /* Get and Populate a free Frame
0629      */
0630     if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
0631         dfailprintk(hd->ioc, printk(MYIOC_s_WARN_FMT
0632             "%s: no msg frames!\n", ioc->name, __func__));
0633         ret = -EAGAIN;
0634         goto out;
0635     }
0636     pReq = (MpiRaidActionRequest_t *)mf;
0637     if (quiesce)
0638         pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
0639     else
0640         pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
0641     pReq->Reserved1 = 0;
0642     pReq->ChainOffset = 0;
0643     pReq->Function = MPI_FUNCTION_RAID_ACTION;
0644     pReq->VolumeID = id;
0645     pReq->VolumeBus = channel;
0646     pReq->PhysDiskNum = 0;
0647     pReq->MsgFlags = 0;
0648     pReq->Reserved2 = 0;
0649     pReq->ActionDataWord = 0; /* Reserved for this action */
0650 
0651     ioc->add_sge((char *)&pReq->ActionDataSGE,
0652         MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
0653 
0654     ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
0655             ioc->name, pReq->Action, channel, id));
0656 
0657     INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
0658     mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
0659     timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done, 10*HZ);
0660     if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
0661         ret = -ETIME;
0662         dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: TIMED OUT!\n",
0663             ioc->name, __func__));
0664         if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
0665             goto out;
0666         if (!timeleft) {
0667             printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
0668                 ioc->name, __func__);
0669             mpt_HardResetHandler(ioc, CAN_SLEEP);
0670             mpt_free_msg_frame(ioc, mf);
0671         }
0672         goto out;
0673     }
0674 
0675     ret = ioc->internal_cmds.completion_code;
0676 
0677  out:
0678     CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
0679     mutex_unlock(&ioc->internal_cmds.mutex);
0680     return ret;
0681 }
0682 
0683 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
0684                  struct scsi_device *sdev)
0685 {
0686     VirtTarget *vtarget = scsi_target(sdev)->hostdata;
0687     MPT_ADAPTER *ioc = hd->ioc;
0688 
0689     /* no DV on RAID devices */
0690     if (sdev->channel == 0 &&
0691         mptspi_is_raid(hd, sdev->id))
0692         return;
0693 
0694     /* If this is a piece of a RAID, then quiesce first */
0695     if (sdev->channel == 1 &&
0696         mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
0697         starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
0698             "Integrated RAID quiesce failed\n", ioc->name);
0699         return;
0700     }
0701 
0702     hd->spi_pending |= (1 << sdev->id);
0703     spi_dv_device(sdev);
0704     hd->spi_pending &= ~(1 << sdev->id);
0705 
0706     if (sdev->channel == 1 &&
0707         mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
0708         starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
0709             "Integrated RAID resume failed\n", ioc->name);
0710 
0711     mptspi_read_parameters(sdev->sdev_target);
0712     spi_display_xfer_agreement(sdev->sdev_target);
0713     mptspi_read_parameters(sdev->sdev_target);
0714 }
0715 
0716 static int mptspi_slave_alloc(struct scsi_device *sdev)
0717 {
0718     MPT_SCSI_HOST *hd = shost_priv(sdev->host);
0719     VirtTarget      *vtarget;
0720     VirtDevice      *vdevice;
0721     struct scsi_target  *starget;
0722     MPT_ADAPTER *ioc = hd->ioc;
0723 
0724     if (sdev->channel == 1 &&
0725         mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0)
0726             return -ENXIO;
0727 
0728     vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
0729     if (!vdevice) {
0730         printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
0731                 ioc->name, sizeof(VirtDevice));
0732         return -ENOMEM;
0733     }
0734 
0735     vdevice->lun = sdev->lun;
0736     sdev->hostdata = vdevice;
0737 
0738     starget = scsi_target(sdev);
0739     vtarget = starget->hostdata;
0740     vdevice->vtarget = vtarget;
0741     vtarget->num_luns++;
0742 
0743     if (sdev->channel == 1)
0744         sdev->no_uld_attach = 1;
0745 
0746     return 0;
0747 }
0748 
0749 static int mptspi_slave_configure(struct scsi_device *sdev)
0750 {
0751     struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
0752     VirtTarget *vtarget = scsi_target(sdev)->hostdata;
0753     int ret;
0754 
0755     mptspi_initTarget(hd, vtarget, sdev);
0756 
0757     ret = mptscsih_slave_configure(sdev);
0758 
0759     if (ret)
0760         return ret;
0761 
0762     ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
0763         " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
0764         sdev->id, spi_min_period(scsi_target(sdev)),
0765         spi_max_offset(scsi_target(sdev)),
0766         spi_max_width(scsi_target(sdev))));
0767 
0768     if ((sdev->channel == 1 ||
0769          !(mptspi_is_raid(hd, sdev->id))) &&
0770         !spi_initial_dv(sdev->sdev_target))
0771         mptspi_dv_device(hd, sdev);
0772 
0773     return 0;
0774 }
0775 
0776 static int
0777 mptspi_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
0778 {
0779     struct _MPT_SCSI_HOST *hd = shost_priv(shost);
0780     VirtDevice  *vdevice = SCpnt->device->hostdata;
0781     MPT_ADAPTER *ioc = hd->ioc;
0782 
0783     if (!vdevice || !vdevice->vtarget) {
0784         SCpnt->result = DID_NO_CONNECT << 16;
0785         scsi_done(SCpnt);
0786         return 0;
0787     }
0788 
0789     if (SCpnt->device->channel == 1 &&
0790         mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) {
0791         SCpnt->result = DID_NO_CONNECT << 16;
0792         scsi_done(SCpnt);
0793         return 0;
0794     }
0795 
0796     if (spi_dv_pending(scsi_target(SCpnt->device)))
0797         ddvprintk(ioc, scsi_print_command(SCpnt));
0798 
0799     return mptscsih_qcmd(SCpnt);
0800 }
0801 
0802 static void mptspi_slave_destroy(struct scsi_device *sdev)
0803 {
0804     struct scsi_target *starget = scsi_target(sdev);
0805     VirtTarget *vtarget = starget->hostdata;
0806     VirtDevice *vdevice = sdev->hostdata;
0807 
0808     /* Will this be the last lun on a non-raid device? */
0809     if (vtarget->num_luns == 1 && vdevice->configured_lun) {
0810         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
0811 
0812         /* Async Narrow */
0813         pg1.RequestedParameters = 0;
0814         pg1.Reserved = 0;
0815         pg1.Configuration = 0;
0816 
0817         mptspi_write_spi_device_pg1(starget, &pg1);
0818     }
0819 
0820     mptscsih_slave_destroy(sdev);
0821 }
0822 
0823 static struct scsi_host_template mptspi_driver_template = {
0824     .module             = THIS_MODULE,
0825     .proc_name          = "mptspi",
0826     .show_info          = mptscsih_show_info,
0827     .name               = "MPT SPI Host",
0828     .info               = mptscsih_info,
0829     .queuecommand           = mptspi_qcmd,
0830     .target_alloc           = mptspi_target_alloc,
0831     .slave_alloc            = mptspi_slave_alloc,
0832     .slave_configure        = mptspi_slave_configure,
0833     .target_destroy         = mptspi_target_destroy,
0834     .slave_destroy          = mptspi_slave_destroy,
0835     .change_queue_depth         = mptscsih_change_queue_depth,
0836     .eh_abort_handler       = mptscsih_abort,
0837     .eh_device_reset_handler    = mptscsih_dev_reset,
0838     .eh_bus_reset_handler       = mptscsih_bus_reset,
0839     .eh_host_reset_handler      = mptscsih_host_reset,
0840     .bios_param         = mptscsih_bios_param,
0841     .can_queue          = MPT_SCSI_CAN_QUEUE,
0842     .this_id            = -1,
0843     .sg_tablesize           = MPT_SCSI_SG_DEPTH,
0844     .max_sectors            = 8192,
0845     .cmd_per_lun            = 7,
0846     .shost_groups           = mptscsih_host_attr_groups,
0847 };
0848 
0849 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
0850                    struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
0851 {
0852     struct Scsi_Host *shost = dev_to_shost(&starget->dev);
0853     struct _MPT_SCSI_HOST *hd = shost_priv(shost);
0854     struct _MPT_ADAPTER *ioc = hd->ioc;
0855     struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
0856     dma_addr_t pg1_dma;
0857     int size;
0858     struct _x_config_parms cfg;
0859     struct _CONFIG_PAGE_HEADER hdr;
0860     int err = -EBUSY;
0861     u32 nego_parms;
0862     u32 period;
0863     struct scsi_device *sdev;
0864     int i;
0865 
0866     /* don't allow updating nego parameters on RAID devices */
0867     if (starget->channel == 0 &&
0868         mptspi_is_raid(hd, starget->id))
0869         return -1;
0870 
0871     size = ioc->spi_data.sdp1length * 4;
0872 
0873     pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
0874     if (pg1 == NULL) {
0875         starget_printk(KERN_ERR, starget, MYIOC_s_FMT
0876             "dma_alloc_coherent for parameters failed\n", ioc->name);
0877         return -EINVAL;
0878     }
0879 
0880     memset(&hdr, 0, sizeof(hdr));
0881 
0882     hdr.PageVersion = ioc->spi_data.sdp1version;
0883     hdr.PageLength = ioc->spi_data.sdp1length;
0884     hdr.PageNumber = 1;
0885     hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
0886 
0887     memset(&cfg, 0, sizeof(cfg));
0888 
0889     cfg.cfghdr.hdr = &hdr;
0890     cfg.physAddr = pg1_dma;
0891     cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
0892     cfg.dir = 1;
0893     cfg.pageAddr = starget->id;
0894 
0895     memcpy(pg1, pass_pg1, size);
0896 
0897     pg1->Header.PageVersion = hdr.PageVersion;
0898     pg1->Header.PageLength = hdr.PageLength;
0899     pg1->Header.PageNumber = hdr.PageNumber;
0900     pg1->Header.PageType = hdr.PageType;
0901 
0902     nego_parms = le32_to_cpu(pg1->RequestedParameters);
0903     period = (nego_parms & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK) >>
0904         MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD;
0905     if (period == 8) {
0906         /* Turn on inline data padding for TAPE when running U320 */
0907         for (i = 0 ; i < 16; i++) {
0908             sdev = scsi_device_lookup_by_target(starget, i);
0909             if (sdev && sdev->type == TYPE_TAPE) {
0910                 sdev_printk(KERN_DEBUG, sdev, MYIOC_s_FMT
0911                         "IDP:ON\n", ioc->name);
0912                 nego_parms |= MPI_SCSIDEVPAGE1_RP_IDP;
0913                 pg1->RequestedParameters =
0914                     cpu_to_le32(nego_parms);
0915                 break;
0916             }
0917         }
0918     }
0919 
0920     mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
0921 
0922     if (mpt_config(ioc, &cfg)) {
0923         starget_printk(KERN_ERR, starget, MYIOC_s_FMT
0924             "mpt_config failed\n", ioc->name);
0925         goto out_free;
0926     }
0927     err = 0;
0928 
0929  out_free:
0930     dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
0931     return err;
0932 }
0933 
0934 static void mptspi_write_offset(struct scsi_target *starget, int offset)
0935 {
0936     struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
0937     u32 nego;
0938 
0939     if (offset < 0)
0940         offset = 0;
0941 
0942     if (offset > 255)
0943         offset = 255;
0944 
0945     if (spi_offset(starget) == -1)
0946         mptspi_read_parameters(starget);
0947 
0948     spi_offset(starget) = offset;
0949 
0950     nego = mptspi_getRP(starget);
0951 
0952     pg1.RequestedParameters = cpu_to_le32(nego);
0953     pg1.Reserved = 0;
0954     pg1.Configuration = 0;
0955 
0956     mptspi_write_spi_device_pg1(starget, &pg1);
0957 }
0958 
0959 static void mptspi_write_period(struct scsi_target *starget, int period)
0960 {
0961     struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
0962     u32 nego;
0963 
0964     if (period < 8)
0965         period = 8;
0966 
0967     if (period > 255)
0968         period = 255;
0969 
0970     if (spi_period(starget) == -1)
0971         mptspi_read_parameters(starget);
0972 
0973     if (period == 8) {
0974         spi_iu(starget) = 1;
0975         spi_dt(starget) = 1;
0976     } else if (period == 9) {
0977         spi_dt(starget) = 1;
0978     }
0979 
0980     spi_period(starget) = period;
0981 
0982     nego = mptspi_getRP(starget);
0983 
0984     pg1.RequestedParameters = cpu_to_le32(nego);
0985     pg1.Reserved = 0;
0986     pg1.Configuration = 0;
0987 
0988     mptspi_write_spi_device_pg1(starget, &pg1);
0989 }
0990 
0991 static void mptspi_write_dt(struct scsi_target *starget, int dt)
0992 {
0993     struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
0994     u32 nego;
0995 
0996     if (spi_period(starget) == -1)
0997         mptspi_read_parameters(starget);
0998 
0999     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 
1014 static 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)              \
1037 static 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 
1053 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1054 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1055 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1056 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1057 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1058 
1059 static 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 
1082 static 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 
1104 struct work_queue_wrapper {
1105     struct work_struct  work;
1106     struct _MPT_SCSI_HOST   *hd;
1107     int         disk;
1108 };
1109 
1110 static 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 
1151 static 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 
1169 static int
1170 mptspi_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 
1190 static int
1191 mptspi_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 
1199 static 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 
1240 static 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 };
1249 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1250 
1251 
1252 /*
1253  * renegotiate for a given target
1254  */
1255 static void
1256 mptspi_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 
1286 static void
1287 mptspi_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  */
1303 static int
1304 mptspi_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  */
1328 static int
1329 mptspi_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  */
1351 static int
1352 mptspi_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_KERNEL);
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 
1539 out_mptspi_probe:
1540 
1541     mptscsih_remove(pdev);
1542     return error;
1543 }
1544 
1545 static 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 
1553 static 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  */
1571 static int __init
1572 mptspi_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  */
1604 static void __exit
1605 mptspi_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 
1618 module_init(mptspi_init);
1619 module_exit(mptspi_exit);