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

   1 /*
   2  *  linux/drivers/message/fusion/mptspi.c
   3  *      For use with LSI Logic PCI chip/adapter(s)
   4  *      running LSI Logic Fusion MPT (Message Passing Technology) firmware.
   5  *
   6  *  Copyright (c) 1999-2007 LSI Logic Corporation
   7  *  (mailto:mpt_linux_developer@lsil.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_compat.h"       /* linux-2.6 tweaks */
  48 #include <linux/module.h>
  49 #include <linux/kernel.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/sched.h>
  58 #include <linux/workqueue.h>
  59 #include <linux/raid_class.h>
  60
  61 #include <scsi/scsi.h>
  62 #include <scsi/scsi_cmnd.h>
  63 #include <scsi/scsi_device.h>
  64 #include <scsi/scsi_host.h>
  65 #include <scsi/scsi_tcq.h>
  66 #include <scsi/scsi_transport.h>
  67 #include <scsi/scsi_transport_spi.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 int      mptspiDoneCtx = -1;
  95 static int      mptspiTaskCtx = -1;
  96 static int      mptspiInternalCtx = -1; /* Used only for internal commands */
  97
  98 static int mptspi_target_alloc(struct scsi_target *starget)
  99 {
 100         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 101         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
 102         int ret;
 103
 104         if (hd == NULL)
 105                 return -ENODEV;
 106
 107         ret = mptscsih_target_alloc(starget);
 108         if (ret)
 109                 return ret;
 110
 111         /* if we're a device on virtual channel 1 and we're not part
 112          * of an array, just return here (otherwise the setup below
 113          * may actually affect a real physical device on channel 0 */
 114         if (starget->channel == 1 &&
 115             mptscsih_raid_id_to_num(hd, starget->id) < 0)
 116                 return 0;
 117
 118         if (hd->ioc->spi_data.nvram &&
 119             hd->ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
 120                 u32 nvram = hd->ioc->spi_data.nvram[starget->id];
 121                 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
 122                 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
 123         } else {
 124                 spi_min_period(starget) = hd->ioc->spi_data.minSyncFactor;
 125                 spi_max_width(starget) = hd->ioc->spi_data.maxBusWidth;
 126         }
 127         spi_max_offset(starget) = hd->ioc->spi_data.maxSyncOffset;
 128
 129         spi_offset(starget) = 0;
 130         mptspi_write_width(starget, 0);
 131
 132         return 0;
 133 }
 134
 135 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
 136                              struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
 137 {
 138         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 139         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
 140         struct _MPT_ADAPTER *ioc = hd->ioc;
 141         struct _CONFIG_PAGE_SCSI_DEVICE_0 *pg0;
 142         dma_addr_t pg0_dma;
 143         int size;
 144         struct _x_config_parms cfg;
 145         struct _CONFIG_PAGE_HEADER hdr;
 146         int err = -EBUSY;
 147
 148         /* No SPI parameters for RAID devices */
 149         if (starget->channel == 0 &&
 150             (hd->ioc->raid_data.isRaid & (1 << starget->id)))
 151                 return -1;
 152
 153         size = ioc->spi_data.sdp0length * 4;
 154         /*
 155         if (ioc->spi_data.sdp0length & 1)
 156                 size += size + 4;
 157         size += 2048;
 158         */
 159
 160         pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg0_dma, GFP_KERNEL);
 161         if (pg0 == NULL) {
 162                 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
 163                 return -EINVAL;
 164         }
 165
 166         memset(&hdr, 0, sizeof(hdr));
 167
 168         hdr.PageVersion = ioc->spi_data.sdp0version;
 169         hdr.PageLength = ioc->spi_data.sdp0length;
 170         hdr.PageNumber = 0;
 171         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 172
 173         memset(&cfg, 0, sizeof(cfg));
 174
 175         cfg.cfghdr.hdr = &hdr;
 176         cfg.physAddr = pg0_dma;
 177         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 178         cfg.dir = 0;
 179         cfg.pageAddr = starget->id;
 180
 181         if (mpt_config(ioc, &cfg)) {
 182                 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
 183                 goto out_free;
 184         }
 185         err = 0;
 186         memcpy(pass_pg0, pg0, size);
 187
 188  out_free:
 189         dma_free_coherent(&ioc->pcidev->dev, size, pg0, pg0_dma);
 190         return err;
 191 }
 192
 193 static u32 mptspi_getRP(struct scsi_target *starget)
 194 {
 195         u32 nego = 0;
 196
 197         nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
 198         nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
 199         nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
 200         nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
 201         nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
 202         nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
 203         nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
 204         nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
 205
 206         nego |= (spi_period(starget) <<  MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
 207         nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
 208         nego |= spi_width(starget) ?  MPI_SCSIDEVPAGE1_RP_WIDE : 0;
 209
 210         return nego;
 211 }
 212
 213 static void mptspi_read_parameters(struct scsi_target *starget)
 214 {
 215         int nego;
 216         struct _CONFIG_PAGE_SCSI_DEVICE_0 pg0;
 217
 218         mptspi_read_spi_device_pg0(starget, &pg0);
 219
 220         nego = le32_to_cpu(pg0.NegotiatedParameters);
 221
 222         spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
 223         spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
 224         spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
 225         spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
 226         spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
 227         spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
 228         spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
 229         spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
 230         spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
 231         spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
 232         spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
 233 }
 234
 235 static int
 236 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, int disk)
 237 {
 238         MpiRaidActionRequest_t  *pReq;
 239         MPT_FRAME_HDR           *mf;
 240
 241         /* Get and Populate a free Frame
 242          */
 243         if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
 244                 ddvprintk((MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
 245                                         hd->ioc->name));
 246                 return -EAGAIN;
 247         }
 248         pReq = (MpiRaidActionRequest_t *)mf;
 249         if (quiesce)
 250                 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
 251         else
 252                 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
 253         pReq->Reserved1 = 0;
 254         pReq->ChainOffset = 0;
 255         pReq->Function = MPI_FUNCTION_RAID_ACTION;
 256         pReq->VolumeID = disk;
 257         pReq->VolumeBus = 0;
 258         pReq->PhysDiskNum = 0;
 259         pReq->MsgFlags = 0;
 260         pReq->Reserved2 = 0;
 261         pReq->ActionDataWord = 0; /* Reserved for this action */
 262
 263         mpt_add_sge((char *)&pReq->ActionDataSGE,
 264                 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
 265
 266         ddvprintk((MYIOC_s_INFO_FMT "RAID Volume action %x id %d\n",
 267                         hd->ioc->name, action, io->id));
 268
 269         hd->pLocal = NULL;
 270         hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
 271         hd->scandv_wait_done = 0;
 272
 273         /* Save cmd pointer, for resource free if timeout or
 274          * FW reload occurs
 275          */
 276         hd->cmdPtr = mf;
 277
 278         add_timer(&hd->timer);
 279         mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
 280         wait_event(hd->scandv_waitq, hd->scandv_wait_done);
 281
 282         if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
 283                 return -1;
 284
 285         return 0;
 286 }
 287
 288 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
 289                              struct scsi_device *sdev)
 290 {
 291         VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 292
 293         /* no DV on RAID devices */
 294         if (sdev->channel == 0 &&
 295             (hd->ioc->raid_data.isRaid & (1 << sdev->id)))
 296                 return;
 297
 298         /* If this is a piece of a RAID, then quiesce first */
 299         if (sdev->channel == 1 &&
 300             mptscsih_quiesce_raid(hd, 1, vtarget->target_id) < 0) {
 301                 starget_printk(KERN_ERR, scsi_target(sdev),
 302                                "Integrated RAID quiesce failed\n");
 303                 return;
 304         }
 305
 306         spi_dv_device(sdev);
 307
 308         if (sdev->channel == 1 &&
 309             mptscsih_quiesce_raid(hd, 0, vtarget->target_id) < 0)
 310                 starget_printk(KERN_ERR, scsi_target(sdev),
 311                                "Integrated RAID resume failed\n");
 312
 313         mptspi_read_parameters(sdev->sdev_target);
 314         spi_display_xfer_agreement(sdev->sdev_target);
 315         mptspi_read_parameters(sdev->sdev_target);
 316 }
 317
 318 static int mptspi_slave_alloc(struct scsi_device *sdev)
 319 {
 320         int ret;
 321         MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
 322         /* gcc doesn't see that all uses of this variable occur within
 323          * the if() statements, so stop it from whining */
 324         int physdisknum = 0;
 325
 326         if (sdev->channel == 1) {
 327                 physdisknum = mptscsih_raid_id_to_num(hd, sdev->id);
 328
 329                 if (physdisknum < 0)
 330                         return physdisknum;
 331         }
 332
 333         ret = mptscsih_slave_alloc(sdev);
 334
 335         if (ret)
 336                 return ret;
 337
 338         if (sdev->channel == 1) {
 339                 VirtDevice *vdev = sdev->hostdata;
 340                 sdev->no_uld_attach = 1;
 341                 vdev->vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
 342                 /* The real channel for this device is zero */
 343                 vdev->vtarget->bus_id = 0;
 344                 /* The actual physdisknum (for RAID passthrough) */
 345                 vdev->vtarget->target_id = physdisknum;
 346         }
 347
 348         return 0;
 349 }
 350
 351 static int mptspi_slave_configure(struct scsi_device *sdev)
 352 {
 353         int ret = mptscsih_slave_configure(sdev);
 354         struct _MPT_SCSI_HOST *hd =
 355                 (struct _MPT_SCSI_HOST *)sdev->host->hostdata;
 356
 357         if (ret)
 358                 return ret;
 359
 360         if ((sdev->channel == 1 ||
 361              !(hd->ioc->raid_data.isRaid & (1 << sdev->id))) &&
 362             !spi_initial_dv(sdev->sdev_target))
 363                 mptspi_dv_device(hd, sdev);
 364
 365         return 0;
 366 }
 367
 368 static void mptspi_slave_destroy(struct scsi_device *sdev)
 369 {
 370         struct scsi_target *starget = scsi_target(sdev);
 371         VirtTarget *vtarget = starget->hostdata;
 372         VirtDevice *vdevice = sdev->hostdata;
 373
 374         /* Will this be the last lun on a non-raid device? */
 375         if (vtarget->num_luns == 1 && vdevice->configured_lun) {
 376                 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 377
 378                 /* Async Narrow */
 379                 pg1.RequestedParameters = 0;
 380                 pg1.Reserved = 0;
 381                 pg1.Configuration = 0;
 382
 383                 mptspi_write_spi_device_pg1(starget, &pg1);
 384         }
 385
 386         mptscsih_slave_destroy(sdev);
 387 }
 388
 389 static struct scsi_host_template mptspi_driver_template = {
 390         .module                         = THIS_MODULE,
 391         .proc_name                      = "mptspi",
 392         .proc_info                      = mptscsih_proc_info,
 393         .name                           = "MPT SPI Host",
 394         .info                           = mptscsih_info,
 395         .queuecommand                   = mptscsih_qcmd,
 396         .target_alloc                   = mptspi_target_alloc,
 397         .slave_alloc                    = mptspi_slave_alloc,
 398         .slave_configure                = mptspi_slave_configure,
 399         .target_destroy                 = mptscsih_target_destroy,
 400         .slave_destroy                  = mptspi_slave_destroy,
 401         .change_queue_depth             = mptscsih_change_queue_depth,
 402         .eh_abort_handler               = mptscsih_abort,
 403         .eh_device_reset_handler        = mptscsih_dev_reset,
 404         .eh_bus_reset_handler           = mptscsih_bus_reset,
 405         .eh_host_reset_handler          = mptscsih_host_reset,
 406         .bios_param                     = mptscsih_bios_param,
 407         .can_queue                      = MPT_SCSI_CAN_QUEUE,
 408         .this_id                        = -1,
 409         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
 410         .max_sectors                    = 8192,
 411         .cmd_per_lun                    = 7,
 412         .use_clustering                 = ENABLE_CLUSTERING,
 413 };
 414
 415 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
 416                                struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
 417 {
 418         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 419         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
 420         struct _MPT_ADAPTER *ioc = hd->ioc;
 421         struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
 422         dma_addr_t pg1_dma;
 423         int size;
 424         struct _x_config_parms cfg;
 425         struct _CONFIG_PAGE_HEADER hdr;
 426         int err = -EBUSY;
 427
 428         /* don't allow updating nego parameters on RAID devices */
 429         if (starget->channel == 0 &&
 430             (hd->ioc->raid_data.isRaid & (1 << starget->id)))
 431                 return -1;
 432
 433         size = ioc->spi_data.sdp1length * 4;
 434
 435         pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
 436         if (pg1 == NULL) {
 437                 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
 438                 return -EINVAL;
 439         }
 440
 441         memset(&hdr, 0, sizeof(hdr));
 442
 443         hdr.PageVersion = ioc->spi_data.sdp1version;
 444         hdr.PageLength = ioc->spi_data.sdp1length;
 445         hdr.PageNumber = 1;
 446         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 447
 448         memset(&cfg, 0, sizeof(cfg));
 449
 450         cfg.cfghdr.hdr = &hdr;
 451         cfg.physAddr = pg1_dma;
 452         cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 453         cfg.dir = 1;
 454         cfg.pageAddr = starget->id;
 455
 456         memcpy(pg1, pass_pg1, size);
 457
 458         pg1->Header.PageVersion = hdr.PageVersion;
 459         pg1->Header.PageLength = hdr.PageLength;
 460         pg1->Header.PageNumber = hdr.PageNumber;
 461         pg1->Header.PageType = hdr.PageType;
 462
 463         if (mpt_config(ioc, &cfg)) {
 464                 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
 465                 goto out_free;
 466         }
 467         err = 0;
 468
 469  out_free:
 470         dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
 471         return err;
 472 }
 473
 474 static void mptspi_write_offset(struct scsi_target *starget, int offset)
 475 {
 476         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 477         u32 nego;
 478
 479         if (offset < 0)
 480                 offset = 0;
 481
 482         if (offset > 255)
 483                 offset = 255;
 484
 485         if (spi_offset(starget) == -1)
 486                 mptspi_read_parameters(starget);
 487
 488         spi_offset(starget) = offset;
 489
 490         nego = mptspi_getRP(starget);
 491
 492         pg1.RequestedParameters = cpu_to_le32(nego);
 493         pg1.Reserved = 0;
 494         pg1.Configuration = 0;
 495
 496         mptspi_write_spi_device_pg1(starget, &pg1);
 497 }
 498
 499 static void mptspi_write_period(struct scsi_target *starget, int period)
 500 {
 501         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 502         u32 nego;
 503
 504         if (period < 8)
 505                 period = 8;
 506
 507         if (period > 255)
 508                 period = 255;
 509
 510         if (spi_period(starget) == -1)
 511                 mptspi_read_parameters(starget);
 512
 513         if (period == 8) {
 514                 spi_iu(starget) = 1;
 515                 spi_dt(starget) = 1;
 516         } else if (period == 9) {
 517                 spi_dt(starget) = 1;
 518         }
 519
 520         spi_period(starget) = period;
 521
 522         nego = mptspi_getRP(starget);
 523
 524         pg1.RequestedParameters = cpu_to_le32(nego);
 525         pg1.Reserved = 0;
 526         pg1.Configuration = 0;
 527
 528         mptspi_write_spi_device_pg1(starget, &pg1);
 529 }
 530
 531 static void mptspi_write_dt(struct scsi_target *starget, int dt)
 532 {
 533         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 534         u32 nego;
 535
 536         if (spi_period(starget) == -1)
 537                 mptspi_read_parameters(starget);
 538
 539         if (!dt && spi_period(starget) < 10)
 540                 spi_period(starget) = 10;
 541
 542         spi_dt(starget) = dt;
 543
 544         nego = mptspi_getRP(starget);
 545
 546
 547         pg1.RequestedParameters = cpu_to_le32(nego);
 548         pg1.Reserved = 0;
 549         pg1.Configuration = 0;
 550
 551         mptspi_write_spi_device_pg1(starget, &pg1);
 552 }
 553
 554 static void mptspi_write_iu(struct scsi_target *starget, int iu)
 555 {
 556         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 557         u32 nego;
 558
 559         if (spi_period(starget) == -1)
 560                 mptspi_read_parameters(starget);
 561
 562         if (!iu && spi_period(starget) < 9)
 563                 spi_period(starget) = 9;
 564
 565         spi_iu(starget) = iu;
 566
 567         nego = mptspi_getRP(starget);
 568
 569         pg1.RequestedParameters = cpu_to_le32(nego);
 570         pg1.Reserved = 0;
 571         pg1.Configuration = 0;
 572
 573         mptspi_write_spi_device_pg1(starget, &pg1);
 574 }
 575
 576 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm)                              \
 577 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
 578 {                                                                       \
 579         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;                          \
 580         u32 nego;                                                       \
 581                                                                         \
 582         spi_##parm(starget) = parm;                                     \
 583                                                                         \
 584         nego = mptspi_getRP(starget);                                   \
 585                                                                         \
 586         pg1.RequestedParameters = cpu_to_le32(nego);                    \
 587         pg1.Reserved = 0;                                               \
 588         pg1.Configuration = 0;                                          \
 589                                                                         \
 590         mptspi_write_spi_device_pg1(starget, &pg1);                             \
 591 }
 592
 593 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
 594 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
 595 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
 596 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
 597 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
 598
 599 static void mptspi_write_qas(struct scsi_target *starget, int qas)
 600 {
 601         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 602         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 603         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
 604         VirtTarget *vtarget = starget->hostdata;
 605         u32 nego;
 606
 607         if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
 608             hd->ioc->spi_data.noQas)
 609                 spi_qas(starget) = 0;
 610         else
 611                 spi_qas(starget) = qas;
 612
 613         nego = mptspi_getRP(starget);
 614
 615         pg1.RequestedParameters = cpu_to_le32(nego);
 616         pg1.Reserved = 0;
 617         pg1.Configuration = 0;
 618
 619         mptspi_write_spi_device_pg1(starget, &pg1);
 620 }
 621
 622 static void mptspi_write_width(struct scsi_target *starget, int width)
 623 {
 624         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 625         u32 nego;
 626
 627         if (!width) {
 628                 spi_dt(starget) = 0;
 629                 if (spi_period(starget) < 10)
 630                         spi_period(starget) = 10;
 631         }
 632
 633         spi_width(starget) = width;
 634
 635         nego = mptspi_getRP(starget);
 636
 637         pg1.RequestedParameters = cpu_to_le32(nego);
 638         pg1.Reserved = 0;
 639         pg1.Configuration = 0;
 640
 641         mptspi_write_spi_device_pg1(starget, &pg1);
 642 }
 643
 644 struct work_queue_wrapper {
 645         struct work_struct      work;
 646         struct _MPT_SCSI_HOST   *hd;
 647         int                     disk;
 648 };
 649
 650 static void mpt_work_wrapper(struct work_struct *work)
 651 {
 652         struct work_queue_wrapper *wqw =
 653                 container_of(work, struct work_queue_wrapper, work);
 654         struct _MPT_SCSI_HOST *hd = wqw->hd;
 655         struct Scsi_Host *shost = hd->ioc->sh;
 656         struct scsi_device *sdev;
 657         int disk = wqw->disk;
 658         struct _CONFIG_PAGE_IOC_3 *pg3;
 659
 660         kfree(wqw);
 661
 662         mpt_findImVolumes(hd->ioc);
 663         pg3 = hd->ioc->raid_data.pIocPg3;
 664         if (!pg3)
 665                 return;
 666
 667         shost_for_each_device(sdev,shost) {
 668                 struct scsi_target *starget = scsi_target(sdev);
 669                 VirtTarget *vtarget = starget->hostdata;
 670
 671                 /* only want to search RAID components */
 672                 if (sdev->channel != 1)
 673                         continue;
 674
 675                 /* The target_id is the raid PhysDiskNum, even if
 676                  * starget->id is the actual target address */
 677                 if(vtarget->target_id != disk)
 678                         continue;
 679
 680                 starget_printk(KERN_INFO, vtarget->starget,
 681                                "Integrated RAID requests DV of new device\n");
 682                 mptspi_dv_device(hd, sdev);
 683         }
 684         shost_printk(KERN_INFO, shost,
 685                      "Integrated RAID detects new device %d\n", disk);
 686         scsi_scan_target(&hd->ioc->sh->shost_gendev, 1, disk, 0, 1);
 687 }
 688
 689
 690 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
 691 {
 692         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
 693
 694         if (!wqw) {
 695                 shost_printk(KERN_ERR, hd->ioc->sh,
 696                              "Failed to act on RAID event for physical disk %d\n",
 697                            disk);
 698                 return;
 699         }
 700         INIT_WORK(&wqw->work, mpt_work_wrapper);
 701         wqw->hd = hd;
 702         wqw->disk = disk;
 703
 704         schedule_work(&wqw->work);
 705 }
 706
 707 static int
 708 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
 709 {
 710         u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
 711         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
 712
 713         if (hd && event ==  MPI_EVENT_INTEGRATED_RAID) {
 714                 int reason
 715                         = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
 716
 717                 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
 718                         int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
 719                         mpt_dv_raid(hd, disk);
 720                 }
 721         }
 722         return mptscsih_event_process(ioc, pEvReply);
 723 }
 724
 725 static int
 726 mptspi_deny_binding(struct scsi_target *starget)
 727 {
 728         struct _MPT_SCSI_HOST *hd =
 729                 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
 730         return ((hd->ioc->raid_data.isRaid & (1 << starget->id)) &&
 731                 starget->channel == 0) ? 1 : 0;
 732 }
 733
 734 static struct spi_function_template mptspi_transport_functions = {
 735         .get_offset     = mptspi_read_parameters,
 736         .set_offset     = mptspi_write_offset,
 737         .show_offset    = 1,
 738         .get_period     = mptspi_read_parameters,
 739         .set_period     = mptspi_write_period,
 740         .show_period    = 1,
 741         .get_width      = mptspi_read_parameters,
 742         .set_width      = mptspi_write_width,
 743         .show_width     = 1,
 744         .get_iu         = mptspi_read_parameters,
 745         .set_iu         = mptspi_write_iu,
 746         .show_iu        = 1,
 747         .get_dt         = mptspi_read_parameters,
 748         .set_dt         = mptspi_write_dt,
 749         .show_dt        = 1,
 750         .get_qas        = mptspi_read_parameters,
 751         .set_qas        = mptspi_write_qas,
 752         .show_qas       = 1,
 753         .get_wr_flow    = mptspi_read_parameters,
 754         .set_wr_flow    = mptspi_write_wr_flow,
 755         .show_wr_flow   = 1,
 756         .get_rd_strm    = mptspi_read_parameters,
 757         .set_rd_strm    = mptspi_write_rd_strm,
 758         .show_rd_strm   = 1,
 759         .get_rti        = mptspi_read_parameters,
 760         .set_rti        = mptspi_write_rti,
 761         .show_rti       = 1,
 762         .get_pcomp_en   = mptspi_read_parameters,
 763         .set_pcomp_en   = mptspi_write_pcomp_en,
 764         .show_pcomp_en  = 1,
 765         .get_hold_mcs   = mptspi_read_parameters,
 766         .set_hold_mcs   = mptspi_write_hold_mcs,
 767         .show_hold_mcs  = 1,
 768         .deny_binding   = mptspi_deny_binding,
 769 };
 770
 771 /****************************************************************************
 772  * Supported hardware
 773  */
 774
 775 static struct pci_device_id mptspi_pci_table[] = {
 776         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
 777                 PCI_ANY_ID, PCI_ANY_ID },
 778         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
 779                 PCI_ANY_ID, PCI_ANY_ID },
 780         {0}     /* Terminating entry */
 781 };
 782 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
 783
 784
 785 /*
 786  * renegotiate for a given target
 787  */
 788 static void
 789 mptspi_dv_renegotiate_work(struct work_struct *work)
 790 {
 791         struct work_queue_wrapper *wqw =
 792                 container_of(work, struct work_queue_wrapper, work);
 793         struct _MPT_SCSI_HOST *hd = wqw->hd;
 794         struct scsi_device *sdev;
 795
 796         kfree(wqw);
 797
 798         shost_for_each_device(sdev, hd->ioc->sh)
 799                 mptspi_dv_device(hd, sdev);
 800 }
 801
 802 static void
 803 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
 804 {
 805         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
 806
 807         if (!wqw)
 808                 return;
 809
 810         INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
 811         wqw->hd = hd;
 812
 813         schedule_work(&wqw->work);
 814 }
 815
 816 /*
 817  * spi module reset handler
 818  */
 819 static int
 820 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
 821 {
 822         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
 823         int rc;
 824
 825         rc = mptscsih_ioc_reset(ioc, reset_phase);
 826
 827         if (reset_phase == MPT_IOC_POST_RESET)
 828                 mptspi_dv_renegotiate(hd);
 829
 830         return rc;
 831 }
 832
 833 #ifdef CONFIG_PM
 834 /*
 835  * spi module resume handler
 836  */
 837 static int
 838 mptspi_resume(struct pci_dev *pdev)
 839 {
 840         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
 841         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
 842         int rc;
 843
 844         rc = mptscsih_resume(pdev);
 845         mptspi_dv_renegotiate(hd);
 846
 847         return rc;
 848 }
 849 #endif
 850
 851 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 852 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 853 /*
 854  *      mptspi_probe - Installs scsi devices per bus.
 855  *      @pdev: Pointer to pci_dev structure
 856  *
 857  *      Returns 0 for success, non-zero for failure.
 858  *
 859  */
 860 static int
 861 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 862 {
 863         struct Scsi_Host        *sh;
 864         MPT_SCSI_HOST           *hd;
 865         MPT_ADAPTER             *ioc;
 866         unsigned long            flags;
 867         int                      ii;
 868         int                      numSGE = 0;
 869         int                      scale;
 870         int                      ioc_cap;
 871         int                     error=0;
 872         int                     r;
 873
 874         if ((r = mpt_attach(pdev,id)) != 0)
 875                 return r;
 876
 877         ioc = pci_get_drvdata(pdev);
 878         ioc->DoneCtx = mptspiDoneCtx;
 879         ioc->TaskCtx = mptspiTaskCtx;
 880         ioc->InternalCtx = mptspiInternalCtx;
 881
 882         /*  Added sanity check on readiness of the MPT adapter.
 883          */
 884         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
 885                 printk(MYIOC_s_WARN_FMT
 886                   "Skipping because it's not operational!\n",
 887                   ioc->name);
 888                 error = -ENODEV;
 889                 goto out_mptspi_probe;
 890         }
 891
 892         if (!ioc->active) {
 893                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
 894                   ioc->name);
 895                 error = -ENODEV;
 896                 goto out_mptspi_probe;
 897         }
 898
 899         /*  Sanity check - ensure at least 1 port is INITIATOR capable
 900          */
 901         ioc_cap = 0;
 902         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
 903                 if (ioc->pfacts[ii].ProtocolFlags &
 904                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
 905                         ioc_cap ++;
 906         }
 907
 908         if (!ioc_cap) {
 909                 printk(MYIOC_s_WARN_FMT
 910                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
 911                         ioc->name, ioc);
 912                 return 0;
 913         }
 914
 915         sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
 916
 917         if (!sh) {
 918                 printk(MYIOC_s_WARN_FMT
 919                         "Unable to register controller with SCSI subsystem\n",
 920                         ioc->name);
 921                 error = -1;
 922                 goto out_mptspi_probe;
 923         }
 924
 925         spin_lock_irqsave(&ioc->FreeQlock, flags);
 926
 927         /* Attach the SCSI Host to the IOC structure
 928          */
 929         ioc->sh = sh;
 930
 931         sh->io_port = 0;
 932         sh->n_io_port = 0;
 933         sh->irq = 0;
 934
 935         /* set 16 byte cdb's */
 936         sh->max_cmd_len = 16;
 937
 938         /* Yikes!  This is important!
 939          * Otherwise, by default, linux
 940          * only scans target IDs 0-7!
 941          * pfactsN->MaxDevices unreliable
 942          * (not supported in early
 943          *      versions of the FW).
 944          * max_id = 1 + actual max id,
 945          * max_lun = 1 + actual last lun,
 946          *      see hosts.h :o(
 947          */
 948         sh->max_id = MPT_MAX_SCSI_DEVICES;
 949
 950         sh->max_lun = MPT_LAST_LUN + 1;
 951         /*
 952          * If RAID Firmware Detected, setup virtual channel
 953          */
 954         if ((ioc->facts.ProductID & MPI_FW_HEADER_PID_PROD_MASK)
 955             > MPI_FW_HEADER_PID_PROD_TARGET_SCSI)
 956                 sh->max_channel = 1;
 957         else
 958                 sh->max_channel = 0;
 959         sh->this_id = ioc->pfacts[0].PortSCSIID;
 960
 961         /* Required entry.
 962          */
 963         sh->unique_id = ioc->id;
 964
 965         /* Verify that we won't exceed the maximum
 966          * number of chain buffers
 967          * We can optimize:  ZZ = req_sz/sizeof(SGE)
 968          * For 32bit SGE's:
 969          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
 970          *               + (req_sz - 64)/sizeof(SGE)
 971          * A slightly different algorithm is required for
 972          * 64bit SGEs.
 973          */
 974         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
 975         if (sizeof(dma_addr_t) == sizeof(u64)) {
 976                 numSGE = (scale - 1) *
 977                   (ioc->facts.MaxChainDepth-1) + scale +
 978                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
 979                   sizeof(u32));
 980         } else {
 981                 numSGE = 1 + (scale - 1) *
 982                   (ioc->facts.MaxChainDepth-1) + scale +
 983                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
 984                   sizeof(u32));
 985         }
 986
 987         if (numSGE < sh->sg_tablesize) {
 988                 /* Reset this value */
 989                 dprintk((MYIOC_s_INFO_FMT
 990                   "Resetting sg_tablesize to %d from %d\n",
 991                   ioc->name, numSGE, sh->sg_tablesize));
 992                 sh->sg_tablesize = numSGE;
 993         }
 994
 995         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
 996
 997         hd = (MPT_SCSI_HOST *) sh->hostdata;
 998         hd->ioc = ioc;
 999
1000         /* SCSI needs scsi_cmnd lookup table!
1001          * (with size equal to req_depth*PtrSz!)
1002          */
1003         hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1004         if (!hd->ScsiLookup) {
1005                 error = -ENOMEM;
1006                 goto out_mptspi_probe;
1007         }
1008
1009         dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
1010                  ioc->name, hd->ScsiLookup));
1011
1012         /* Allocate memory for the device structures.
1013          * A non-Null pointer at an offset
1014          * indicates a device exists.
1015          * max_id = 1 + maximum id (hosts.h)
1016          */
1017         hd->Targets = kcalloc(sh->max_id * (sh->max_channel + 1),
1018                               sizeof(void *), GFP_ATOMIC);
1019         if (!hd->Targets) {
1020                 error = -ENOMEM;
1021                 goto out_mptspi_probe;
1022         }
1023
1024         dprintk((KERN_INFO "  vdev @ %p\n", hd->Targets));
1025
1026         /* Clear the TM flags
1027          */
1028         hd->tmPending = 0;
1029         hd->tmState = TM_STATE_NONE;
1030         hd->resetPending = 0;
1031         hd->abortSCpnt = NULL;
1032
1033         /* Clear the pointer used to store
1034          * single-threaded commands, i.e., those
1035          * issued during a bus scan, dv and
1036          * configuration pages.
1037          */
1038         hd->cmdPtr = NULL;
1039
1040         /* Initialize this SCSI Hosts' timers
1041          * To use, set the timer expires field
1042          * and add_timer
1043          */
1044         init_timer(&hd->timer);
1045         hd->timer.data = (unsigned long) hd;
1046         hd->timer.function = mptscsih_timer_expired;
1047
1048         ioc->spi_data.Saf_Te = mpt_saf_te;
1049
1050         hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1051         ddvprintk((MYIOC_s_INFO_FMT
1052                 "saf_te %x\n",
1053                 ioc->name,
1054                 mpt_saf_te));
1055         ioc->spi_data.noQas = 0;
1056
1057         init_waitqueue_head(&hd->scandv_waitq);
1058         hd->scandv_wait_done = 0;
1059         hd->last_queue_full = 0;
1060
1061         /* Some versions of the firmware don't support page 0; without
1062          * that we can't get the parameters */
1063         if (hd->ioc->spi_data.sdp0length != 0)
1064                 sh->transportt = mptspi_transport_template;
1065
1066         error = scsi_add_host (sh, &ioc->pcidev->dev);
1067         if(error) {
1068                 dprintk((KERN_ERR MYNAM
1069                   "scsi_add_host failed\n"));
1070                 goto out_mptspi_probe;
1071         }
1072
1073         /*
1074          * issue internal bus reset
1075          */
1076         if (ioc->spi_data.bus_reset)
1077                 mptscsih_TMHandler(hd,
1078                     MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1079                     0, 0, 0, 0, 5);
1080
1081         scsi_scan_host(sh);
1082         return 0;
1083
1084 out_mptspi_probe:
1085
1086         mptscsih_remove(pdev);
1087         return error;
1088 }
1089
1090 static struct pci_driver mptspi_driver = {
1091         .name           = "mptspi",
1092         .id_table       = mptspi_pci_table,
1093         .probe          = mptspi_probe,
1094         .remove         = __devexit_p(mptscsih_remove),
1095         .shutdown       = mptscsih_shutdown,
1096 #ifdef CONFIG_PM
1097         .suspend        = mptscsih_suspend,
1098         .resume         = mptspi_resume,
1099 #endif
1100 };
1101
1102 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1103 /**
1104  *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1105  *
1106  *      Returns 0 for success, non-zero for failure.
1107  */
1108 static int __init
1109 mptspi_init(void)
1110 {
1111         show_mptmod_ver(my_NAME, my_VERSION);
1112
1113         mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1114         if (!mptspi_transport_template)
1115                 return -ENODEV;
1116
1117         mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1118         mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1119         mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1120
1121         if (mpt_event_register(mptspiDoneCtx, mptspi_event_process) == 0) {
1122                 devtverboseprintk((KERN_INFO MYNAM
1123                   ": Registered for IOC event notifications\n"));
1124         }
1125
1126         if (mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset) == 0) {
1127                 dprintk((KERN_INFO MYNAM
1128                   ": Registered for IOC reset notifications\n"));
1129         }
1130
1131         return pci_register_driver(&mptspi_driver);
1132 }
1133
1134 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1135 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1136 /**
1137  *      mptspi_exit - Unregisters MPT adapter(s)
1138  */
1139 static void __exit
1140 mptspi_exit(void)
1141 {
1142         pci_unregister_driver(&mptspi_driver);
1143
1144         mpt_reset_deregister(mptspiDoneCtx);
1145         dprintk((KERN_INFO MYNAM
1146           ": Deregistered for IOC reset notifications\n"));
1147
1148         mpt_event_deregister(mptspiDoneCtx);
1149         dprintk((KERN_INFO MYNAM
1150           ": Deregistered for IOC event notifications\n"));
1151
1152         mpt_deregister(mptspiInternalCtx);
1153         mpt_deregister(mptspiTaskCtx);
1154         mpt_deregister(mptspiDoneCtx);
1155         spi_release_transport(mptspi_transport_template);
1156 }
1157
1158 module_init(mptspi_init);
1159 module_exit(mptspi_exit);