// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2021 Broadcom. All Rights Reserved. The term
 * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
 */

#include "efct_driver.h"
#include "efct_unsol.h"

static struct dentry *efct_debugfs_root;
static atomic_t efct_debugfs_count;

static const struct scsi_host_template efct_template = {
 .module   = THIS_MODULE,
 .name   = EFCT_DRIVER_NAME,
 .supported_mode  = MODE_TARGET,
};

/* globals */
static struct fc_function_template efct_xport_functions;
static struct fc_function_template efct_vport_functions;

static struct scsi_transport_template *efct_xport_fc_tt;
static struct scsi_transport_template *efct_vport_fc_tt;

struct efct_xport *
efct_xport_alloc(struct efct *efct)
{
 struct efct_xport *xport;

 xport = kzalloc(sizeof(*xport), GFP_KERNEL);
 if (!xport)
  return xport;

 xport->efct = efct;
 return xport;
}

static int
efct_xport_init_debugfs(struct efct *efct)
{
 /* Setup efct debugfs root directory */
 if (!efct_debugfs_root) {
  efct_debugfs_root = debugfs_create_dir("efct", NULL);
  atomic_set(&efct_debugfs_count, 0);
 }

 /* Create a directory for sessions in root */
 if (!efct->sess_debugfs_dir) {
  efct->sess_debugfs_dir = debugfs_create_dir("sessions",
       efct_debugfs_root);
  if (IS_ERR(efct->sess_debugfs_dir)) {
   efc_log_err(efct,
        "failed to create debugfs entry for sessions\n");
   goto debugfs_fail;
  }
  atomic_inc(&efct_debugfs_count);
 }

 return 0;

debugfs_fail:
 return -EIO;
}

static void efct_xport_delete_debugfs(struct efct *efct)
{
 /* Remove session debugfs directory */
 debugfs_remove(efct->sess_debugfs_dir);
 efct->sess_debugfs_dir = NULL;
 atomic_dec(&efct_debugfs_count);

 if (atomic_read(&efct_debugfs_count) == 0) {
  /* remove root debugfs directory */
  debugfs_remove(efct_debugfs_root);
  efct_debugfs_root = NULL;
 }
}

int
efct_xport_attach(struct efct_xport *xport)
{
 struct efct *efct = xport->efct;
 int rc;

 rc = efct_hw_setup(&efct->hw, efct, efct->pci);
 if (rc) {
  efc_log_err(efct, "%s: Can't setup hardware\n", efct->desc);
  return rc;
 }

 efct_hw_parse_filter(&efct->hw, (void *)efct->filter_def);

 xport->io_pool = efct_io_pool_create(efct, efct->hw.config.n_sgl);
 if (!xport->io_pool) {
  efc_log_err(efct, "Can't allocate IO pool\n");
  return -ENOMEM;
 }

 return 0;
}

static void
efct_xport_link_stats_cb(int status, u32 num_counters,
    struct efct_hw_link_stat_counts *counters, void *arg)
{
 union efct_xport_stats_u *result = arg;

 result->stats.link_stats.link_failure_error_count =
  counters[EFCT_HW_LINK_STAT_LINK_FAILURE_COUNT].counter;
 result->stats.link_stats.loss_of_sync_error_count =
  counters[EFCT_HW_LINK_STAT_LOSS_OF_SYNC_COUNT].counter;
 result->stats.link_stats.primitive_sequence_error_count =
  counters[EFCT_HW_LINK_STAT_PRIMITIVE_SEQ_COUNT].counter;
 result->stats.link_stats.invalid_transmission_word_error_count =
  counters[EFCT_HW_LINK_STAT_INVALID_XMIT_WORD_COUNT].counter;
 result->stats.link_stats.crc_error_count =
  counters[EFCT_HW_LINK_STAT_CRC_COUNT].counter;

 complete(&result->stats.done);
}

static void
efct_xport_host_stats_cb(int status, u32 num_counters,
    struct efct_hw_host_stat_counts *counters, void *arg)
{
 union efct_xport_stats_u *result = arg;

 result->stats.host_stats.transmit_kbyte_count =
  counters[EFCT_HW_HOST_STAT_TX_KBYTE_COUNT].counter;
 result->stats.host_stats.receive_kbyte_count =
  counters[EFCT_HW_HOST_STAT_RX_KBYTE_COUNT].counter;
 result->stats.host_stats.transmit_frame_count =
  counters[EFCT_HW_HOST_STAT_TX_FRAME_COUNT].counter;
 result->stats.host_stats.receive_frame_count =
  counters[EFCT_HW_HOST_STAT_RX_FRAME_COUNT].counter;

 complete(&result->stats.done);
}

static void
efct_xport_async_link_stats_cb(int status, u32 num_counters,
          struct efct_hw_link_stat_counts *counters,
          void *arg)
{
 union efct_xport_stats_u *result = arg;

 result->stats.link_stats.link_failure_error_count =
  counters[EFCT_HW_LINK_STAT_LINK_FAILURE_COUNT].counter;
 result->stats.link_stats.loss_of_sync_error_count =
  counters[EFCT_HW_LINK_STAT_LOSS_OF_SYNC_COUNT].counter;
 result->stats.link_stats.primitive_sequence_error_count =
  counters[EFCT_HW_LINK_STAT_PRIMITIVE_SEQ_COUNT].counter;
 result->stats.link_stats.invalid_transmission_word_error_count =
  counters[EFCT_HW_LINK_STAT_INVALID_XMIT_WORD_COUNT].counter;
 result->stats.link_stats.crc_error_count =
  counters[EFCT_HW_LINK_STAT_CRC_COUNT].counter;
}

static void
efct_xport_async_host_stats_cb(int status, u32 num_counters,
          struct efct_hw_host_stat_counts *counters,
          void *arg)
{
 union efct_xport_stats_u *result = arg;

 result->stats.host_stats.transmit_kbyte_count =
  counters[EFCT_HW_HOST_STAT_TX_KBYTE_COUNT].counter;
 result->stats.host_stats.receive_kbyte_count =
  counters[EFCT_HW_HOST_STAT_RX_KBYTE_COUNT].counter;
 result->stats.host_stats.transmit_frame_count =
  counters[EFCT_HW_HOST_STAT_TX_FRAME_COUNT].counter;
 result->stats.host_stats.receive_frame_count =
  counters[EFCT_HW_HOST_STAT_RX_FRAME_COUNT].counter;
}

static void
efct_xport_config_stats_timer(struct efct *efct);

static void
efct_xport_stats_timer_cb(struct timer_list *t)
{
 struct efct_xport *xport = timer_container_of(xport, t, stats_timer);
 struct efct *efct = xport->efct;

 efct_xport_config_stats_timer(efct);
}

static void
efct_xport_config_stats_timer(struct efct *efct)
{
 u32 timeout = 3 * 1000;
 struct efct_xport *xport = NULL;

 if (!efct) {
  pr_err("%s: failed to locate EFCT device\n", __func__);
  return;
 }

 xport = efct->xport;
 efct_hw_get_link_stats(&efct->hw, 0, 0, 0,
          efct_xport_async_link_stats_cb,
          &xport->fc_xport_stats);
 efct_hw_get_host_stats(&efct->hw, 0, efct_xport_async_host_stats_cb,
          &xport->fc_xport_stats);

 timer_setup(&xport->stats_timer,
      &efct_xport_stats_timer_cb, 0);
 mod_timer(&xport->stats_timer,
    jiffies + msecs_to_jiffies(timeout));
}

int
efct_xport_initialize(struct efct_xport *xport)
{
 struct efct *efct = xport->efct;
 int rc = 0;

 /* Initialize io lists */
 spin_lock_init(&xport->io_pending_lock);
 INIT_LIST_HEAD(&xport->io_pending_list);
 atomic_set(&xport->io_active_count, 0);
 atomic_set(&xport->io_pending_count, 0);
 atomic_set(&xport->io_total_free, 0);
 atomic_set(&xport->io_total_pending, 0);
 atomic_set(&xport->io_alloc_failed_count, 0);
 atomic_set(&xport->io_pending_recursing, 0);

 rc = efct_hw_init(&efct->hw);
 if (rc) {
  efc_log_err(efct, "efct_hw_init failure\n");
  goto out;
 }

 rc = efct_scsi_tgt_new_device(efct);
 if (rc) {
  efc_log_err(efct, "failed to initialize target\n");
  goto hw_init_out;
 }

 rc = efct_scsi_new_device(efct);
 if (rc) {
  efc_log_err(efct, "failed to initialize initiator\n");
  goto tgt_dev_out;
 }

 /* Get FC link and host statistics perodically*/
 efct_xport_config_stats_timer(efct);

 efct_xport_init_debugfs(efct);

 return rc;

tgt_dev_out:
 efct_scsi_tgt_del_device(efct);

hw_init_out:
 efct_hw_teardown(&efct->hw);
out:
 return rc;
}

int
efct_xport_status(struct efct_xport *xport, enum efct_xport_status cmd,
    union efct_xport_stats_u *result)
{
 int rc = 0;
 struct efct *efct = NULL;
 union efct_xport_stats_u value;

 efct = xport->efct;

 switch (cmd) {
 case EFCT_XPORT_CONFIG_PORT_STATUS:
  if (xport->configured_link_state == 0) {
   /*
    * Initial state is offline. configured_link_state is
    * set to online explicitly when port is brought online
 */
   xport->configured_link_state = EFCT_XPORT_PORT_OFFLINE;
  }
  result->value = xport->configured_link_state;
  break;

 case EFCT_XPORT_PORT_STATUS:
  /* Determine port status based on link speed. */
  value.value = efct_hw_get_link_speed(&efct->hw);
  if (value.value == 0)
   result->value = EFCT_XPORT_PORT_OFFLINE;
  else
   result->value = EFCT_XPORT_PORT_ONLINE;
  break;

 case EFCT_XPORT_LINK_SPEED:
  result->value = efct_hw_get_link_speed(&efct->hw);
  break;

 case EFCT_XPORT_LINK_STATISTICS:
  memcpy((void *)result, &efct->xport->fc_xport_stats,
         sizeof(union efct_xport_stats_u));
  break;
 case EFCT_XPORT_LINK_STAT_RESET: {
  /* Create a completion to synchronize the stat reset process */
  init_completion(&result->stats.done);

  /* First reset the link stats */
  rc = efct_hw_get_link_stats(&efct->hw, 0, 1, 1,
         efct_xport_link_stats_cb, result);
  if (rc)
   break;

  /* Wait for completion to be signaled when the cmd completes */
  if (wait_for_completion_interruptible(&result->stats.done)) {
   /* Undefined failure */
   efc_log_debug(efct, "sem wait failed\n");
   rc = -EIO;
   break;
  }

  /* Next reset the host stats */
  rc = efct_hw_get_host_stats(&efct->hw, 1,
         efct_xport_host_stats_cb, result);

  if (rc)
   break;

  /* Wait for completion to be signaled when the cmd completes */
  if (wait_for_completion_interruptible(&result->stats.done)) {
   /* Undefined failure */
   efc_log_debug(efct, "sem wait failed\n");
   rc = -EIO;
   break;
  }
  break;
 }
 default:
  rc = -EIO;
  break;
 }

 return rc;
}

static int
efct_get_link_supported_speeds(struct efct *efct)
{
 u32 supported_speeds = 0;
 u32 link_module_type, i;
 struct {
  u32 lmt_speed;
  u32 speed;
 } supported_speed_list[] = {
  {SLI4_LINK_MODULE_TYPE_1GB, FC_PORTSPEED_1GBIT},
  {SLI4_LINK_MODULE_TYPE_2GB, FC_PORTSPEED_2GBIT},
  {SLI4_LINK_MODULE_TYPE_4GB, FC_PORTSPEED_4GBIT},
  {SLI4_LINK_MODULE_TYPE_8GB, FC_PORTSPEED_8GBIT},
  {SLI4_LINK_MODULE_TYPE_16GB, FC_PORTSPEED_16GBIT},
  {SLI4_LINK_MODULE_TYPE_32GB, FC_PORTSPEED_32GBIT},
  {SLI4_LINK_MODULE_TYPE_64GB, FC_PORTSPEED_64GBIT},
  {SLI4_LINK_MODULE_TYPE_128GB, FC_PORTSPEED_128GBIT},
 };

 link_module_type = sli_get_lmt(&efct->hw.sli);

 /* populate link supported speeds */
 for (i = 0; i < ARRAY_SIZE(supported_speed_list); i++) {
  if (link_module_type & supported_speed_list[i].lmt_speed)
   supported_speeds |= supported_speed_list[i].speed;
 }

 return supported_speeds;
}

int
efct_scsi_new_device(struct efct *efct)
{
 struct Scsi_Host *shost = NULL;
 int error = 0;
 struct efct_vport *vport = NULL;

 shost = scsi_host_alloc(&efct_template, sizeof(*vport));
 if (!shost) {
  efc_log_err(efct, "failed to allocate Scsi_Host struct\n");
  return -ENOMEM;
 }

 /* save shost to initiator-client context */
 efct->shost = shost;

 /* save efct information to shost LLD-specific space */
 vport = (struct efct_vport *)shost->hostdata;
 vport->efct = efct;

 /*
  * Set initial can_queue value to the max SCSI IOs. This is the maximum
  * global queue depth (as opposed to the per-LUN queue depth --
  * .cmd_per_lun This may need to be adjusted for I+T mode.
 */
 shost->can_queue = efct->hw.config.n_io;
 shost->max_cmd_len = 16; /* 16-byte CDBs */
 shost->max_id = 0xffff;
 shost->max_lun = 0xffffffff;

 /*
  * can only accept (from mid-layer) as many SGEs as we've
  * pre-registered
 */
 shost->sg_tablesize = sli_get_max_sgl(&efct->hw.sli);

 /* attach FC Transport template to shost */
 shost->transportt = efct_xport_fc_tt;
 efc_log_debug(efct, "transport template=%p\n", efct_xport_fc_tt);

 /* get pci_dev structure and add host to SCSI ML */
 error = scsi_add_host_with_dma(shost, &efct->pci->dev,
           &efct->pci->dev);
 if (error) {
  efc_log_debug(efct, "failed scsi_add_host_with_dma\n");
  return -EIO;
 }

 /* Set symbolic name for host port */
 snprintf(fc_host_symbolic_name(shost),
   sizeof(fc_host_symbolic_name(shost)),
       "Emulex %s FV%s DV%s", efct->model,
       efct->hw.sli.fw_name[0], EFCT_DRIVER_VERSION);

 /* Set host port supported classes */
 fc_host_supported_classes(shost) = FC_COS_CLASS3;

 fc_host_supported_speeds(shost) = efct_get_link_supported_speeds(efct);

 fc_host_node_name(shost) = efct_get_wwnn(&efct->hw);
 fc_host_port_name(shost) = efct_get_wwpn(&efct->hw);
 fc_host_max_npiv_vports(shost) = 128;

 return 0;
}

struct scsi_transport_template *
efct_attach_fc_transport(void)
{
 struct scsi_transport_template *efct_fc_template = NULL;

 efct_fc_template = fc_attach_transport(&efct_xport_functions);

 if (!efct_fc_template)
  pr_err("failed to attach EFCT with fc transport\n");

 return efct_fc_template;
}

struct scsi_transport_template *
efct_attach_vport_fc_transport(void)
{
 struct scsi_transport_template *efct_fc_template = NULL;

 efct_fc_template = fc_attach_transport(&efct_vport_functions);

 if (!efct_fc_template)
  pr_err("failed to attach EFCT with fc transport\n");

 return efct_fc_template;
}

int
efct_scsi_reg_fc_transport(void)
{
 /* attach to appropriate scsi_tranport_* module */
 efct_xport_fc_tt = efct_attach_fc_transport();
 if (!efct_xport_fc_tt) {
  pr_err("%s: failed to attach to scsi_transport_*", __func__);
  return -EIO;
 }

 efct_vport_fc_tt = efct_attach_vport_fc_transport();
 if (!efct_vport_fc_tt) {
  pr_err("%s: failed to attach to scsi_transport_*", __func__);
  efct_release_fc_transport(efct_xport_fc_tt);
  efct_xport_fc_tt = NULL;
  return -EIO;
 }

 return 0;
}

void
efct_scsi_release_fc_transport(void)
{
 /* detach from scsi_transport_* */
 efct_release_fc_transport(efct_xport_fc_tt);
 efct_xport_fc_tt = NULL;
 if (efct_vport_fc_tt)
  efct_release_fc_transport(efct_vport_fc_tt);

 efct_vport_fc_tt = NULL;
}

void
efct_xport_detach(struct efct_xport *xport)
{
 struct efct *efct = xport->efct;

 /* free resources associated with target-server and initiator-client */
 efct_scsi_tgt_del_device(efct);

 efct_scsi_del_device(efct);

 /*Shutdown FC Statistics timer*/
 if (timer_pending(&xport->stats_timer))
  timer_delete(&xport->stats_timer);

 efct_hw_teardown(&efct->hw);

 efct_xport_delete_debugfs(efct);
}

static void
efct_xport_domain_free_cb(struct efc *efc, void *arg)
{
 struct completion *done = arg;

 complete(done);
}

int
efct_xport_control(struct efct_xport *xport, enum efct_xport_ctrl cmd, ...)
{
 u32 rc = 0;
 struct efct *efct = NULL;
 va_list argp;

 efct = xport->efct;

 switch (cmd) {
 case EFCT_XPORT_PORT_ONLINE: {
  /* Bring the port on-line */
  rc = efct_hw_port_control(&efct->hw, EFCT_HW_PORT_INIT, 0,
       NULL, NULL);
  if (rc)
   efc_log_err(efct,
        "%s: Can't init port\n", efct->desc);
  else
   xport->configured_link_state = cmd;
  break;
 }
 case EFCT_XPORT_PORT_OFFLINE: {
  if (efct_hw_port_control(&efct->hw, EFCT_HW_PORT_SHUTDOWN, 0,
      NULL, NULL))
   efc_log_err(efct, "port shutdown failed\n");
  else
   xport->configured_link_state = cmd;
  break;
 }

 case EFCT_XPORT_SHUTDOWN: {
  struct completion done;
  unsigned long timeout;

  /* if a PHYSDEV reset was performed (e.g. hw dump), will affect
   * all PCI functions; orderly shutdown won't work,
   * just force free
 */
  if (sli_reset_required(&efct->hw.sli)) {
   struct efc_domain *domain = efct->efcport->domain;

   if (domain)
    efc_domain_cb(efct->efcport, EFC_HW_DOMAIN_LOST,
           domain);
  } else {
   efct_hw_port_control(&efct->hw, EFCT_HW_PORT_SHUTDOWN,
          0, NULL, NULL);
  }

  init_completion(&done);

  efc_register_domain_free_cb(efct->efcport,
         efct_xport_domain_free_cb, &done);

  efc_log_debug(efct, "Waiting %d seconds for domain shutdown\n",
         (EFC_SHUTDOWN_TIMEOUT_USEC / 1000000));

  timeout = usecs_to_jiffies(EFC_SHUTDOWN_TIMEOUT_USEC);
  if (!wait_for_completion_timeout(&done, timeout)) {
   efc_log_err(efct, "Domain shutdown timed out!!\n");
   WARN_ON(1);
  }

  efc_register_domain_free_cb(efct->efcport, NULL, NULL);

  /* Free up any saved virtual ports */
  efc_vport_del_all(efct->efcport);
  break;
 }

 /*
  * Set wwnn for the port. This will be used instead of the default
  * provided by FW.
 */
 case EFCT_XPORT_WWNN_SET: {
  u64 wwnn;

  /* Retrieve arguments */
  va_start(argp, cmd);
  wwnn = va_arg(argp, uint64_t);
  va_end(argp);

  efc_log_debug(efct, " WWNN %016llx\n", wwnn);
  xport->req_wwnn = wwnn;

  break;
 }
 /*
  * Set wwpn for the port. This will be used instead of the default
  * provided by FW.
 */
 case EFCT_XPORT_WWPN_SET: {
  u64 wwpn;

  /* Retrieve arguments */
  va_start(argp, cmd);
  wwpn = va_arg(argp, uint64_t);
  va_end(argp);

  efc_log_debug(efct, " WWPN %016llx\n", wwpn);
  xport->req_wwpn = wwpn;

  break;
 }

 default:
  break;
 }
 return rc;
}

void
efct_xport_free(struct efct_xport *xport)
{
 if (xport) {
  efct_io_pool_free(xport->io_pool);

  kfree(xport);
 }
}

void
efct_release_fc_transport(struct scsi_transport_template *transport_template)
{
 if (transport_template)
  pr_err("releasing transport layer\n");

 /* Releasing FC transport */
 fc_release_transport(transport_template);
}

static void
efct_xport_remove_host(struct Scsi_Host *shost)
{
 fc_remove_host(shost);
}

void
efct_scsi_del_device(struct efct *efct)
{
 if (!efct->shost)
  return;

 efc_log_debug(efct, "Unregistering with Transport Layer\n");
 efct_xport_remove_host(efct->shost);
 efc_log_debug(efct, "Unregistering with SCSI Midlayer\n");
 scsi_remove_host(efct->shost);
 scsi_host_put(efct->shost);
 efct->shost = NULL;
}

static void
efct_get_host_port_id(struct Scsi_Host *shost)
{
 struct efct_vport *vport = (struct efct_vport *)shost->hostdata;
 struct efct *efct = vport->efct;
 struct efc *efc = efct->efcport;
 struct efc_nport *nport;

 if (efc->domain && efc->domain->nport) {
  nport = efc->domain->nport;
  fc_host_port_id(shost) = nport->fc_id;
 }
}

static void
efct_get_host_port_type(struct Scsi_Host *shost)
{
 struct efct_vport *vport = (struct efct_vport *)shost->hostdata;
 struct efct *efct = vport->efct;
 struct efc *efc = efct->efcport;
 int type = FC_PORTTYPE_UNKNOWN;

 if (efc->domain && efc->domain->nport) {
  if (efc->domain->is_loop) {
   type = FC_PORTTYPE_LPORT;
  } else {
   struct efc_nport *nport = efc->domain->nport;

   if (nport->is_vport)
    type = FC_PORTTYPE_NPIV;
   else if (nport->topology == EFC_NPORT_TOPO_P2P)
    type = FC_PORTTYPE_PTP;
   else if (nport->topology == EFC_NPORT_TOPO_UNKNOWN)
    type = FC_PORTTYPE_UNKNOWN;
   else
    type = FC_PORTTYPE_NPORT;
  }
 }
 fc_host_port_type(shost) = type;
}

static void
efct_get_host_vport_type(struct Scsi_Host *shost)
{
 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
}

static void
efct_get_host_port_state(struct Scsi_Host *shost)
{
 struct efct_vport *vport = (struct efct_vport *)shost->hostdata;
 struct efct *efct = vport->efct;
 union efct_xport_stats_u status;
 int rc;

 rc = efct_xport_status(efct->xport, EFCT_XPORT_PORT_STATUS, &status);
 if ((!rc) && (status.value == EFCT_XPORT_PORT_ONLINE))
  fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
 else
  fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
}

static void
efct_get_host_speed(struct Scsi_Host *shost)
{
 struct efct_vport *vport = (struct efct_vport *)shost->hostdata;
 struct efct *efct = vport->efct;
 struct efc *efc = efct->efcport;
 union efct_xport_stats_u speed;
 u32 fc_speed = FC_PORTSPEED_UNKNOWN;
 int rc;

 if (!efc->domain || !efc->domain->nport) {
  fc_host_speed(shost) = fc_speed;
  return;
 }

 rc = efct_xport_status(efct->xport, EFCT_XPORT_LINK_SPEED, &speed);
 if (!rc) {
  switch (speed.value) {
  case 1000:
   fc_speed = FC_PORTSPEED_1GBIT;
   break;
  case 2000:
   fc_speed = FC_PORTSPEED_2GBIT;
   break;
  case 4000:
   fc_speed = FC_PORTSPEED_4GBIT;
   break;
  case 8000:
   fc_speed = FC_PORTSPEED_8GBIT;
   break;
  case 10000:
   fc_speed = FC_PORTSPEED_10GBIT;
   break;
  case 16000:
   fc_speed = FC_PORTSPEED_16GBIT;
   break;
  case 32000:
   fc_speed = FC_PORTSPEED_32GBIT;
   break;
  case 64000:
   fc_speed = FC_PORTSPEED_64GBIT;
   break;
  case 128000:
   fc_speed = FC_PORTSPEED_128GBIT;
   break;
  }
 }

 fc_host_speed(shost) = fc_speed;
}

static void
efct_get_host_fabric_name(struct Scsi_Host *shost)
{
 struct efct_vport *vport = (struct efct_vport *)shost->hostdata;
 struct efct *efct = vport->efct;
 struct efc *efc = efct->efcport;

 if (efc->domain) {
  struct fc_els_flogi  *sp =
   (struct fc_els_flogi  *)
    efc->domain->flogi_service_params;

  fc_host_fabric_name(shost) = be64_to_cpu(sp->fl_wwnn);
 }
}

static struct fc_host_statistics *
efct_get_stats(struct Scsi_Host *shost)
{
 struct efct_vport *vport = (struct efct_vport *)shost->hostdata;
 struct efct *efct = vport->efct;
 union efct_xport_stats_u stats;
 struct efct_xport *xport = efct->xport;
 int rc = 0;

 rc = efct_xport_status(xport, EFCT_XPORT_LINK_STATISTICS, &stats);
 if (rc) {
  pr_err("efct_xport_status returned non 0 - %d\n", rc);
  return NULL;
 }

 vport->fc_host_stats.loss_of_sync_count =
  stats.stats.link_stats.loss_of_sync_error_count;
 vport->fc_host_stats.link_failure_count =
  stats.stats.link_stats.link_failure_error_count;
 vport->fc_host_stats.prim_seq_protocol_err_count =
  stats.stats.link_stats.primitive_sequence_error_count;
 vport->fc_host_stats.invalid_tx_word_count =
  stats.stats.link_stats.invalid_transmission_word_error_count;
 vport->fc_host_stats.invalid_crc_count =
  stats.stats.link_stats.crc_error_count;
 /* mbox returns kbyte count so we need to convert to words */
 vport->fc_host_stats.tx_words =
  stats.stats.host_stats.transmit_kbyte_count * 256;
 /* mbox returns kbyte count so we need to convert to words */
 vport->fc_host_stats.rx_words =
  stats.stats.host_stats.receive_kbyte_count * 256;
 vport->fc_host_stats.tx_frames =
  stats.stats.host_stats.transmit_frame_count;
 vport->fc_host_stats.rx_frames =
  stats.stats.host_stats.receive_frame_count;

 vport->fc_host_stats.fcp_input_requests =
   xport->fcp_stats.input_requests;
 vport->fc_host_stats.fcp_output_requests =
   xport->fcp_stats.output_requests;
 vport->fc_host_stats.fcp_output_megabytes =
   xport->fcp_stats.output_bytes >> 20;
 vport->fc_host_stats.fcp_input_megabytes =
   xport->fcp_stats.input_bytes >> 20;
 vport->fc_host_stats.fcp_control_requests =
   xport->fcp_stats.control_requests;

 return &vport->fc_host_stats;
}

static void
efct_reset_stats(struct Scsi_Host *shost)
{
 struct efct_vport *vport = (struct efct_vport *)shost->hostdata;
 struct efct *efct = vport->efct;
 /* argument has no purpose for this action */
 union efct_xport_stats_u dummy;
 int rc;

 rc = efct_xport_status(efct->xport, EFCT_XPORT_LINK_STAT_RESET, &dummy);
 if (rc)
  pr_err("efct_xport_status returned non 0 - %d\n", rc);
}

static int
efct_issue_lip(struct Scsi_Host *shost)
{
 struct efct_vport *vport =
   shost ? (struct efct_vport *)shost->hostdata : NULL;
 struct efct *efct = vport ? vport->efct : NULL;

 if (!shost || !vport || !efct) {
  pr_err("%s: shost=%p vport=%p efct=%p\n", __func__,
         shost, vport, efct);
  return -EPERM;
 }

 /*
  * Bring the link down gracefully then re-init the link.
  * The firmware will re-initialize the Fibre Channel interface as
  * required. It does not issue a LIP.
 */

 if (efct_xport_control(efct->xport, EFCT_XPORT_PORT_OFFLINE))
  efc_log_debug(efct, "EFCT_XPORT_PORT_OFFLINE failed\n");

 if (efct_xport_control(efct->xport, EFCT_XPORT_PORT_ONLINE))
  efc_log_debug(efct, "EFCT_XPORT_PORT_ONLINE failed\n");

 return 0;
}

struct efct_vport *
efct_scsi_new_vport(struct efct *efct, struct device *dev)
{
 struct Scsi_Host *shost = NULL;
 int error = 0;
 struct efct_vport *vport = NULL;

 shost = scsi_host_alloc(&efct_template, sizeof(*vport));
 if (!shost) {
  efc_log_err(efct, "failed to allocate Scsi_Host struct\n");
  return NULL;
 }

 /* save efct information to shost LLD-specific space */
 vport = (struct efct_vport *)shost->hostdata;
 vport->efct = efct;
 vport->is_vport = true;

 shost->can_queue = efct->hw.config.n_io;
 shost->max_cmd_len = 16; /* 16-byte CDBs */
 shost->max_id = 0xffff;
 shost->max_lun = 0xffffffff;

 /* can only accept (from mid-layer) as many SGEs as we've pre-regited*/
 shost->sg_tablesize = sli_get_max_sgl(&efct->hw.sli);

 /* attach FC Transport template to shost */
 shost->transportt = efct_vport_fc_tt;
 efc_log_debug(efct, "vport transport template=%p\n",
        efct_vport_fc_tt);

 /* get pci_dev structure and add host to SCSI ML */
 error = scsi_add_host_with_dma(shost, dev, &efct->pci->dev);
 if (error) {
  efc_log_debug(efct, "failed scsi_add_host_with_dma\n");
  return NULL;
 }

 /* Set symbolic name for host port */
 snprintf(fc_host_symbolic_name(shost),
   sizeof(fc_host_symbolic_name(shost)),
   "Emulex %s FV%s DV%s", efct->model, efct->hw.sli.fw_name[0],
   EFCT_DRIVER_VERSION);

 /* Set host port supported classes */
 fc_host_supported_classes(shost) = FC_COS_CLASS3;

 fc_host_supported_speeds(shost) = efct_get_link_supported_speeds(efct);
 vport->shost = shost;

 return vport;
}

int efct_scsi_del_vport(struct efct *efct, struct Scsi_Host *shost)
{
 if (shost) {
  efc_log_debug(efct,
         "Unregistering vport with Transport Layer\n");
  efct_xport_remove_host(shost);
  efc_log_debug(efct, "Unregistering vport with SCSI Midlayer\n");
  scsi_remove_host(shost);
  scsi_host_put(shost);
  return 0;
 }
 return -EIO;
}

static int
efct_vport_create(struct fc_vport *fc_vport, bool disable)
{
 struct Scsi_Host *shost = fc_vport ? fc_vport->shost : NULL;
 struct efct_vport *pport = shost ?
     (struct efct_vport *)shost->hostdata :
     NULL;
 struct efct *efct = pport ? pport->efct : NULL;
 struct efct_vport *vport = NULL;

 if (!fc_vport || !shost || !efct)
  goto fail;

 vport = efct_scsi_new_vport(efct, &fc_vport->dev);
 if (!vport) {
  efc_log_err(efct, "failed to create vport\n");
  goto fail;
 }

 vport->fc_vport = fc_vport;
 vport->npiv_wwpn = fc_vport->port_name;
 vport->npiv_wwnn = fc_vport->node_name;
 fc_host_node_name(vport->shost) = vport->npiv_wwnn;
 fc_host_port_name(vport->shost) = vport->npiv_wwpn;
 *(struct efct_vport **)fc_vport->dd_data = vport;

 return 0;

fail:
 return -EIO;
}

static int
efct_vport_delete(struct fc_vport *fc_vport)
{
 struct efct_vport *vport = *(struct efct_vport **)fc_vport->dd_data;
 struct Scsi_Host *shost = vport ? vport->shost : NULL;
 struct efct *efct = vport ? vport->efct : NULL;
 int rc;

 rc = efct_scsi_del_vport(efct, shost);

 if (rc)
  pr_err("%s: vport delete failed\n", __func__);

 return rc;
}

static int
efct_vport_disable(struct fc_vport *fc_vport, bool disable)
{
 return 0;
}

static struct fc_function_template efct_xport_functions = {
 .get_host_port_id = efct_get_host_port_id,
 .get_host_port_type = efct_get_host_port_type,
 .get_host_port_state = efct_get_host_port_state,
 .get_host_speed = efct_get_host_speed,
 .get_host_fabric_name = efct_get_host_fabric_name,

 .get_fc_host_stats = efct_get_stats,
 .reset_fc_host_stats = efct_reset_stats,

 .issue_fc_host_lip = efct_issue_lip,

 .vport_disable = efct_vport_disable,

 /* allocation lengths for host-specific data */
 .dd_fcrport_size = sizeof(struct efct_rport_data),
 .dd_fcvport_size = 128, /* should be sizeof(...) */

 /* remote port fixed attributes */
 .show_rport_maxframe_size = 1,
 .show_rport_supported_classes = 1,
 .show_rport_dev_loss_tmo = 1,

 /* target dynamic attributes */
 .show_starget_node_name = 1,
 .show_starget_port_name = 1,
 .show_starget_port_id = 1,

 /* host fixed attributes */
 .show_host_node_name = 1,
 .show_host_port_name = 1,
 .show_host_supported_classes = 1,
 .show_host_supported_fc4s = 1,
 .show_host_supported_speeds = 1,
 .show_host_maxframe_size = 1,

 /* host dynamic attributes */
 .show_host_port_id = 1,
 .show_host_port_type = 1,
 .show_host_port_state = 1,
 /* active_fc4s is shown but doesn't change (thus no get function) */
 .show_host_active_fc4s = 1,
 .show_host_speed = 1,
 .show_host_fabric_name = 1,
 .show_host_symbolic_name = 1,
 .vport_create = efct_vport_create,
 .vport_delete = efct_vport_delete,
};

static struct fc_function_template efct_vport_functions = {
 .get_host_port_id = efct_get_host_port_id,
 .get_host_port_type = efct_get_host_vport_type,
 .get_host_port_state = efct_get_host_port_state,
 .get_host_speed = efct_get_host_speed,
 .get_host_fabric_name = efct_get_host_fabric_name,

 .get_fc_host_stats = efct_get_stats,
 .reset_fc_host_stats = efct_reset_stats,

 .issue_fc_host_lip = efct_issue_lip,

 /* allocation lengths for host-specific data */
 .dd_fcrport_size = sizeof(struct efct_rport_data),
 .dd_fcvport_size = 128, /* should be sizeof(...) */

 /* remote port fixed attributes */
 .show_rport_maxframe_size = 1,
 .show_rport_supported_classes = 1,
 .show_rport_dev_loss_tmo = 1,

 /* target dynamic attributes */
 .show_starget_node_name = 1,
 .show_starget_port_name = 1,
 .show_starget_port_id = 1,

 /* host fixed attributes */
 .show_host_node_name = 1,
 .show_host_port_name = 1,
 .show_host_supported_classes = 1,
 .show_host_supported_fc4s = 1,
 .show_host_supported_speeds = 1,
 .show_host_maxframe_size = 1,

 /* host dynamic attributes */
 .show_host_port_id = 1,
 .show_host_port_type = 1,
 .show_host_port_state = 1,
 /* active_fc4s is shown but doesn't change (thus no get function) */
 .show_host_active_fc4s = 1,
 .show_host_speed = 1,
 .show_host_fabric_name = 1,
 .show_host_symbolic_name = 1,
};