mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1111 lines
28 KiB
1111 lines
28 KiB
// 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 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, |
|
};
|
|
|