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-2005 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
  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
  66 #include "mptbase.h"
  67 #include "mptscsih.h"
  68
  69 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  70 #define my_NAME         "Fusion MPT SPI Host driver"
  71 #define my_VERSION      MPT_LINUX_VERSION_COMMON
  72 #define MYNAM           "mptspi"
  73
  74 MODULE_AUTHOR(MODULEAUTHOR);
  75 MODULE_DESCRIPTION(my_NAME);
  76 MODULE_LICENSE("GPL");
  77
  78 /* Command line args */
  79 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION
  80 static int mpt_dv = MPTSCSIH_DOMAIN_VALIDATION;
  81 module_param(mpt_dv, int, 0);
  82 MODULE_PARM_DESC(mpt_dv, " DV Algorithm: enhanced=1, basic=0 (default=MPTSCSIH_DOMAIN_VALIDATION=1)");
  83
  84 static int mpt_width = MPTSCSIH_MAX_WIDTH;
  85 module_param(mpt_width, int, 0);
  86 MODULE_PARM_DESC(mpt_width, " Max Bus Width: wide=1, narrow=0 (default=MPTSCSIH_MAX_WIDTH=1)");
  87
  88 static ushort mpt_factor = MPTSCSIH_MIN_SYNC;
  89 module_param(mpt_factor, ushort, 0);
  90 MODULE_PARM_DESC(mpt_factor, " Min Sync Factor (default=MPTSCSIH_MIN_SYNC=0x08)");
  91 #endif
  92
  93 static int mpt_saf_te = MPTSCSIH_SAF_TE;
  94 module_param(mpt_saf_te, int, 0);
  95 MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1  (default=MPTSCSIH_SAF_TE=0)");
  96
  97 static int mpt_pq_filter = 0;
  98 module_param(mpt_pq_filter, int, 0);
  99 MODULE_PARM_DESC(mpt_pq_filter, " Enable peripheral qualifier filter: enable=1  (default=0)");
 100
 101 static int      mptspiDoneCtx = -1;
 102 static int      mptspiTaskCtx = -1;
 103 static int      mptspiInternalCtx = -1; /* Used only for internal commands */
 104
 105 static struct scsi_host_template mptspi_driver_template = {
 106         .module                         = THIS_MODULE,
 107         .proc_name                      = "mptspi",
 108         .proc_info                      = mptscsih_proc_info,
 109         .name                           = "MPT SPI Host",
 110         .info                           = mptscsih_info,
 111         .queuecommand                   = mptscsih_qcmd,
 112         .slave_alloc                    = mptscsih_slave_alloc,
 113         .slave_configure                = mptscsih_slave_configure,
 114         .slave_destroy                  = mptscsih_slave_destroy,
 115         .change_queue_depth             = mptscsih_change_queue_depth,
 116         .eh_abort_handler               = mptscsih_abort,
 117         .eh_device_reset_handler        = mptscsih_dev_reset,
 118         .eh_bus_reset_handler           = mptscsih_bus_reset,
 119         .eh_host_reset_handler          = mptscsih_host_reset,
 120         .bios_param                     = mptscsih_bios_param,
 121         .can_queue                      = MPT_SCSI_CAN_QUEUE,
 122         .this_id                        = -1,
 123         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
 124         .max_sectors                    = 8192,
 125         .cmd_per_lun                    = 7,
 126         .use_clustering                 = ENABLE_CLUSTERING,
 127 };
 128
 129
 130 /****************************************************************************
 131  * Supported hardware
 132  */
 133
 134 static struct pci_device_id mptspi_pci_table[] = {
 135         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C1030,
 136                 PCI_ANY_ID, PCI_ANY_ID },
 137         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_1030_53C1035,
 138                 PCI_ANY_ID, PCI_ANY_ID },
 139         {0}     /* Terminating entry */
 140 };
 141 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
 142
 143 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 144 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 145 /*
 146  *      mptspi_probe - Installs scsi devices per bus.
 147  *      @pdev: Pointer to pci_dev structure
 148  *
 149  *      Returns 0 for success, non-zero for failure.
 150  *
 151  */
 152 static int
 153 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 154 {
 155         struct Scsi_Host        *sh;
 156         MPT_SCSI_HOST           *hd;
 157         MPT_ADAPTER             *ioc;
 158         unsigned long            flags;
 159         int                      sz, ii;
 160         int                      numSGE = 0;
 161         int                      scale;
 162         int                      ioc_cap;
 163         u8                      *mem;
 164         int                     error=0;
 165         int                     r;
 166
 167         if ((r = mpt_attach(pdev,id)) != 0)
 168                 return r;
 169
 170         ioc = pci_get_drvdata(pdev);
 171         ioc->DoneCtx = mptspiDoneCtx;
 172         ioc->TaskCtx = mptspiTaskCtx;
 173         ioc->InternalCtx = mptspiInternalCtx;
 174
 175         /*  Added sanity check on readiness of the MPT adapter.
 176          */
 177         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
 178                 printk(MYIOC_s_WARN_FMT
 179                   "Skipping because it's not operational!\n",
 180                   ioc->name);
 181                 return -ENODEV;
 182         }
 183
 184         if (!ioc->active) {
 185                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
 186                   ioc->name);
 187                 return -ENODEV;
 188         }
 189
 190         /*  Sanity check - ensure at least 1 port is INITIATOR capable
 191          */
 192         ioc_cap = 0;
 193         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
 194                 if (ioc->pfacts[ii].ProtocolFlags &
 195                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
 196                         ioc_cap ++;
 197         }
 198
 199         if (!ioc_cap) {
 200                 printk(MYIOC_s_WARN_FMT
 201                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
 202                         ioc->name, ioc);
 203                 return 0;
 204         }
 205
 206         sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
 207
 208         if (!sh) {
 209                 printk(MYIOC_s_WARN_FMT
 210                         "Unable to register controller with SCSI subsystem\n",
 211                         ioc->name);
 212                 return -1;
 213         }
 214
 215         spin_lock_irqsave(&ioc->FreeQlock, flags);
 216
 217         /* Attach the SCSI Host to the IOC structure
 218          */
 219         ioc->sh = sh;
 220
 221         sh->io_port = 0;
 222         sh->n_io_port = 0;
 223         sh->irq = 0;
 224
 225         /* set 16 byte cdb's */
 226         sh->max_cmd_len = 16;
 227
 228         /* Yikes!  This is important!
 229          * Otherwise, by default, linux
 230          * only scans target IDs 0-7!
 231          * pfactsN->MaxDevices unreliable
 232          * (not supported in early
 233          *      versions of the FW).
 234          * max_id = 1 + actual max id,
 235          * max_lun = 1 + actual last lun,
 236          *      see hosts.h :o(
 237          */
 238         sh->max_id = MPT_MAX_SCSI_DEVICES;
 239
 240         sh->max_lun = MPT_LAST_LUN + 1;
 241         sh->max_channel = 0;
 242         sh->this_id = ioc->pfacts[0].PortSCSIID;
 243
 244         /* Required entry.
 245          */
 246         sh->unique_id = ioc->id;
 247
 248         /* Verify that we won't exceed the maximum
 249          * number of chain buffers
 250          * We can optimize:  ZZ = req_sz/sizeof(SGE)
 251          * For 32bit SGE's:
 252          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
 253          *               + (req_sz - 64)/sizeof(SGE)
 254          * A slightly different algorithm is required for
 255          * 64bit SGEs.
 256          */
 257         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
 258         if (sizeof(dma_addr_t) == sizeof(u64)) {
 259                 numSGE = (scale - 1) *
 260                   (ioc->facts.MaxChainDepth-1) + scale +
 261                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
 262                   sizeof(u32));
 263         } else {
 264                 numSGE = 1 + (scale - 1) *
 265                   (ioc->facts.MaxChainDepth-1) + scale +
 266                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
 267                   sizeof(u32));
 268         }
 269
 270         if (numSGE < sh->sg_tablesize) {
 271                 /* Reset this value */
 272                 dprintk((MYIOC_s_INFO_FMT
 273                   "Resetting sg_tablesize to %d from %d\n",
 274                   ioc->name, numSGE, sh->sg_tablesize));
 275                 sh->sg_tablesize = numSGE;
 276         }
 277
 278         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
 279
 280         hd = (MPT_SCSI_HOST *) sh->hostdata;
 281         hd->ioc = ioc;
 282
 283         /* SCSI needs scsi_cmnd lookup table!
 284          * (with size equal to req_depth*PtrSz!)
 285          */
 286         sz = ioc->req_depth * sizeof(void *);
 287         mem = kmalloc(sz, GFP_ATOMIC);
 288         if (mem == NULL) {
 289                 error = -ENOMEM;
 290                 goto mptspi_probe_failed;
 291         }
 292
 293         memset(mem, 0, sz);
 294         hd->ScsiLookup = (struct scsi_cmnd **) mem;
 295
 296         dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p, sz=%d\n",
 297                  ioc->name, hd->ScsiLookup, sz));
 298
 299         /* Allocate memory for the device structures.
 300          * A non-Null pointer at an offset
 301          * indicates a device exists.
 302          * max_id = 1 + maximum id (hosts.h)
 303          */
 304         sz = sh->max_id * sizeof(void *);
 305         mem = kmalloc(sz, GFP_ATOMIC);
 306         if (mem == NULL) {
 307                 error = -ENOMEM;
 308                 goto mptspi_probe_failed;
 309         }
 310
 311         memset(mem, 0, sz);
 312         hd->Targets = (VirtDevice **) mem;
 313
 314         dprintk((KERN_INFO
 315           "  Targets @ %p, sz=%d\n", hd->Targets, sz));
 316
 317         /* Clear the TM flags
 318          */
 319         hd->tmPending = 0;
 320         hd->tmState = TM_STATE_NONE;
 321         hd->resetPending = 0;
 322         hd->abortSCpnt = NULL;
 323
 324         /* Clear the pointer used to store
 325          * single-threaded commands, i.e., those
 326          * issued during a bus scan, dv and
 327          * configuration pages.
 328          */
 329         hd->cmdPtr = NULL;
 330
 331         /* Initialize this SCSI Hosts' timers
 332          * To use, set the timer expires field
 333          * and add_timer
 334          */
 335         init_timer(&hd->timer);
 336         hd->timer.data = (unsigned long) hd;
 337         hd->timer.function = mptscsih_timer_expired;
 338
 339         ioc->spi_data.Saf_Te = mpt_saf_te;
 340         hd->mpt_pq_filter = mpt_pq_filter;
 341
 342 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION
 343         if (ioc->spi_data.maxBusWidth > mpt_width)
 344                 ioc->spi_data.maxBusWidth = mpt_width;
 345         if (ioc->spi_data.minSyncFactor < mpt_factor)
 346                 ioc->spi_data.minSyncFactor = mpt_factor;
 347         if (ioc->spi_data.minSyncFactor == MPT_ASYNC) {
 348                 ioc->spi_data.maxSyncOffset = 0;
 349         }
 350         ioc->spi_data.mpt_dv = mpt_dv;
 351         hd->negoNvram = 0;
 352
 353         ddvprintk((MYIOC_s_INFO_FMT
 354                 "dv %x width %x factor %x saf_te %x mpt_pq_filter %x\n",
 355                 ioc->name,
 356                 mpt_dv,
 357                 mpt_width,
 358                 mpt_factor,
 359                 mpt_saf_te,
 360                 mpt_pq_filter));
 361 #else
 362         hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
 363         ddvprintk((MYIOC_s_INFO_FMT
 364                 "saf_te %x mpt_pq_filter %x\n",
 365                 ioc->name,
 366                 mpt_saf_te,
 367                 mpt_pq_filter));
 368 #endif
 369
 370         ioc->spi_data.forceDv = 0;
 371         ioc->spi_data.noQas = 0;
 372
 373         for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++)
 374                 ioc->spi_data.dvStatus[ii] =
 375                   MPT_SCSICFG_NEGOTIATE;
 376
 377         for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++)
 378                 ioc->spi_data.dvStatus[ii] |=
 379                   MPT_SCSICFG_DV_NOT_DONE;
 380
 381         init_waitqueue_head(&hd->scandv_waitq);
 382         hd->scandv_wait_done = 0;
 383         hd->last_queue_full = 0;
 384
 385         error = scsi_add_host (sh, &ioc->pcidev->dev);
 386         if(error) {
 387                 dprintk((KERN_ERR MYNAM
 388                   "scsi_add_host failed\n"));
 389                 goto mptspi_probe_failed;
 390         }
 391
 392         scsi_scan_host(sh);
 393         return 0;
 394
 395 mptspi_probe_failed:
 396
 397         mptscsih_remove(pdev);
 398         return error;
 399 }
 400
 401 static struct pci_driver mptspi_driver = {
 402         .name           = "mptspi",
 403         .id_table       = mptspi_pci_table,
 404         .probe          = mptspi_probe,
 405         .remove         = __devexit_p(mptscsih_remove),
 406         .shutdown       = mptscsih_shutdown,
 407 #ifdef CONFIG_PM
 408         .suspend        = mptscsih_suspend,
 409         .resume         = mptscsih_resume,
 410 #endif
 411 };
 412
 413 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 414 /**
 415  *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with
 416  *      linux scsi mid-layer.
 417  *
 418  *      Returns 0 for success, non-zero for failure.
 419  */
 420 static int __init
 421 mptspi_init(void)
 422 {
 423
 424         show_mptmod_ver(my_NAME, my_VERSION);
 425
 426         mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
 427         mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
 428         mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
 429
 430         if (mpt_event_register(mptspiDoneCtx, mptscsih_event_process) == 0) {
 431                 devtprintk((KERN_INFO MYNAM
 432                   ": Registered for IOC event notifications\n"));
 433         }
 434
 435         if (mpt_reset_register(mptspiDoneCtx, mptscsih_ioc_reset) == 0) {
 436                 dprintk((KERN_INFO MYNAM
 437                   ": Registered for IOC reset notifications\n"));
 438         }
 439
 440         return pci_register_driver(&mptspi_driver);
 441 }
 442
 443 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 444 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 445 /**
 446  *      mptspi_exit - Unregisters MPT adapter(s)
 447  *
 448  */
 449 static void __exit
 450 mptspi_exit(void)
 451 {
 452         pci_unregister_driver(&mptspi_driver);
 453
 454         mpt_reset_deregister(mptspiDoneCtx);
 455         dprintk((KERN_INFO MYNAM
 456           ": Deregistered for IOC reset notifications\n"));
 457
 458         mpt_event_deregister(mptspiDoneCtx);
 459         dprintk((KERN_INFO MYNAM
 460           ": Deregistered for IOC event notifications\n"));
 461
 462         mpt_deregister(mptspiInternalCtx);
 463         mpt_deregister(mptspiTaskCtx);
 464         mpt_deregister(mptspiDoneCtx);
 465 }
 466
 467 module_init(mptspi_init);
 468 module_exit(mptspi_exit);