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