almalinux/kernel
14
0
Fork 0
Code Issues Pull Requests Releases Activity
fdf04f711e
kernel/drivers/scsi/elx/libefc/efc_domain.c

1089 lines
26 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2021 Broadcom. All Rights Reserved. The term
* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
*/
/*
* domain_sm Domain State Machine: States
*/
#include "efc.h"
int
efc_domain_cb(void *arg, int event, void *data)
{
struct efc *efc = arg;
struct efc_domain *domain = NULL;
int rc = 0;
unsigned long flags = 0;
if (event != EFC_HW_DOMAIN_FOUND)
domain = data;
/* Accept domain callback events from the user driver */
spin_lock_irqsave(&efc->lock, flags);
switch (event) {
case EFC_HW_DOMAIN_FOUND: {
u64 fcf_wwn = 0;
struct efc_domain_record *drec = data;
/* extract the fcf_wwn */
fcf_wwn = be64_to_cpu(*((__be64 *)drec->wwn));
efc_log_debug(efc, "Domain found: wwn %016llX\n", fcf_wwn);
/* lookup domain, or allocate a new one */
domain = efc->domain;
if (!domain) {
domain = efc_domain_alloc(efc, fcf_wwn);
if (!domain) {
efc_log_err(efc, "efc_domain_alloc() failed\n");
rc = -1;
break;
}
efc_sm_transition(&domain->drvsm, __efc_domain_init,
NULL);
}
efc_domain_post_event(domain, EFC_EVT_DOMAIN_FOUND, drec);
break;
}
case EFC_HW_DOMAIN_LOST:
domain_trace(domain, "EFC_HW_DOMAIN_LOST:\n");
efc->hold_frames = true;
efc_domain_post_event(domain, EFC_EVT_DOMAIN_LOST, NULL);
break;
case EFC_HW_DOMAIN_ALLOC_OK:
domain_trace(domain, "EFC_HW_DOMAIN_ALLOC_OK:\n");
efc_domain_post_event(domain, EFC_EVT_DOMAIN_ALLOC_OK, NULL);
break;
case EFC_HW_DOMAIN_ALLOC_FAIL:
domain_trace(domain, "EFC_HW_DOMAIN_ALLOC_FAIL:\n");
efc_domain_post_event(domain, EFC_EVT_DOMAIN_ALLOC_FAIL,
NULL);
break;
case EFC_HW_DOMAIN_ATTACH_OK:
domain_trace(domain, "EFC_HW_DOMAIN_ATTACH_OK:\n");
efc_domain_post_event(domain, EFC_EVT_DOMAIN_ATTACH_OK, NULL);
break;
case EFC_HW_DOMAIN_ATTACH_FAIL:
domain_trace(domain, "EFC_HW_DOMAIN_ATTACH_FAIL:\n");
efc_domain_post_event(domain,
EFC_EVT_DOMAIN_ATTACH_FAIL, NULL);
break;
case EFC_HW_DOMAIN_FREE_OK:
domain_trace(domain, "EFC_HW_DOMAIN_FREE_OK:\n");
efc_domain_post_event(domain, EFC_EVT_DOMAIN_FREE_OK, NULL);
break;
case EFC_HW_DOMAIN_FREE_FAIL:
domain_trace(domain, "EFC_HW_DOMAIN_FREE_FAIL:\n");
efc_domain_post_event(domain, EFC_EVT_DOMAIN_FREE_FAIL, NULL);
break;
default:
efc_log_warn(efc, "unsupported event %#x\n", event);
}
spin_unlock_irqrestore(&efc->lock, flags);
if (efc->domain && domain->req_accept_frames) {
domain->req_accept_frames = false;
efc->hold_frames = false;
}
return rc;
}
static void
_efc_domain_free(struct kref *arg)
{
struct efc_domain *domain = container_of(arg, struct efc_domain, ref);
struct efc *efc = domain->efc;
if (efc->domain_free_cb)
(*efc->domain_free_cb)(efc, efc->domain_free_cb_arg);
kfree(domain);
}
void
efc_domain_free(struct efc_domain *domain)
{
struct efc *efc;
efc = domain->efc;
/* Hold frames to clear the domain pointer from the xport lookup */
efc->hold_frames = false;
efc_log_debug(efc, "Domain free: wwn %016llX\n", domain->fcf_wwn);
xa_destroy(&domain->lookup);
efc->domain = NULL;
kref_put(&domain->ref, domain->release);
}
struct efc_domain *
efc_domain_alloc(struct efc *efc, uint64_t fcf_wwn)
{
struct efc_domain *domain;
domain = kzalloc(sizeof(*domain), GFP_ATOMIC);
if (!domain)
return NULL;
domain->efc = efc;
domain->drvsm.app = domain;
/* initialize refcount */
kref_init(&domain->ref);
domain->release = _efc_domain_free;
xa_init(&domain->lookup);
INIT_LIST_HEAD(&domain->nport_list);
efc->domain = domain;
domain->fcf_wwn = fcf_wwn;
efc_log_debug(efc, "Domain allocated: wwn %016llX\n", domain->fcf_wwn);
return domain;
}
void
efc_register_domain_free_cb(struct efc *efc,
void (*callback)(struct efc *efc, void *arg),
void *arg)
{
/* Register a callback to be called when the domain is freed */
efc->domain_free_cb = callback;
efc->domain_free_cb_arg = arg;
if (!efc->domain && callback)
(*callback)(efc, arg);
}
static void
__efc_domain_common(const char *funcname, struct efc_sm_ctx *ctx,
enum efc_sm_event evt, void *arg)
{
struct efc_domain *domain = ctx->app;
switch (evt) {
case EFC_EVT_ENTER:
case EFC_EVT_REENTER:
case EFC_EVT_EXIT:
case EFC_EVT_ALL_CHILD_NODES_FREE:
/*
* this can arise if an FLOGI fails on the NPORT,
* and the NPORT is shutdown
*/
break;
default:
efc_log_warn(domain->efc, "%-20s %-20s not handled\n",
funcname, efc_sm_event_name(evt));
}
}
static void
__efc_domain_common_shutdown(const char *funcname, struct efc_sm_ctx *ctx,
enum efc_sm_event evt, void *arg)
{
struct efc_domain *domain = ctx->app;
switch (evt) {
case EFC_EVT_ENTER:
case EFC_EVT_REENTER:
case EFC_EVT_EXIT:
break;
case EFC_EVT_DOMAIN_FOUND:
/* save drec, mark domain_found_pending */
memcpy(&domain->pending_drec, arg,
sizeof(domain->pending_drec));
domain->domain_found_pending = true;
break;
case EFC_EVT_DOMAIN_LOST:
/* unmark domain_found_pending */
domain->domain_found_pending = false;
break;
default:
efc_log_warn(domain->efc, "%-20s %-20s not handled\n",
funcname, efc_sm_event_name(evt));
}
}
#define std_domain_state_decl(...)\
struct efc_domain *domain = NULL;\
struct efc *efc = NULL;\
\
WARN_ON(!ctx || !ctx->app);\
domain = ctx->app;\
WARN_ON(!domain->efc);\
efc = domain->efc
void
__efc_domain_init(struct efc_sm_ctx *ctx, enum efc_sm_event evt,
void *arg)
{
std_domain_state_decl();
domain_sm_trace(domain);
switch (evt) {
case EFC_EVT_ENTER:
domain->attached = false;
break;
case EFC_EVT_DOMAIN_FOUND: {
u32 i;
struct efc_domain_record *drec = arg;
struct efc_nport *nport;
u64 my_wwnn = efc->req_wwnn;
u64 my_wwpn = efc->req_wwpn;
__be64 bewwpn;
if (my_wwpn == 0 || my_wwnn == 0) {
efc_log_debug(efc, "using default hardware WWN config\n");
my_wwpn = efc->def_wwpn;
my_wwnn = efc->def_wwnn;
}
efc_log_debug(efc, "Create nport WWPN %016llX WWNN %016llX\n",
my_wwpn, my_wwnn);
/* Allocate a nport and transition to __efc_nport_allocated */
nport = efc_nport_alloc(domain, my_wwpn, my_wwnn, U32_MAX,
efc->enable_ini, efc->enable_tgt);
if (!nport) {
efc_log_err(efc, "efc_nport_alloc() failed\n");
break;
}
efc_sm_transition(&nport->sm, __efc_nport_allocated, NULL);
bewwpn = cpu_to_be64(nport->wwpn);
/* allocate struct efc_nport object for local port
* Note: drec->fc_id is ALPA from read_topology only if loop
*/
if (efc_cmd_nport_alloc(efc, nport, NULL, (uint8_t *)&bewwpn)) {
efc_log_err(efc, "Can't allocate port\n");
efc_nport_free(nport);
break;
}
domain->is_loop = drec->is_loop;
/*
* If the loop position map includes ALPA == 0,
* then we are in a public loop (NL_PORT)
* Note that the first element of the loopmap[]
* contains the count of elements, and if
* ALPA == 0 is present, it will occupy the first
* location after the count.
*/
domain->is_nlport = drec->map.loop[1] == 0x00;
if (!domain->is_loop) {
/* Initiate HW domain alloc */
if (efc_cmd_domain_alloc(efc, domain, drec->index)) {
efc_log_err(efc,
"Failed to initiate HW domain allocation\n");
break;
}
efc_sm_transition(ctx, __efc_domain_wait_alloc, arg);
break;
}
efc_log_debug(efc, "%s fc_id=%#x speed=%d\n",
drec->is_loop ?
(domain->is_nlport ?
"public-loop" : "loop") : "other",
drec->fc_id, drec->speed);
nport->fc_id = drec->fc_id;
nport->topology = EFC_NPORT_TOPO_FC_AL;
snprintf(nport->display_name, sizeof(nport->display_name),
"s%06x", drec->fc_id);
if (efc->enable_ini) {
u32 count = drec->map.loop[0];
efc_log_debug(efc, "%d position map entries\n",
count);
for (i = 1; i <= count; i++) {
if (drec->map.loop[i] != drec->fc_id) {
struct efc_node *node;
efc_log_debug(efc, "%#x -> %#x\n",
drec->fc_id,
drec->map.loop[i]);
node = efc_node_alloc(nport,
drec->map.loop[i],
false, true);
if (!node) {
efc_log_err(efc,
"efc_node_alloc() failed\n");
break;
}
efc_node_transition(node,
__efc_d_wait_loop,
NULL);
}
}
}
/* Initiate HW domain alloc */
if (efc_cmd_domain_alloc(efc, domain, drec->index)) {
efc_log_err(efc,
"Failed to initiate HW domain allocation\n");
break;
}
efc_sm_transition(ctx, __efc_domain_wait_alloc, arg);
break;
}
default:
__efc_domain_common(__func__, ctx, evt, arg);
}
}
void
__efc_domain_wait_alloc(struct efc_sm_ctx *ctx,
enum efc_sm_event evt, void *arg)
{
std_domain_state_decl();
domain_sm_trace(domain);
switch (evt) {
case EFC_EVT_DOMAIN_ALLOC_OK: {
struct fc_els_flogi *sp;
struct efc_nport *nport;
nport = domain->nport;
if (WARN_ON(!nport))
return;
sp = (struct fc_els_flogi *)nport->service_params;
/* Save the domain service parameters */
memcpy(domain->service_params + 4, domain->dma.virt,
sizeof(struct fc_els_flogi) - 4);
memcpy(nport->service_params + 4, domain->dma.virt,
sizeof(struct fc_els_flogi) - 4);
/*
* Update the nport's service parameters,
* user might have specified non-default names
*/
sp->fl_wwpn = cpu_to_be64(nport->wwpn);
sp->fl_wwnn = cpu_to_be64(nport->wwnn);
/*
* Take the loop topology path,
* unless we are an NL_PORT (public loop)
*/
if (domain->is_loop && !domain->is_nlport) {
/*
* For loop, we already have our FC ID
* and don't need fabric login.
* Transition to the allocated state and
* post an event to attach to
* the domain. Note that this breaks the
* normal action/transition
* pattern here to avoid a race with the
* domain attach callback.
*/
/* sm: is_loop / domain_attach */
efc_sm_transition(ctx, __efc_domain_allocated, NULL);
__efc_domain_attach_internal(domain, nport->fc_id);
break;
}
{
struct efc_node *node;
/* alloc fabric node, send FLOGI */
node = efc_node_find(nport, FC_FID_FLOGI);
if (node) {
efc_log_err(efc,
"Fabric Controller node already exists\n");
break;
}
node = efc_node_alloc(nport, FC_FID_FLOGI,
false, false);
if (!node) {
efc_log_err(efc,
"Error: efc_node_alloc() failed\n");
} else {
efc_node_transition(node,
__efc_fabric_init, NULL);
}
/* Accept frames */
domain->req_accept_frames = true;
}
/* sm: / start fabric logins */
efc_sm_transition(ctx, __efc_domain_allocated, NULL);
break;
}
case EFC_EVT_DOMAIN_ALLOC_FAIL:
efc_log_err(efc, "%s recv'd waiting for DOMAIN_ALLOC_OK;",
efc_sm_event_name(evt));
efc_log_err(efc, "shutting down domain\n");
domain->req_domain_free = true;
break;
case EFC_EVT_DOMAIN_FOUND:
/* Should not happen */
break;
case EFC_EVT_DOMAIN_LOST:
efc_log_debug(efc,
"%s received while waiting for hw_domain_alloc()\n",
efc_sm_event_name(evt));
efc_sm_transition(ctx, __efc_domain_wait_domain_lost, NULL);
break;
default:
__efc_domain_common(__func__, ctx, evt, arg);
}
}
void
__efc_domain_allocated(struct efc_sm_ctx *ctx,
enum efc_sm_event evt, void *arg)
{
std_domain_state_decl();
domain_sm_trace(domain);
switch (evt) {
case EFC_EVT_DOMAIN_REQ_ATTACH: {
int rc = 0;
u32 fc_id;
if (WARN_ON(!arg))
return;
fc_id = *((u32 *)arg);
efc_log_debug(efc, "Requesting hw domain attach fc_id x%x\n",
fc_id);
/* Update nport lookup */
rc = xa_err(xa_store(&domain->lookup, fc_id, domain->nport,
GFP_ATOMIC));
if (rc) {
efc_log_err(efc, "Sport lookup store failed: %d\n", rc);
return;
}
/* Update display name for the nport */
efc_node_fcid_display(fc_id, domain->nport->display_name,
sizeof(domain->nport->display_name));
/* Issue domain attach call */
rc = efc_cmd_domain_attach(efc, domain, fc_id);
if (rc) {
efc_log_err(efc, "efc_hw_domain_attach failed: %d\n",
rc);
return;
}
/* sm: / domain_attach */
efc_sm_transition(ctx, __efc_domain_wait_attach, NULL);
break;
}
case EFC_EVT_DOMAIN_FOUND:
/* Should not happen */
efc_log_err(efc, "%s: evt: %d should not happen\n",
__func__, evt);
break;
case EFC_EVT_DOMAIN_LOST: {
efc_log_debug(efc,
"%s received while in EFC_EVT_DOMAIN_REQ_ATTACH\n",
efc_sm_event_name(evt));
if (!list_empty(&domain->nport_list)) {
/*
* if there are nports, transition to
* wait state and send shutdown to each
* nport
*/
struct efc_nport *nport = NULL, *nport_next = NULL;
efc_sm_transition(ctx, __efc_domain_wait_nports_free,
NULL);
list_for_each_entry_safe(nport, nport_next,
&domain->nport_list,
list_entry) {
efc_sm_post_event(&nport->sm,
EFC_EVT_SHUTDOWN, NULL);
}
} else {
/* no nports exist, free domain */
efc_sm_transition(ctx, __efc_domain_wait_shutdown,
NULL);
if (efc_cmd_domain_free(efc, domain))
efc_log_err(efc, "hw_domain_free failed\n");
}
break;
}
default:
__efc_domain_common(__func__, ctx, evt, arg);
}
}
void
__efc_domain_wait_attach(struct efc_sm_ctx *ctx,
enum efc_sm_event evt, void *arg)
{
std_domain_state_decl();
domain_sm_trace(domain);
switch (evt) {
case EFC_EVT_DOMAIN_ATTACH_OK: {
struct efc_node *node = NULL;
struct efc_nport *nport, *next_nport;
unsigned long index;
/*
* Set domain notify pending state to avoid
* duplicate domain event post
*/
domain->domain_notify_pend = true;
/* Mark as attached */
domain->attached = true;
/* Transition to ready */
/* sm: / forward event to all nports and nodes */
efc_sm_transition(ctx, __efc_domain_ready, NULL);
/* We have an FCFI, so we can accept frames */
domain->req_accept_frames = true;
/*
* Notify all nodes that the domain attach request
* has completed
* Note: nport will have already received notification
* of nport attached as a result of the HW's port attach.
*/
list_for_each_entry_safe(nport, next_nport,
&domain->nport_list, list_entry) {
xa_for_each(&nport->lookup, index, node) {
efc_node_post_event(node,
EFC_EVT_DOMAIN_ATTACH_OK,
NULL);
}
}
domain->domain_notify_pend = false;
break;
}
case EFC_EVT_DOMAIN_ATTACH_FAIL:
efc_log_debug(efc,
"%s received while waiting for hw attach\n",
efc_sm_event_name(evt));
break;
case EFC_EVT_DOMAIN_FOUND:
/* Should not happen */
efc_log_err(efc, "%s: evt: %d should not happen\n",
__func__, evt);
break;
case EFC_EVT_DOMAIN_LOST:
/*
* Domain lost while waiting for an attach to complete,
* go to a state that waits for the domain attach to
* complete, then handle domain lost
*/
efc_sm_transition(ctx, __efc_domain_wait_domain_lost, NULL);
break;
case EFC_EVT_DOMAIN_REQ_ATTACH:
/*
* In P2P we can get an attach request from
* the other FLOGI path, so drop this one
*/
break;
default:
__efc_domain_common(__func__, ctx, evt, arg);
}
}
void
__efc_domain_ready(struct efc_sm_ctx *ctx, enum efc_sm_event evt, void *arg)
{
std_domain_state_decl();
domain_sm_trace(domain);
switch (evt) {
case EFC_EVT_ENTER: {
/* start any pending vports */
if (efc_vport_start(domain)) {
efc_log_debug(domain->efc,
"efc_vport_start didn't start vports\n");
}
break;
}
case EFC_EVT_DOMAIN_LOST: {
if (!list_empty(&domain->nport_list)) {
/*
* if there are nports, transition to wait state
* and send shutdown to each nport
*/
struct efc_nport *nport = NULL, *nport_next = NULL;
efc_sm_transition(ctx, __efc_domain_wait_nports_free,
NULL);
list_for_each_entry_safe(nport, nport_next,
&domain->nport_list,
list_entry) {
efc_sm_post_event(&nport->sm,
EFC_EVT_SHUTDOWN, NULL);
}
} else {
/* no nports exist, free domain */
efc_sm_transition(ctx, __efc_domain_wait_shutdown,
NULL);
if (efc_cmd_domain_free(efc, domain))
efc_log_err(efc, "hw_domain_free failed\n");
}
break;
}
case EFC_EVT_DOMAIN_FOUND:
/* Should not happen */
efc_log_err(efc, "%s: evt: %d should not happen\n",
__func__, evt);
break;
case EFC_EVT_DOMAIN_REQ_ATTACH: {
/* can happen during p2p */
u32 fc_id;
fc_id = *((u32 *)arg);
/* Assume that the domain is attached */
WARN_ON(!domain->attached);
/*
* Verify that the requested FC_ID
* is the same as the one we're working with
*/
WARN_ON(domain->nport->fc_id != fc_id);
break;
}
default:
__efc_domain_common(__func__, ctx, evt, arg);
}
}
void
__efc_domain_wait_nports_free(struct efc_sm_ctx *ctx, enum efc_sm_event evt,
void *arg)
{
std_domain_state_decl();
domain_sm_trace(domain);
/* Wait for nodes to free prior to the domain shutdown */
switch (evt) {
case EFC_EVT_ALL_CHILD_NODES_FREE: {
int rc;
/* sm: / efc_hw_domain_free */
efc_sm_transition(ctx, __efc_domain_wait_shutdown, NULL);
/* Request efc_hw_domain_free and wait for completion */
rc = efc_cmd_domain_free(efc, domain);
if (rc) {
efc_log_err(efc, "efc_hw_domain_free() failed: %d\n",
rc);
}
break;
}
default:
__efc_domain_common_shutdown(__func__, ctx, evt, arg);
}
}
void
__efc_domain_wait_shutdown(struct efc_sm_ctx *ctx,
enum efc_sm_event evt, void *arg)
{
std_domain_state_decl();
domain_sm_trace(domain);
switch (evt) {
case EFC_EVT_DOMAIN_FREE_OK:
/* sm: / domain_free */
if (domain->domain_found_pending) {
/*
* save fcf_wwn and drec from this domain,
* free current domain and allocate
* a new one with the same fcf_wwn
* could use a SLI-4 "re-register VPI"
* operation here?
*/
u64 fcf_wwn = domain->fcf_wwn;
struct efc_domain_record drec = domain->pending_drec;
efc_log_debug(efc, "Reallocating domain\n");
domain->req_domain_free = true;
domain = efc_domain_alloc(efc, fcf_wwn);
if (!domain) {
efc_log_err(efc,
"efc_domain_alloc() failed\n");
return;
}
/*
* got a new domain; at this point,
* there are at least two domains
* once the req_domain_free flag is processed,
* the associated domain will be removed.
*/
efc_sm_transition(&domain->drvsm, __efc_domain_init,
NULL);
efc_sm_post_event(&domain->drvsm,
EFC_EVT_DOMAIN_FOUND, &drec);
} else {
domain->req_domain_free = true;
}
break;
default:
__efc_domain_common_shutdown(__func__, ctx, evt, arg);
}
}
void
__efc_domain_wait_domain_lost(struct efc_sm_ctx *ctx,
enum efc_sm_event evt, void *arg)
{
std_domain_state_decl();
domain_sm_trace(domain);
/*
* Wait for the domain alloc/attach completion
* after receiving a domain lost.
*/
switch (evt) {
case EFC_EVT_DOMAIN_ALLOC_OK:
case EFC_EVT_DOMAIN_ATTACH_OK: {
if (!list_empty(&domain->nport_list)) {
/*
* if there are nports, transition to
* wait state and send shutdown to each nport
*/
struct efc_nport *nport = NULL, *nport_next = NULL;
efc_sm_transition(ctx, __efc_domain_wait_nports_free,
NULL);
list_for_each_entry_safe(nport, nport_next,
&domain->nport_list,
list_entry) {
efc_sm_post_event(&nport->sm,
EFC_EVT_SHUTDOWN, NULL);
}
} else {
/* no nports exist, free domain */
efc_sm_transition(ctx, __efc_domain_wait_shutdown,
NULL);
if (efc_cmd_domain_free(efc, domain))
efc_log_err(efc, "hw_domain_free() failed\n");
}
break;
}
case EFC_EVT_DOMAIN_ALLOC_FAIL:
case EFC_EVT_DOMAIN_ATTACH_FAIL:
efc_log_err(efc, "[domain] %-20s: failed\n",
efc_sm_event_name(evt));
break;
default:
__efc_domain_common_shutdown(__func__, ctx, evt, arg);
}
}
void
__efc_domain_attach_internal(struct efc_domain *domain, u32 s_id)
{
memcpy(domain->dma.virt,
((uint8_t *)domain->flogi_service_params) + 4,
sizeof(struct fc_els_flogi) - 4);
(void)efc_sm_post_event(&domain->drvsm, EFC_EVT_DOMAIN_REQ_ATTACH,
&s_id);
}
void
efc_domain_attach(struct efc_domain *domain, u32 s_id)
{
__efc_domain_attach_internal(domain, s_id);
}
int
efc_domain_post_event(struct efc_domain *domain,
enum efc_sm_event event, void *arg)
{
int rc;
bool req_domain_free;
rc = efc_sm_post_event(&domain->drvsm, event, arg);
req_domain_free = domain->req_domain_free;
domain->req_domain_free = false;
if (req_domain_free)
efc_domain_free(domain);
return rc;
}
static void
efct_domain_process_pending(struct efc_domain *domain)
{
struct efc *efc = domain->efc;
struct efc_hw_sequence *seq = NULL;
u32 processed = 0;
unsigned long flags = 0;
for (;;) {
/* need to check for hold frames condition after each frame
* processed because any given frame could cause a transition
* to a state that holds frames
*/
if (efc->hold_frames)
break;
/* Get next frame/sequence */
spin_lock_irqsave(&efc->pend_frames_lock, flags);
if (!list_empty(&efc->pend_frames)) {
seq = list_first_entry(&efc->pend_frames,
struct efc_hw_sequence, list_entry);
list_del(&seq->list_entry);
}
if (!seq) {
processed = efc->pend_frames_processed;
efc->pend_frames_processed = 0;
spin_unlock_irqrestore(&efc->pend_frames_lock, flags);
break;
}
efc->pend_frames_processed++;
spin_unlock_irqrestore(&efc->pend_frames_lock, flags);
/* now dispatch frame(s) to dispatch function */
if (efc_domain_dispatch_frame(domain, seq))
efc->tt.hw_seq_free(efc, seq);
seq = NULL;
}
if (processed != 0)
efc_log_debug(efc, "%u domain frames held and processed\n",
processed);
}
void
efc_dispatch_frame(struct efc *efc, struct efc_hw_sequence *seq)
{
struct efc_domain *domain = efc->domain;
/*
* If we are holding frames or the domain is not yet registered or
* there's already frames on the pending list,
* then add the new frame to pending list
*/
if (!domain || efc->hold_frames || !list_empty(&efc->pend_frames)) {
unsigned long flags = 0;
spin_lock_irqsave(&efc->pend_frames_lock, flags);
INIT_LIST_HEAD(&seq->list_entry);
list_add_tail(&seq->list_entry, &efc->pend_frames);
spin_unlock_irqrestore(&efc->pend_frames_lock, flags);
if (domain) {
/* immediately process pending frames */
efct_domain_process_pending(domain);
}
} else {
/*
* We are not holding frames and pending list is empty,
* just process frame. A non-zero return means the frame
* was not handled - so cleanup
*/
if (efc_domain_dispatch_frame(domain, seq))
efc->tt.hw_seq_free(efc, seq);
}
}
int
efc_domain_dispatch_frame(void *arg, struct efc_hw_sequence *seq)
{
struct efc_domain *domain = (struct efc_domain *)arg;
struct efc *efc = domain->efc;
struct fc_frame_header *hdr;
struct efc_node *node = NULL;
struct efc_nport *nport = NULL;
unsigned long flags = 0;
u32 s_id, d_id, rc = EFC_HW_SEQ_FREE;
if (!seq->header || !seq->header->dma.virt || !seq->payload->dma.virt) {
efc_log_err(efc, "Sequence header or payload is null\n");
return rc;
}
hdr = seq->header->dma.virt;
/* extract the s_id and d_id */
s_id = ntoh24(hdr->fh_s_id);
d_id = ntoh24(hdr->fh_d_id);
spin_lock_irqsave(&efc->lock, flags);
nport = efc_nport_find(domain, d_id);
if (!nport) {
if (hdr->fh_type == FC_TYPE_FCP) {
/* Drop frame */
efc_log_warn(efc, "FCP frame with invalid d_id x%x\n",
d_id);
goto out;
}
/* p2p will use this case */
nport = domain->nport;
if (!nport || !kref_get_unless_zero(&nport->ref)) {
efc_log_err(efc, "Physical nport is NULL\n");
goto out;
}
}
/* Lookup the node given the remote s_id */
node = efc_node_find(nport, s_id);
/* If not found, then create a new node */
if (!node) {
/*
* If this is solicited data or control based on R_CTL and
* there is no node context, then we can drop the frame
*/
if ((hdr->fh_r_ctl == FC_RCTL_DD_SOL_DATA) ||
(hdr->fh_r_ctl == FC_RCTL_DD_SOL_CTL)) {
efc_log_debug(efc, "sol data/ctrl frame without node\n");
goto out_release;
}
node = efc_node_alloc(nport, s_id, false, false);
if (!node) {
efc_log_err(efc, "efc_node_alloc() failed\n");
goto out_release;
}
/* don't send PLOGI on efc_d_init entry */
efc_node_init_device(node, false);
}
if (node->hold_frames || !list_empty(&node->pend_frames)) {
/* add frame to node's pending list */
spin_lock(&node->pend_frames_lock);
INIT_LIST_HEAD(&seq->list_entry);
list_add_tail(&seq->list_entry, &node->pend_frames);
spin_unlock(&node->pend_frames_lock);
rc = EFC_HW_SEQ_HOLD;
goto out_release;
}
/* now dispatch frame to the node frame handler */
efc_node_dispatch_frame(node, seq);
out_release:
kref_put(&nport->ref, nport->release);
out:
spin_unlock_irqrestore(&efc->lock, flags);
return rc;
}
void
efc_node_dispatch_frame(void *arg, struct efc_hw_sequence *seq)
{
struct fc_frame_header *hdr = seq->header->dma.virt;
u32 port_id;
struct efc_node *node = (struct efc_node *)arg;
struct efc *efc = node->efc;
port_id = ntoh24(hdr->fh_s_id);
if (WARN_ON(port_id != node->rnode.fc_id))
return;
if ((!(ntoh24(hdr->fh_f_ctl) & FC_FC_END_SEQ)) ||
!(ntoh24(hdr->fh_f_ctl) & FC_FC_SEQ_INIT)) {
node_printf(node,
"Drop frame hdr = %08x %08x %08x %08x %08x %08x\n",
cpu_to_be32(((u32 *)hdr)[0]),
cpu_to_be32(((u32 *)hdr)[1]),
cpu_to_be32(((u32 *)hdr)[2]),
cpu_to_be32(((u32 *)hdr)[3]),
cpu_to_be32(((u32 *)hdr)[4]),
cpu_to_be32(((u32 *)hdr)[5]));
return;
}
switch (hdr->fh_r_ctl) {
case FC_RCTL_ELS_REQ:
case FC_RCTL_ELS_REP:
efc_node_recv_els_frame(node, seq);
break;
case FC_RCTL_BA_ABTS:
case FC_RCTL_BA_ACC:
case FC_RCTL_BA_RJT:
case FC_RCTL_BA_NOP:
efc_log_err(efc, "Received ABTS:\n");
break;
case FC_RCTL_DD_UNSOL_CMD:
case FC_RCTL_DD_UNSOL_CTL:
switch (hdr->fh_type) {
case FC_TYPE_FCP:
if ((hdr->fh_r_ctl & 0xf) == FC_RCTL_DD_UNSOL_CMD) {
if (!node->fcp_enabled) {
efc_node_recv_fcp_cmd(node, seq);
break;
}
efc_log_err(efc, "Recvd FCP CMD. Drop IO\n");
} else if ((hdr->fh_r_ctl & 0xf) ==
FC_RCTL_DD_SOL_DATA) {
node_printf(node,
"solicited data recvd. Drop IO\n");
}
break;
case FC_TYPE_CT:
efc_node_recv_ct_frame(node, seq);
break;
default:
break;
}
break;
default:
efc_log_err(efc, "Unhandled frame rctl: %02x\n", hdr->fh_r_ctl);
}
}
Reference in New Issue View Git Blame Copy Permalink