drivers/message/fusion/mptspi.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
mptspi_setTargetNegoParms
mptspi_writeIOCPage4
mptspi_initTarget
mptspi_is_raid
mptspi_target_alloc
mptspi_target_destroy
mptspi_print_write_nego
mptspi_print_read_nego
mptspi_read_spi_device_pg0
mptspi_getRP
mptspi_read_parameters
mptscsih_quiesce_raid
mptspi_dv_device
mptspi_slave_alloc
mptspi_slave_configure
mptspi_qcmd
mptspi_slave_destroy
mptspi_write_spi_device_pg1
mptspi_write_offset
mptspi_write_period
mptspi_write_dt
mptspi_write_iu
MPTSPI_SIMPLE_TRANSPORT_PARM
mptspi_write_width
mpt_work_wrapper
mpt_dv_raid
mptspi_event_process
mptspi_deny_binding
mptspi_dv_renegotiate_work
mptspi_dv_renegotiate
mptspi_ioc_reset
mptspi_resume
mptspi_probe
mptspi_remove
mptspi_init
mptspi_exit
   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 
  77 MODULE_AUTHOR(MODULEAUTHOR);
  78 MODULE_DESCRIPTION(my_NAME);
  79 MODULE_LICENSE("GPL");
  80 MODULE_VERSION(my_VERSION);
  81 
  82 /* Command line args */
  83 static int mpt_saf_te = MPTSCSIH_SAF_TE;
  84 module_param(mpt_saf_te, int, 0);
  85 MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1  (default=MPTSCSIH_SAF_TE=0)");
  86 
  87 static void mptspi_write_offset(struct scsi_target *, int);
  88 static void mptspi_write_width(struct scsi_target *, int);
  89 static int mptspi_write_spi_device_pg1(struct scsi_target *,
  90                                        struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
  91 
  92 static struct scsi_transport_template *mptspi_transport_template = NULL;
  93 
  94 static u8       mptspiDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
  95 static u8       mptspiTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
  96 static 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  **/
 107 static void
 108 mptspi_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  **/
 253 static int
 254 mptspi_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  **/
 327 static void
 328 mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
 329                     struct scsi_device *sdev)
 330 {
 331 
 332         /* Is LUN supported? If so, upper 2 bits will be 0
 333         * in first byte of inquiry data.
 334         */
 335         if (sdev->inq_periph_qual != 0)
 336                 return;
 337 
 338         if (vtarget == NULL)
 339                 return;
 340 
 341         vtarget->type = sdev->type;
 342 
 343         if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
 344                 /* Treat all Processors as SAF-TE if
 345                  * command line option is set */
 346                 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
 347                 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
 348         }else if ((sdev->type == TYPE_PROCESSOR) &&
 349                 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
 350                 if (sdev->inquiry_len > 49 ) {
 351                         if (sdev->inquiry[44] == 'S' &&
 352                             sdev->inquiry[45] == 'A' &&
 353                             sdev->inquiry[46] == 'F' &&
 354                             sdev->inquiry[47] == '-' &&
 355                             sdev->inquiry[48] == 'T' &&
 356                             sdev->inquiry[49] == 'E' ) {
 357                                 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
 358                                 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
 359                         }
 360                 }
 361         }
 362         mptspi_setTargetNegoParms(hd, vtarget, sdev);
 363 }
 364 
 365 /**
 366  *      mptspi_is_raid - Determines whether target is belonging to volume
 367  *      @hd: Pointer to a SCSI HOST structure
 368  *      @id: target device id
 369  *
 370  *      Return:
 371  *              non-zero = true
 372  *              zero = false
 373  *
 374  */
 375 static int
 376 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
 377 {
 378         int i, rc = 0;
 379         MPT_ADAPTER *ioc = hd->ioc;
 380 
 381         if (!ioc->raid_data.pIocPg2)
 382                 goto out;
 383 
 384         if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
 385                 goto out;
 386         for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
 387                 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
 388                         rc = 1;
 389                         goto out;
 390                 }
 391         }
 392 
 393  out:
 394         return rc;
 395 }
 396 
 397 static int mptspi_target_alloc(struct scsi_target *starget)
 398 {
 399         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 400         struct _MPT_SCSI_HOST *hd = shost_priv(shost);
 401         VirtTarget              *vtarget;
 402         MPT_ADAPTER *ioc;
 403 
 404         if (hd == NULL)
 405                 return -ENODEV;
 406 
 407         ioc = hd->ioc;
 408         vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
 409         if (!vtarget)
 410                 return -ENOMEM;
 411 
 412         vtarget->ioc_id = ioc->id;
 413         vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
 414         vtarget->id = (u8)starget->id;
 415         vtarget->channel = (u8)starget->channel;
 416         vtarget->starget = starget;
 417         starget->hostdata = vtarget;
 418 
 419         if (starget->channel == 1) {
 420                 if (mptscsih_is_phys_disk(ioc, 0, starget->id) == 0)
 421                         return 0;
 422                 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
 423                 /* The real channel for this device is zero */
 424                 vtarget->channel = 0;
 425                 /* The actual physdisknum (for RAID passthrough) */
 426                 vtarget->id = mptscsih_raid_id_to_num(ioc, 0,
 427                     starget->id);
 428         }
 429 
 430         if (starget->channel == 0 &&
 431             mptspi_is_raid(hd, starget->id)) {
 432                 vtarget->raidVolume = 1;
 433                 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 434                     "RAID Volume @ channel=%d id=%d\n", ioc->name, starget->channel,
 435                     starget->id));
 436         }
 437 
 438         if (ioc->spi_data.nvram &&
 439             ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
 440                 u32 nvram = ioc->spi_data.nvram[starget->id];
 441                 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
 442                 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
 443         } else {
 444                 spi_min_period(starget) = ioc->spi_data.minSyncFactor;
 445                 spi_max_width(starget) = ioc->spi_data.maxBusWidth;
 446         }
 447         spi_max_offset(starget) = ioc->spi_data.maxSyncOffset;
 448 
 449         spi_offset(starget) = 0;
 450         spi_period(starget) = 0xFF;
 451         mptspi_write_width(starget, 0);
 452 
 453         return 0;
 454 }
 455 
 456 static void
 457 mptspi_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  */
 470 static void
 471 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
 472 {
 473         ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x"
 474             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
 475             hd->ioc->name, starget->id, ii,
 476             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
 477             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
 478             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
 479             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
 480             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
 481             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
 482             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
 483             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
 484             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
 485             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
 486 }
 487 
 488 /**
 489  *      mptspi_print_read_nego - negotiation parameters debug info that is being read
 490  *      @hd: Pointer to a SCSI HOST structure
 491  *      @starget: SCSI target
 492  *      @ii: negotiation parameters
 493  *
 494  */
 495 static void
 496 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
 497 {
 498         ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x"
 499             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
 500             hd->ioc->name, starget->id, ii,
 501             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
 502             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
 503             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
 504             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
 505             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
 506             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
 507             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
 508             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
 509             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
 510             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
 511 }
 512 
 513 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
 514                              struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
 515 {
 516         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 517         struct _MPT_SCSI_HOST *hd = shost_priv(shost);
 518         struct _MPT_ADAPTER *ioc = hd->ioc;
 519         struct _CONFIG_PAGE_SCSI_DEVICE_0 *spi_dev_pg0;
 520         dma_addr_t spi_dev_pg0_dma;
 521         int size;
 522         struct _x_config_parms cfg;
 523         struct _CONFIG_PAGE_HEADER hdr;
 524         int err = -EBUSY;
 525 
 526         /* No SPI parameters for RAID devices */
 527         if (starget->channel == 0 &&
 528             mptspi_is_raid(hd, starget->id))
 529                 return -1;
 530 
 531         size = ioc->spi_data.sdp0length * 4;
 532         /*
 533         if (ioc->spi_data.sdp0length & 1)
 534                 size += size + 4;
 535         size += 2048;
 536         */
 537 
 538         spi_dev_pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &spi_dev_pg0_dma, GFP_KERNEL);
 539         if (spi_dev_pg0 == NULL) {
 540                 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
 541                     "dma_alloc_coherent for parameters failed\n", ioc->name);
 542                 return -EINVAL;
 543         }
 544 
 545         memset(&hdr, 0, sizeof(hdr));
 546 
 547         hdr.PageVersion = ioc->spi_data.sdp0version;
 548         hdr.PageLength = ioc->spi_data.sdp0length;
 549         hdr.PageNumber = 0;
 550         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 551 
 552         memset(&cfg, 0, sizeof(cfg));
 553 
 554         cfg.cfghdr.hdr = &hdr;
 555         cfg.physAddr = spi_dev_pg0_dma;
 556         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 557         cfg.dir = 0;
 558         cfg.pageAddr = starget->id;
 559         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 
 575 static 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 
 595 static 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 
 617 static int
 618 mptscsih_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 
 683 static 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 
 716 static 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 
 749 static 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 
 776 static int
 777 mptspi_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 
 802 static 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 
 823 static 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 
 849 static 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 
 934 static 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 
 959 static 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 
 991 static 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 
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_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 
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);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/message/fusion/mptspi.c

DEFINITIONS
