drivers/message/fusion/mptfc.c

   1 /*
   2  *  linux/drivers/message/fusion/mptfc.c
   3  *      For use with LSI PCI chip/adapter(s)
   4  *      running LSI Fusion MPT (Message Passing Technology) firmware.
   5  *
   6  *  Copyright (c) 1999-2008 LSI Corporation
   7  *  (mailto:DL-MPTFusionLinux@lsi.com)
   8  *
   9  */
  10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  11 /*
  12     This program is free software; you can redistribute it and/or modify
  13     it under the terms of the GNU General Public License as published by
  14     the Free Software Foundation; version 2 of the License.
  15
  16     This program is distributed in the hope that it will be useful,
  17     but WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19     GNU General Public License for more details.
  20
  21     NO WARRANTY
  22     THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  23     CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  24     LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  25     MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  26     solely responsible for determining the appropriateness of using and
  27     distributing the Program and assumes all risks associated with its
  28     exercise of rights under this Agreement, including but not limited to
  29     the risks and costs of program errors, damage to or loss of data,
  30     programs or equipment, and unavailability or interruption of operations.
  31
  32     DISCLAIMER OF LIABILITY
  33     NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  34     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  35     DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  36     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  37     TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  38     USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  39     HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  40
  41     You should have received a copy of the GNU General Public License
  42     along with this program; if not, write to the Free Software
  43     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  44 */
  45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  46 #include <linux/module.h>
  47 #include <linux/kernel.h>
  48 #include <linux/init.h>
  49 #include <linux/errno.h>
  50 #include <linux/kdev_t.h>
  51 #include <linux/blkdev.h>
  52 #include <linux/delay.h>        /* for mdelay */
  53 #include <linux/interrupt.h>
  54 #include <linux/reboot.h>       /* notifier code */
  55 #include <linux/workqueue.h>
  56 #include <linux/sort.h>
  57 #include <linux/slab.h>
  58
  59 #include <scsi/scsi.h>
  60 #include <scsi/scsi_cmnd.h>
  61 #include <scsi/scsi_device.h>
  62 #include <scsi/scsi_host.h>
  63 #include <scsi/scsi_tcq.h>
  64 #include <scsi/scsi_transport_fc.h>
  65
  66 #include "mptbase.h"
  67 #include "mptscsih.h"
  68
  69 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  70 #define my_NAME         "Fusion MPT FC Host driver"
  71 #define my_VERSION      MPT_LINUX_VERSION_COMMON
  72 #define MYNAM           "mptfc"
  73
  74 MODULE_AUTHOR(MODULEAUTHOR);
  75 MODULE_DESCRIPTION(my_NAME);
  76 MODULE_LICENSE("GPL");
  77 MODULE_VERSION(my_VERSION);
  78
  79 /* Command line args */
  80 #define MPTFC_DEV_LOSS_TMO (60)
  81 static int mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO;     /* reasonable default */
  82 module_param(mptfc_dev_loss_tmo, int, 0);
  83 MODULE_PARM_DESC(mptfc_dev_loss_tmo, " Initial time the driver programs the "
  84                                      " transport to wait for an rport to "
  85                                      " return following a device loss event."
  86                                      "  Default=60.");
  87
  88 /* scsi-mid layer global parmeter is max_report_luns, which is 511 */
  89 #define MPTFC_MAX_LUN (16895)
  90 static int max_lun = MPTFC_MAX_LUN;
  91 module_param(max_lun, int, 0);
  92 MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
  93
  94 static u8       mptfcDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
  95 static u8       mptfcTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
  96 static u8       mptfcInternalCtx = MPT_MAX_PROTOCOL_DRIVERS;
  97
  98 static int mptfc_target_alloc(struct scsi_target *starget);
  99 static int mptfc_slave_alloc(struct scsi_device *sdev);
 100 static int mptfc_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt);
 101 static void mptfc_target_destroy(struct scsi_target *starget);
 102 static void mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout);
 103 static void mptfc_remove(struct pci_dev *pdev);
 104 static int mptfc_abort(struct scsi_cmnd *SCpnt);
 105 static int mptfc_dev_reset(struct scsi_cmnd *SCpnt);
 106 static int mptfc_bus_reset(struct scsi_cmnd *SCpnt);
 107
 108 static struct scsi_host_template mptfc_driver_template = {
 109         .module                         = THIS_MODULE,
 110         .proc_name                      = "mptfc",
 111         .show_info                      = mptscsih_show_info,
 112         .name                           = "MPT FC Host",
 113         .info                           = mptscsih_info,
 114         .queuecommand                   = mptfc_qcmd,
 115         .target_alloc                   = mptfc_target_alloc,
 116         .slave_alloc                    = mptfc_slave_alloc,
 117         .slave_configure                = mptscsih_slave_configure,
 118         .target_destroy                 = mptfc_target_destroy,
 119         .slave_destroy                  = mptscsih_slave_destroy,
 120         .change_queue_depth             = mptscsih_change_queue_depth,
 121         .eh_timed_out                   = fc_eh_timed_out,
 122         .eh_abort_handler               = mptfc_abort,
 123         .eh_device_reset_handler        = mptfc_dev_reset,
 124         .eh_bus_reset_handler           = mptfc_bus_reset,
 125         .eh_host_reset_handler          = mptscsih_host_reset,
 126         .bios_param                     = mptscsih_bios_param,
 127         .can_queue                      = MPT_FC_CAN_QUEUE,
 128         .this_id                        = -1,
 129         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
 130         .max_sectors                    = 8192,
 131         .cmd_per_lun                    = 7,
 132         .shost_groups                   = mptscsih_host_attr_groups,
 133 };
 134
 135 /****************************************************************************
 136  * Supported hardware
 137  */
 138
 139 static struct pci_device_id mptfc_pci_table[] = {
 140         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC909,
 141                 PCI_ANY_ID, PCI_ANY_ID },
 142         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC919,
 143                 PCI_ANY_ID, PCI_ANY_ID },
 144         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC929,
 145                 PCI_ANY_ID, PCI_ANY_ID },
 146         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC919X,
 147                 PCI_ANY_ID, PCI_ANY_ID },
 148         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC929X,
 149                 PCI_ANY_ID, PCI_ANY_ID },
 150         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC939X,
 151                 PCI_ANY_ID, PCI_ANY_ID },
 152         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC949X,
 153                 PCI_ANY_ID, PCI_ANY_ID },
 154         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC949E,
 155                 PCI_ANY_ID, PCI_ANY_ID },
 156         { PCI_VENDOR_ID_BROCADE, MPI_MANUFACTPAGE_DEVICEID_FC949E,
 157                 PCI_ANY_ID, PCI_ANY_ID },
 158         {0}     /* Terminating entry */
 159 };
 160 MODULE_DEVICE_TABLE(pci, mptfc_pci_table);
 161
 162 static struct scsi_transport_template *mptfc_transport_template = NULL;
 163
 164 static struct fc_function_template mptfc_transport_functions = {
 165         .dd_fcrport_size = 8,
 166         .show_host_node_name = 1,
 167         .show_host_port_name = 1,
 168         .show_host_supported_classes = 1,
 169         .show_host_port_id = 1,
 170         .show_rport_supported_classes = 1,
 171         .show_starget_node_name = 1,
 172         .show_starget_port_name = 1,
 173         .show_starget_port_id = 1,
 174         .set_rport_dev_loss_tmo = mptfc_set_rport_loss_tmo,
 175         .show_rport_dev_loss_tmo = 1,
 176         .show_host_supported_speeds = 1,
 177         .show_host_maxframe_size = 1,
 178         .show_host_speed = 1,
 179         .show_host_fabric_name = 1,
 180         .show_host_port_type = 1,
 181         .show_host_port_state = 1,
 182         .show_host_symbolic_name = 1,
 183 };
 184
 185 static int
 186 mptfc_block_error_handler(struct scsi_cmnd *SCpnt,
 187                           int (*func)(struct scsi_cmnd *SCpnt),
 188                           const char *caller)
 189 {
 190         MPT_SCSI_HOST           *hd;
 191         struct scsi_device      *sdev = SCpnt->device;
 192         struct Scsi_Host        *shost = sdev->host;
 193         struct fc_rport         *rport = starget_to_rport(scsi_target(sdev));
 194         unsigned long           flags;
 195         int                     ready;
 196         MPT_ADAPTER             *ioc;
 197         int                     loops = 40;     /* seconds */
 198
 199         hd = shost_priv(SCpnt->device->host);
 200         ioc = hd->ioc;
 201         spin_lock_irqsave(shost->host_lock, flags);
 202         while ((ready = fc_remote_port_chkready(rport) >> 16) == DID_IMM_RETRY
 203          || (loops > 0 && ioc->active == 0)) {
 204                 spin_unlock_irqrestore(shost->host_lock, flags);
 205                 dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
 206                         "mptfc_block_error_handler.%d: %d:%llu, port status is "
 207                         "%x, active flag %d, deferring %s recovery.\n",
 208                         ioc->name, ioc->sh->host_no,
 209                         SCpnt->device->id, SCpnt->device->lun,
 210                         ready, ioc->active, caller));
 211                 msleep(1000);
 212                 spin_lock_irqsave(shost->host_lock, flags);
 213                 loops --;
 214         }
 215         spin_unlock_irqrestore(shost->host_lock, flags);
 216
 217         if (ready == DID_NO_CONNECT || !SCpnt->device->hostdata
 218          || ioc->active == 0) {
 219                 dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
 220                         "%s.%d: %d:%llu, failing recovery, "
 221                         "port state %x, active %d, vdevice %p.\n", caller,
 222                         ioc->name, ioc->sh->host_no,
 223                         SCpnt->device->id, SCpnt->device->lun, ready,
 224                         ioc->active, SCpnt->device->hostdata));
 225                 return FAILED;
 226         }
 227         dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
 228                 "%s.%d: %d:%llu, executing recovery.\n", caller,
 229                 ioc->name, ioc->sh->host_no,
 230                 SCpnt->device->id, SCpnt->device->lun));
 231         return (*func)(SCpnt);
 232 }
 233
 234 static int
 235 mptfc_abort(struct scsi_cmnd *SCpnt)
 236 {
 237         return
 238             mptfc_block_error_handler(SCpnt, mptscsih_abort, __func__);
 239 }
 240
 241 static int
 242 mptfc_dev_reset(struct scsi_cmnd *SCpnt)
 243 {
 244         return
 245             mptfc_block_error_handler(SCpnt, mptscsih_dev_reset, __func__);
 246 }
 247
 248 static int
 249 mptfc_bus_reset(struct scsi_cmnd *SCpnt)
 250 {
 251         return
 252             mptfc_block_error_handler(SCpnt, mptscsih_bus_reset, __func__);
 253 }
 254
 255 static void
 256 mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
 257 {
 258         if (timeout > 0)
 259                 rport->dev_loss_tmo = timeout;
 260         else
 261                 rport->dev_loss_tmo = mptfc_dev_loss_tmo;
 262 }
 263
 264 static int
 265 mptfc_FcDevPage0_cmp_func(const void *a, const void *b)
 266 {
 267         FCDevicePage0_t **aa = (FCDevicePage0_t **)a;
 268         FCDevicePage0_t **bb = (FCDevicePage0_t **)b;
 269
 270         if ((*aa)->CurrentBus == (*bb)->CurrentBus) {
 271                 if ((*aa)->CurrentTargetID == (*bb)->CurrentTargetID)
 272                         return 0;
 273                 if ((*aa)->CurrentTargetID < (*bb)->CurrentTargetID)
 274                         return -1;
 275                 return 1;
 276         }
 277         if ((*aa)->CurrentBus < (*bb)->CurrentBus)
 278                 return -1;
 279         return 1;
 280 }
 281
 282 static int
 283 mptfc_GetFcDevPage0(MPT_ADAPTER *ioc, int ioc_port,
 284         void(*func)(MPT_ADAPTER *ioc,int channel, FCDevicePage0_t *arg))
 285 {
 286         ConfigPageHeader_t       hdr;
 287         CONFIGPARMS              cfg;
 288         FCDevicePage0_t         *ppage0_alloc, *fc;
 289         dma_addr_t               page0_dma;
 290         int                      data_sz;
 291         int                      ii;
 292
 293         FCDevicePage0_t         *p0_array=NULL, *p_p0;
 294         FCDevicePage0_t         **pp0_array=NULL, **p_pp0;
 295
 296         int                      rc = -ENOMEM;
 297         U32                      port_id = 0xffffff;
 298         int                      num_targ = 0;
 299         int                      max_bus = ioc->facts.MaxBuses;
 300         int                      max_targ;
 301
 302         max_targ = (ioc->facts.MaxDevices == 0) ? 256 : ioc->facts.MaxDevices;
 303
 304         data_sz = sizeof(FCDevicePage0_t) * max_bus * max_targ;
 305         p_p0 = p0_array =  kzalloc(data_sz, GFP_KERNEL);
 306         if (!p0_array)
 307                 goto out;
 308
 309         data_sz = sizeof(FCDevicePage0_t *) * max_bus * max_targ;
 310         p_pp0 = pp0_array = kzalloc(data_sz, GFP_KERNEL);
 311         if (!pp0_array)
 312                 goto out;
 313
 314         do {
 315                 /* Get FC Device Page 0 header */
 316                 hdr.PageVersion = 0;
 317                 hdr.PageLength = 0;
 318                 hdr.PageNumber = 0;
 319                 hdr.PageType = MPI_CONFIG_PAGETYPE_FC_DEVICE;
 320                 cfg.cfghdr.hdr = &hdr;
 321                 cfg.physAddr = -1;
 322                 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 323                 cfg.dir = 0;
 324                 cfg.pageAddr = port_id;
 325                 cfg.timeout = 0;
 326
 327                 if ((rc = mpt_config(ioc, &cfg)) != 0)
 328                         break;
 329
 330                 if (hdr.PageLength <= 0)
 331                         break;
 332
 333                 data_sz = hdr.PageLength * 4;
 334                 ppage0_alloc = dma_alloc_coherent(&ioc->pcidev->dev, data_sz,
 335                                                   &page0_dma, GFP_KERNEL);
 336                 rc = -ENOMEM;
 337                 if (!ppage0_alloc)
 338                         break;
 339
 340                 cfg.physAddr = page0_dma;
 341                 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 342
 343                 if ((rc = mpt_config(ioc, &cfg)) == 0) {
 344                         ppage0_alloc->PortIdentifier =
 345                                 le32_to_cpu(ppage0_alloc->PortIdentifier);
 346
 347                         ppage0_alloc->WWNN.Low =
 348                                 le32_to_cpu(ppage0_alloc->WWNN.Low);
 349
 350                         ppage0_alloc->WWNN.High =
 351                                 le32_to_cpu(ppage0_alloc->WWNN.High);
 352
 353                         ppage0_alloc->WWPN.Low =
 354                                 le32_to_cpu(ppage0_alloc->WWPN.Low);
 355
 356                         ppage0_alloc->WWPN.High =
 357                                 le32_to_cpu(ppage0_alloc->WWPN.High);
 358
 359                         ppage0_alloc->BBCredit =
 360                                 le16_to_cpu(ppage0_alloc->BBCredit);
 361
 362                         ppage0_alloc->MaxRxFrameSize =
 363                                 le16_to_cpu(ppage0_alloc->MaxRxFrameSize);
 364
 365                         port_id = ppage0_alloc->PortIdentifier;
 366                         num_targ++;
 367                         *p_p0 = *ppage0_alloc;  /* save data */
 368                         *p_pp0++ = p_p0++;      /* save addr */
 369                 }
 370                 dma_free_coherent(&ioc->pcidev->dev, data_sz,
 371                                   ppage0_alloc, page0_dma);
 372                 if (rc != 0)
 373                         break;
 374
 375         } while (port_id <= 0xff0000);
 376
 377         if (num_targ) {
 378                 /* sort array */
 379                 if (num_targ > 1)
 380                         sort (pp0_array, num_targ, sizeof(FCDevicePage0_t *),
 381                                 mptfc_FcDevPage0_cmp_func, NULL);
 382                 /* call caller's func for each targ */
 383                 for (ii = 0; ii < num_targ;  ii++) {
 384                         fc = *(pp0_array+ii);
 385                         func(ioc, ioc_port, fc);
 386                 }
 387         }
 388
 389  out:
 390         kfree(pp0_array);
 391         kfree(p0_array);
 392         return rc;
 393 }
 394
 395 static int
 396 mptfc_generate_rport_ids(FCDevicePage0_t *pg0, struct fc_rport_identifiers *rid)
 397 {
 398         /* not currently usable */
 399         if (pg0->Flags & (MPI_FC_DEVICE_PAGE0_FLAGS_PLOGI_INVALID |
 400                           MPI_FC_DEVICE_PAGE0_FLAGS_PRLI_INVALID))
 401                 return -1;
 402
 403         if (!(pg0->Flags & MPI_FC_DEVICE_PAGE0_FLAGS_TARGETID_BUS_VALID))
 404                 return -1;
 405
 406         if (!(pg0->Protocol & MPI_FC_DEVICE_PAGE0_PROT_FCP_TARGET))
 407                 return -1;
 408
 409         /*
 410          * board data structure already normalized to platform endianness
 411          * shifted to avoid unaligned access on 64 bit architecture
 412          */
 413         rid->node_name = ((u64)pg0->WWNN.High) << 32 | (u64)pg0->WWNN.Low;
 414         rid->port_name = ((u64)pg0->WWPN.High) << 32 | (u64)pg0->WWPN.Low;
 415         rid->port_id =   pg0->PortIdentifier;
 416         rid->roles = FC_RPORT_ROLE_UNKNOWN;
 417
 418         return 0;
 419 }
 420
 421 static void
 422 mptfc_register_dev(MPT_ADAPTER *ioc, int channel, FCDevicePage0_t *pg0)
 423 {
 424         struct fc_rport_identifiers rport_ids;
 425         struct fc_rport         *rport;
 426         struct mptfc_rport_info *ri;
 427         int                     new_ri = 1;
 428         u64                     pn, nn;
 429         VirtTarget              *vtarget;
 430         u32                     roles = FC_RPORT_ROLE_UNKNOWN;
 431
 432         if (mptfc_generate_rport_ids(pg0, &rport_ids) < 0)
 433                 return;
 434
 435         roles |= FC_RPORT_ROLE_FCP_TARGET;
 436         if (pg0->Protocol & MPI_FC_DEVICE_PAGE0_PROT_FCP_INITIATOR)
 437                 roles |= FC_RPORT_ROLE_FCP_INITIATOR;
 438
 439         /* scan list looking for a match */
 440         list_for_each_entry(ri, &ioc->fc_rports, list) {
 441                 pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low;
 442                 if (pn == rport_ids.port_name) {        /* match */
 443                         list_move_tail(&ri->list, &ioc->fc_rports);
 444                         new_ri = 0;
 445                         break;
 446                 }
 447         }
 448         if (new_ri) {   /* allocate one */
 449                 ri = kzalloc(sizeof(struct mptfc_rport_info), GFP_KERNEL);
 450                 if (!ri)
 451                         return;
 452                 list_add_tail(&ri->list, &ioc->fc_rports);
 453         }
 454
 455         ri->pg0 = *pg0; /* add/update pg0 data */
 456         ri->flags &= ~MPT_RPORT_INFO_FLAGS_MISSING;
 457
 458         /* MPT_RPORT_INFO_FLAGS_REGISTERED - rport not previously deleted */
 459         if (!(ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED)) {
 460                 ri->flags |= MPT_RPORT_INFO_FLAGS_REGISTERED;
 461                 rport = fc_remote_port_add(ioc->sh, channel, &rport_ids);
 462                 if (rport) {
 463                         ri->rport = rport;
 464                         if (new_ri) /* may have been reset by user */
 465                                 rport->dev_loss_tmo = mptfc_dev_loss_tmo;
 466                         /*
 467                          * if already mapped, remap here.  If not mapped,
 468                          * target_alloc will allocate vtarget and map,
 469                          * slave_alloc will fill in vdevice from vtarget.
 470                          */
 471                         if (ri->starget) {
 472                                 vtarget = ri->starget->hostdata;
 473                                 if (vtarget) {
 474                                         vtarget->id = pg0->CurrentTargetID;
 475                                         vtarget->channel = pg0->CurrentBus;
 476                                         vtarget->deleted = 0;
 477                                 }
 478                         }
 479                         *((struct mptfc_rport_info **)rport->dd_data) = ri;
 480                         /* scan will be scheduled once rport becomes a target */
 481                         fc_remote_port_rolechg(rport,roles);
 482
 483                         pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low;
 484                         nn = (u64)ri->pg0.WWNN.High << 32 | (u64)ri->pg0.WWNN.Low;
 485                         dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
 486                                 "mptfc_reg_dev.%d: %x, %llx / %llx, tid %d, "
 487                                 "rport tid %d, tmo %d\n",
 488                                         ioc->name,
 489                                         ioc->sh->host_no,
 490                                         pg0->PortIdentifier,
 491                                         (unsigned long long)nn,
 492                                         (unsigned long long)pn,
 493                                         pg0->CurrentTargetID,
 494                                         ri->rport->scsi_target_id,
 495                                         ri->rport->dev_loss_tmo));
 496                 } else {
 497                         list_del(&ri->list);
 498                         kfree(ri);
 499                         ri = NULL;
 500                 }
 501         }
 502 }
 503
 504 /*
 505  *      OS entry point to allow for host driver to free allocated memory
 506  *      Called if no device present or device being unloaded
 507  */
 508 static void
 509 mptfc_target_destroy(struct scsi_target *starget)
 510 {
 511         struct fc_rport         *rport;
 512         struct mptfc_rport_info *ri;
 513
 514         rport = starget_to_rport(starget);
 515         if (rport) {
 516                 ri = *((struct mptfc_rport_info **)rport->dd_data);
 517                 if (ri) /* better be! */
 518                         ri->starget = NULL;
 519         }
 520         kfree(starget->hostdata);
 521         starget->hostdata = NULL;
 522 }
 523
 524 /*
 525  *      OS entry point to allow host driver to alloc memory
 526  *      for each scsi target. Called once per device the bus scan.
 527  *      Return non-zero if allocation fails.
 528  */
 529 static int
 530 mptfc_target_alloc(struct scsi_target *starget)
 531 {
 532         VirtTarget              *vtarget;
 533         struct fc_rport         *rport;
 534         struct mptfc_rport_info *ri;
 535         int                     rc;
 536
 537         vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
 538         if (!vtarget)
 539                 return -ENOMEM;
 540         starget->hostdata = vtarget;
 541
 542         rc = -ENODEV;
 543         rport = starget_to_rport(starget);
 544         if (rport) {
 545                 ri = *((struct mptfc_rport_info **)rport->dd_data);
 546                 if (ri) {       /* better be! */
 547                         vtarget->id = ri->pg0.CurrentTargetID;
 548                         vtarget->channel = ri->pg0.CurrentBus;
 549                         ri->starget = starget;
 550                         rc = 0;
 551                 }
 552         }
 553         if (rc != 0) {
 554                 kfree(vtarget);
 555                 starget->hostdata = NULL;
 556         }
 557
 558         return rc;
 559 }
 560 /*
 561  *      mptfc_dump_lun_info
 562  *      @ioc
 563  *      @rport
 564  *      @sdev
 565  *
 566  */
 567 static void
 568 mptfc_dump_lun_info(MPT_ADAPTER *ioc, struct fc_rport *rport, struct scsi_device *sdev,
 569                 VirtTarget *vtarget)
 570 {
 571         u64 nn, pn;
 572         struct mptfc_rport_info *ri;
 573
 574         ri = *((struct mptfc_rport_info **)rport->dd_data);
 575         pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low;
 576         nn = (u64)ri->pg0.WWNN.High << 32 | (u64)ri->pg0.WWNN.Low;
 577         dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
 578                 "mptfc_slv_alloc.%d: num_luns %d, sdev.id %d, "
 579                 "CurrentTargetID %d, %x %llx %llx\n",
 580                 ioc->name,
 581                 sdev->host->host_no,
 582                 vtarget->num_luns,
 583                 sdev->id, ri->pg0.CurrentTargetID,
 584                 ri->pg0.PortIdentifier,
 585                 (unsigned long long)pn,
 586                 (unsigned long long)nn));
 587 }
 588
 589
 590 /*
 591  *      OS entry point to allow host driver to alloc memory
 592  *      for each scsi device. Called once per device the bus scan.
 593  *      Return non-zero if allocation fails.
 594  *      Init memory once per LUN.
 595  */
 596 static int
 597 mptfc_slave_alloc(struct scsi_device *sdev)
 598 {
 599         MPT_SCSI_HOST           *hd;
 600         VirtTarget              *vtarget;
 601         VirtDevice              *vdevice;
 602         struct scsi_target      *starget;
 603         struct fc_rport         *rport;
 604         MPT_ADAPTER             *ioc;
 605
 606         starget = scsi_target(sdev);
 607         rport = starget_to_rport(starget);
 608
 609         if (!rport || fc_remote_port_chkready(rport))
 610                 return -ENXIO;
 611
 612         hd = shost_priv(sdev->host);
 613         ioc = hd->ioc;
 614
 615         vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
 616         if (!vdevice) {
 617                 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
 618                                 ioc->name, sizeof(VirtDevice));
 619                 return -ENOMEM;
 620         }
 621
 622
 623         sdev->hostdata = vdevice;
 624         vtarget = starget->hostdata;
 625
 626         if (vtarget->num_luns == 0) {
 627                 vtarget->ioc_id = ioc->id;
 628                 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
 629         }
 630
 631         vdevice->vtarget = vtarget;
 632         vdevice->lun = sdev->lun;
 633
 634         vtarget->num_luns++;
 635
 636
 637         mptfc_dump_lun_info(ioc, rport, sdev, vtarget);
 638
 639         return 0;
 640 }
 641
 642 static int
 643 mptfc_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
 644 {
 645         struct mptfc_rport_info *ri;
 646         struct fc_rport *rport = starget_to_rport(scsi_target(SCpnt->device));
 647         int             err;
 648         VirtDevice      *vdevice = SCpnt->device->hostdata;
 649
 650         if (!vdevice || !vdevice->vtarget) {
 651                 SCpnt->result = DID_NO_CONNECT << 16;
 652                 scsi_done(SCpnt);
 653                 return 0;
 654         }
 655
 656         err = fc_remote_port_chkready(rport);
 657         if (unlikely(err)) {
 658                 SCpnt->result = err;
 659                 scsi_done(SCpnt);
 660                 return 0;
 661         }
 662
 663         /* dd_data is null until finished adding target */
 664         ri = *((struct mptfc_rport_info **)rport->dd_data);
 665         if (unlikely(!ri)) {
 666                 SCpnt->result = DID_IMM_RETRY << 16;
 667                 scsi_done(SCpnt);
 668                 return 0;
 669         }
 670
 671         return mptscsih_qcmd(SCpnt);
 672 }
 673
 674 /*
 675  *      mptfc_display_port_link_speed - displaying link speed
 676  *      @ioc: Pointer to MPT_ADAPTER structure
 677  *      @portnum: IOC Port number
 678  *      @pp0dest: port page0 data payload
 679  *
 680  */
 681 static void
 682 mptfc_display_port_link_speed(MPT_ADAPTER *ioc, int portnum, FCPortPage0_t *pp0dest)
 683 {
 684         u8      old_speed, new_speed, state;
 685         char    *old, *new;
 686
 687         if (portnum >= 2)
 688                 return;
 689
 690         old_speed = ioc->fc_link_speed[portnum];
 691         new_speed = pp0dest->CurrentSpeed;
 692         state = pp0dest->PortState;
 693
 694         if (state != MPI_FCPORTPAGE0_PORTSTATE_OFFLINE &&
 695             new_speed != MPI_FCPORTPAGE0_CURRENT_SPEED_UNKNOWN) {
 696
 697                 old = old_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_1GBIT ? "1 Gbps" :
 698                        old_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_2GBIT ? "2 Gbps" :
 699                         old_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_4GBIT ? "4 Gbps" :
 700                          "Unknown";
 701                 new = new_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_1GBIT ? "1 Gbps" :
 702                        new_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_2GBIT ? "2 Gbps" :
 703                         new_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_4GBIT ? "4 Gbps" :
 704                          "Unknown";
 705                 if (old_speed == 0)
 706                         printk(MYIOC_s_NOTE_FMT
 707                                 "FC Link Established, Speed = %s\n",
 708                                 ioc->name, new);
 709                 else if (old_speed != new_speed)
 710                         printk(MYIOC_s_WARN_FMT
 711                                 "FC Link Speed Change, Old Speed = %s, New Speed = %s\n",
 712                                 ioc->name, old, new);
 713
 714                 ioc->fc_link_speed[portnum] = new_speed;
 715         }
 716 }
 717
 718 /*
 719  *      mptfc_GetFcPortPage0 - Fetch FCPort config Page0.
 720  *      @ioc: Pointer to MPT_ADAPTER structure
 721  *      @portnum: IOC Port number
 722  *
 723  *      Return: 0 for success
 724  *      -ENOMEM if no memory available
 725  *              -EPERM if not allowed due to ISR context
 726  *              -EAGAIN if no msg frames currently available
 727  *              -EFAULT for non-successful reply or no reply (timeout)
 728  *              -EINVAL portnum arg out of range (hardwired to two elements)
 729  */
 730 static int
 731 mptfc_GetFcPortPage0(MPT_ADAPTER *ioc, int portnum)
 732 {
 733         ConfigPageHeader_t       hdr;
 734         CONFIGPARMS              cfg;
 735         FCPortPage0_t           *ppage0_alloc;
 736         FCPortPage0_t           *pp0dest;
 737         dma_addr_t               page0_dma;
 738         int                      data_sz;
 739         int                      copy_sz;
 740         int                      rc;
 741         int                      count = 400;
 742
 743         if (portnum > 1)
 744                 return -EINVAL;
 745
 746         /* Get FCPort Page 0 header */
 747         hdr.PageVersion = 0;
 748         hdr.PageLength = 0;
 749         hdr.PageNumber = 0;
 750         hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT;
 751         cfg.cfghdr.hdr = &hdr;
 752         cfg.physAddr = -1;
 753         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 754         cfg.dir = 0;
 755         cfg.pageAddr = portnum;
 756         cfg.timeout = 0;
 757
 758         if ((rc = mpt_config(ioc, &cfg)) != 0)
 759                 return rc;
 760
 761         if (hdr.PageLength == 0)
 762                 return 0;
 763
 764         data_sz = hdr.PageLength * 4;
 765         rc = -ENOMEM;
 766         ppage0_alloc = dma_alloc_coherent(&ioc->pcidev->dev, data_sz,
 767                                           &page0_dma, GFP_KERNEL);
 768         if (ppage0_alloc) {
 769
 770  try_again:
 771                 memset((u8 *)ppage0_alloc, 0, data_sz);
 772                 cfg.physAddr = page0_dma;
 773                 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 774
 775                 if ((rc = mpt_config(ioc, &cfg)) == 0) {
 776                         /* save the data */
 777                         pp0dest = &ioc->fc_port_page0[portnum];
 778                         copy_sz = min_t(int, sizeof(FCPortPage0_t), data_sz);
 779                         memcpy(pp0dest, ppage0_alloc, copy_sz);
 780
 781                         /*
 782                          *      Normalize endianness of structure data,
 783                          *      by byte-swapping all > 1 byte fields!
 784                          */
 785                         pp0dest->Flags = le32_to_cpu(pp0dest->Flags);
 786                         pp0dest->PortIdentifier = le32_to_cpu(pp0dest->PortIdentifier);
 787                         pp0dest->WWNN.Low = le32_to_cpu(pp0dest->WWNN.Low);
 788                         pp0dest->WWNN.High = le32_to_cpu(pp0dest->WWNN.High);
 789                         pp0dest->WWPN.Low = le32_to_cpu(pp0dest->WWPN.Low);
 790                         pp0dest->WWPN.High = le32_to_cpu(pp0dest->WWPN.High);
 791                         pp0dest->SupportedServiceClass = le32_to_cpu(pp0dest->SupportedServiceClass);
 792                         pp0dest->SupportedSpeeds = le32_to_cpu(pp0dest->SupportedSpeeds);
 793                         pp0dest->CurrentSpeed = le32_to_cpu(pp0dest->CurrentSpeed);
 794                         pp0dest->MaxFrameSize = le32_to_cpu(pp0dest->MaxFrameSize);
 795                         pp0dest->FabricWWNN.Low = le32_to_cpu(pp0dest->FabricWWNN.Low);
 796                         pp0dest->FabricWWNN.High = le32_to_cpu(pp0dest->FabricWWNN.High);
 797                         pp0dest->FabricWWPN.Low = le32_to_cpu(pp0dest->FabricWWPN.Low);
 798                         pp0dest->FabricWWPN.High = le32_to_cpu(pp0dest->FabricWWPN.High);
 799                         pp0dest->DiscoveredPortsCount = le32_to_cpu(pp0dest->DiscoveredPortsCount);
 800                         pp0dest->MaxInitiators = le32_to_cpu(pp0dest->MaxInitiators);
 801
 802                         /*
 803                          * if still doing discovery,
 804                          * hang loose a while until finished
 805                          */
 806                         if ((pp0dest->PortState == MPI_FCPORTPAGE0_PORTSTATE_UNKNOWN) ||
 807                             (pp0dest->PortState == MPI_FCPORTPAGE0_PORTSTATE_ONLINE &&
 808                              (pp0dest->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_TYPE_MASK)
 809                               == MPI_FCPORTPAGE0_FLAGS_ATTACH_NO_INIT)) {
 810                                 if (count-- > 0) {
 811                                         msleep(100);
 812                                         goto try_again;
 813                                 }
 814                                 printk(MYIOC_s_INFO_FMT "Firmware discovery not"
 815                                                         " complete.\n",
 816                                                 ioc->name);
 817                         }
 818                         mptfc_display_port_link_speed(ioc, portnum, pp0dest);
 819                 }
 820
 821                 dma_free_coherent(&ioc->pcidev->dev, data_sz, ppage0_alloc,
 822                                   page0_dma);
 823         }
 824
 825         return rc;
 826 }
 827
 828 static int
 829 mptfc_WriteFcPortPage1(MPT_ADAPTER *ioc, int portnum)
 830 {
 831         ConfigPageHeader_t       hdr;
 832         CONFIGPARMS              cfg;
 833         int                      rc;
 834
 835         if (portnum > 1)
 836                 return -EINVAL;
 837
 838         if (!(ioc->fc_data.fc_port_page1[portnum].data))
 839                 return -EINVAL;
 840
 841         /* get fcport page 1 header */
 842         hdr.PageVersion = 0;
 843         hdr.PageLength = 0;
 844         hdr.PageNumber = 1;
 845         hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT;
 846         cfg.cfghdr.hdr = &hdr;
 847         cfg.physAddr = -1;
 848         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 849         cfg.dir = 0;
 850         cfg.pageAddr = portnum;
 851         cfg.timeout = 0;
 852
 853         if ((rc = mpt_config(ioc, &cfg)) != 0)
 854                 return rc;
 855
 856         if (hdr.PageLength == 0)
 857                 return -ENODEV;
 858
 859         if (hdr.PageLength*4 != ioc->fc_data.fc_port_page1[portnum].pg_sz)
 860                 return -EINVAL;
 861
 862         cfg.physAddr = ioc->fc_data.fc_port_page1[portnum].dma;
 863         cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 864         cfg.dir = 1;
 865
 866         rc = mpt_config(ioc, &cfg);
 867
 868         return rc;
 869 }
 870
 871 static int
 872 mptfc_GetFcPortPage1(MPT_ADAPTER *ioc, int portnum)
 873 {
 874         ConfigPageHeader_t       hdr;
 875         CONFIGPARMS              cfg;
 876         FCPortPage1_t           *page1_alloc;
 877         dma_addr_t               page1_dma;
 878         int                      data_sz;
 879         int                      rc;
 880
 881         if (portnum > 1)
 882                 return -EINVAL;
 883
 884         /* get fcport page 1 header */
 885         hdr.PageVersion = 0;
 886         hdr.PageLength = 0;
 887         hdr.PageNumber = 1;
 888         hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT;
 889         cfg.cfghdr.hdr = &hdr;
 890         cfg.physAddr = -1;
 891         cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 892         cfg.dir = 0;
 893         cfg.pageAddr = portnum;
 894         cfg.timeout = 0;
 895
 896         if ((rc = mpt_config(ioc, &cfg)) != 0)
 897                 return rc;
 898
 899         if (hdr.PageLength == 0)
 900                 return -ENODEV;
 901
 902 start_over:
 903
 904         if (ioc->fc_data.fc_port_page1[portnum].data == NULL) {
 905                 data_sz = hdr.PageLength * 4;
 906                 if (data_sz < sizeof(FCPortPage1_t))
 907                         data_sz = sizeof(FCPortPage1_t);
 908
 909                 page1_alloc = dma_alloc_coherent(&ioc->pcidev->dev, data_sz,
 910                                                  &page1_dma, GFP_KERNEL);
 911                 if (!page1_alloc)
 912                         return -ENOMEM;
 913         }
 914         else {
 915                 page1_alloc = ioc->fc_data.fc_port_page1[portnum].data;
 916                 page1_dma = ioc->fc_data.fc_port_page1[portnum].dma;
 917                 data_sz = ioc->fc_data.fc_port_page1[portnum].pg_sz;
 918                 if (hdr.PageLength * 4 > data_sz) {
 919                         ioc->fc_data.fc_port_page1[portnum].data = NULL;
 920                         dma_free_coherent(&ioc->pcidev->dev, data_sz,
 921                                           page1_alloc, page1_dma);
 922                         goto start_over;
 923                 }
 924         }
 925
 926         cfg.physAddr = page1_dma;
 927         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 928
 929         if ((rc = mpt_config(ioc, &cfg)) == 0) {
 930                 ioc->fc_data.fc_port_page1[portnum].data = page1_alloc;
 931                 ioc->fc_data.fc_port_page1[portnum].pg_sz = data_sz;
 932                 ioc->fc_data.fc_port_page1[portnum].dma = page1_dma;
 933         }
 934         else {
 935                 ioc->fc_data.fc_port_page1[portnum].data = NULL;
 936                 dma_free_coherent(&ioc->pcidev->dev, data_sz, page1_alloc,
 937                                   page1_dma);
 938         }
 939
 940         return rc;
 941 }
 942
 943 static void
 944 mptfc_SetFcPortPage1_defaults(MPT_ADAPTER *ioc)
 945 {
 946         int             ii;
 947         FCPortPage1_t   *pp1;
 948
 949         #define MPTFC_FW_DEVICE_TIMEOUT (1)
 950         #define MPTFC_FW_IO_PEND_TIMEOUT (1)
 951         #define ON_FLAGS  (MPI_FCPORTPAGE1_FLAGS_IMMEDIATE_ERROR_REPLY)
 952         #define OFF_FLAGS (MPI_FCPORTPAGE1_FLAGS_VERBOSE_RESCAN_EVENTS)
 953
 954         for (ii=0; ii<ioc->facts.NumberOfPorts; ii++) {
 955                 if (mptfc_GetFcPortPage1(ioc, ii) != 0)
 956                         continue;
 957                 pp1 = ioc->fc_data.fc_port_page1[ii].data;
 958                 if ((pp1->InitiatorDeviceTimeout == MPTFC_FW_DEVICE_TIMEOUT)
 959                  && (pp1->InitiatorIoPendTimeout == MPTFC_FW_IO_PEND_TIMEOUT)
 960                  && ((pp1->Flags & ON_FLAGS) == ON_FLAGS)
 961                  && ((pp1->Flags & OFF_FLAGS) == 0))
 962                         continue;
 963                 pp1->InitiatorDeviceTimeout = MPTFC_FW_DEVICE_TIMEOUT;
 964                 pp1->InitiatorIoPendTimeout = MPTFC_FW_IO_PEND_TIMEOUT;
 965                 pp1->Flags &= ~OFF_FLAGS;
 966                 pp1->Flags |= ON_FLAGS;
 967                 mptfc_WriteFcPortPage1(ioc, ii);
 968         }
 969 }
 970
 971
 972 static void
 973 mptfc_init_host_attr(MPT_ADAPTER *ioc,int portnum)
 974 {
 975         unsigned        class = 0;
 976         unsigned        cos = 0;
 977         unsigned        speed;
 978         unsigned        port_type;
 979         unsigned        port_state;
 980         FCPortPage0_t   *pp0;
 981         struct Scsi_Host *sh;
 982         char            *sn;
 983
 984         /* don't know what to do as only one scsi (fc) host was allocated */
 985         if (portnum != 0)
 986                 return;
 987
 988         pp0 = &ioc->fc_port_page0[portnum];
 989         sh = ioc->sh;
 990
 991         sn = fc_host_symbolic_name(sh);
 992         snprintf(sn, FC_SYMBOLIC_NAME_SIZE, "%s %s%08xh",
 993             ioc->prod_name,
 994             MPT_FW_REV_MAGIC_ID_STRING,
 995             ioc->facts.FWVersion.Word);
 996
 997         fc_host_tgtid_bind_type(sh) = FC_TGTID_BIND_BY_WWPN;
 998
 999         fc_host_maxframe_size(sh) = pp0->MaxFrameSize;
1000
1001         fc_host_node_name(sh) =
1002                 (u64)pp0->WWNN.High << 32 | (u64)pp0->WWNN.Low;
1003
1004         fc_host_port_name(sh) =
1005                 (u64)pp0->WWPN.High << 32 | (u64)pp0->WWPN.Low;
1006
1007         fc_host_port_id(sh) = pp0->PortIdentifier;
1008
1009         class = pp0->SupportedServiceClass;
1010         if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_1)
1011                 cos |= FC_COS_CLASS1;
1012         if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_2)
1013                 cos |= FC_COS_CLASS2;
1014         if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_3)
1015                 cos |= FC_COS_CLASS3;
1016         fc_host_supported_classes(sh) = cos;
1017
1018         if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_1GBIT)
1019                 speed = FC_PORTSPEED_1GBIT;
1020         else if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_2GBIT)
1021                 speed = FC_PORTSPEED_2GBIT;
1022         else if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_4GBIT)
1023                 speed = FC_PORTSPEED_4GBIT;
1024         else if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_10GBIT)
1025                 speed = FC_PORTSPEED_10GBIT;
1026         else
1027                 speed = FC_PORTSPEED_UNKNOWN;
1028         fc_host_speed(sh) = speed;
1029
1030         speed = 0;
1031         if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_1GBIT_SPEED)
1032                 speed |= FC_PORTSPEED_1GBIT;
1033         if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_2GBIT_SPEED)
1034                 speed |= FC_PORTSPEED_2GBIT;
1035         if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_4GBIT_SPEED)
1036                 speed |= FC_PORTSPEED_4GBIT;
1037         if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_10GBIT_SPEED)
1038                 speed |= FC_PORTSPEED_10GBIT;
1039         fc_host_supported_speeds(sh) = speed;
1040
1041         port_state = FC_PORTSTATE_UNKNOWN;
1042         if (pp0->PortState == MPI_FCPORTPAGE0_PORTSTATE_ONLINE)
1043                 port_state = FC_PORTSTATE_ONLINE;
1044         else if (pp0->PortState == MPI_FCPORTPAGE0_PORTSTATE_OFFLINE)
1045                 port_state = FC_PORTSTATE_LINKDOWN;
1046         fc_host_port_state(sh) = port_state;
1047
1048         port_type = FC_PORTTYPE_UNKNOWN;
1049         if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_POINT_TO_POINT)
1050                 port_type = FC_PORTTYPE_PTP;
1051         else if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_PRIVATE_LOOP)
1052                 port_type = FC_PORTTYPE_LPORT;
1053         else if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_PUBLIC_LOOP)
1054                 port_type = FC_PORTTYPE_NLPORT;
1055         else if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_FABRIC_DIRECT)
1056                 port_type = FC_PORTTYPE_NPORT;
1057         fc_host_port_type(sh) = port_type;
1058
1059         fc_host_fabric_name(sh) =
1060             (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_FABRIC_WWN_VALID) ?
1061                 (u64) pp0->FabricWWNN.High << 32 | (u64) pp0->FabricWWPN.Low :
1062                 (u64)pp0->WWNN.High << 32 | (u64)pp0->WWNN.Low;
1063
1064 }
1065
1066 static void
1067 mptfc_link_status_change(struct work_struct *work)
1068 {
1069         MPT_ADAPTER             *ioc =
1070                 container_of(work, MPT_ADAPTER, fc_rescan_work);
1071         int ii;
1072
1073         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++)
1074                 (void) mptfc_GetFcPortPage0(ioc, ii);
1075
1076 }
1077
1078 static void
1079 mptfc_setup_reset(struct work_struct *work)
1080 {
1081         MPT_ADAPTER             *ioc =
1082                 container_of(work, MPT_ADAPTER, fc_setup_reset_work);
1083         u64                     pn;
1084         struct mptfc_rport_info *ri;
1085         struct scsi_target      *starget;
1086         VirtTarget              *vtarget;
1087
1088         /* reset about to happen, delete (block) all rports */
1089         list_for_each_entry(ri, &ioc->fc_rports, list) {
1090                 if (ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED) {
1091                         ri->flags &= ~MPT_RPORT_INFO_FLAGS_REGISTERED;
1092                         fc_remote_port_delete(ri->rport);       /* won't sleep */
1093                         ri->rport = NULL;
1094                         starget = ri->starget;
1095                         if (starget) {
1096                                 vtarget = starget->hostdata;
1097                                 if (vtarget)
1098                                         vtarget->deleted = 1;
1099                         }
1100
1101                         pn = (u64)ri->pg0.WWPN.High << 32 |
1102                              (u64)ri->pg0.WWPN.Low;
1103                         dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
1104                                 "mptfc_setup_reset.%d: %llx deleted\n",
1105                                 ioc->name,
1106                                 ioc->sh->host_no,
1107                                 (unsigned long long)pn));
1108                 }
1109         }
1110 }
1111
1112 static void
1113 mptfc_rescan_devices(struct work_struct *work)
1114 {
1115         MPT_ADAPTER             *ioc =
1116                 container_of(work, MPT_ADAPTER, fc_rescan_work);
1117         int                     ii;
1118         u64                     pn;
1119         struct mptfc_rport_info *ri;
1120         struct scsi_target      *starget;
1121         VirtTarget              *vtarget;
1122
1123         /* start by tagging all ports as missing */
1124         list_for_each_entry(ri, &ioc->fc_rports, list) {
1125                 if (ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED) {
1126                         ri->flags |= MPT_RPORT_INFO_FLAGS_MISSING;
1127                 }
1128         }
1129
1130         /*
1131          * now rescan devices known to adapter,
1132          * will reregister existing rports
1133          */
1134         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1135                 (void) mptfc_GetFcPortPage0(ioc, ii);
1136                 mptfc_init_host_attr(ioc, ii);  /* refresh */
1137                 mptfc_GetFcDevPage0(ioc, ii, mptfc_register_dev);
1138         }
1139
1140         /* delete devices still missing */
1141         list_for_each_entry(ri, &ioc->fc_rports, list) {
1142                 /* if newly missing, delete it */
1143                 if (ri->flags & MPT_RPORT_INFO_FLAGS_MISSING) {
1144
1145                         ri->flags &= ~(MPT_RPORT_INFO_FLAGS_REGISTERED|
1146                                        MPT_RPORT_INFO_FLAGS_MISSING);
1147                         fc_remote_port_delete(ri->rport);       /* won't sleep */
1148                         ri->rport = NULL;
1149                         starget = ri->starget;
1150                         if (starget) {
1151                                 vtarget = starget->hostdata;
1152                                 if (vtarget)
1153                                         vtarget->deleted = 1;
1154                         }
1155
1156                         pn = (u64)ri->pg0.WWPN.High << 32 |
1157                              (u64)ri->pg0.WWPN.Low;
1158                         dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
1159                                 "mptfc_rescan.%d: %llx deleted\n",
1160                                 ioc->name,
1161                                 ioc->sh->host_no,
1162                                 (unsigned long long)pn));
1163                 }
1164         }
1165 }
1166
1167 static int
1168 mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1169 {
1170         struct Scsi_Host        *sh;
1171         MPT_SCSI_HOST           *hd;
1172         MPT_ADAPTER             *ioc;
1173         unsigned long            flags;
1174         int                      ii;
1175         int                      numSGE = 0;
1176         int                      scale;
1177         int                      ioc_cap;
1178         int                     error=0;
1179         int                     r;
1180
1181         if ((r = mpt_attach(pdev,id)) != 0)
1182                 return r;
1183
1184         ioc = pci_get_drvdata(pdev);
1185         ioc->DoneCtx = mptfcDoneCtx;
1186         ioc->TaskCtx = mptfcTaskCtx;
1187         ioc->InternalCtx = mptfcInternalCtx;
1188
1189         /*  Added sanity check on readiness of the MPT adapter.
1190          */
1191         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1192                 printk(MYIOC_s_WARN_FMT
1193                   "Skipping because it's not operational!\n",
1194                   ioc->name);
1195                 error = -ENODEV;
1196                 goto out_mptfc_probe;
1197         }
1198
1199         if (!ioc->active) {
1200                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1201                   ioc->name);
1202                 error = -ENODEV;
1203                 goto out_mptfc_probe;
1204         }
1205
1206         /*  Sanity check - ensure at least 1 port is INITIATOR capable
1207          */
1208         ioc_cap = 0;
1209         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1210                 if (ioc->pfacts[ii].ProtocolFlags &
1211                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
1212                         ioc_cap ++;
1213         }
1214
1215         if (!ioc_cap) {
1216                 printk(MYIOC_s_WARN_FMT
1217                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1218                         ioc->name, ioc);
1219                 return 0;
1220         }
1221
1222         sh = scsi_host_alloc(&mptfc_driver_template, sizeof(MPT_SCSI_HOST));
1223
1224         if (!sh) {
1225                 printk(MYIOC_s_WARN_FMT
1226                         "Unable to register controller with SCSI subsystem\n",
1227                         ioc->name);
1228                 error = -1;
1229                 goto out_mptfc_probe;
1230         }
1231
1232         spin_lock_init(&ioc->fc_rescan_work_lock);
1233         INIT_WORK(&ioc->fc_rescan_work, mptfc_rescan_devices);
1234         INIT_WORK(&ioc->fc_setup_reset_work, mptfc_setup_reset);
1235         INIT_WORK(&ioc->fc_lsc_work, mptfc_link_status_change);
1236
1237         spin_lock_irqsave(&ioc->FreeQlock, flags);
1238
1239         /* Attach the SCSI Host to the IOC structure
1240          */
1241         ioc->sh = sh;
1242
1243         sh->io_port = 0;
1244         sh->n_io_port = 0;
1245         sh->irq = 0;
1246
1247         /* set 16 byte cdb's */
1248         sh->max_cmd_len = 16;
1249
1250         sh->max_id = ioc->pfacts->MaxDevices;
1251         sh->max_lun = max_lun;
1252
1253         /* Required entry.
1254          */
1255         sh->unique_id = ioc->id;
1256
1257         /* Verify that we won't exceed the maximum
1258          * number of chain buffers
1259          * We can optimize:  ZZ = req_sz/sizeof(SGE)
1260          * For 32bit SGE's:
1261          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1262          *               + (req_sz - 64)/sizeof(SGE)
1263          * A slightly different algorithm is required for
1264          * 64bit SGEs.
1265          */
1266         scale = ioc->req_sz/ioc->SGE_size;
1267         if (ioc->sg_addr_size == sizeof(u64)) {
1268                 numSGE = (scale - 1) *
1269                   (ioc->facts.MaxChainDepth-1) + scale +
1270                   (ioc->req_sz - 60) / ioc->SGE_size;
1271         } else {
1272                 numSGE = 1 + (scale - 1) *
1273                   (ioc->facts.MaxChainDepth-1) + scale +
1274                   (ioc->req_sz - 64) / ioc->SGE_size;
1275         }
1276
1277         if (numSGE < sh->sg_tablesize) {
1278                 /* Reset this value */
1279                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1280                   "Resetting sg_tablesize to %d from %d\n",
1281                   ioc->name, numSGE, sh->sg_tablesize));
1282                 sh->sg_tablesize = numSGE;
1283         }
1284
1285         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1286
1287         hd = shost_priv(sh);
1288         hd->ioc = ioc;
1289
1290         /* SCSI needs scsi_cmnd lookup table!
1291          * (with size equal to req_depth*PtrSz!)
1292          */
1293         ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_KERNEL);
1294         if (!ioc->ScsiLookup) {
1295                 error = -ENOMEM;
1296                 goto out_mptfc_probe;
1297         }
1298         spin_lock_init(&ioc->scsi_lookup_lock);
1299
1300         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1301                  ioc->name, ioc->ScsiLookup));
1302
1303         hd->last_queue_full = 0;
1304
1305         sh->transportt = mptfc_transport_template;
1306         error = scsi_add_host (sh, &ioc->pcidev->dev);
1307         if(error) {
1308                 dprintk(ioc, printk(MYIOC_s_ERR_FMT
1309                   "scsi_add_host failed\n", ioc->name));
1310                 goto out_mptfc_probe;
1311         }
1312
1313         /* initialize workqueue */
1314
1315         snprintf(ioc->fc_rescan_work_q_name, sizeof(ioc->fc_rescan_work_q_name),
1316                  "mptfc_wq_%d", sh->host_no);
1317         ioc->fc_rescan_work_q =
1318                 alloc_ordered_workqueue(ioc->fc_rescan_work_q_name,
1319                                         WQ_MEM_RECLAIM);
1320         if (!ioc->fc_rescan_work_q) {
1321                 error = -ENOMEM;
1322                 goto out_mptfc_host;
1323         }
1324
1325         /*
1326          *  Pre-fetch FC port WWN and stuff...
1327          *  (FCPortPage0_t stuff)
1328          */
1329         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1330                 (void) mptfc_GetFcPortPage0(ioc, ii);
1331         }
1332         mptfc_SetFcPortPage1_defaults(ioc);
1333
1334         /*
1335          * scan for rports -
1336          *      by doing it via the workqueue, some locking is eliminated
1337          */
1338
1339         queue_work(ioc->fc_rescan_work_q, &ioc->fc_rescan_work);
1340         flush_workqueue(ioc->fc_rescan_work_q);
1341
1342         return 0;
1343
1344 out_mptfc_host:
1345         scsi_remove_host(sh);
1346
1347 out_mptfc_probe:
1348
1349         mptscsih_remove(pdev);
1350         return error;
1351 }
1352
1353 static struct pci_driver mptfc_driver = {
1354         .name           = "mptfc",
1355         .id_table       = mptfc_pci_table,
1356         .probe          = mptfc_probe,
1357         .remove         = mptfc_remove,
1358         .shutdown       = mptscsih_shutdown,
1359 #ifdef CONFIG_PM
1360         .suspend        = mptscsih_suspend,
1361         .resume         = mptscsih_resume,
1362 #endif
1363 };
1364
1365 static int
1366 mptfc_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1367 {
1368         MPT_SCSI_HOST *hd;
1369         u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1370         unsigned long flags;
1371         int rc=1;
1372
1373         if (ioc->bus_type != FC)
1374                 return 0;
1375
1376         devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MPT event (=%02Xh) routed to SCSI host driver!\n",
1377                         ioc->name, event));
1378
1379         if (ioc->sh == NULL ||
1380                 ((hd = shost_priv(ioc->sh)) == NULL))
1381                 return 1;
1382
1383         switch (event) {
1384         case MPI_EVENT_RESCAN:
1385                 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1386                 if (ioc->fc_rescan_work_q) {
1387                         queue_work(ioc->fc_rescan_work_q,
1388                                    &ioc->fc_rescan_work);
1389                 }
1390                 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1391                 break;
1392         case MPI_EVENT_LINK_STATUS_CHANGE:
1393                 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1394                 if (ioc->fc_rescan_work_q) {
1395                         queue_work(ioc->fc_rescan_work_q,
1396                                    &ioc->fc_lsc_work);
1397                 }
1398                 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1399                 break;
1400         default:
1401                 rc = mptscsih_event_process(ioc,pEvReply);
1402                 break;
1403         }
1404         return rc;
1405 }
1406
1407 static int
1408 mptfc_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1409 {
1410         int             rc;
1411         unsigned long   flags;
1412
1413         rc = mptscsih_ioc_reset(ioc,reset_phase);
1414         if ((ioc->bus_type != FC) || (!rc))
1415                 return rc;
1416
1417
1418         dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1419                 ": IOC %s_reset routed to FC host driver!\n",ioc->name,
1420                 reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
1421                 reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
1422
1423         if (reset_phase == MPT_IOC_SETUP_RESET) {
1424                 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1425                 if (ioc->fc_rescan_work_q) {
1426                         queue_work(ioc->fc_rescan_work_q,
1427                                    &ioc->fc_setup_reset_work);
1428                 }
1429                 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1430         }
1431
1432         else if (reset_phase == MPT_IOC_PRE_RESET) {
1433         }
1434
1435         else {  /* MPT_IOC_POST_RESET */
1436                 mptfc_SetFcPortPage1_defaults(ioc);
1437                 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1438                 if (ioc->fc_rescan_work_q) {
1439                         queue_work(ioc->fc_rescan_work_q,
1440                                    &ioc->fc_rescan_work);
1441                 }
1442                 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1443         }
1444         return 1;
1445 }
1446
1447 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1448 /**
1449  *      mptfc_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1450  *
1451  *      Returns 0 for success, non-zero for failure.
1452  */
1453 static int __init
1454 mptfc_init(void)
1455 {
1456         int error;
1457
1458         show_mptmod_ver(my_NAME, my_VERSION);
1459
1460         /* sanity check module parameters */
1461         if (mptfc_dev_loss_tmo <= 0)
1462                 mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO;
1463
1464         mptfc_transport_template =
1465                 fc_attach_transport(&mptfc_transport_functions);
1466
1467         if (!mptfc_transport_template)
1468                 return -ENODEV;
1469
1470         mptfcDoneCtx = mpt_register(mptscsih_io_done, MPTFC_DRIVER,
1471             "mptscsih_scandv_complete");
1472         mptfcTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTFC_DRIVER,
1473             "mptscsih_scandv_complete");
1474         mptfcInternalCtx = mpt_register(mptscsih_scandv_complete, MPTFC_DRIVER,
1475             "mptscsih_scandv_complete");
1476
1477         mpt_event_register(mptfcDoneCtx, mptfc_event_process);
1478         mpt_reset_register(mptfcDoneCtx, mptfc_ioc_reset);
1479
1480         error = pci_register_driver(&mptfc_driver);
1481         if (error)
1482                 fc_release_transport(mptfc_transport_template);
1483
1484         return error;
1485 }
1486
1487 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1488 /**
1489  *      mptfc_remove - Remove fc infrastructure for devices
1490  *      @pdev: Pointer to pci_dev structure
1491  *
1492  */
1493 static void mptfc_remove(struct pci_dev *pdev)
1494 {
1495         MPT_ADAPTER             *ioc = pci_get_drvdata(pdev);
1496         struct mptfc_rport_info *p, *n;
1497         struct workqueue_struct *work_q;
1498         unsigned long           flags;
1499         int                     ii;
1500
1501         /* destroy workqueue */
1502         if ((work_q=ioc->fc_rescan_work_q)) {
1503                 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1504                 ioc->fc_rescan_work_q = NULL;
1505                 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1506                 destroy_workqueue(work_q);
1507         }
1508
1509         fc_remove_host(ioc->sh);
1510
1511         list_for_each_entry_safe(p, n, &ioc->fc_rports, list) {
1512                 list_del(&p->list);
1513                 kfree(p);
1514         }
1515
1516         for (ii=0; ii<ioc->facts.NumberOfPorts; ii++) {
1517                 if (ioc->fc_data.fc_port_page1[ii].data) {
1518                         dma_free_coherent(&ioc->pcidev->dev,
1519                                           ioc->fc_data.fc_port_page1[ii].pg_sz,
1520                                           ioc->fc_data.fc_port_page1[ii].data,
1521                                           ioc->fc_data.fc_port_page1[ii].dma);
1522                         ioc->fc_data.fc_port_page1[ii].data = NULL;
1523                 }
1524         }
1525
1526         scsi_remove_host(ioc->sh);
1527
1528         mptscsih_remove(pdev);
1529 }
1530
1531 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1532 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1533 /**
1534  *      mptfc_exit - Unregisters MPT adapter(s)
1535  *
1536  */
1537 static void __exit
1538 mptfc_exit(void)
1539 {
1540         pci_unregister_driver(&mptfc_driver);
1541         fc_release_transport(mptfc_transport_template);
1542
1543         mpt_reset_deregister(mptfcDoneCtx);
1544         mpt_event_deregister(mptfcDoneCtx);
1545
1546         mpt_deregister(mptfcInternalCtx);
1547         mpt_deregister(mptfcTaskCtx);
1548         mpt_deregister(mptfcDoneCtx);
1549 }
1550
1551 module_init(mptfc_init);
1552 module_exit(mptfc_exit);