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 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_remap_sdev(struct scsi_device *sdev, void *arg)
 353 {
 354         VirtDevice              *vdev;
 355         VirtTarget              *vtarget;
 356         struct scsi_target      *starget;
 357
 358         starget = scsi_target(sdev);
 359         if (starget->hostdata == arg) {
 360                 vtarget = arg;
 361                 vdev = sdev->hostdata;
 362                 if (vdev) {
 363                         vdev->bus_id = vtarget->bus_id;
 364                         vdev->target_id = vtarget->target_id;
 365                 }
 366         }
 367 }
 368
 369 static void
 370 mptfc_register_dev(MPT_ADAPTER *ioc, int channel, FCDevicePage0_t *pg0)
 371 {
 372         struct fc_rport_identifiers rport_ids;
 373         struct fc_rport         *rport;
 374         struct mptfc_rport_info *ri;
 375         int                     new_ri = 1;
 376         u64                     pn;
 377         unsigned long           flags;
 378         VirtTarget              *vtarget;
 379
 380         if (mptfc_generate_rport_ids(pg0, &rport_ids) < 0)
 381                 return;
 382
 383         /* scan list looking for a match */
 384         spin_lock_irqsave(&ioc->fc_rport_lock, flags);
 385         list_for_each_entry(ri, &ioc->fc_rports, list) {
 386                 pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low;
 387                 if (pn == rport_ids.port_name) {        /* match */
 388                         list_move_tail(&ri->list, &ioc->fc_rports);
 389                         new_ri = 0;
 390                         break;
 391                 }
 392         }
 393         if (new_ri) {   /* allocate one */
 394                 spin_unlock_irqrestore(&ioc->fc_rport_lock, flags);
 395                 ri = kzalloc(sizeof(struct mptfc_rport_info), GFP_KERNEL);
 396                 if (!ri)
 397                         return;
 398                 spin_lock_irqsave(&ioc->fc_rport_lock, flags);
 399                 list_add_tail(&ri->list, &ioc->fc_rports);
 400         }
 401
 402         ri->pg0 = *pg0; /* add/update pg0 data */
 403         ri->flags &= ~MPT_RPORT_INFO_FLAGS_MISSING;
 404
 405         /* MPT_RPORT_INFO_FLAGS_REGISTERED - rport not previously deleted */
 406         if (!(ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED)) {
 407                 ri->flags |= MPT_RPORT_INFO_FLAGS_REGISTERED;
 408                 spin_unlock_irqrestore(&ioc->fc_rport_lock, flags);
 409                 rport = fc_remote_port_add(ioc->sh, channel, &rport_ids);
 410                 spin_lock_irqsave(&ioc->fc_rport_lock, flags);
 411                 if (rport) {
 412                         ri->rport = rport;
 413                         if (new_ri) /* may have been reset by user */
 414                                 rport->dev_loss_tmo = mptfc_dev_loss_tmo;
 415                         *((struct mptfc_rport_info **)rport->dd_data) = ri;
 416                         /*
 417                          * if already mapped, remap here.  If not mapped,
 418                          * target_alloc will allocate vtarget and map,
 419                          * slave_alloc will fill in vdev from vtarget.
 420                          */
 421                         if (ri->starget) {
 422                                 vtarget = ri->starget->hostdata;
 423                                 if (vtarget) {
 424                                         vtarget->target_id = pg0->CurrentTargetID;
 425                                         vtarget->bus_id = pg0->CurrentBus;
 426                                         starget_for_each_device(ri->starget,
 427                                                 vtarget,mptfc_remap_sdev);
 428                                 }
 429                                 ri->remap_needed = 0;
 430                         }
 431                         dfcprintk ((MYIOC_s_INFO_FMT
 432                                 "mptfc_reg_dev.%d: %x, %llx / %llx, tid %d, "
 433                                 "rport tid %d, tmo %d\n",
 434                                         ioc->name,
 435                                         oc->sh->host_no,
 436                                         pg0->PortIdentifier,
 437                                         pg0->WWNN,
 438                                         pg0->WWPN,
 439                                         pg0->CurrentTargetID,
 440                                         ri->rport->scsi_target_id,
 441                                         ri->rport->dev_loss_tmo));
 442                 } else {
 443                         list_del(&ri->list);
 444                         kfree(ri);
 445                         ri = NULL;
 446                 }
 447         }
 448         spin_unlock_irqrestore(&ioc->fc_rport_lock,flags);
 449
 450 }
 451
 452 /*
 453  *      OS entry point to allow for host driver to free allocated memory
 454  *      Called if no device present or device being unloaded
 455  */
 456 static void
 457 mptfc_target_destroy(struct scsi_target *starget)
 458 {
 459         struct fc_rport         *rport;
 460         struct mptfc_rport_info *ri;
 461
 462         rport = starget_to_rport(starget);
 463         if (rport) {
 464                 ri = *((struct mptfc_rport_info **)rport->dd_data);
 465                 if (ri) /* better be! */
 466                         ri->starget = NULL;
 467         }
 468         if (starget->hostdata)
 469                 kfree(starget->hostdata);
 470         starget->hostdata = NULL;
 471 }
 472
 473 /*
 474  *      OS entry point to allow host driver to alloc memory
 475  *      for each scsi target. Called once per device the bus scan.
 476  *      Return non-zero if allocation fails.
 477  */
 478 static int
 479 mptfc_target_alloc(struct scsi_target *starget)
 480 {
 481         VirtTarget              *vtarget;
 482         struct fc_rport         *rport;
 483         struct mptfc_rport_info *ri;
 484         int                     rc;
 485
 486         vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
 487         if (!vtarget)
 488                 return -ENOMEM;
 489         starget->hostdata = vtarget;
 490
 491         rc = -ENODEV;
 492         rport = starget_to_rport(starget);
 493         if (rport) {
 494                 ri = *((struct mptfc_rport_info **)rport->dd_data);
 495                 if (ri) {       /* better be! */
 496                         vtarget->target_id = ri->pg0.CurrentTargetID;
 497                         vtarget->bus_id = ri->pg0.CurrentBus;
 498                         ri->starget = starget;
 499                         ri->remap_needed = 0;
 500                         rc = 0;
 501                 }
 502         }
 503         if (rc != 0) {
 504                 kfree(vtarget);
 505                 starget->hostdata = NULL;
 506         }
 507
 508         return rc;
 509 }
 510
 511 /*
 512  *      OS entry point to allow host driver to alloc memory
 513  *      for each scsi device. Called once per device the bus scan.
 514  *      Return non-zero if allocation fails.
 515  *      Init memory once per LUN.
 516  */
 517 int
 518 mptfc_slave_alloc(struct scsi_device *sdev)
 519 {
 520         MPT_SCSI_HOST           *hd;
 521         VirtTarget              *vtarget;
 522         VirtDevice              *vdev;
 523         struct scsi_target      *starget;
 524         struct fc_rport         *rport;
 525         unsigned long           flags;
 526
 527
 528         rport = starget_to_rport(scsi_target(sdev));
 529
 530         if (!rport || fc_remote_port_chkready(rport))
 531                 return -ENXIO;
 532
 533         hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
 534
 535         vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
 536         if (!vdev) {
 537                 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
 538                                 hd->ioc->name, sizeof(VirtDevice));
 539                 return -ENOMEM;
 540         }
 541
 542         spin_lock_irqsave(&hd->ioc->fc_rport_lock,flags);
 543
 544         sdev->hostdata = vdev;
 545         starget = scsi_target(sdev);
 546         vtarget = starget->hostdata;
 547
 548         if (vtarget->num_luns == 0) {
 549                 vtarget->ioc_id = hd->ioc->id;
 550                 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES |
 551                                   MPT_TARGET_FLAGS_VALID_INQUIRY;
 552                 hd->Targets[sdev->id] = vtarget;
 553         }
 554
 555         vdev->vtarget = vtarget;
 556         vdev->ioc_id = hd->ioc->id;
 557         vdev->lun = sdev->lun;
 558         vdev->target_id = vtarget->target_id;
 559         vdev->bus_id = vtarget->bus_id;
 560
 561         spin_unlock_irqrestore(&hd->ioc->fc_rport_lock,flags);
 562
 563         vtarget->num_luns++;
 564
 565         dfcprintk ((MYIOC_s_INFO_FMT
 566                 "mptfc_slv_alloc.%d: num_luns %d, sdev.id %d, "
 567                 "CurrentTargetID %d, %x %llx %llx\n",
 568                 ioc->name,
 569                 sdev->host->host_no,
 570                 vtarget->num_luns,
 571                 sdev->id, ri->pg0.CurrentTargetID,
 572                 ri->pg0.PortIdentifier, ri->pg0.WWPN, ri->pg0.WWNN));
 573
 574         return 0;
 575 }
 576
 577 static int
 578 mptfc_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
 579 {
 580         struct mptfc_rport_info *ri;
 581         struct fc_rport *rport = starget_to_rport(scsi_target(SCpnt->device));
 582         int             err;
 583
 584         err = fc_remote_port_chkready(rport);
 585         if (unlikely(err)) {
 586                 SCpnt->result = err;
 587                 done(SCpnt);
 588                 return 0;
 589         }
 590         ri = *((struct mptfc_rport_info **)rport->dd_data);
 591         if (unlikely(ri->remap_needed))
 592                 return SCSI_MLQUEUE_HOST_BUSY;
 593
 594         return mptscsih_qcmd(SCpnt,done);
 595 }
 596
 597 static void
 598 mptfc_init_host_attr(MPT_ADAPTER *ioc,int portnum)
 599 {
 600         unsigned class = 0, cos = 0;
 601
 602         /* don't know what to do as only one scsi (fc) host was allocated */
 603         if (portnum != 0)
 604                 return;
 605
 606         class = ioc->fc_port_page0[portnum].SupportedServiceClass;
 607         if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_1)
 608                 cos |= FC_COS_CLASS1;
 609         if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_2)
 610                 cos |= FC_COS_CLASS2;
 611         if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_3)
 612                 cos |= FC_COS_CLASS3;
 613
 614         fc_host_node_name(ioc->sh) =
 615                 (u64)ioc->fc_port_page0[portnum].WWNN.High << 32
 616                     | (u64)ioc->fc_port_page0[portnum].WWNN.Low;
 617
 618         fc_host_port_name(ioc->sh) =
 619                 (u64)ioc->fc_port_page0[portnum].WWPN.High << 32
 620                     | (u64)ioc->fc_port_page0[portnum].WWPN.Low;
 621
 622         fc_host_port_id(ioc->sh) = ioc->fc_port_page0[portnum].PortIdentifier;
 623
 624         fc_host_supported_classes(ioc->sh) = cos;
 625
 626         fc_host_tgtid_bind_type(ioc->sh) = FC_TGTID_BIND_BY_WWPN;
 627 }
 628
 629 static void
 630 mptfc_rescan_devices(void *arg)
 631 {
 632         MPT_ADAPTER             *ioc = (MPT_ADAPTER *)arg;
 633         int                     ii;
 634         int                     work_to_do;
 635         unsigned long           flags;
 636         struct mptfc_rport_info *ri;
 637
 638         do {
 639                 /* start by tagging all ports as missing */
 640                 spin_lock_irqsave(&ioc->fc_rport_lock,flags);
 641                 list_for_each_entry(ri, &ioc->fc_rports, list) {
 642                         if (ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED) {
 643                                 ri->flags |= MPT_RPORT_INFO_FLAGS_MISSING;
 644                         }
 645                 }
 646                 spin_unlock_irqrestore(&ioc->fc_rport_lock,flags);
 647
 648                 /*
 649                  * now rescan devices known to adapter,
 650                  * will reregister existing rports
 651                  */
 652                 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
 653                         (void) mptbase_GetFcPortPage0(ioc, ii);
 654                         mptfc_init_host_attr(ioc,ii);   /* refresh */
 655                         mptfc_GetFcDevPage0(ioc,ii,mptfc_register_dev);
 656                 }
 657
 658                 /* delete devices still missing */
 659                 spin_lock_irqsave(&ioc->fc_rport_lock, flags);
 660                 list_for_each_entry(ri, &ioc->fc_rports, list) {
 661                         /* if newly missing, delete it */
 662                         if ((ri->flags & (MPT_RPORT_INFO_FLAGS_REGISTERED |
 663                                           MPT_RPORT_INFO_FLAGS_MISSING))
 664                           == (MPT_RPORT_INFO_FLAGS_REGISTERED |
 665                               MPT_RPORT_INFO_FLAGS_MISSING)) {
 666
 667                                 ri->flags &= ~(MPT_RPORT_INFO_FLAGS_REGISTERED|
 668                                                MPT_RPORT_INFO_FLAGS_MISSING);
 669                                 ri->remap_needed = 1;
 670                                 fc_remote_port_delete(ri->rport);
 671                                 /*
 672                                  * remote port not really deleted 'cause
 673                                  * binding is by WWPN and driver only
 674                                  * registers FCP_TARGETs but cannot trust
 675                                  * data structures.
 676                                  */
 677                                 ri->rport = NULL;
 678                                 dfcprintk ((MYIOC_s_INFO_FMT
 679                                         "mptfc_rescan.%d: %llx deleted\n",
 680                                         ioc->name,
 681                                         ioc->sh->host_no,
 682                                         ri->pg0.WWPN));
 683                         }
 684                 }
 685                 spin_unlock_irqrestore(&ioc->fc_rport_lock,flags);
 686
 687                 /*
 688                  * allow multiple passes as target state
 689                  * might have changed during scan
 690                  */
 691                 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
 692                 if (ioc->fc_rescan_work_count > 2)      /* only need one more */
 693                         ioc->fc_rescan_work_count = 2;
 694                 work_to_do = --ioc->fc_rescan_work_count;
 695                 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
 696         } while (work_to_do);
 697 }
 698
 699 static int
 700 mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 701 {
 702         struct Scsi_Host        *sh;
 703         MPT_SCSI_HOST           *hd;
 704         MPT_ADAPTER             *ioc;
 705         unsigned long            flags;
 706         int                      ii;
 707         int                      numSGE = 0;
 708         int                      scale;
 709         int                      ioc_cap;
 710         int                     error=0;
 711         int                     r;
 712
 713         if ((r = mpt_attach(pdev,id)) != 0)
 714                 return r;
 715
 716         ioc = pci_get_drvdata(pdev);
 717         ioc->DoneCtx = mptfcDoneCtx;
 718         ioc->TaskCtx = mptfcTaskCtx;
 719         ioc->InternalCtx = mptfcInternalCtx;
 720
 721         /*  Added sanity check on readiness of the MPT adapter.
 722          */
 723         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
 724                 printk(MYIOC_s_WARN_FMT
 725                   "Skipping because it's not operational!\n",
 726                   ioc->name);
 727                 error = -ENODEV;
 728                 goto out_mptfc_probe;
 729         }
 730
 731         if (!ioc->active) {
 732                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
 733                   ioc->name);
 734                 error = -ENODEV;
 735                 goto out_mptfc_probe;
 736         }
 737
 738         /*  Sanity check - ensure at least 1 port is INITIATOR capable
 739          */
 740         ioc_cap = 0;
 741         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
 742                 if (ioc->pfacts[ii].ProtocolFlags &
 743                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
 744                         ioc_cap ++;
 745         }
 746
 747         if (!ioc_cap) {
 748                 printk(MYIOC_s_WARN_FMT
 749                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
 750                         ioc->name, ioc);
 751                 return -ENODEV;
 752         }
 753
 754         sh = scsi_host_alloc(&mptfc_driver_template, sizeof(MPT_SCSI_HOST));
 755
 756         if (!sh) {
 757                 printk(MYIOC_s_WARN_FMT
 758                         "Unable to register controller with SCSI subsystem\n",
 759                         ioc->name);
 760                 error = -1;
 761                 goto out_mptfc_probe;
 762         }
 763
 764         INIT_WORK(&ioc->fc_rescan_work, mptfc_rescan_devices,(void *)ioc);
 765
 766         spin_lock_irqsave(&ioc->FreeQlock, flags);
 767
 768         /* Attach the SCSI Host to the IOC structure
 769          */
 770         ioc->sh = sh;
 771
 772         sh->io_port = 0;
 773         sh->n_io_port = 0;
 774         sh->irq = 0;
 775
 776         /* set 16 byte cdb's */
 777         sh->max_cmd_len = 16;
 778
 779         sh->max_id = MPT_MAX_FC_DEVICES<256 ? MPT_MAX_FC_DEVICES : 255;
 780
 781         sh->max_lun = MPT_LAST_LUN + 1;
 782         sh->max_channel = 0;
 783         sh->this_id = ioc->pfacts[0].PortSCSIID;
 784
 785         /* Required entry.
 786          */
 787         sh->unique_id = ioc->id;
 788
 789         /* Verify that we won't exceed the maximum
 790          * number of chain buffers
 791          * We can optimize:  ZZ = req_sz/sizeof(SGE)
 792          * For 32bit SGE's:
 793          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
 794          *               + (req_sz - 64)/sizeof(SGE)
 795          * A slightly different algorithm is required for
 796          * 64bit SGEs.
 797          */
 798         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
 799         if (sizeof(dma_addr_t) == sizeof(u64)) {
 800                 numSGE = (scale - 1) *
 801                   (ioc->facts.MaxChainDepth-1) + scale +
 802                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
 803                   sizeof(u32));
 804         } else {
 805                 numSGE = 1 + (scale - 1) *
 806                   (ioc->facts.MaxChainDepth-1) + scale +
 807                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
 808                   sizeof(u32));
 809         }
 810
 811         if (numSGE < sh->sg_tablesize) {
 812                 /* Reset this value */
 813                 dprintk((MYIOC_s_INFO_FMT
 814                   "Resetting sg_tablesize to %d from %d\n",
 815                   ioc->name, numSGE, sh->sg_tablesize));
 816                 sh->sg_tablesize = numSGE;
 817         }
 818
 819         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
 820
 821         hd = (MPT_SCSI_HOST *) sh->hostdata;
 822         hd->ioc = ioc;
 823
 824         /* SCSI needs scsi_cmnd lookup table!
 825          * (with size equal to req_depth*PtrSz!)
 826          */
 827         hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
 828         if (!hd->ScsiLookup) {
 829                 error = -ENOMEM;
 830                 goto out_mptfc_probe;
 831         }
 832
 833         dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
 834                  ioc->name, hd->ScsiLookup));
 835
 836         /* Allocate memory for the device structures.
 837          * A non-Null pointer at an offset
 838          * indicates a device exists.
 839          * max_id = 1 + maximum id (hosts.h)
 840          */
 841         hd->Targets = kcalloc(sh->max_id, sizeof(void *), GFP_ATOMIC);
 842         if (!hd->Targets) {
 843                 error = -ENOMEM;
 844                 goto out_mptfc_probe;
 845         }
 846
 847         dprintk((KERN_INFO "  vdev @ %p\n", hd->Targets));
 848
 849         /* Clear the TM flags
 850          */
 851         hd->tmPending = 0;
 852         hd->tmState = TM_STATE_NONE;
 853         hd->resetPending = 0;
 854         hd->abortSCpnt = NULL;
 855
 856         /* Clear the pointer used to store
 857          * single-threaded commands, i.e., those
 858          * issued during a bus scan, dv and
 859          * configuration pages.
 860          */
 861         hd->cmdPtr = NULL;
 862
 863         /* Initialize this SCSI Hosts' timers
 864          * To use, set the timer expires field
 865          * and add_timer
 866          */
 867         init_timer(&hd->timer);
 868         hd->timer.data = (unsigned long) hd;
 869         hd->timer.function = mptscsih_timer_expired;
 870
 871         hd->mpt_pq_filter = mpt_pq_filter;
 872
 873         ddvprintk((MYIOC_s_INFO_FMT
 874                 "mpt_pq_filter %x\n",
 875                 ioc->name,
 876                 mpt_pq_filter));
 877
 878         init_waitqueue_head(&hd->scandv_waitq);
 879         hd->scandv_wait_done = 0;
 880         hd->last_queue_full = 0;
 881
 882         sh->transportt = mptfc_transport_template;
 883         error = scsi_add_host (sh, &ioc->pcidev->dev);
 884         if(error) {
 885                 dprintk((KERN_ERR MYNAM
 886                   "scsi_add_host failed\n"));
 887                 goto out_mptfc_probe;
 888         }
 889
 890         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
 891                 mptfc_init_host_attr(ioc,ii);
 892                 mptfc_GetFcDevPage0(ioc,ii,mptfc_register_dev);
 893         }
 894
 895         return 0;
 896
 897 out_mptfc_probe:
 898
 899         mptscsih_remove(pdev);
 900         return error;
 901 }
 902
 903 static struct pci_driver mptfc_driver = {
 904         .name           = "mptfc",
 905         .id_table       = mptfc_pci_table,
 906         .probe          = mptfc_probe,
 907         .remove         = __devexit_p(mptfc_remove),
 908         .shutdown       = mptscsih_shutdown,
 909 #ifdef CONFIG_PM
 910         .suspend        = mptscsih_suspend,
 911         .resume         = mptscsih_resume,
 912 #endif
 913 };
 914
 915 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 916 /**
 917  *      mptfc_init - Register MPT adapter(s) as SCSI host(s) with
 918  *      linux scsi mid-layer.
 919  *
 920  *      Returns 0 for success, non-zero for failure.
 921  */
 922 static int __init
 923 mptfc_init(void)
 924 {
 925         int error;
 926
 927         show_mptmod_ver(my_NAME, my_VERSION);
 928
 929         /* sanity check module parameter */
 930         if (mptfc_dev_loss_tmo == 0)
 931                 mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO;
 932
 933         mptfc_transport_template =
 934                 fc_attach_transport(&mptfc_transport_functions);
 935
 936         if (!mptfc_transport_template)
 937                 return -ENODEV;
 938
 939         mptfcDoneCtx = mpt_register(mptscsih_io_done, MPTFC_DRIVER);
 940         mptfcTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTFC_DRIVER);
 941         mptfcInternalCtx = mpt_register(mptscsih_scandv_complete, MPTFC_DRIVER);
 942
 943         if (mpt_event_register(mptfcDoneCtx, mptscsih_event_process) == 0) {
 944                 devtprintk((KERN_INFO MYNAM
 945                   ": Registered for IOC event notifications\n"));
 946         }
 947
 948         if (mpt_reset_register(mptfcDoneCtx, mptscsih_ioc_reset) == 0) {
 949                 dprintk((KERN_INFO MYNAM
 950                   ": Registered for IOC reset notifications\n"));
 951         }
 952
 953         error = pci_register_driver(&mptfc_driver);
 954         if (error)
 955                 fc_release_transport(mptfc_transport_template);
 956
 957         return error;
 958 }
 959
 960 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 961 /**
 962  *      mptfc_remove - Removed fc infrastructure for devices
 963  *      @pdev: Pointer to pci_dev structure
 964  *
 965  */
 966 static void __devexit
 967 mptfc_remove(struct pci_dev *pdev)
 968 {
 969         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
 970         struct mptfc_rport_info *p, *n;
 971
 972         fc_remove_host(ioc->sh);
 973
 974         list_for_each_entry_safe(p, n, &ioc->fc_rports, list) {
 975                 list_del(&p->list);
 976                 kfree(p);
 977         }
 978
 979         mptscsih_remove(pdev);
 980 }
 981
 982 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 983 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 984 /**
 985  *      mptfc_exit - Unregisters MPT adapter(s)
 986  *
 987  */
 988 static void __exit
 989 mptfc_exit(void)
 990 {
 991         pci_unregister_driver(&mptfc_driver);
 992         fc_release_transport(mptfc_transport_template);
 993
 994         mpt_reset_deregister(mptfcDoneCtx);
 995         dprintk((KERN_INFO MYNAM
 996           ": Deregistered for IOC reset notifications\n"));
 997
 998         mpt_event_deregister(mptfcDoneCtx);
 999         dprintk((KERN_INFO MYNAM
1000           ": Deregistered for IOC event notifications\n"));
1001
1002         mpt_deregister(mptfcInternalCtx);
1003         mpt_deregister(mptfcTaskCtx);
1004         mpt_deregister(mptfcDoneCtx);
1005 }
1006
1007 module_init(mptfc_init);
1008 module_exit(mptfc_exit);