drivers/message/fusion/mptfc.c

   1 /*
   2  *  linux/drivers/message/fusion/mptfc.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 #include "linux_compat.h"       /* linux-2.6 tweaks */
  47 #include <linux/module.h>
  48 #include <linux/kernel.h>
  49 #include <linux/init.h>
  50 #include <linux/errno.h>
  51 #include <linux/kdev_t.h>
  52 #include <linux/blkdev.h>
  53 #include <linux/delay.h>        /* for mdelay */
  54 #include <linux/interrupt.h>    /* needed for in_interrupt() proto */
  55 #include <linux/reboot.h>       /* notifier code */
  56 #include <linux/sched.h>
  57 #include <linux/workqueue.h>
  58 #include <linux/sort.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_fc.h>
  66
  67 #include "mptbase.h"
  68 #include "mptscsih.h"
  69
  70 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  71 #define my_NAME         "Fusion MPT FC Host driver"
  72 #define my_VERSION      MPT_LINUX_VERSION_COMMON
  73 #define MYNAM           "mptfc"
  74
  75 MODULE_AUTHOR(MODULEAUTHOR);
  76 MODULE_DESCRIPTION(my_NAME);
  77 MODULE_LICENSE("GPL");
  78
  79 /* Command line args */
  80 static int mpt_pq_filter = 0;
  81 module_param(mpt_pq_filter, int, 0);
  82 MODULE_PARM_DESC(mpt_pq_filter, " Enable peripheral qualifier filter: enable=1  (default=0)");
  83
  84 #define MPTFC_DEV_LOSS_TMO (60)
  85 static int mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO;     /* reasonable default */
  86 module_param(mptfc_dev_loss_tmo, int, 0);
  87 MODULE_PARM_DESC(mptfc_dev_loss_tmo, " Initial time the driver programs the "
  88                                      " transport to wait for an rport to "
  89                                      " return following a device loss event."
  90                                      "  Default=60.");
  91
  92 static int      mptfcDoneCtx = -1;
  93 static int      mptfcTaskCtx = -1;
  94 static int      mptfcInternalCtx = -1; /* Used only for internal commands */
  95
  96 static int mptfc_target_alloc(struct scsi_target *starget);
  97 static int mptfc_slave_alloc(struct scsi_device *sdev);
  98 static int mptfc_qcmd(struct scsi_cmnd *SCpnt,
  99                       void (*done)(struct scsi_cmnd *));
 100 static void mptfc_target_destroy(struct scsi_target *starget);
 101 static void mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout);
 102 static void __devexit mptfc_remove(struct pci_dev *pdev);
 103
 104 static struct scsi_host_template mptfc_driver_template = {
 105         .module                         = THIS_MODULE,
 106         .proc_name                      = "mptfc",
 107         .proc_info                      = mptscsih_proc_info,
 108         .name                           = "MPT FC Host",
 109         .info                           = mptscsih_info,
 110         .queuecommand                   = mptfc_qcmd,
 111         .target_alloc                   = mptfc_target_alloc,
 112         .slave_alloc                    = mptfc_slave_alloc,
 113         .slave_configure                = mptscsih_slave_configure,
 114         .target_destroy                 = mptfc_target_destroy,
 115         .slave_destroy                  = mptscsih_slave_destroy,
 116         .change_queue_depth             = mptscsih_change_queue_depth,
 117         .eh_abort_handler               = mptscsih_abort,
 118         .eh_device_reset_handler        = mptscsih_dev_reset,
 119         .eh_bus_reset_handler           = mptscsih_bus_reset,
 120         .eh_host_reset_handler          = mptscsih_host_reset,
 121         .bios_param                     = mptscsih_bios_param,
 122         .can_queue                      = MPT_FC_CAN_QUEUE,
 123         .this_id                        = -1,
 124         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
 125         .max_sectors                    = 8192,
 126         .cmd_per_lun                    = 7,
 127         .use_clustering                 = ENABLE_CLUSTERING,
 128 };
 129
 130 /****************************************************************************
 131  * Supported hardware
 132  */
 133
 134 static struct pci_device_id mptfc_pci_table[] = {
 135         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC909,
 136                 PCI_ANY_ID, PCI_ANY_ID },
 137         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC919,
 138                 PCI_ANY_ID, PCI_ANY_ID },
 139         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC929,
 140                 PCI_ANY_ID, PCI_ANY_ID },
 141         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC919X,
 142                 PCI_ANY_ID, PCI_ANY_ID },
 143         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC929X,
 144                 PCI_ANY_ID, PCI_ANY_ID },
 145         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC939X,
 146                 PCI_ANY_ID, PCI_ANY_ID },
 147         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC949X,
 148                 PCI_ANY_ID, PCI_ANY_ID },
 149         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC949ES,
 150                 PCI_ANY_ID, PCI_ANY_ID },
 151         {0}     /* Terminating entry */
 152 };
 153 MODULE_DEVICE_TABLE(pci, mptfc_pci_table);
 154
 155 static struct scsi_transport_template *mptfc_transport_template = NULL;
 156
 157 static struct fc_function_template mptfc_transport_functions = {
 158         .dd_fcrport_size = 8,
 159         .show_host_node_name = 1,
 160         .show_host_port_name = 1,
 161         .show_host_supported_classes = 1,
 162         .show_host_port_id = 1,
 163         .show_rport_supported_classes = 1,
 164         .show_starget_node_name = 1,
 165         .show_starget_port_name = 1,
 166         .show_starget_port_id = 1,
 167         .set_rport_dev_loss_tmo = mptfc_set_rport_loss_tmo,
 168         .show_rport_dev_loss_tmo = 1,
 169
 170 };
 171
 172 /* FIXME! values controlling firmware RESCAN event
 173  * need to be set low to allow dev_loss_tmo to
 174  * work as expected.  Currently, firmware doesn't
 175  * notify driver of RESCAN event until some number
 176  * of seconds elapse.  This value can be set via
 177  * lsiutil.
 178  */
 179 static void
 180 mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
 181 {
 182         if (timeout > 0)
 183                 rport->dev_loss_tmo = timeout;
 184         else
 185                 rport->dev_loss_tmo = mptfc_dev_loss_tmo;
 186 }
 187
 188 static int
 189 mptfc_FcDevPage0_cmp_func(const void *a, const void *b)
 190 {
 191         FCDevicePage0_t **aa = (FCDevicePage0_t **)a;
 192         FCDevicePage0_t **bb = (FCDevicePage0_t **)b;
 193
 194         if ((*aa)->CurrentBus == (*bb)->CurrentBus) {
 195                 if ((*aa)->CurrentTargetID == (*bb)->CurrentTargetID)
 196                         return 0;
 197                 if ((*aa)->CurrentTargetID < (*bb)->CurrentTargetID)
 198                         return -1;
 199                 return 1;
 200         }
 201         if ((*aa)->CurrentBus < (*bb)->CurrentBus)
 202                 return -1;
 203         return 1;
 204 }
 205
 206 static int
 207 mptfc_GetFcDevPage0(MPT_ADAPTER *ioc, int ioc_port,
 208         void(*func)(MPT_ADAPTER *ioc,int channel, FCDevicePage0_t *arg))
 209 {
 210         ConfigPageHeader_t       hdr;
 211         CONFIGPARMS              cfg;
 212         FCDevicePage0_t         *ppage0_alloc, *fc;
 213         dma_addr_t               page0_dma;
 214         int                      data_sz;
 215         int                      ii;
 216
 217         FCDevicePage0_t         *p0_array=NULL, *p_p0;
 218         FCDevicePage0_t         **pp0_array=NULL, **p_pp0;
 219
 220         int                      rc = -ENOMEM;
 221         U32                      port_id = 0xffffff;
 222         int                      num_targ = 0;
 223         int                      max_bus = ioc->facts.MaxBuses;
 224         int                      max_targ = ioc->facts.MaxDevices;
 225
 226         if (max_bus == 0 || max_targ == 0)
 227                 goto out;
 228
 229         data_sz = sizeof(FCDevicePage0_t) * max_bus * max_targ;
 230         p_p0 = p0_array =  kzalloc(data_sz, GFP_KERNEL);
 231         if (!p0_array)
 232                 goto out;
 233
 234         data_sz = sizeof(FCDevicePage0_t *) * max_bus * max_targ;
 235         p_pp0 = pp0_array = kzalloc(data_sz, GFP_KERNEL);
 236         if (!pp0_array)
 237                 goto out;
 238
 239         do {
 240                 /* Get FC Device Page 0 header */
 241                 hdr.PageVersion = 0;
 242                 hdr.PageLength = 0;
 243                 hdr.PageNumber = 0;
 244                 hdr.PageType = MPI_CONFIG_PAGETYPE_FC_DEVICE;
 245                 cfg.cfghdr.hdr = &hdr;
 246                 cfg.physAddr = -1;
 247                 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 248                 cfg.dir = 0;
 249                 cfg.pageAddr = port_id;
 250                 cfg.timeout = 0;
 251
 252                 if ((rc = mpt_config(ioc, &cfg)) != 0)
 253                         break;
 254
 255                 if (hdr.PageLength <= 0)
 256                         break;
 257
 258                 data_sz = hdr.PageLength * 4;
 259                 ppage0_alloc = pci_alloc_consistent(ioc->pcidev, data_sz,
 260                                                         &page0_dma);
 261                 rc = -ENOMEM;
 262                 if (!ppage0_alloc)
 263                         break;
 264
 265                 cfg.physAddr = page0_dma;
 266                 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 267
 268                 if ((rc = mpt_config(ioc, &cfg)) == 0) {
 269                         ppage0_alloc->PortIdentifier =
 270                                 le32_to_cpu(ppage0_alloc->PortIdentifier);
 271
 272                         ppage0_alloc->WWNN.Low =
 273                                 le32_to_cpu(ppage0_alloc->WWNN.Low);
 274
 275                         ppage0_alloc->WWNN.High =
 276                                 le32_to_cpu(ppage0_alloc->WWNN.High);
 277
 278                         ppage0_alloc->WWPN.Low =
 279                                 le32_to_cpu(ppage0_alloc->WWPN.Low);
 280
 281                         ppage0_alloc->WWPN.High =
 282                                 le32_to_cpu(ppage0_alloc->WWPN.High);
 283
 284                         ppage0_alloc->BBCredit =
 285                                 le16_to_cpu(ppage0_alloc->BBCredit);
 286
 287                         ppage0_alloc->MaxRxFrameSize =
 288                                 le16_to_cpu(ppage0_alloc->MaxRxFrameSize);
 289
 290                         port_id = ppage0_alloc->PortIdentifier;
 291                         num_targ++;
 292                         *p_p0 = *ppage0_alloc;  /* save data */
 293                         *p_pp0++ = p_p0++;      /* save addr */
 294                 }
 295                 pci_free_consistent(ioc->pcidev, data_sz,
 296                                         (u8 *) ppage0_alloc, page0_dma);
 297                 if (rc != 0)
 298                         break;
 299
 300         } while (port_id <= 0xff0000);
 301
 302         if (num_targ) {
 303                 /* sort array */
 304                 if (num_targ > 1)
 305                         sort (pp0_array, num_targ, sizeof(FCDevicePage0_t *),
 306                                 mptfc_FcDevPage0_cmp_func, NULL);
 307                 /* call caller's func for each targ */
 308                 for (ii = 0; ii < num_targ;  ii++) {
 309                         fc = *(pp0_array+ii);
 310                         func(ioc, ioc_port, fc);
 311                 }
 312         }
 313
 314  out:
 315         if (pp0_array)
 316                 kfree(pp0_array);
 317         if (p0_array)
 318                 kfree(p0_array);
 319         return rc;
 320 }
 321
 322 static int
 323 mptfc_generate_rport_ids(FCDevicePage0_t *pg0, struct fc_rport_identifiers *rid)
 324 {
 325         /* not currently usable */
 326         if (pg0->Flags & (MPI_FC_DEVICE_PAGE0_FLAGS_PLOGI_INVALID |
 327                           MPI_FC_DEVICE_PAGE0_FLAGS_PRLI_INVALID))
 328                 return -1;
 329
 330         if (!(pg0->Flags & MPI_FC_DEVICE_PAGE0_FLAGS_TARGETID_BUS_VALID))
 331                 return -1;
 332
 333         if (!(pg0->Protocol & MPI_FC_DEVICE_PAGE0_PROT_FCP_TARGET))
 334                 return -1;
 335
 336         /*
 337          * board data structure already normalized to platform endianness
 338          * shifted to avoid unaligned access on 64 bit architecture
 339          */
 340         rid->node_name = ((u64)pg0->WWNN.High) << 32 | (u64)pg0->WWNN.Low;
 341         rid->port_name = ((u64)pg0->WWPN.High) << 32 | (u64)pg0->WWPN.Low;
 342         rid->port_id =   pg0->PortIdentifier;
 343         rid->roles = FC_RPORT_ROLE_UNKNOWN;
 344         rid->roles |= FC_RPORT_ROLE_FCP_TARGET;
 345         if (pg0->Protocol & MPI_FC_DEVICE_PAGE0_PROT_FCP_INITIATOR)
 346                 rid->roles |= FC_RPORT_ROLE_FCP_INITIATOR;
 347
 348         return 0;
 349 }
 350
 351 static void
 352 mptfc_register_dev(MPT_ADAPTER *ioc, int channel, FCDevicePage0_t *pg0)
 353 {
 354         struct fc_rport_identifiers rport_ids;
 355         struct fc_rport         *rport;
 356         struct mptfc_rport_info *ri;
 357         int                     new_ri = 1;
 358         u64                     pn;
 359         unsigned long           flags;
 360         VirtTarget              *vtarget;
 361
 362         if (mptfc_generate_rport_ids(pg0, &rport_ids) < 0)
 363                 return;
 364
 365         /* scan list looking for a match */
 366         spin_lock_irqsave(&ioc->fc_rport_lock, flags);
 367         list_for_each_entry(ri, &ioc->fc_rports, list) {
 368                 pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low;
 369                 if (pn == rport_ids.port_name) {        /* match */
 370                         list_move_tail(&ri->list, &ioc->fc_rports);
 371                         new_ri = 0;
 372                         break;
 373                 }
 374         }
 375         if (new_ri) {   /* allocate one */
 376                 spin_unlock_irqrestore(&ioc->fc_rport_lock, flags);
 377                 ri = kzalloc(sizeof(struct mptfc_rport_info), GFP_KERNEL);
 378                 if (!ri)
 379                         return;
 380                 spin_lock_irqsave(&ioc->fc_rport_lock, flags);
 381                 list_add_tail(&ri->list, &ioc->fc_rports);
 382         }
 383
 384         ri->pg0 = *pg0; /* add/update pg0 data */
 385         ri->flags &= ~MPT_RPORT_INFO_FLAGS_MISSING;
 386
 387         /* MPT_RPORT_INFO_FLAGS_REGISTERED - rport not previously deleted */
 388         if (!(ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED)) {
 389                 ri->flags |= MPT_RPORT_INFO_FLAGS_REGISTERED;
 390                 spin_unlock_irqrestore(&ioc->fc_rport_lock, flags);
 391                 rport = fc_remote_port_add(ioc->sh, channel, &rport_ids);
 392                 spin_lock_irqsave(&ioc->fc_rport_lock, flags);
 393                 if (rport) {
 394                         ri->rport = rport;
 395                         if (new_ri) /* may have been reset by user */
 396                                 rport->dev_loss_tmo = mptfc_dev_loss_tmo;
 397                         *((struct mptfc_rport_info **)rport->dd_data) = ri;
 398                         /*
 399                          * if already mapped, remap here.  If not mapped,
 400                          * target_alloc will allocate vtarget and map,
 401                          * slave_alloc will fill in vdev from vtarget.
 402                          */
 403                         if (ri->starget) {
 404                                 vtarget = ri->starget->hostdata;
 405                                 if (vtarget) {
 406                                         vtarget->target_id = pg0->CurrentTargetID;
 407                                         vtarget->bus_id = pg0->CurrentBus;
 408                                 }
 409                                 ri->remap_needed = 0;
 410                         }
 411                         dfcprintk ((MYIOC_s_INFO_FMT
 412                                 "mptfc_reg_dev.%d: %x, %llx / %llx, tid %d, "
 413                                 "rport tid %d, tmo %d\n",
 414                                         ioc->name,
 415                                         ioc->sh->host_no,
 416                                         pg0->PortIdentifier,
 417                                         pg0->WWNN,
 418                                         pg0->WWPN,
 419                                         pg0->CurrentTargetID,
 420                                         ri->rport->scsi_target_id,
 421                                         ri->rport->dev_loss_tmo));
 422                 } else {
 423                         list_del(&ri->list);
 424                         kfree(ri);
 425                         ri = NULL;
 426                 }
 427         }
 428         spin_unlock_irqrestore(&ioc->fc_rport_lock,flags);
 429
 430 }
 431
 432 /*
 433  *      OS entry point to allow for host driver to free allocated memory
 434  *      Called if no device present or device being unloaded
 435  */
 436 static void
 437 mptfc_target_destroy(struct scsi_target *starget)
 438 {
 439         struct fc_rport         *rport;
 440         struct mptfc_rport_info *ri;
 441
 442         rport = starget_to_rport(starget);
 443         if (rport) {
 444                 ri = *((struct mptfc_rport_info **)rport->dd_data);
 445                 if (ri) /* better be! */
 446                         ri->starget = NULL;
 447         }
 448         if (starget->hostdata)
 449                 kfree(starget->hostdata);
 450         starget->hostdata = NULL;
 451 }
 452
 453 /*
 454  *      OS entry point to allow host driver to alloc memory
 455  *      for each scsi target. Called once per device the bus scan.
 456  *      Return non-zero if allocation fails.
 457  */
 458 static int
 459 mptfc_target_alloc(struct scsi_target *starget)
 460 {
 461         VirtTarget              *vtarget;
 462         struct fc_rport         *rport;
 463         struct mptfc_rport_info *ri;
 464         int                     rc;
 465
 466         vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
 467         if (!vtarget)
 468                 return -ENOMEM;
 469         starget->hostdata = vtarget;
 470
 471         rc = -ENODEV;
 472         rport = starget_to_rport(starget);
 473         if (rport) {
 474                 ri = *((struct mptfc_rport_info **)rport->dd_data);
 475                 if (ri) {       /* better be! */
 476                         vtarget->target_id = ri->pg0.CurrentTargetID;
 477                         vtarget->bus_id = ri->pg0.CurrentBus;
 478                         ri->starget = starget;
 479                         ri->remap_needed = 0;
 480                         rc = 0;
 481                 }
 482         }
 483         if (rc != 0) {
 484                 kfree(vtarget);
 485                 starget->hostdata = NULL;
 486         }
 487
 488         return rc;
 489 }
 490
 491 /*
 492  *      OS entry point to allow host driver to alloc memory
 493  *      for each scsi device. Called once per device the bus scan.
 494  *      Return non-zero if allocation fails.
 495  *      Init memory once per LUN.
 496  */
 497 static int
 498 mptfc_slave_alloc(struct scsi_device *sdev)
 499 {
 500         MPT_SCSI_HOST           *hd;
 501         VirtTarget              *vtarget;
 502         VirtDevice              *vdev;
 503         struct scsi_target      *starget;
 504         struct fc_rport         *rport;
 505         unsigned long           flags;
 506
 507
 508         rport = starget_to_rport(scsi_target(sdev));
 509
 510         if (!rport || fc_remote_port_chkready(rport))
 511                 return -ENXIO;
 512
 513         hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
 514
 515         vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
 516         if (!vdev) {
 517                 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
 518                                 hd->ioc->name, sizeof(VirtDevice));
 519                 return -ENOMEM;
 520         }
 521
 522         spin_lock_irqsave(&hd->ioc->fc_rport_lock,flags);
 523
 524         sdev->hostdata = vdev;
 525         starget = scsi_target(sdev);
 526         vtarget = starget->hostdata;
 527
 528         if (vtarget->num_luns == 0) {
 529                 vtarget->ioc_id = hd->ioc->id;
 530                 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES |
 531                                   MPT_TARGET_FLAGS_VALID_INQUIRY;
 532                 hd->Targets[sdev->id] = vtarget;
 533         }
 534
 535         vdev->vtarget = vtarget;
 536         vdev->lun = sdev->lun;
 537
 538         spin_unlock_irqrestore(&hd->ioc->fc_rport_lock,flags);
 539
 540         vtarget->num_luns++;
 541
 542 #ifdef DMPT_DEBUG_FC
 543          {
 544         struct mptfc_rport_info *ri;
 545         ri = *((struct mptfc_rport_info **)rport->dd_data);
 546         dfcprintk ((MYIOC_s_INFO_FMT
 547                 "mptfc_slv_alloc.%d: num_luns %d, sdev.id %d, "
 548                 "CurrentTargetID %d, %x %llx %llx\n",
 549                 hd->ioc->name,
 550                 sdev->host->host_no,
 551                 vtarget->num_luns,
 552                 sdev->id, ri->pg0.CurrentTargetID,
 553                 ri->pg0.PortIdentifier, ri->pg0.WWPN, ri->pg0.WWNN));
 554         }
 555 #endif
 556
 557         return 0;
 558 }
 559
 560 static int
 561 mptfc_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
 562 {
 563         struct mptfc_rport_info *ri;
 564         struct fc_rport *rport = starget_to_rport(scsi_target(SCpnt->device));
 565         int             err;
 566
 567         err = fc_remote_port_chkready(rport);
 568         if (unlikely(err)) {
 569                 SCpnt->result = err;
 570                 done(SCpnt);
 571                 return 0;
 572         }
 573         ri = *((struct mptfc_rport_info **)rport->dd_data);
 574         if (unlikely(ri->remap_needed))
 575                 return SCSI_MLQUEUE_HOST_BUSY;
 576
 577         return mptscsih_qcmd(SCpnt,done);
 578 }
 579
 580 static void
 581 mptfc_init_host_attr(MPT_ADAPTER *ioc,int portnum)
 582 {
 583         unsigned class = 0, cos = 0;
 584
 585         /* don't know what to do as only one scsi (fc) host was allocated */
 586         if (portnum != 0)
 587                 return;
 588
 589         class = ioc->fc_port_page0[portnum].SupportedServiceClass;
 590         if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_1)
 591                 cos |= FC_COS_CLASS1;
 592         if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_2)
 593                 cos |= FC_COS_CLASS2;
 594         if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_3)
 595                 cos |= FC_COS_CLASS3;
 596
 597         fc_host_node_name(ioc->sh) =
 598                 (u64)ioc->fc_port_page0[portnum].WWNN.High << 32
 599                     | (u64)ioc->fc_port_page0[portnum].WWNN.Low;
 600
 601         fc_host_port_name(ioc->sh) =
 602                 (u64)ioc->fc_port_page0[portnum].WWPN.High << 32
 603                     | (u64)ioc->fc_port_page0[portnum].WWPN.Low;
 604
 605         fc_host_port_id(ioc->sh) = ioc->fc_port_page0[portnum].PortIdentifier;
 606
 607         fc_host_supported_classes(ioc->sh) = cos;
 608
 609         fc_host_tgtid_bind_type(ioc->sh) = FC_TGTID_BIND_BY_WWPN;
 610 }
 611
 612 static void
 613 mptfc_rescan_devices(void *arg)
 614 {
 615         MPT_ADAPTER             *ioc = (MPT_ADAPTER *)arg;
 616         int                     ii;
 617         int                     work_to_do;
 618         unsigned long           flags;
 619         struct mptfc_rport_info *ri;
 620
 621         do {
 622                 /* start by tagging all ports as missing */
 623                 spin_lock_irqsave(&ioc->fc_rport_lock,flags);
 624                 list_for_each_entry(ri, &ioc->fc_rports, list) {
 625                         if (ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED) {
 626                                 ri->flags |= MPT_RPORT_INFO_FLAGS_MISSING;
 627                         }
 628                 }
 629                 spin_unlock_irqrestore(&ioc->fc_rport_lock,flags);
 630
 631                 /*
 632                  * now rescan devices known to adapter,
 633                  * will reregister existing rports
 634                  */
 635                 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
 636                         (void) mptbase_GetFcPortPage0(ioc, ii);
 637                         mptfc_init_host_attr(ioc,ii);   /* refresh */
 638                         mptfc_GetFcDevPage0(ioc,ii,mptfc_register_dev);
 639                 }
 640
 641                 /* delete devices still missing */
 642                 spin_lock_irqsave(&ioc->fc_rport_lock, flags);
 643                 list_for_each_entry(ri, &ioc->fc_rports, list) {
 644                         /* if newly missing, delete it */
 645                         if ((ri->flags & (MPT_RPORT_INFO_FLAGS_REGISTERED |
 646                                           MPT_RPORT_INFO_FLAGS_MISSING))
 647                           == (MPT_RPORT_INFO_FLAGS_REGISTERED |
 648                               MPT_RPORT_INFO_FLAGS_MISSING)) {
 649
 650                                 ri->flags &= ~(MPT_RPORT_INFO_FLAGS_REGISTERED|
 651                                                MPT_RPORT_INFO_FLAGS_MISSING);
 652                                 ri->remap_needed = 1;
 653                                 fc_remote_port_delete(ri->rport);
 654                                 /*
 655                                  * remote port not really deleted 'cause
 656                                  * binding is by WWPN and driver only
 657                                  * registers FCP_TARGETs but cannot trust
 658                                  * data structures.
 659                                  */
 660                                 ri->rport = NULL;
 661                                 dfcprintk ((MYIOC_s_INFO_FMT
 662                                         "mptfc_rescan.%d: %llx deleted\n",
 663                                         ioc->name,
 664                                         ioc->sh->host_no,
 665                                         ri->pg0.WWPN));
 666                         }
 667                 }
 668                 spin_unlock_irqrestore(&ioc->fc_rport_lock,flags);
 669
 670                 /*
 671                  * allow multiple passes as target state
 672                  * might have changed during scan
 673                  */
 674                 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
 675                 if (ioc->fc_rescan_work_count > 2)      /* only need one more */
 676                         ioc->fc_rescan_work_count = 2;
 677                 work_to_do = --ioc->fc_rescan_work_count;
 678                 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
 679         } while (work_to_do);
 680 }
 681
 682 static int
 683 mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 684 {
 685         struct Scsi_Host        *sh;
 686         MPT_SCSI_HOST           *hd;
 687         MPT_ADAPTER             *ioc;
 688         unsigned long            flags;
 689         int                      ii;
 690         int                      numSGE = 0;
 691         int                      scale;
 692         int                      ioc_cap;
 693         int                     error=0;
 694         int                     r;
 695
 696         if ((r = mpt_attach(pdev,id)) != 0)
 697                 return r;
 698
 699         ioc = pci_get_drvdata(pdev);
 700         ioc->DoneCtx = mptfcDoneCtx;
 701         ioc->TaskCtx = mptfcTaskCtx;
 702         ioc->InternalCtx = mptfcInternalCtx;
 703
 704         /*  Added sanity check on readiness of the MPT adapter.
 705          */
 706         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
 707                 printk(MYIOC_s_WARN_FMT
 708                   "Skipping because it's not operational!\n",
 709                   ioc->name);
 710                 error = -ENODEV;
 711                 goto out_mptfc_probe;
 712         }
 713
 714         if (!ioc->active) {
 715                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
 716                   ioc->name);
 717                 error = -ENODEV;
 718                 goto out_mptfc_probe;
 719         }
 720
 721         /*  Sanity check - ensure at least 1 port is INITIATOR capable
 722          */
 723         ioc_cap = 0;
 724         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
 725                 if (ioc->pfacts[ii].ProtocolFlags &
 726                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
 727                         ioc_cap ++;
 728         }
 729
 730         if (!ioc_cap) {
 731                 printk(MYIOC_s_WARN_FMT
 732                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
 733                         ioc->name, ioc);
 734                 return -ENODEV;
 735         }
 736
 737         sh = scsi_host_alloc(&mptfc_driver_template, sizeof(MPT_SCSI_HOST));
 738
 739         if (!sh) {
 740                 printk(MYIOC_s_WARN_FMT
 741                         "Unable to register controller with SCSI subsystem\n",
 742                         ioc->name);
 743                 error = -1;
 744                 goto out_mptfc_probe;
 745         }
 746
 747         INIT_WORK(&ioc->fc_rescan_work, mptfc_rescan_devices,(void *)ioc);
 748
 749         spin_lock_irqsave(&ioc->FreeQlock, flags);
 750
 751         /* Attach the SCSI Host to the IOC structure
 752          */
 753         ioc->sh = sh;
 754
 755         sh->io_port = 0;
 756         sh->n_io_port = 0;
 757         sh->irq = 0;
 758
 759         /* set 16 byte cdb's */
 760         sh->max_cmd_len = 16;
 761
 762         sh->max_id = MPT_MAX_FC_DEVICES<256 ? MPT_MAX_FC_DEVICES : 255;
 763
 764         sh->max_lun = MPT_LAST_LUN + 1;
 765         sh->max_channel = 0;
 766         sh->this_id = ioc->pfacts[0].PortSCSIID;
 767
 768         /* Required entry.
 769          */
 770         sh->unique_id = ioc->id;
 771
 772         /* Verify that we won't exceed the maximum
 773          * number of chain buffers
 774          * We can optimize:  ZZ = req_sz/sizeof(SGE)
 775          * For 32bit SGE's:
 776          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
 777          *               + (req_sz - 64)/sizeof(SGE)
 778          * A slightly different algorithm is required for
 779          * 64bit SGEs.
 780          */
 781         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
 782         if (sizeof(dma_addr_t) == sizeof(u64)) {
 783                 numSGE = (scale - 1) *
 784                   (ioc->facts.MaxChainDepth-1) + scale +
 785                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
 786                   sizeof(u32));
 787         } else {
 788                 numSGE = 1 + (scale - 1) *
 789                   (ioc->facts.MaxChainDepth-1) + scale +
 790                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
 791                   sizeof(u32));
 792         }
 793
 794         if (numSGE < sh->sg_tablesize) {
 795                 /* Reset this value */
 796                 dprintk((MYIOC_s_INFO_FMT
 797                   "Resetting sg_tablesize to %d from %d\n",
 798                   ioc->name, numSGE, sh->sg_tablesize));
 799                 sh->sg_tablesize = numSGE;
 800         }
 801
 802         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
 803
 804         hd = (MPT_SCSI_HOST *) sh->hostdata;
 805         hd->ioc = ioc;
 806
 807         /* SCSI needs scsi_cmnd lookup table!
 808          * (with size equal to req_depth*PtrSz!)
 809          */
 810         hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
 811         if (!hd->ScsiLookup) {
 812                 error = -ENOMEM;
 813                 goto out_mptfc_probe;
 814         }
 815
 816         dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
 817                  ioc->name, hd->ScsiLookup));
 818
 819         /* Allocate memory for the device structures.
 820          * A non-Null pointer at an offset
 821          * indicates a device exists.
 822          * max_id = 1 + maximum id (hosts.h)
 823          */
 824         hd->Targets = kcalloc(sh->max_id, sizeof(void *), GFP_ATOMIC);
 825         if (!hd->Targets) {
 826                 error = -ENOMEM;
 827                 goto out_mptfc_probe;
 828         }
 829
 830         dprintk((KERN_INFO "  vdev @ %p\n", hd->Targets));
 831
 832         /* Clear the TM flags
 833          */
 834         hd->tmPending = 0;
 835         hd->tmState = TM_STATE_NONE;
 836         hd->resetPending = 0;
 837         hd->abortSCpnt = NULL;
 838
 839         /* Clear the pointer used to store
 840          * single-threaded commands, i.e., those
 841          * issued during a bus scan, dv and
 842          * configuration pages.
 843          */
 844         hd->cmdPtr = NULL;
 845
 846         /* Initialize this SCSI Hosts' timers
 847          * To use, set the timer expires field
 848          * and add_timer
 849          */
 850         init_timer(&hd->timer);
 851         hd->timer.data = (unsigned long) hd;
 852         hd->timer.function = mptscsih_timer_expired;
 853
 854         hd->mpt_pq_filter = mpt_pq_filter;
 855
 856         ddvprintk((MYIOC_s_INFO_FMT
 857                 "mpt_pq_filter %x\n",
 858                 ioc->name,
 859                 mpt_pq_filter));
 860
 861         init_waitqueue_head(&hd->scandv_waitq);
 862         hd->scandv_wait_done = 0;
 863         hd->last_queue_full = 0;
 864
 865         sh->transportt = mptfc_transport_template;
 866         error = scsi_add_host (sh, &ioc->pcidev->dev);
 867         if(error) {
 868                 dprintk((KERN_ERR MYNAM
 869                   "scsi_add_host failed\n"));
 870                 goto out_mptfc_probe;
 871         }
 872
 873         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
 874                 mptfc_init_host_attr(ioc,ii);
 875                 mptfc_GetFcDevPage0(ioc,ii,mptfc_register_dev);
 876         }
 877
 878         return 0;
 879
 880 out_mptfc_probe:
 881
 882         mptscsih_remove(pdev);
 883         return error;
 884 }
 885
 886 static struct pci_driver mptfc_driver = {
 887         .name           = "mptfc",
 888         .id_table       = mptfc_pci_table,
 889         .probe          = mptfc_probe,
 890         .remove         = __devexit_p(mptfc_remove),
 891         .shutdown       = mptscsih_shutdown,
 892 #ifdef CONFIG_PM
 893         .suspend        = mptscsih_suspend,
 894         .resume         = mptscsih_resume,
 895 #endif
 896 };
 897
 898 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 899 /**
 900  *      mptfc_init - Register MPT adapter(s) as SCSI host(s) with
 901  *      linux scsi mid-layer.
 902  *
 903  *      Returns 0 for success, non-zero for failure.
 904  */
 905 static int __init
 906 mptfc_init(void)
 907 {
 908         int error;
 909
 910         show_mptmod_ver(my_NAME, my_VERSION);
 911
 912         /* sanity check module parameter */
 913         if (mptfc_dev_loss_tmo == 0)
 914                 mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO;
 915
 916         mptfc_transport_template =
 917                 fc_attach_transport(&mptfc_transport_functions);
 918
 919         if (!mptfc_transport_template)
 920                 return -ENODEV;
 921
 922         mptfcDoneCtx = mpt_register(mptscsih_io_done, MPTFC_DRIVER);
 923         mptfcTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTFC_DRIVER);
 924         mptfcInternalCtx = mpt_register(mptscsih_scandv_complete, MPTFC_DRIVER);
 925
 926         if (mpt_event_register(mptfcDoneCtx, mptscsih_event_process) == 0) {
 927                 devtverboseprintk((KERN_INFO MYNAM
 928                   ": Registered for IOC event notifications\n"));
 929         }
 930
 931         if (mpt_reset_register(mptfcDoneCtx, mptscsih_ioc_reset) == 0) {
 932                 dprintk((KERN_INFO MYNAM
 933                   ": Registered for IOC reset notifications\n"));
 934         }
 935
 936         error = pci_register_driver(&mptfc_driver);
 937         if (error)
 938                 fc_release_transport(mptfc_transport_template);
 939
 940         return error;
 941 }
 942
 943 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 944 /**
 945  *      mptfc_remove - Removed fc infrastructure for devices
 946  *      @pdev: Pointer to pci_dev structure
 947  *
 948  */
 949 static void __devexit
 950 mptfc_remove(struct pci_dev *pdev)
 951 {
 952         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
 953         struct mptfc_rport_info *p, *n;
 954
 955         fc_remove_host(ioc->sh);
 956
 957         list_for_each_entry_safe(p, n, &ioc->fc_rports, list) {
 958                 list_del(&p->list);
 959                 kfree(p);
 960         }
 961
 962         mptscsih_remove(pdev);
 963 }
 964
 965 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 966 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 967 /**
 968  *      mptfc_exit - Unregisters MPT adapter(s)
 969  *
 970  */
 971 static void __exit
 972 mptfc_exit(void)
 973 {
 974         pci_unregister_driver(&mptfc_driver);
 975         fc_release_transport(mptfc_transport_template);
 976
 977         mpt_reset_deregister(mptfcDoneCtx);
 978         dprintk((KERN_INFO MYNAM
 979           ": Deregistered for IOC reset notifications\n"));
 980
 981         mpt_event_deregister(mptfcDoneCtx);
 982         dprintk((KERN_INFO MYNAM
 983           ": Deregistered for IOC event notifications\n"));
 984
 985         mpt_deregister(mptfcInternalCtx);
 986         mpt_deregister(mptfcTaskCtx);
 987         mpt_deregister(mptfcDoneCtx);
 988 }
 989
 990 module_init(mptfc_init);
 991 module_exit(mptfc_exit);