// 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 = from_timer(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))
del_timer(&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,
};
Codebase Browser
linux