efct: Broadcom (Emulex) FC Target driver
Subsystems (2)
PATCH v4 13/31 elx: libefc: Fabric node state machine interfaces
In reply to James SmartThis patch continues the libefc library population.
This patch adds library interface definitions for:
- Fabric node initialization and logins.
- Name/Directory Services node.
- Fabric Controller node to process rscn events.
These are all interactions with remote ports that correspond to well-known fabric entities
---
v4:
Move all SM functions return value from void * to void.
--- drivers/scsi/elx/libefc/efc_fabric.c | 1565 ++++++++++++++++++++++++++ drivers/scsi/elx/libefc/efc_fabric.h | 116 ++ 2 files changed, 1681 insertions(+) create mode 100644 drivers/scsi/elx/libefc/efc_fabric.c create mode 100644 drivers/scsi/elx/libefc/efc_fabric.h
drivers/scsi/elx/libefc/efc_fabric.c new file +1565 -0
@@ -0,0 +1,1565 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +/* +* This file implements remote node state machines for: +* - Fabric logins. +* - Fabric controller events. +* - Name/directory services interaction. +* - Point-to-point logins. +*/ + +/* +* fabric_sm Node State Machine: Fabric States +* ns_sm Node State Machine: Name/Directory Services States +* p2p_sm Node State Machine: Point-to-Point Node States +*/ + +#include "efc.h" + +static void +efc_fabric_initiate_shutdown (struct efc_node *node) +{ +struct efc *efc = node->efc; + +efc_io_alloc_disable (node); +if (node->attached) { +int rc; + +/* issue hw node free; don't care if succeeds right away +* or sometime later, will check node->attached later in +* shutdown process +*/ + rc =efc_cmd_node_detach (efc, &node->rnode); +if (rc !=EFC_HW_RTN_SUCCESS && + rc !=EFC_HW_RTN_SUCCESS_SYNC ) { +node_printf (node,"Failed freeing HW node, rc=%d\n" , + rc); + } + } +/* +* node has either been detached or is in the process of being detached, +* call common node's initiate cleanup function +*/ +efc_node_initiate_cleanup (node); +} + +static void +__efc_fabric_common (const char *funcname,struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node =NULL ; + + node = ctx->app; + +switch (evt) { +case EFC_EVT_DOMAIN_ATTACH_OK : +break ; +case EFC_EVT_SHUTDOWN : + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); +break ; + +default : +/* call default event handler common to all nodes */ +__efc_node_common (funcname, ctx, evt, arg); + } +} + +void +__efc_fabric_init (struct efc_sm_ctx *ctx,enum efc_sm_event evt, +void *arg) +{ +struct efc_node *node = ctx->app; +struct efc *efc = node->efc; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_REENTER :/* not sure why we're getting these ... */ +efc_log_debug (efc,">>> reenter !!\n" ); + fallthrough; + +case EFC_EVT_ENTER : +/* sm: / send FLOGI */ +efc_send_flogi (node); +efc_node_transition (node, __efc_fabric_flogi_wait_rsp,NULL ); +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +efc_fabric_set_topology (struct efc_node *node, +enum efc_nport_topology topology) +{ + node->nport->topology = topology; +} + +void +efc_fabric_notify_topology (struct efc_node *node) +{ +struct efc_node *tmp_node; +struct efc_node *next; +enum efc_nport_topology topology = node->nport->topology; + +/* +* now loop through the nodes in the nport +* and send topology notification +*/ +list_for_each_entry_safe (tmp_node, next, &node->nport->node_list, + list_entry) { +if (tmp_node != node) { +efc_node_post_event (tmp_node, +EFC_EVT_SPORT_TOPOLOGY_NOTIFY , + (void *)topology); + } + } +} + +static bool efc_rnode_is_nport (struct fc_els_flogi *rsp) +{ +return !(ntohs (rsp->fl_csp.sp_features) &FC_SP_FT_FPORT ); +} + +void +__efc_fabric_flogi_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : { +if (efc_node_check_els_req (ctx, evt, arg,ELS_FLOGI , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; + +memcpy (node->nport->domain->flogi_service_params, + cbdata->els_rsp.virt, +sizeof (struct fc_els_flogi )); + +/* Check to see if the fabric is an F_PORT or and N_PORT */ +if (!efc_rnode_is_nport (cbdata->els_rsp.virt)) { +/* sm: if not nport / efc_domain_attach */ +/* ext_status has the fc_id, attach domain */ +efc_fabric_set_topology (node, +EFC_SPORT_TOPOLOGY_FABRIC ); +efc_fabric_notify_topology (node); +WARN_ON (node->nport->domain->attached); +efc_domain_attach (node->nport->domain, + cbdata->ext_status); +efc_node_transition (node, + __efc_fabric_wait_domain_attach, +NULL ); +break ; + } + +/* sm: if nport and p2p_winner / efc_domain_attach */ +efc_fabric_set_topology (node,EFC_SPORT_TOPOLOGY_P2P ); +if (efc_p2p_setup (node->nport)) { +node_printf (node, +"p2p setup failed, shutting down node\n" ); + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); +break ; + } + +if (node->nport->p2p_winner) { +efc_node_transition (node, + __efc_p2p_wait_domain_attach, +NULL ); +if (node->nport->domain->attached && + !node->nport->domain->domain_notify_pend) { +/* +* already attached, +* just send ATTACH_OK +*/ +node_printf (node, +"p2p winner, domain already attached\n" ); +efc_node_post_event (node, +EFC_EVT_DOMAIN_ATTACH_OK , +NULL ); + } + }else { +/* +* peer is p2p winner; +* PLOGI will be received on the +* remote SID=1 node; +* this node has served its purpose +*/ + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); + } + +break ; + } + +case EFC_EVT_ELS_REQ_ABORTED : +case EFC_EVT_SRRS_ELS_REQ_RJT : +case EFC_EVT_SRRS_ELS_REQ_FAIL : { +struct efc_nport *nport = node->nport; +/* +* with these errors, we have no recovery, +* so shutdown the nport, leave the link +* up and the domain ready +*/ +if (efc_node_check_els_req (ctx, evt, arg,ELS_FLOGI , + __efc_fabric_common, __func__)) { +return ; + } +node_printf (node, +"FLOGI failed evt=%s, shutting down nport [%s]\n" , +efc_sm_event_name (evt), nport->display_name); +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +efc_sm_post_event (&nport->sm,EFC_EVT_SHUTDOWN ,NULL ); +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_vport_fabric_init (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +/* sm: / send FDISC */ +efc_send_fdisc (node); +efc_node_transition (node, __efc_fabric_fdisc_wait_rsp,NULL ); +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_fabric_fdisc_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : { +/* fc_id is in ext_status */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_FDISC , + __efc_fabric_common, __func__)) { +return ; + } + +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / efc_nport_attach */ +efc_nport_attach (node->nport, cbdata->ext_status); +efc_node_transition (node, __efc_fabric_wait_domain_attach, +NULL ); +break ; + } + +case EFC_EVT_SRRS_ELS_REQ_RJT : +case EFC_EVT_SRRS_ELS_REQ_FAIL : { +if (efc_node_check_els_req (ctx, evt, arg,ELS_FDISC , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +efc_log_err (node->efc,"FDISC failed, shutting down nport\n" ); +/* sm: / shutdown nport */ +efc_sm_post_event (&node->nport->sm,EFC_EVT_SHUTDOWN ,NULL ); +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +static int +efc_start_ns_node (struct efc_nport *nport) +{ +struct efc_node *ns; + +/* Instantiate a name services node */ + ns =efc_node_find (nport,FC_FID_DIR_SERV ); +if (!ns) { + ns =efc_node_alloc (nport,FC_FID_DIR_SERV , false, false); +if (!ns) +return EFC_FAIL ; + } +/* +* for found ns, should we be transitioning from here? +* breaks transition only +* 1. from within state machine or +* 2. if after alloc +*/ +if (ns->efc->nodedb_mask &EFC_NODEDB_PAUSE_NAMESERVER ) +efc_node_pause (ns, __efc_ns_init); +else +efc_node_transition (ns, __efc_ns_init,NULL ); +return EFC_SUCCESS ; +} + +static int +efc_start_fabctl_node (struct efc_nport *nport) +{ +struct efc_node *fabctl; + + fabctl =efc_node_find (nport,FC_FID_FCTRL ); +if (!fabctl) { + fabctl =efc_node_alloc (nport,FC_FID_FCTRL , + false, false); +if (!fabctl) +return EFC_FAIL ; + } +/* +* for found ns, should we be transitioning from here? +* breaks transition only +* 1. from within state machine or +* 2. if after alloc +*/ +efc_node_transition (fabctl, __efc_fabctl_init,NULL ); +return EFC_SUCCESS ; +} + +void +__efc_fabric_wait_domain_attach (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; +case EFC_EVT_DOMAIN_ATTACH_OK : +case EFC_EVT_SPORT_ATTACH_OK : { +int rc; + + rc =efc_start_ns_node (node->nport); +if (rc) +return ; + +/* sm: if enable_ini / start fabctl node */ +/* Instantiate the fabric controller (sends SCR) */ +if (node->nport->enable_rscn) { + rc =efc_start_fabctl_node (node->nport); +if (rc) +return ; + } +efc_node_transition (node, __efc_fabric_idle,NULL ); +break ; + } +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_fabric_idle (struct efc_sm_ctx *ctx,enum efc_sm_event evt, +void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_DOMAIN_ATTACH_OK : +break ; +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_ns_init (struct efc_sm_ctx *ctx,enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +/* sm: / send PLOGI */ +efc_send_plogi (node); +efc_node_transition (node, __efc_ns_plogi_wait_rsp,NULL ); +break ; +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_ns_plogi_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : { +int rc; + +/* Save service parameters */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_PLOGI , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / save sparams, efc_node_attach */ +efc_node_save_sparms (node, cbdata->els_rsp.virt); + rc =efc_node_attach (node); +efc_node_transition (node, __efc_ns_wait_node_attach,NULL ); +if (rc ==EFC_HW_RTN_SUCCESS_SYNC ) +efc_node_post_event (node,EFC_EVT_NODE_ATTACH_OK , +NULL ); +break ; + } +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_ns_wait_node_attach (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_NODE_ATTACH_OK : + node->attached = true; +/* sm: / send RFTID */ +efc_ns_send_rftid (node); +efc_node_transition (node, __efc_ns_rftid_wait_rsp,NULL ); +break ; + +case EFC_EVT_NODE_ATTACH_FAIL : +/* node attach failed, shutdown the node */ + node->attached = false; +node_printf (node,"Node attach failed\n" ); + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); +break ; + +case EFC_EVT_SHUTDOWN : +node_printf (node,"Shutdown event received\n" ); + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_node_transition (node, + __efc_fabric_wait_attach_evt_shutdown, +NULL ); +break ; + +/* +* if receive RSCN just ignore, +* we haven't sent GID_PT yet (ACC sent by fabctl node) +*/ +case EFC_EVT_RSCN_RCVD : +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_fabric_wait_attach_evt_shutdown (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +/* wait for any of these attach events and then shutdown */ +case EFC_EVT_NODE_ATTACH_OK : + node->attached = true; +node_printf (node,"Attach evt=%s, proceed to shutdown\n" , +efc_sm_event_name (evt)); +efc_fabric_initiate_shutdown (node); +break ; + +case EFC_EVT_NODE_ATTACH_FAIL : + node->attached = false; +node_printf (node,"Attach evt=%s, proceed to shutdown\n" , +efc_sm_event_name (evt)); +efc_fabric_initiate_shutdown (node); +break ; + +/* ignore shutdown event as we're already in shutdown path */ +case EFC_EVT_SHUTDOWN : +node_printf (node,"Shutdown event received\n" ); +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_ns_rftid_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : +if (efc_node_check_ns_req (ctx, evt, arg,FC_NS_RFT_ID , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / send RFFID */ +efc_ns_send_rffid (node); +efc_node_transition (node, __efc_ns_rffid_wait_rsp,NULL ); +break ; + +/* +* if receive RSCN just ignore, +* we haven't sent GID_PT yet (ACC sent by fabctl node) +*/ +case EFC_EVT_RSCN_RCVD : +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_ns_rffid_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +/* +* Waits for an RFFID response event; +* if rscn enabled, a GIDPT name services request is issued. +*/ +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : { +if (efc_node_check_ns_req (ctx, evt, arg,FC_NS_RFF_ID , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +if (node->nport->enable_rscn) { +/* sm: if enable_rscn / send GIDPT */ +efc_ns_send_gidpt (node); + +efc_node_transition (node, __efc_ns_gidpt_wait_rsp, +NULL ); + }else { +/* if 'T' only, we're done, go to idle */ +efc_node_transition (node, __efc_ns_idle,NULL ); + } +break ; + } +/* +* if receive RSCN just ignore, +* we haven't sent GID_PT yet (ACC sent by fabctl node) +*/ +case EFC_EVT_RSCN_RCVD : +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +static int +efc_process_gidpt_payload (struct efc_node *node, +void *data,u32 gidpt_len) +{ +u32 i, j; +struct efc_node *newnode; +struct efc_nport *nport = node->nport; +struct efc *efc = node->efc; +u32 port_id =0 , port_count, plist_count; +struct efc_node *n; +struct efc_node **active_nodes; +int residual; +struct { +struct fc_ct_hdr hdr; +struct fc_gid_pn_resp pn_rsp; + } *rsp; +struct fc_gid_pn_resp *gidpt; + + rsp = data; + gidpt = &rsp->pn_rsp; + residual =be16_to_cpu (rsp->hdr.ct_mr_size); + +if (residual !=0 ) +efc_log_debug (node->efc,"residual is %u words\n" , residual); + +if (be16_to_cpu (rsp->hdr.ct_cmd) ==FC_FS_RJT ) { +node_printf (node, +"GIDPT request failed: rsn x%x rsn_expl x%x\n" , + rsp->hdr.ct_reason, rsp->hdr.ct_explan); +return EFC_FAIL ; + } + + plist_count = (gidpt_len -sizeof (struct fc_ct_hdr )) /sizeof (*gidpt); + +/* Count the number of nodes */ + port_count =0 ; +list_for_each_entry (n, &nport->node_list, list_entry) { + port_count++; + } + +/* Allocate a buffer for all nodes */ + active_nodes =kzalloc (port_count *sizeof (*active_nodes),GFP_ATOMIC ); +if (!active_nodes) { +node_printf (node,"efc_malloc failed\n" ); +return EFC_FAIL ; + } + +/* Fill buffer with fc_id of active nodes */ + i =0 ; +list_for_each_entry (n, &nport->node_list, list_entry) { + port_id = n->rnode.fc_id; +switch (port_id) { +case FC_FID_FLOGI : +case FC_FID_FCTRL : +case FC_FID_DIR_SERV : +break ; +default : +if (port_id !=FC_FID_DOM_MGR ) + active_nodes[i++] = n; +break ; + } + } + +/* update the active nodes buffer */ +for (i =0 ; i < plist_count; i++) { +hton24 (gidpt[i].fp_fid, port_id); + +for (j =0 ; j < port_count; j++) { +if (active_nodes[j] && + port_id == active_nodes[j]->rnode.fc_id) { + active_nodes[j] =NULL ; + } + } + +if (gidpt[i].fp_resvd &FC_NS_FID_LAST ) +break ; + } + +/* Those remaining in the active_nodes[] are now gone ! */ +for (i =0 ; i < port_count; i++) { +/* +* if we're an initiator and the remote node +* is a target, then post the node missing event. +* if we're target and we have enabled +* target RSCN, then post the node missing event. +*/ +if (!active_nodes[i]) +continue ; + +if ((node->nport->enable_ini && active_nodes[i]->targ) || + (node->nport->enable_tgt &&enable_target_rscn (efc))) { +efc_node_post_event (active_nodes[i], +EFC_EVT_NODE_MISSING ,NULL ); + }else { +node_printf (node, +"GID_PT: skipping non-tgt port_id x%06x\n" , + active_nodes[i]->rnode.fc_id); + } + } +kfree (active_nodes); + +for (i =0 ; i < plist_count; i++) { +hton24 (gidpt[i].fp_fid, port_id); + +/* Don't create node for ourselves */ +if (port_id == node->rnode.nport->fc_id) { +if (gidpt[i].fp_resvd &FC_NS_FID_LAST ) +break ; +continue ; + } + + newnode =efc_node_find (nport, port_id); +if (!newnode) { +if (!node->nport->enable_ini) +continue ; + + newnode =efc_node_alloc (nport, port_id, false, false); +if (!newnode) { +efc_log_err (efc,"efc_node_alloc() failed\n" ); +return EFC_FAIL ; + } +/* +* send PLOGI automatically +* if initiator +*/ +efc_node_init_device (newnode, true); + } + +if (node->nport->enable_ini && newnode->targ) { +efc_node_post_event (newnode,EFC_EVT_NODE_REFOUND , +NULL ); + } + +if (gidpt[i].fp_resvd &FC_NS_FID_LAST ) +break ; + } +return EFC_SUCCESS ; +} + +void +__efc_ns_gidpt_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); +/* +* Wait for a GIDPT response from the name server. Process the FC_IDs +* that are reported by creating new remote ports, as needed. +*/ + +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : { +if (efc_node_check_ns_req (ctx, evt, arg,FC_NS_GID_PT , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / process GIDPT payload */ +efc_process_gidpt_payload (node, cbdata->els_rsp.virt, + cbdata->els_rsp.len); +efc_node_transition (node, __efc_ns_idle,NULL ); +break ; + } + +case EFC_EVT_SRRS_ELS_REQ_FAIL : { +/* not much we can do; will retry with the next RSCN */ +node_printf (node,"GID_PT failed to complete\n" ); +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +efc_node_transition (node, __efc_ns_idle,NULL ); +break ; + } + +/* if receive RSCN here, queue up another discovery processing */ +case EFC_EVT_RSCN_RCVD : { +node_printf (node,"RSCN received during GID_PT processing\n" ); + node->rscn_pending = true; +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_ns_idle (struct efc_sm_ctx *ctx,enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; +struct efc *efc = node->efc; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +/* +* Wait for RSCN received events (posted from the fabric controller) +* and restart the GIDPT name services query and processing. +*/ + +switch (evt) { +case EFC_EVT_ENTER : +if (!node->rscn_pending) +break ; + +node_printf (node,"RSCN pending, restart discovery\n" ); + node->rscn_pending = false; + fallthrough; + +case EFC_EVT_RSCN_RCVD : { +/* sm: / send GIDPT */ +/* +* If target RSCN processing is enabled, +* and this is target only (not initiator), +* and tgt_rscn_delay is non-zero, +* then we delay issuing the GID_PT +*/ +if (efc->tgt_rscn_delay_msec !=0 && + !node->nport->enable_ini && node->nport->enable_tgt && +enable_target_rscn (efc)) { +efc_node_transition (node, __efc_ns_gidpt_delay,NULL ); + }else { +efc_ns_send_gidpt (node); +efc_node_transition (node, __efc_ns_gidpt_wait_rsp, +NULL ); + } +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +static void +gidpt_delay_timer_cb (struct timer_list *t) +{ +struct efc_node *node =from_timer (node, t, gidpt_delay_timer); + +del_timer (&node->gidpt_delay_timer); + +efc_node_post_event (node,EFC_EVT_GIDPT_DELAY_EXPIRED ,NULL ); +} + +void +__efc_ns_gidpt_delay (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; +struct efc *efc = node->efc; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : { +u64 delay_msec, tmp; + +/* +* Compute the delay time. +* Set to tgt_rscn_delay, if the time since last GIDPT +* is less than tgt_rscn_period, then use tgt_rscn_period. +*/ + delay_msec = efc->tgt_rscn_delay_msec; + tmp =jiffies_to_msecs (jiffies) - node->time_last_gidpt_msec; +if (tmp < efc->tgt_rscn_period_msec) + delay_msec = efc->tgt_rscn_period_msec; + +timer_setup (&node->gidpt_delay_timer, &gidpt_delay_timer_cb, +0 ); +mod_timer (&node->gidpt_delay_timer, + jiffies +msecs_to_jiffies (delay_msec)); + +break ; + } + +case EFC_EVT_GIDPT_DELAY_EXPIRED : + node->time_last_gidpt_msec =jiffies_to_msecs (jiffies); + +efc_ns_send_gidpt (node); +efc_node_transition (node, __efc_ns_gidpt_wait_rsp,NULL ); +break ; + +case EFC_EVT_RSCN_RCVD : { +efc_log_debug (efc, +"RSCN received while in GIDPT delay - no action\n" ); +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_fabctl_init (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +/* no need to login to fabric controller, just send SCR */ +efc_send_scr (node); +efc_node_transition (node, __efc_fabctl_wait_scr_rsp,NULL ); +break ; + +case EFC_EVT_NODE_ATTACH_OK : + node->attached = true; +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_fabctl_wait_scr_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +/* +* Fabric controller node state machine: +* Wait for an SCR response from the fabric controller. +*/ +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : +if (efc_node_check_els_req (ctx, evt, arg,ELS_SCR , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +efc_node_transition (node, __efc_fabctl_ready,NULL ); +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +static void +efc_process_rscn (struct efc_node *node,struct efc_node_cb *cbdata) +{ +struct efc *efc = node->efc; +struct efc_nport *nport = node->nport; +struct efc_node *ns; + +/* Forward this event to the name-services node */ + ns =efc_node_find (nport,FC_FID_DIR_SERV ); +if (ns) +efc_node_post_event (ns,EFC_EVT_RSCN_RCVD , cbdata); +else +efc_log_warn (efc,"can't find name server node\n" ); +} + +void +__efc_fabctl_ready (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +/* +* Fabric controller node state machine: Ready. +* In this state, the fabric controller sends a RSCN, which is received +* by this node and is forwarded to the name services node object; and +* the RSCN LS_ACC is sent. +*/ +switch (evt) { +case EFC_EVT_RSCN_RCVD : { +struct fc_frame_header *hdr = cbdata->header->dma.virt; + +/* +* sm: / process RSCN (forward to name services node), +* send LS_ACC +*/ +efc_process_rscn (node, cbdata); +efc_send_ls_acc (node,be16_to_cpu (hdr->fh_ox_id)); +efc_node_transition (node, __efc_fabctl_wait_ls_acc_cmpl, +NULL ); +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_fabctl_wait_ls_acc_cmpl (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_SRRS_ELS_CMPL_OK : +WARN_ON (!node->els_cmpl_cnt); + node->els_cmpl_cnt--; +efc_node_transition (node, __efc_fabctl_ready,NULL ); +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +static uint64_t +efc_get_wwpn (struct fc_els_flogi *sp) +{ +return be64_to_cpu (sp->fl_wwnn); +} + +static int +efc_rnode_is_winner (struct efc_nport *nport) +{ +struct fc_els_flogi *remote_sp; +u64 remote_wwpn; +u64 local_wwpn = nport->wwpn; +u64 wwn_bump =0 ; + + remote_sp = (struct fc_els_flogi *)nport->domain->flogi_service_params; + remote_wwpn =efc_get_wwpn (remote_sp); + + local_wwpn ^= wwn_bump; + +efc_log_debug (nport->efc,"r: %llx\n" , +be64_to_cpu (remote_sp->fl_wwpn)); +efc_log_debug (nport->efc,"l: %llx\n" , local_wwpn); + +if (remote_wwpn == local_wwpn) { +efc_log_warn (nport->efc, +"WWPN of remote node [%08x %08x] matches local WWPN\n" , + (u32)(local_wwpn >>32ll ), + (u32 )local_wwpn); +return -1 ; + } + +return (remote_wwpn > local_wwpn); +} + +void +__efc_p2p_wait_domain_attach (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; +struct efc *efc = node->efc; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_DOMAIN_ATTACH_OK : { +struct efc_nport *nport = node->nport; +struct efc_node *rnode; + +/* +* this transient node (SID=0 (recv'd FLOGI) +* or DID=fabric (sent FLOGI)) +* is the p2p winner, will use a separate node +* to send PLOGI to peer +*/ +WARN_ON (!node->nport->p2p_winner); + + rnode =efc_node_find (nport, node->nport->p2p_remote_port_id); +if (rnode) { +/* +* the "other" transient p2p node has +* already kicked off the +* new node from which PLOGI is sent +*/ +node_printf (node, +"Node with fc_id x%x already exists\n" , + rnode->rnode.fc_id); + }else { +/* +* create new node (SID=1, DID=2) +* from which to send PLOGI +*/ + rnode =efc_node_alloc (nport, + nport->p2p_remote_port_id, + false, false); +if (!rnode) { +efc_log_err (efc,"node alloc failed\n" ); +return ; + } + +efc_fabric_notify_topology (node); +/* sm: / allocate p2p remote node */ +efc_node_transition (rnode, __efc_p2p_rnode_init, +NULL ); + } + +/* +* the transient node (SID=0 or DID=fabric) +* has served its purpose +*/ +if (node->rnode.fc_id ==0 ) { +/* +* if this is the SID=0 node, +* move to the init state in case peer +* has restarted FLOGI discovery and FLOGI is pending +*/ +/* don't send PLOGI on efc_d_init entry */ +efc_node_init_device (node, false); + }else { +/* +* if this is the DID=fabric node +* (we initiated FLOGI), shut it down +*/ + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); + } +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_p2p_rnode_init (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +/* sm: / send PLOGI */ +efc_send_plogi (node); +efc_node_transition (node, __efc_p2p_wait_plogi_rsp,NULL ); +break ; + +case EFC_EVT_ABTS_RCVD : +/* sm: send BA_ACC */ +efc_send_bls_acc (node, cbdata->header->dma.virt); + +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_p2p_wait_flogi_acc_cmpl (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_SRRS_ELS_CMPL_OK : +WARN_ON (!node->els_cmpl_cnt); + node->els_cmpl_cnt--; + +/* sm: if p2p_winner / domain_attach */ +if (node->nport->p2p_winner) { +efc_node_transition (node, + __efc_p2p_wait_domain_attach, +NULL ); +if (!node->nport->domain->attached) { +node_printf (node,"Domain not attached\n" ); +efc_domain_attach (node->nport->domain, + node->nport->p2p_port_id); + }else { +node_printf (node,"Domain already attached\n" ); +efc_node_post_event (node, +EFC_EVT_DOMAIN_ATTACH_OK , +NULL ); + } + }else { +/* this node has served its purpose; +* we'll expect a PLOGI on a separate +* node (remote SID=0x1); return this node +* to init state in case peer +* restarts discovery -- it may already +* have (pending frames may exist). +*/ +/* don't send PLOGI on efc_d_init entry */ +efc_node_init_device (node, false); + } +break ; + +case EFC_EVT_SRRS_ELS_CMPL_FAIL : +/* +* LS_ACC failed, possibly due to link down; +* shutdown node and wait +* for FLOGI discovery to restart +*/ +node_printf (node,"FLOGI LS_ACC failed, shutting down\n" ); +WARN_ON (!node->els_cmpl_cnt); + node->els_cmpl_cnt--; + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); +break ; + +case EFC_EVT_ABTS_RCVD : { +/* sm: / send BA_ACC */ +efc_send_bls_acc (node, cbdata->header->dma.virt); +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_p2p_wait_plogi_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : { +int rc; + +if (efc_node_check_els_req (ctx, evt, arg,ELS_PLOGI , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / save sparams, efc_node_attach */ +efc_node_save_sparms (node, cbdata->els_rsp.virt); + rc =efc_node_attach (node); +efc_node_transition (node, __efc_p2p_wait_node_attach,NULL ); +if (rc ==EFC_HW_RTN_SUCCESS_SYNC ) +efc_node_post_event (node,EFC_EVT_NODE_ATTACH_OK , +NULL ); +break ; + } +case EFC_EVT_SRRS_ELS_REQ_FAIL : { +if (efc_node_check_els_req (ctx, evt, arg,ELS_PLOGI , + __efc_fabric_common, __func__)) { +return ; + } +node_printf (node,"PLOGI failed, shutting down\n" ); +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); +break ; + } + +case EFC_EVT_PLOGI_RCVD : { +struct fc_frame_header *hdr = cbdata->header->dma.virt; +/* if we're in external loopback mode, just send LS_ACC */ +if (node->efc->external_loopback) { +efc_send_plogi_acc (node,be16_to_cpu (hdr->fh_ox_id)); + }else { +/* +* if this isn't external loopback, +* pass to default handler +*/ +__efc_fabric_common (__func__, ctx, evt, arg); + } +break ; + } +case EFC_EVT_PRLI_RCVD : +/* I, or I+T */ +/* sent PLOGI and before completion was seen, received the +* PRLI from the remote node (WCQEs and RCQEs come in on +* different queues and order of processing cannot be assumed) +* Save OXID so PRLI can be sent after the attach and continue +* to wait for PLOGI response +*/ +efc_process_prli_payload (node, cbdata->payload->dma.virt); +efc_send_ls_acc_after_attach (node, + cbdata->header->dma.virt, +EFC_NODE_SEND_LS_ACC_PRLI ); +efc_node_transition (node, __efc_p2p_wait_plogi_rsp_recvd_prli, +NULL ); +break ; +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_p2p_wait_plogi_rsp_recvd_prli (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +/* +* Since we've received a PRLI, we have a port login and will +* just need to wait for the PLOGI response to do the node +* attach and then we can send the LS_ACC for the PRLI. If, +* during this time, we receive FCP_CMNDs (which is possible +* since we've already sent a PRLI and our peer may have +* accepted). +* At this time, we are not waiting on any other unsolicited +* frames to continue with the login process. Thus, it will not +* hurt to hold frames here. +*/ +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_SRRS_ELS_REQ_OK : {/* PLOGI response received */ +int rc; + +/* Completion from PLOGI sent */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_PLOGI , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / save sparams, efc_node_attach */ +efc_node_save_sparms (node, cbdata->els_rsp.virt); + rc =efc_node_attach (node); +efc_node_transition (node, __efc_p2p_wait_node_attach,NULL ); +if (rc ==EFC_HW_RTN_SUCCESS_SYNC ) +efc_node_post_event (node,EFC_EVT_NODE_ATTACH_OK , +NULL ); +break ; + } +case EFC_EVT_SRRS_ELS_REQ_FAIL :/* PLOGI response received */ +case EFC_EVT_SRRS_ELS_REQ_RJT : +/* PLOGI failed, shutdown the node */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_PLOGI , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_p2p_wait_node_attach (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_NODE_ATTACH_OK : + node->attached = true; +switch (node->send_ls_acc) { +case EFC_NODE_SEND_LS_ACC_PRLI : { +efc_d_send_prli_rsp (node->ls_acc_io, + node->ls_acc_oxid); + node->send_ls_acc =EFC_NODE_SEND_LS_ACC_NONE ; + node->ls_acc_io =NULL ; +break ; + } +case EFC_NODE_SEND_LS_ACC_PLOGI :/* Can't happen in P2P */ +case EFC_NODE_SEND_LS_ACC_NONE : +default : +/* Normal case for I */ +/* sm: send_plogi_acc is not set / send PLOGI acc */ +efc_node_transition (node, __efc_d_port_logged_in, +NULL ); +break ; + } +break ; + +case EFC_EVT_NODE_ATTACH_FAIL : +/* node attach failed, shutdown the node */ + node->attached = false; +node_printf (node,"Node attach failed\n" ); + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); +break ; + +case EFC_EVT_SHUTDOWN : +node_printf (node,"%s received\n" ,efc_sm_event_name (evt)); + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_node_transition (node, + __efc_fabric_wait_attach_evt_shutdown, +NULL ); +break ; +case EFC_EVT_PRLI_RCVD : +node_printf (node,"%s: PRLI received before node is attached\n" , +efc_sm_event_name (evt)); +efc_process_prli_payload (node, cbdata->payload->dma.virt); +efc_send_ls_acc_after_attach (node, + cbdata->header->dma.virt, +EFC_NODE_SEND_LS_ACC_PRLI ); +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +int +efc_p2p_setup (struct efc_nport *nport) +{ +struct efc *efc = nport->efc; +int rnode_winner; + + rnode_winner =efc_rnode_is_winner (nport); + +/* set nport flags to indicate p2p "winner" */ +if (rnode_winner ==1 ) { + nport->p2p_remote_port_id =0 ; + nport->p2p_port_id =0 ; + nport->p2p_winner = false; + }else if (rnode_winner ==0 ) { + nport->p2p_remote_port_id =2 ; + nport->p2p_port_id =1 ; + nport->p2p_winner = true; + }else { +/* no winner; only okay if external loopback enabled */ +if (nport->efc->external_loopback) { +/* +* External loopback mode enabled; +* local nport and remote node +* will be registered with an NPortID = 1; +*/ +efc_log_debug (efc, +"External loopback mode enabled\n" ); + nport->p2p_remote_port_id =1 ; + nport->p2p_port_id =1 ; + nport->p2p_winner = true; + }else { +efc_log_warn (efc, +"failed to determine p2p winner\n" ); +return rnode_winner; + } + } +return EFC_SUCCESS ; +}
drivers/scsi/elx/libefc/efc_fabric.h new file +116 -0
116 lines not on this page · raw message
Signature · 1 line
2.26.2
Re: [PATCH v4 13/31] elx: libefc: Fabric node state machine interfaces
Quoted 107 lines · James Smart
This patch continues the libefc library population.
This patch adds library interface definitions for:
- Fabric node initialization and logins.
- Name/Directory Services node.
- Fabric Controller node to process rscn events.These are all interactions with remote ports that correspond to well-known fabric entities
Co-developed-by Ram Vegesna <[email protected]>Signed-off-by Ram Vegesna <[email protected]>Signed-off-by James Smart <[email protected]>---
v4:
Move all SM functions return value from void * to void.--- drivers/scsi/elx/libefc/efc_fabric.c | 1565 ++++++++++++++++++++++++++ drivers/scsi/elx/libefc/efc_fabric.h | 116 ++ 2 files changed, 1681 insertions(+)create mode 100644
drivers/scsi/elx/libefc/efc_fabric.ccreate mode 100644drivers/scsi/elx/libefc/efc_fabric.hdrivers/scsi/elx/libefc/efc_fabric.c new file +77
-0@@ -0,0 +1,1565 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +/* +* This file implements remote node state machines for: +* - Fabric logins. +* - Fabric controller events. +* - Name/directory services interaction. +* - Point-to-point logins. +*/ + +/* +* fabric_sm Node State Machine: Fabric States +* ns_sm Node State Machine: Name/Directory Services States +* p2p_sm Node State Machine: Point-to-Point Node States +*/ + +#include "efc.h" + +static void +efc_fabric_initiate_shutdown (struct efc_node *node) +{ +struct efc *efc = node->efc; + +efc_io_alloc_disable (node); +if (node->attached) { +int rc; + +/* issue hw node free; don't care if succeeds right away +* or sometime later, will check node->attached later in +* shutdown process +*/ + rc =efc_cmd_node_detach (efc, &node->rnode); +if (rc !=EFC_HW_RTN_SUCCESS && + rc !=EFC_HW_RTN_SUCCESS_SYNC ) { +node_printf (node,"Failed freeing HW node, rc=%d\n" , + rc); + } + } +/* +* node has either been detached or is in the process of being detached, +* call common node's initiate cleanup function +*/ +efc_node_initiate_cleanup (node); +} + +static void +__efc_fabric_common (const char *funcname,struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node =NULL ; + + node = ctx->app; + +switch (evt) { +case EFC_EVT_DOMAIN_ATTACH_OK : +break ; +case EFC_EVT_SHUTDOWN : + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); +break ; + +default : +/* call default event handler common to all nodes */ +__efc_node_common (funcname, ctx, evt, arg); + } +} + +void +__efc_fabric_init (struct efc_sm_ctx *ctx,enum efc_sm_event evt, +void *arg) +{ +struct efc_node *node = ctx->app; +struct efc *efc = node->efc;
drivers/scsi/elx/libefc/efc_fabric.c line 87
Quoted 10 lines
drivers/scsi/elx/libefc/efc_fabric.c new file +10
-0+ +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_REENTER :/* not sure why we're getting these ... */ +efc_log_debug (efc,">>> reenter !!\n" ); + fallthrough; +
Tsk. A new driver and you don't know what's happening?
Quoted 1,591 lines
drivers/scsi/elx/libefc/efc_fabric.c new file +1478
-0+case EFC_EVT_ENTER : +/* sm: / send FLOGI */ +efc_send_flogi (node); +efc_node_transition (node, __efc_fabric_flogi_wait_rsp,NULL ); +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +efc_fabric_set_topology (struct efc_node *node, +enum efc_nport_topology topology) +{ + node->nport->topology = topology; +} + +void +efc_fabric_notify_topology (struct efc_node *node) +{ +struct efc_node *tmp_node; +struct efc_node *next; +enum efc_nport_topology topology = node->nport->topology; + +/* +* now loop through the nodes in the nport +* and send topology notification +*/ +list_for_each_entry_safe (tmp_node, next, &node->nport->node_list, + list_entry) { +if (tmp_node != node) { +efc_node_post_event (tmp_node, +EFC_EVT_SPORT_TOPOLOGY_NOTIFY , + (void *)topology); + } + } +} + +static bool efc_rnode_is_nport (struct fc_els_flogi *rsp) +{ +return !(ntohs (rsp->fl_csp.sp_features) &FC_SP_FT_FPORT ); +} + +void +__efc_fabric_flogi_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : { +if (efc_node_check_els_req (ctx, evt, arg,ELS_FLOGI , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; + +memcpy (node->nport->domain->flogi_service_params, + cbdata->els_rsp.virt, +sizeof (struct fc_els_flogi )); + +/* Check to see if the fabric is an F_PORT or and N_PORT */ +if (!efc_rnode_is_nport (cbdata->els_rsp.virt)) { +/* sm: if not nport / efc_domain_attach */ +/* ext_status has the fc_id, attach domain */ +efc_fabric_set_topology (node, +EFC_SPORT_TOPOLOGY_FABRIC ); +efc_fabric_notify_topology (node); +WARN_ON (node->nport->domain->attached); +efc_domain_attach (node->nport->domain, + cbdata->ext_status); +efc_node_transition (node, + __efc_fabric_wait_domain_attach, +NULL ); +break ; + } + +/* sm: if nport and p2p_winner / efc_domain_attach */ +efc_fabric_set_topology (node,EFC_SPORT_TOPOLOGY_P2P ); +if (efc_p2p_setup (node->nport)) { +node_printf (node, +"p2p setup failed, shutting down node\n" ); + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); +break ; + } + +if (node->nport->p2p_winner) { +efc_node_transition (node, + __efc_p2p_wait_domain_attach, +NULL ); +if (node->nport->domain->attached && + !node->nport->domain->domain_notify_pend) { +/* +* already attached, +* just send ATTACH_OK +*/ +node_printf (node, +"p2p winner, domain already attached\n" ); +efc_node_post_event (node, +EFC_EVT_DOMAIN_ATTACH_OK , +NULL ); + } + }else { +/* +* peer is p2p winner; +* PLOGI will be received on the +* remote SID=1 node; +* this node has served its purpose +*/ + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); + } + +break ; + } + +case EFC_EVT_ELS_REQ_ABORTED : +case EFC_EVT_SRRS_ELS_REQ_RJT : +case EFC_EVT_SRRS_ELS_REQ_FAIL : { +struct efc_nport *nport = node->nport; +/* +* with these errors, we have no recovery, +* so shutdown the nport, leave the link +* up and the domain ready +*/ +if (efc_node_check_els_req (ctx, evt, arg,ELS_FLOGI , + __efc_fabric_common, __func__)) { +return ; + } +node_printf (node, +"FLOGI failed evt=%s, shutting down nport [%s]\n" , +efc_sm_event_name (evt), nport->display_name); +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +efc_sm_post_event (&nport->sm,EFC_EVT_SHUTDOWN ,NULL ); +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_vport_fabric_init (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +/* sm: / send FDISC */ +efc_send_fdisc (node); +efc_node_transition (node, __efc_fabric_fdisc_wait_rsp,NULL ); +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_fabric_fdisc_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : { +/* fc_id is in ext_status */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_FDISC , + __efc_fabric_common, __func__)) { +return ; + } + +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / efc_nport_attach */ +efc_nport_attach (node->nport, cbdata->ext_status); +efc_node_transition (node, __efc_fabric_wait_domain_attach, +NULL ); +break ; + } + +case EFC_EVT_SRRS_ELS_REQ_RJT : +case EFC_EVT_SRRS_ELS_REQ_FAIL : { +if (efc_node_check_els_req (ctx, evt, arg,ELS_FDISC , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +efc_log_err (node->efc,"FDISC failed, shutting down nport\n" ); +/* sm: / shutdown nport */ +efc_sm_post_event (&node->nport->sm,EFC_EVT_SHUTDOWN ,NULL ); +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +static int +efc_start_ns_node (struct efc_nport *nport) +{ +struct efc_node *ns; + +/* Instantiate a name services node */ + ns =efc_node_find (nport,FC_FID_DIR_SERV ); +if (!ns) { + ns =efc_node_alloc (nport,FC_FID_DIR_SERV , false, false); +if (!ns) +return EFC_FAIL ; + } +/* +* for found ns, should we be transitioning from here? +* breaks transition only +* 1. from within state machine or +* 2. if after alloc +*/ +if (ns->efc->nodedb_mask &EFC_NODEDB_PAUSE_NAMESERVER ) +efc_node_pause (ns, __efc_ns_init); +else +efc_node_transition (ns, __efc_ns_init,NULL ); +return EFC_SUCCESS ; +} + +static int +efc_start_fabctl_node (struct efc_nport *nport) +{ +struct efc_node *fabctl; + + fabctl =efc_node_find (nport,FC_FID_FCTRL ); +if (!fabctl) { + fabctl =efc_node_alloc (nport,FC_FID_FCTRL , + false, false); +if (!fabctl) +return EFC_FAIL ; + } +/* +* for found ns, should we be transitioning from here? +* breaks transition only +* 1. from within state machine or +* 2. if after alloc +*/ +efc_node_transition (fabctl, __efc_fabctl_init,NULL ); +return EFC_SUCCESS ; +} + +void +__efc_fabric_wait_domain_attach (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; +case EFC_EVT_DOMAIN_ATTACH_OK : +case EFC_EVT_SPORT_ATTACH_OK : { +int rc; + + rc =efc_start_ns_node (node->nport); +if (rc) +return ; + +/* sm: if enable_ini / start fabctl node */ +/* Instantiate the fabric controller (sends SCR) */ +if (node->nport->enable_rscn) { + rc =efc_start_fabctl_node (node->nport); +if (rc) +return ; + } +efc_node_transition (node, __efc_fabric_idle,NULL ); +break ; + } +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_fabric_idle (struct efc_sm_ctx *ctx,enum efc_sm_event evt, +void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_DOMAIN_ATTACH_OK : +break ; +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_ns_init (struct efc_sm_ctx *ctx,enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +/* sm: / send PLOGI */ +efc_send_plogi (node); +efc_node_transition (node, __efc_ns_plogi_wait_rsp,NULL ); +break ; +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_ns_plogi_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : { +int rc; + +/* Save service parameters */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_PLOGI , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / save sparams, efc_node_attach */ +efc_node_save_sparms (node, cbdata->els_rsp.virt); + rc =efc_node_attach (node); +efc_node_transition (node, __efc_ns_wait_node_attach,NULL ); +if (rc ==EFC_HW_RTN_SUCCESS_SYNC ) +efc_node_post_event (node,EFC_EVT_NODE_ATTACH_OK , +NULL ); +break ; + } +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_ns_wait_node_attach (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_NODE_ATTACH_OK : + node->attached = true; +/* sm: / send RFTID */ +efc_ns_send_rftid (node); +efc_node_transition (node, __efc_ns_rftid_wait_rsp,NULL ); +break ; + +case EFC_EVT_NODE_ATTACH_FAIL : +/* node attach failed, shutdown the node */ + node->attached = false; +node_printf (node,"Node attach failed\n" ); + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); +break ; + +case EFC_EVT_SHUTDOWN : +node_printf (node,"Shutdown event received\n" ); + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_node_transition (node, + __efc_fabric_wait_attach_evt_shutdown, +NULL ); +break ; + +/* +* if receive RSCN just ignore, +* we haven't sent GID_PT yet (ACC sent by fabctl node) +*/ +case EFC_EVT_RSCN_RCVD : +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_fabric_wait_attach_evt_shutdown (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +/* wait for any of these attach events and then shutdown */ +case EFC_EVT_NODE_ATTACH_OK : + node->attached = true; +node_printf (node,"Attach evt=%s, proceed to shutdown\n" , +efc_sm_event_name (evt)); +efc_fabric_initiate_shutdown (node); +break ; + +case EFC_EVT_NODE_ATTACH_FAIL : + node->attached = false; +node_printf (node,"Attach evt=%s, proceed to shutdown\n" , +efc_sm_event_name (evt)); +efc_fabric_initiate_shutdown (node); +break ; + +/* ignore shutdown event as we're already in shutdown path */ +case EFC_EVT_SHUTDOWN : +node_printf (node,"Shutdown event received\n" ); +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_ns_rftid_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : +if (efc_node_check_ns_req (ctx, evt, arg,FC_NS_RFT_ID , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / send RFFID */ +efc_ns_send_rffid (node); +efc_node_transition (node, __efc_ns_rffid_wait_rsp,NULL ); +break ; + +/* +* if receive RSCN just ignore, +* we haven't sent GID_PT yet (ACC sent by fabctl node) +*/ +case EFC_EVT_RSCN_RCVD : +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_ns_rffid_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +/* +* Waits for an RFFID response event; +* if rscn enabled, a GIDPT name services request is issued. +*/ +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : { +if (efc_node_check_ns_req (ctx, evt, arg,FC_NS_RFF_ID , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +if (node->nport->enable_rscn) { +/* sm: if enable_rscn / send GIDPT */ +efc_ns_send_gidpt (node); + +efc_node_transition (node, __efc_ns_gidpt_wait_rsp, +NULL ); + }else { +/* if 'T' only, we're done, go to idle */ +efc_node_transition (node, __efc_ns_idle,NULL ); + } +break ; + } +/* +* if receive RSCN just ignore, +* we haven't sent GID_PT yet (ACC sent by fabctl node) +*/ +case EFC_EVT_RSCN_RCVD : +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +static int +efc_process_gidpt_payload (struct efc_node *node, +void *data,u32 gidpt_len) +{ +u32 i, j; +struct efc_node *newnode; +struct efc_nport *nport = node->nport; +struct efc *efc = node->efc; +u32 port_id =0 , port_count, plist_count; +struct efc_node *n; +struct efc_node **active_nodes; +int residual; +struct { +struct fc_ct_hdr hdr; +struct fc_gid_pn_resp pn_rsp; + } *rsp; +struct fc_gid_pn_resp *gidpt; + + rsp = data; + gidpt = &rsp->pn_rsp; + residual =be16_to_cpu (rsp->hdr.ct_mr_size); + +if (residual !=0 ) +efc_log_debug (node->efc,"residual is %u words\n" , residual); + +if (be16_to_cpu (rsp->hdr.ct_cmd) ==FC_FS_RJT ) { +node_printf (node, +"GIDPT request failed: rsn x%x rsn_expl x%x\n" , + rsp->hdr.ct_reason, rsp->hdr.ct_explan); +return EFC_FAIL ; + } + + plist_count = (gidpt_len -sizeof (struct fc_ct_hdr )) /sizeof (*gidpt); + +/* Count the number of nodes */ + port_count =0 ; +list_for_each_entry (n, &nport->node_list, list_entry) { + port_count++; + } + +/* Allocate a buffer for all nodes */ + active_nodes =kzalloc (port_count *sizeof (*active_nodes),GFP_ATOMIC ); +if (!active_nodes) { +node_printf (node,"efc_malloc failed\n" ); +return EFC_FAIL ; + } + +/* Fill buffer with fc_id of active nodes */ + i =0 ; +list_for_each_entry (n, &nport->node_list, list_entry) { + port_id = n->rnode.fc_id; +switch (port_id) { +case FC_FID_FLOGI : +case FC_FID_FCTRL : +case FC_FID_DIR_SERV : +break ; +default : +if (port_id !=FC_FID_DOM_MGR ) + active_nodes[i++] = n; +break ; + } + } + +/* update the active nodes buffer */ +for (i =0 ; i < plist_count; i++) { +hton24 (gidpt[i].fp_fid, port_id); + +for (j =0 ; j < port_count; j++) { +if (active_nodes[j] && + port_id == active_nodes[j]->rnode.fc_id) { + active_nodes[j] =NULL ; + } + } + +if (gidpt[i].fp_resvd &FC_NS_FID_LAST ) +break ; + } + +/* Those remaining in the active_nodes[] are now gone ! */ +for (i =0 ; i < port_count; i++) { +/* +* if we're an initiator and the remote node +* is a target, then post the node missing event. +* if we're target and we have enabled +* target RSCN, then post the node missing event. +*/ +if (!active_nodes[i]) +continue ; + +if ((node->nport->enable_ini && active_nodes[i]->targ) || + (node->nport->enable_tgt &&enable_target_rscn (efc))) { +efc_node_post_event (active_nodes[i], +EFC_EVT_NODE_MISSING ,NULL ); + }else { +node_printf (node, +"GID_PT: skipping non-tgt port_id x%06x\n" , + active_nodes[i]->rnode.fc_id); + } + } +kfree (active_nodes); + +for (i =0 ; i < plist_count; i++) { +hton24 (gidpt[i].fp_fid, port_id); + +/* Don't create node for ourselves */ +if (port_id == node->rnode.nport->fc_id) { +if (gidpt[i].fp_resvd &FC_NS_FID_LAST ) +break ; +continue ; + } + + newnode =efc_node_find (nport, port_id); +if (!newnode) { +if (!node->nport->enable_ini) +continue ; + + newnode =efc_node_alloc (nport, port_id, false, false); +if (!newnode) { +efc_log_err (efc,"efc_node_alloc() failed\n" ); +return EFC_FAIL ; + } +/* +* send PLOGI automatically +* if initiator +*/ +efc_node_init_device (newnode, true); + } + +if (node->nport->enable_ini && newnode->targ) { +efc_node_post_event (newnode,EFC_EVT_NODE_REFOUND , +NULL ); + } + +if (gidpt[i].fp_resvd &FC_NS_FID_LAST ) +break ; + } +return EFC_SUCCESS ; +} + +void +__efc_ns_gidpt_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); +/* +* Wait for a GIDPT response from the name server. Process the FC_IDs +* that are reported by creating new remote ports, as needed. +*/ + +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : { +if (efc_node_check_ns_req (ctx, evt, arg,FC_NS_GID_PT , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / process GIDPT payload */ +efc_process_gidpt_payload (node, cbdata->els_rsp.virt, + cbdata->els_rsp.len); +efc_node_transition (node, __efc_ns_idle,NULL ); +break ; + } + +case EFC_EVT_SRRS_ELS_REQ_FAIL : { +/* not much we can do; will retry with the next RSCN */ +node_printf (node,"GID_PT failed to complete\n" ); +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +efc_node_transition (node, __efc_ns_idle,NULL ); +break ; + } + +/* if receive RSCN here, queue up another discovery processing */ +case EFC_EVT_RSCN_RCVD : { +node_printf (node,"RSCN received during GID_PT processing\n" ); + node->rscn_pending = true; +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_ns_idle (struct efc_sm_ctx *ctx,enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; +struct efc *efc = node->efc; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +/* +* Wait for RSCN received events (posted from the fabric controller) +* and restart the GIDPT name services query and processing. +*/ + +switch (evt) { +case EFC_EVT_ENTER : +if (!node->rscn_pending) +break ; + +node_printf (node,"RSCN pending, restart discovery\n" ); + node->rscn_pending = false; + fallthrough; + +case EFC_EVT_RSCN_RCVD : { +/* sm: / send GIDPT */ +/* +* If target RSCN processing is enabled, +* and this is target only (not initiator), +* and tgt_rscn_delay is non-zero, +* then we delay issuing the GID_PT +*/ +if (efc->tgt_rscn_delay_msec !=0 && + !node->nport->enable_ini && node->nport->enable_tgt && +enable_target_rscn (efc)) { +efc_node_transition (node, __efc_ns_gidpt_delay,NULL ); + }else { +efc_ns_send_gidpt (node); +efc_node_transition (node, __efc_ns_gidpt_wait_rsp, +NULL ); + } +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +static void +gidpt_delay_timer_cb (struct timer_list *t) +{ +struct efc_node *node =from_timer (node, t, gidpt_delay_timer); + +del_timer (&node->gidpt_delay_timer); + +efc_node_post_event (node,EFC_EVT_GIDPT_DELAY_EXPIRED ,NULL ); +} + +void +__efc_ns_gidpt_delay (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; +struct efc *efc = node->efc; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : { +u64 delay_msec, tmp; + +/* +* Compute the delay time. +* Set to tgt_rscn_delay, if the time since last GIDPT +* is less than tgt_rscn_period, then use tgt_rscn_period. +*/ + delay_msec = efc->tgt_rscn_delay_msec; + tmp =jiffies_to_msecs (jiffies) - node->time_last_gidpt_msec; +if (tmp < efc->tgt_rscn_period_msec) + delay_msec = efc->tgt_rscn_period_msec; + +timer_setup (&node->gidpt_delay_timer, &gidpt_delay_timer_cb, +0 ); +mod_timer (&node->gidpt_delay_timer, + jiffies +msecs_to_jiffies (delay_msec)); + +break ; + } + +case EFC_EVT_GIDPT_DELAY_EXPIRED : + node->time_last_gidpt_msec =jiffies_to_msecs (jiffies); + +efc_ns_send_gidpt (node); +efc_node_transition (node, __efc_ns_gidpt_wait_rsp,NULL ); +break ; + +case EFC_EVT_RSCN_RCVD : { +efc_log_debug (efc, +"RSCN received while in GIDPT delay - no action\n" ); +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_fabctl_init (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +/* no need to login to fabric controller, just send SCR */ +efc_send_scr (node); +efc_node_transition (node, __efc_fabctl_wait_scr_rsp,NULL ); +break ; + +case EFC_EVT_NODE_ATTACH_OK : + node->attached = true; +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_fabctl_wait_scr_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +/* +* Fabric controller node state machine: +* Wait for an SCR response from the fabric controller. +*/ +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : +if (efc_node_check_els_req (ctx, evt, arg,ELS_SCR , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +efc_node_transition (node, __efc_fabctl_ready,NULL ); +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +static void +efc_process_rscn (struct efc_node *node,struct efc_node_cb *cbdata) +{ +struct efc *efc = node->efc; +struct efc_nport *nport = node->nport; +struct efc_node *ns; + +/* Forward this event to the name-services node */ + ns =efc_node_find (nport,FC_FID_DIR_SERV ); +if (ns) +efc_node_post_event (ns,EFC_EVT_RSCN_RCVD , cbdata); +else +efc_log_warn (efc,"can't find name server node\n" ); +} + +void +__efc_fabctl_ready (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +/* +* Fabric controller node state machine: Ready. +* In this state, the fabric controller sends a RSCN, which is received +* by this node and is forwarded to the name services node object; and +* the RSCN LS_ACC is sent. +*/ +switch (evt) { +case EFC_EVT_RSCN_RCVD : { +struct fc_frame_header *hdr = cbdata->header->dma.virt; + +/* +* sm: / process RSCN (forward to name services node), +* send LS_ACC +*/ +efc_process_rscn (node, cbdata); +efc_send_ls_acc (node,be16_to_cpu (hdr->fh_ox_id)); +efc_node_transition (node, __efc_fabctl_wait_ls_acc_cmpl, +NULL ); +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_fabctl_wait_ls_acc_cmpl (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_SRRS_ELS_CMPL_OK : +WARN_ON (!node->els_cmpl_cnt); + node->els_cmpl_cnt--; +efc_node_transition (node, __efc_fabctl_ready,NULL ); +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +static uint64_t +efc_get_wwpn (struct fc_els_flogi *sp) +{ +return be64_to_cpu (sp->fl_wwnn); +} + +static int +efc_rnode_is_winner (struct efc_nport *nport) +{ +struct fc_els_flogi *remote_sp; +u64 remote_wwpn; +u64 local_wwpn = nport->wwpn; +u64 wwn_bump =0 ; + + remote_sp = (struct fc_els_flogi *)nport->domain->flogi_service_params; + remote_wwpn =efc_get_wwpn (remote_sp); + + local_wwpn ^= wwn_bump; + +efc_log_debug (nport->efc,"r: %llx\n" , +be64_to_cpu (remote_sp->fl_wwpn)); +efc_log_debug (nport->efc,"l: %llx\n" , local_wwpn); + +if (remote_wwpn == local_wwpn) { +efc_log_warn (nport->efc, +"WWPN of remote node [%08x %08x] matches local WWPN\n" , + (u32)(local_wwpn >>32ll ), + (u32 )local_wwpn); +return -1 ; + } + +return (remote_wwpn > local_wwpn); +} + +void +__efc_p2p_wait_domain_attach (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; +struct efc *efc = node->efc; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_DOMAIN_ATTACH_OK : { +struct efc_nport *nport = node->nport; +struct efc_node *rnode; + +/* +* this transient node (SID=0 (recv'd FLOGI) +* or DID=fabric (sent FLOGI)) +* is the p2p winner, will use a separate node +* to send PLOGI to peer +*/ +WARN_ON (!node->nport->p2p_winner); + + rnode =efc_node_find (nport, node->nport->p2p_remote_port_id); +if (rnode) { +/* +* the "other" transient p2p node has +* already kicked off the +* new node from which PLOGI is sent +*/ +node_printf (node, +"Node with fc_id x%x already exists\n" , + rnode->rnode.fc_id); + }else { +/* +* create new node (SID=1, DID=2) +* from which to send PLOGI +*/ + rnode =efc_node_alloc (nport, + nport->p2p_remote_port_id, + false, false); +if (!rnode) { +efc_log_err (efc,"node alloc failed\n" ); +return ; + } + +efc_fabric_notify_topology (node); +/* sm: / allocate p2p remote node */ +efc_node_transition (rnode, __efc_p2p_rnode_init, +NULL ); + } + +/* +* the transient node (SID=0 or DID=fabric) +* has served its purpose +*/ +if (node->rnode.fc_id ==0 ) { +/* +* if this is the SID=0 node, +* move to the init state in case peer +* has restarted FLOGI discovery and FLOGI is pending +*/ +/* don't send PLOGI on efc_d_init entry */ +efc_node_init_device (node, false); + }else { +/* +* if this is the DID=fabric node +* (we initiated FLOGI), shut it down +*/ + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); + } +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_p2p_rnode_init (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +/* sm: / send PLOGI */ +efc_send_plogi (node); +efc_node_transition (node, __efc_p2p_wait_plogi_rsp,NULL ); +break ; + +case EFC_EVT_ABTS_RCVD : +/* sm: send BA_ACC */ +efc_send_bls_acc (node, cbdata->header->dma.virt); + +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_p2p_wait_flogi_acc_cmpl (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_SRRS_ELS_CMPL_OK : +WARN_ON (!node->els_cmpl_cnt); + node->els_cmpl_cnt--; + +/* sm: if p2p_winner / domain_attach */ +if (node->nport->p2p_winner) { +efc_node_transition (node, + __efc_p2p_wait_domain_attach, +NULL ); +if (!node->nport->domain->attached) { +node_printf (node,"Domain not attached\n" ); +efc_domain_attach (node->nport->domain, + node->nport->p2p_port_id); + }else { +node_printf (node,"Domain already attached\n" ); +efc_node_post_event (node, +EFC_EVT_DOMAIN_ATTACH_OK , +NULL ); + } + }else { +/* this node has served its purpose; +* we'll expect a PLOGI on a separate +* node (remote SID=0x1); return this node +* to init state in case peer +* restarts discovery -- it may already +* have (pending frames may exist). +*/ +/* don't send PLOGI on efc_d_init entry */ +efc_node_init_device (node, false); + } +break ; + +case EFC_EVT_SRRS_ELS_CMPL_FAIL : +/* +* LS_ACC failed, possibly due to link down; +* shutdown node and wait +* for FLOGI discovery to restart +*/ +node_printf (node,"FLOGI LS_ACC failed, shutting down\n" ); +WARN_ON (!node->els_cmpl_cnt); + node->els_cmpl_cnt--; + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); +break ; + +case EFC_EVT_ABTS_RCVD : { +/* sm: / send BA_ACC */ +efc_send_bls_acc (node, cbdata->header->dma.virt); +break ; + } + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_p2p_wait_plogi_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : { +int rc; + +if (efc_node_check_els_req (ctx, evt, arg,ELS_PLOGI , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / save sparams, efc_node_attach */ +efc_node_save_sparms (node, cbdata->els_rsp.virt); + rc =efc_node_attach (node); +efc_node_transition (node, __efc_p2p_wait_node_attach,NULL ); +if (rc ==EFC_HW_RTN_SUCCESS_SYNC ) +efc_node_post_event (node,EFC_EVT_NODE_ATTACH_OK , +NULL ); +break ; + } +case EFC_EVT_SRRS_ELS_REQ_FAIL : { +if (efc_node_check_els_req (ctx, evt, arg,ELS_PLOGI , + __efc_fabric_common, __func__)) { +return ; + } +node_printf (node,"PLOGI failed, shutting down\n" ); +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); +break ; + } + +case EFC_EVT_PLOGI_RCVD : { +struct fc_frame_header *hdr = cbdata->header->dma.virt; +/* if we're in external loopback mode, just send LS_ACC */ +if (node->efc->external_loopback) { +efc_send_plogi_acc (node,be16_to_cpu (hdr->fh_ox_id)); + }else { +/* +* if this isn't external loopback, +* pass to default handler +*/ +__efc_fabric_common (__func__, ctx, evt, arg); + } +break ; + } +case EFC_EVT_PRLI_RCVD : +/* I, or I+T */ +/* sent PLOGI and before completion was seen, received the +* PRLI from the remote node (WCQEs and RCQEs come in on +* different queues and order of processing cannot be assumed) +* Save OXID so PRLI can be sent after the attach and continue +* to wait for PLOGI response +*/ +efc_process_prli_payload (node, cbdata->payload->dma.virt); +efc_send_ls_acc_after_attach (node, + cbdata->header->dma.virt, +EFC_NODE_SEND_LS_ACC_PRLI ); +efc_node_transition (node, __efc_p2p_wait_plogi_rsp_recvd_prli, +NULL ); +break ; +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_p2p_wait_plogi_rsp_recvd_prli (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +/* +* Since we've received a PRLI, we have a port login and will +* just need to wait for the PLOGI response to do the node +* attach and then we can send the LS_ACC for the PRLI. If, +* during this time, we receive FCP_CMNDs (which is possible +* since we've already sent a PRLI and our peer may have +* accepted). +* At this time, we are not waiting on any other unsolicited +* frames to continue with the login process. Thus, it will not +* hurt to hold frames here. +*/ +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_SRRS_ELS_REQ_OK : {/* PLOGI response received */ +int rc; + +/* Completion from PLOGI sent */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_PLOGI , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / save sparams, efc_node_attach */ +efc_node_save_sparms (node, cbdata->els_rsp.virt); + rc =efc_node_attach (node); +efc_node_transition (node, __efc_p2p_wait_node_attach,NULL ); +if (rc ==EFC_HW_RTN_SUCCESS_SYNC ) +efc_node_post_event (node,EFC_EVT_NODE_ATTACH_OK , +NULL ); +break ; + } +case EFC_EVT_SRRS_ELS_REQ_FAIL :/* PLOGI response received */ +case EFC_EVT_SRRS_ELS_REQ_RJT : +/* PLOGI failed, shutdown the node */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_PLOGI , + __efc_fabric_common, __func__)) { +return ; + } +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +void +__efc_p2p_wait_node_attach (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_NODE_ATTACH_OK : + node->attached = true; +switch (node->send_ls_acc) { +case EFC_NODE_SEND_LS_ACC_PRLI : { +efc_d_send_prli_rsp (node->ls_acc_io, + node->ls_acc_oxid); + node->send_ls_acc =EFC_NODE_SEND_LS_ACC_NONE ; + node->ls_acc_io =NULL ; +break ; + } +case EFC_NODE_SEND_LS_ACC_PLOGI :/* Can't happen in P2P */ +case EFC_NODE_SEND_LS_ACC_NONE : +default : +/* Normal case for I */ +/* sm: send_plogi_acc is not set / send PLOGI acc */ +efc_node_transition (node, __efc_d_port_logged_in, +NULL ); +break ; + } +break ; + +case EFC_EVT_NODE_ATTACH_FAIL : +/* node attach failed, shutdown the node */ + node->attached = false; +node_printf (node,"Node attach failed\n" ); + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_fabric_initiate_shutdown (node); +break ; + +case EFC_EVT_SHUTDOWN : +node_printf (node,"%s received\n" ,efc_sm_event_name (evt)); + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_node_transition (node, + __efc_fabric_wait_attach_evt_shutdown, +NULL ); +break ; +case EFC_EVT_PRLI_RCVD : +node_printf (node,"%s: PRLI received before node is attached\n" , +efc_sm_event_name (evt)); +efc_process_prli_payload (node, cbdata->payload->dma.virt); +efc_send_ls_acc_after_attach (node, + cbdata->header->dma.virt, +EFC_NODE_SEND_LS_ACC_PRLI ); +break ; + +default : +__efc_fabric_common (__func__, ctx, evt, arg); + } +} + +int +efc_p2p_setup (struct efc_nport *nport) +{ +struct efc *efc = nport->efc; +int rnode_winner; + + rnode_winner =efc_rnode_is_winner (nport); + +/* set nport flags to indicate p2p "winner" */ +if (rnode_winner ==1 ) { + nport->p2p_remote_port_id =0 ; + nport->p2p_port_id =0 ; + nport->p2p_winner = false; + }else if (rnode_winner ==0 ) { + nport->p2p_remote_port_id =2 ; + nport->p2p_port_id =1 ; + nport->p2p_winner = true; + }else { +/* no winner; only okay if external loopback enabled */ +if (nport->efc->external_loopback) { +/* +* External loopback mode enabled; +* local nport and remote node +* will be registered with an NPortID = 1; +*/ +efc_log_debug (efc, +"External loopback mode enabled\n" ); + nport->p2p_remote_port_id =1 ; + nport->p2p_port_id =1 ; + nport->p2p_winner = true; + }else { +efc_log_warn (efc, +"failed to determine p2p winner\n" ); +return rnode_winner; + } + } +return EFC_SUCCESS ; +}drivers/scsi/elx/libefc/efc_fabric.h new file +106
-0@@ -0,0 +1,116 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +/* +* Declarations for the interface exported by efc_fabric +*/ + +#ifndef __EFCT_FABRIC_H__ +#define __EFCT_FABRIC_H__ +#include "scsi/fc/fc_els.h" +#include "scsi/fc/fc_fs.h" +#include "scsi/fc/fc_ns.h" + +void +__efc_fabric_init (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_fabric_flogi_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_fabric_domain_attach_wait (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_fabric_wait_domain_attach (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); + +void +__efc_vport_fabric_init (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_fabric_fdisc_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_fabric_wait_nport_attach (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); + +void +__efc_ns_init (struct efc_sm_ctx *ctx,enum efc_sm_event evt,void *arg); +void +__efc_ns_plogi_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_ns_rftid_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_ns_rffid_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_ns_wait_node_attach (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_fabric_wait_attach_evt_shutdown (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_ns_logo_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event ,void *arg); +void +__efc_ns_gidpt_wait_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_ns_idle (struct efc_sm_ctx *ctx,enum efc_sm_event evt,void *arg); +void +__efc_ns_gidpt_delay (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_fabctl_init (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_fabctl_wait_node_attach (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_fabctl_wait_scr_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_fabctl_ready (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_fabctl_wait_ls_acc_cmpl (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_fabric_idle (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); + +void +__efc_p2p_rnode_init (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_p2p_domain_attach_wait (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_p2p_wait_flogi_acc_cmpl (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_p2p_wait_plogi_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_p2p_wait_plogi_rsp_recvd_prli (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_p2p_wait_domain_attach (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg); +void +__efc_p2p_wait_node_attach(struct efc_sm_ctx *ctx,
drivers/scsi/elx/libefc/efc_fabric.h line 116
Quoted 10 lines
drivers/scsi/elx/libefc/efc_fabric.h new file +10
-0+ enum efc_sm_event evt, void *arg); + +int +efc_p2p_setup (struct efc_nport *nport); +void +efc_fabric_set_topology (struct efc_node *node, +enum efc_nport_topology topology); +void efc_fabric_notify_topology (struct efc_node *node); + +#endif /* __EFCT_FABRIC_H__ */
Other than that:
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
PATCH v4 14/31 elx: libefc: FC node ELS and state handling
In reply to James SmartThis patch continues the libefc library population.
This patch adds library interface definitions for:
- FC node PRLI handling and state management
---
v4:
Replace fall through comment with fallthrough statement.
--- drivers/scsi/elx/libefc/efc_device.c | 1600 ++++++++++++++++++++++++++ drivers/scsi/elx/libefc/efc_device.h | 72 ++ 2 files changed, 1672 insertions(+) create mode 100644 drivers/scsi/elx/libefc/efc_device.c create mode 100644 drivers/scsi/elx/libefc/efc_device.h
drivers/scsi/elx/libefc/efc_device.c new file +1600 -0
@@ -0,0 +1,1600 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +/* +* device_sm Node State Machine: Remote Device States +*/ + +#include "efc.h" +#include "efc_device.h" +#include "efc_fabric.h" + +void +efc_d_send_prli_rsp (struct efc_node *node,uint16_t ox_id) +{ +u32 rc =EFC_SCSI_CALL_COMPLETE ; +struct efc *efc = node->efc; + + node->ls_acc_oxid = ox_id; + node->send_ls_acc =EFC_NODE_SEND_LS_ACC_PRLI ; + +/* +* Wait for backend session registration +* to complete before sending PRLI resp +*/ + +if (node->init) { +efc_log_info (efc,"[%s] found(initiator) WWPN:%s WWNN:%s\n" , + node->display_name, node->wwpn, node->wwnn); +if (node->nport->enable_tgt) + rc = efc->tt.scsi_new_node (efc, node); + } + +if (rc ==EFC_SCSI_CALL_COMPLETE ) +efc_node_post_event (node,EFC_EVT_NODE_SESS_REG_OK ,NULL ); +} + +static void +__efc_d_common (const char *funcname,struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node =NULL ; +struct efc *efc =NULL ; + + node = ctx->app; + efc = node->efc; + +switch (evt) { +/* Handle shutdown events */ +case EFC_EVT_SHUTDOWN : +efc_log_debug (efc,"[%s] %-20s %-20s\n" , node->display_name, + funcname,efc_sm_event_name (evt)); + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_node_transition (node, __efc_d_initiate_shutdown,NULL ); +break ; +case EFC_EVT_SHUTDOWN_EXPLICIT_LOGO : +efc_log_debug (efc,"[%s] %-20s %-20s\n" , + node->display_name, funcname, +efc_sm_event_name (evt)); + node->shutdown_reason =EFC_NODE_SHUTDOWN_EXPLICIT_LOGO ; +efc_node_transition (node, __efc_d_initiate_shutdown,NULL ); +break ; +case EFC_EVT_SHUTDOWN_IMPLICIT_LOGO : +efc_log_debug (efc,"[%s] %-20s %-20s\n" , node->display_name, + funcname,efc_sm_event_name (evt)); + node->shutdown_reason =EFC_NODE_SHUTDOWN_IMPLICIT_LOGO ; +efc_node_transition (node, __efc_d_initiate_shutdown,NULL ); +break ; + +default : +/* call default event handler common to all nodes */ +__efc_node_common (funcname, ctx, evt, arg); + } +} + +static void +__efc_d_wait_del_node (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +/* +* State is entered when a node sends a delete initiator/target call +* to the target-server/initiator-client and needs to wait for that +* work to complete. +*/ +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); + fallthrough; + +case EFC_EVT_NODE_ACTIVE_IO_LIST_EMPTY : +case EFC_EVT_ALL_CHILD_NODES_FREE : +/* These are expected events. */ +break ; + +case EFC_EVT_NODE_DEL_INI_COMPLETE : +case EFC_EVT_NODE_DEL_TGT_COMPLETE : +/* +* node has either been detached or is in the process +* of being detached, +* call common node's initiate cleanup function +*/ +efc_node_initiate_cleanup (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_SRRS_ELS_REQ_FAIL : +/* Can happen as ELS IO IO's complete */ +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +break ; + +/* ignore shutdown events as we're already in shutdown path */ +case EFC_EVT_SHUTDOWN : +/* have default shutdown event take precedence */ + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; + fallthrough; + +case EFC_EVT_SHUTDOWN_EXPLICIT_LOGO : +case EFC_EVT_SHUTDOWN_IMPLICIT_LOGO : +node_printf (node,"%s received\n" ,efc_sm_event_name (evt)); +break ; +case EFC_EVT_DOMAIN_ATTACH_OK : +/* don't care about domain_attach_ok */ +break ; +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +static void +__efc_d_wait_del_ini_tgt (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); + fallthrough; + +case EFC_EVT_NODE_ACTIVE_IO_LIST_EMPTY : +case EFC_EVT_ALL_CHILD_NODES_FREE : +/* These are expected events. */ +break ; + +case EFC_EVT_NODE_DEL_INI_COMPLETE : +case EFC_EVT_NODE_DEL_TGT_COMPLETE : +efc_node_transition (node, __efc_d_wait_del_node,NULL ); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_SRRS_ELS_REQ_FAIL : +/* Can happen as ELS IO IO's complete */ +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +break ; + +/* ignore shutdown events as we're already in shutdown path */ +case EFC_EVT_SHUTDOWN : +/* have default shutdown event take precedence */ + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; + fallthrough; + +case EFC_EVT_SHUTDOWN_EXPLICIT_LOGO : +case EFC_EVT_SHUTDOWN_IMPLICIT_LOGO : +node_printf (node,"%s received\n" ,efc_sm_event_name (evt)); +break ; +case EFC_EVT_DOMAIN_ATTACH_OK : +/* don't care about domain_attach_ok */ +break ; +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +__efc_d_initiate_shutdown (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; +struct efc *efc = node->efc; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : { +/* assume no wait needed */ +int rc =EFC_SCSI_CALL_COMPLETE ; + +efc_io_alloc_disable (node); + +/* make necessary delete upcall(s) */ +if (node->init && !node->targ) { +efc_log_info (node->efc, +"[%s] delete (initiator) WWPN %s WWNN %s\n" , + node->display_name, + node->wwpn, node->wwnn); +efc_node_transition (node, + __efc_d_wait_del_node, +NULL ); +if (node->nport->enable_tgt) + rc = efc->tt.scsi_del_node (efc, node, +EFC_SCSI_INITIATOR_DELETED ); + +if (rc ==EFC_SCSI_CALL_COMPLETE ) +efc_node_post_event (node, +EFC_EVT_NODE_DEL_INI_COMPLETE ,NULL ); + + }else if (node->targ && !node->init) { +efc_log_info (node->efc, +"[%s] delete (target) WWPN %s WWNN %s\n" , + node->display_name, + node->wwpn, node->wwnn); +efc_node_transition (node, + __efc_d_wait_del_node, +NULL ); +if (node->nport->enable_ini) + rc = efc->tt.scsi_del_node (efc, node, +EFC_SCSI_TARGET_DELETED ); + +if (rc ==EFC_SCSI_CALL_COMPLETE ) +efc_node_post_event (node, +EFC_EVT_NODE_DEL_TGT_COMPLETE ,NULL ); + + }else if (node->init && node->targ) { +efc_log_info (node->efc, +"[%s] delete (I+T) WWPN %s WWNN %s\n" , + node->display_name, node->wwpn, node->wwnn); +efc_node_transition (node, __efc_d_wait_del_ini_tgt, +NULL ); +if (node->nport->enable_tgt) + rc = efc->tt.scsi_del_node (efc, node, +EFC_SCSI_INITIATOR_DELETED ); + +if (rc ==EFC_SCSI_CALL_COMPLETE ) +efc_node_post_event (node, +EFC_EVT_NODE_DEL_INI_COMPLETE ,NULL ); +/* assume no wait needed */ + rc =EFC_SCSI_CALL_COMPLETE ; +if (node->nport->enable_ini) + rc = efc->tt.scsi_del_node (efc, node, +EFC_SCSI_TARGET_DELETED ); + +if (rc ==EFC_SCSI_CALL_COMPLETE ) +efc_node_post_event (node, +EFC_EVT_NODE_DEL_TGT_COMPLETE ,NULL ); + } + +/* we've initiated the upcalls as needed, now kick off the node +* detach to precipitate the aborting of outstanding exchanges +* associated with said node +* +* Beware: if we've made upcall(s), we've already transitioned +* to a new state by the time we execute this. +* consider doing this before the upcalls? +*/ +if (node->attached) { +/* issue hw node free; don't care if succeeds right +* away or sometime later, will check node->attached +* later in shutdown process +*/ + rc =efc_cmd_node_detach (efc, &node->rnode); +if (rc !=EFC_HW_RTN_SUCCESS && + rc !=EFC_HW_RTN_SUCCESS_SYNC ) +node_printf (node, +"Failed freeing HW node, rc=%d\n" , + rc); + } + +/* if neither initiator nor target, proceed to cleanup */ +if (!node->init && !node->targ) { +/* +* node has either been detached or is in +* the process of being detached, +* call common node's initiate cleanup function +*/ +efc_node_initiate_cleanup (node); + } +break ; + } +case EFC_EVT_ALL_CHILD_NODES_FREE : +/* Ignore, this can happen if an ELS is +* aborted while in a delay/retry state +*/ +break ; +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +__efc_d_wait_loop (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_DOMAIN_ATTACH_OK : { +/* send PLOGI automatically if initiator */ +efc_node_init_device (node, true); +break ; + } +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +efc_send_ls_acc_after_attach (struct efc_node *node, +struct fc_frame_header *hdr, +enum efc_node_send_ls_acc ls) +{ +u16 ox_id =be16_to_cpu (hdr->fh_ox_id); + +/* Save the OX_ID for sending LS_ACC sometime later */ +WARN_ON (node->send_ls_acc !=EFC_NODE_SEND_LS_ACC_NONE ); + + node->ls_acc_oxid = ox_id; + node->send_ls_acc = ls; + node->ls_acc_did =ntoh24 (hdr->fh_d_id); +} + +void +efc_process_prli_payload (struct efc_node *node,void *prli) +{ +struct { +struct fc_els_prli prli; +struct fc_els_spp sp; + } *pp; + + pp = prli; + node->init = (pp->sp.spp_flags &FCP_SPPF_INIT_FCN ) !=0 ; + node->targ = (pp->sp.spp_flags &FCP_SPPF_TARG_FCN ) !=0 ; +} + +void +__efc_d_wait_plogi_acc_cmpl (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_SRRS_ELS_CMPL_FAIL : +WARN_ON (!node->els_cmpl_cnt); + node->els_cmpl_cnt--; + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_node_transition (node, __efc_d_initiate_shutdown,NULL ); +break ; + +case EFC_EVT_SRRS_ELS_CMPL_OK :/* PLOGI ACC completions */ +WARN_ON (!node->els_cmpl_cnt); + node->els_cmpl_cnt--; +efc_node_transition (node, __efc_d_port_logged_in,NULL ); +break ; + +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +__efc_d_wait_logo_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_SRRS_ELS_REQ_OK : +case EFC_EVT_SRRS_ELS_REQ_RJT : +case EFC_EVT_SRRS_ELS_REQ_FAIL : +/* LOGO response received, sent shutdown */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_LOGO , + __efc_d_common, __func__)) +return ; + +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +node_printf (node, +"LOGO sent (evt=%s), shutdown node\n" , +efc_sm_event_name (evt)); +/* sm: / post explicit logout */ +efc_node_post_event (node,EFC_EVT_SHUTDOWN_EXPLICIT_LOGO , +NULL ); +break ; + +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +efc_node_init_device (struct efc_node *node,bool send_plogi) +{ + node->send_plogi = send_plogi; +if ((node->efc->nodedb_mask &EFC_NODEDB_PAUSE_NEW_NODES ) && + (node->rnode.fc_id !=FC_FID_DOM_MGR )) { + node->nodedb_state = __efc_d_init; +efc_node_transition (node, __efc_node_paused,NULL ); + }else { +efc_node_transition (node, __efc_d_init,NULL ); + } +} + +static void +efc_d_check_plogi_topology (struct efc_node *node,u32 d_id) +{ +switch (node->nport->topology) { +case EFC_SPORT_TOPOLOGY_P2P : +/* we're not attached and nport is p2p, +* need to attach +*/ +efc_domain_attach (node->nport->domain, d_id); +efc_node_transition (node, __efc_d_wait_domain_attach,NULL ); +break ; +case EFC_SPORT_TOPOLOGY_FABRIC : +/* we're not attached and nport is fabric, domain +* attach should have already been requested as part +* of the fabric state machine, wait for it +*/ +efc_node_transition (node, __efc_d_wait_domain_attach,NULL ); +break ; +case EFC_SPORT_TOPOLOGY_UNKNOWN : +/* Two possibilities: +* 1. received a PLOGI before our FLOGI has completed +* (possible since completion comes in on another +* CQ), thus we don't know what we're connected to +* yet; transition to a state to wait for the +* fabric node to tell us; +* 2. PLOGI received before link went down and we +* haven't performed domain attach yet. +* Note: we cannot distinguish between 1. and 2. +* so have to assume PLOGI +* was received after link back up. +*/ +node_printf (node,"received PLOGI, unknown topology did=0x%x\n" , + d_id); +efc_node_transition (node, __efc_d_wait_topology_notify,NULL ); +break ; +default : +node_printf (node,"received PLOGI, unexpected topology %d\n" , + node->nport->topology); + } +} + +void +__efc_d_init (struct efc_sm_ctx *ctx,enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +/* +* This state is entered when a node is instantiated, +* either having been discovered from a name services query, +* or having received a PLOGI/FLOGI. +*/ +switch (evt) { +case EFC_EVT_ENTER : +if (!node->send_plogi) +break ; +/* only send if we have initiator capability, +* and domain is attached +*/ +if (node->nport->enable_ini && + node->nport->domain->attached) { +efc_send_plogi (node); + +efc_node_transition (node, __efc_d_wait_plogi_rsp,NULL ); + }else { +node_printf (node,"not sending plogi nport.ini=%d," , + node->nport->enable_ini); +node_printf (node,"domain attached=%d\n" , + node->nport->domain->attached); + } +break ; +case EFC_EVT_PLOGI_RCVD : { +/* T, or I+T */ +struct fc_frame_header *hdr = cbdata->header->dma.virt; +int rc; + +efc_node_save_sparms (node, cbdata->payload->dma.virt); +efc_send_ls_acc_after_attach (node, + cbdata->header->dma.virt, +EFC_NODE_SEND_LS_ACC_PLOGI ); + +/* domain not attached; several possibilities: */ +if (!node->nport->domain->attached) { +efc_d_check_plogi_topology (node,ntoh24 (hdr->fh_d_id)); +break ; + } + +/* domain already attached */ + rc =efc_node_attach (node); +efc_node_transition (node, __efc_d_wait_node_attach,NULL ); +if (rc ==EFC_HW_RTN_SUCCESS_SYNC ) +efc_node_post_event (node,EFC_EVT_NODE_ATTACH_OK ,NULL ); + +break ; + } + +case EFC_EVT_FDISC_RCVD : { +__efc_d_common (__func__, ctx, evt, arg); +break ; + } + +case EFC_EVT_FLOGI_RCVD : { +struct fc_frame_header *hdr = cbdata->header->dma.virt; +u32 d_id =ntoh24 (hdr->fh_d_id); + +/* sm: / save sparams, send FLOGI acc */ +memcpy (node->nport->domain->flogi_service_params, + cbdata->payload->dma.virt, +sizeof (struct fc_els_flogi )); + +/* send FC LS_ACC response, override s_id */ +efc_fabric_set_topology (node,EFC_SPORT_TOPOLOGY_P2P ); + +efc_send_flogi_p2p_acc (node,be16_to_cpu (hdr->fh_ox_id), d_id); + +if (efc_p2p_setup (node->nport)) { +node_printf (node,"p2p failed, shutting down node\n" ); +efc_node_post_event (node,EFC_EVT_SHUTDOWN ,NULL ); +break ; + } + +efc_node_transition (node, __efc_p2p_wait_flogi_acc_cmpl,NULL ); +break ; + } + +case EFC_EVT_LOGO_RCVD : { +struct fc_frame_header *hdr = cbdata->header->dma.virt; + +if (!node->nport->domain->attached) { +/* most likely a frame left over from before a link +* down; drop and +* shut node down w/ "explicit logout" so pending +* frames are processed +*/ +node_printf (node,"%s domain not attached, dropping\n" , +efc_sm_event_name (evt)); +efc_node_post_event (node, +EFC_EVT_SHUTDOWN_EXPLICIT_LOGO ,NULL ); +break ; + } + +efc_send_logo_acc (node,be16_to_cpu (hdr->fh_ox_id)); +efc_node_transition (node, __efc_d_wait_logo_acc_cmpl,NULL ); +break ; + } + +case EFC_EVT_PRLI_RCVD : +case EFC_EVT_PRLO_RCVD : +case EFC_EVT_PDISC_RCVD : +case EFC_EVT_ADISC_RCVD : +case EFC_EVT_RSCN_RCVD : { +struct fc_frame_header *hdr = cbdata->header->dma.virt; + +if (!node->nport->domain->attached) { +/* most likely a frame left over from before a link +* down; drop and shut node down w/ "explicit logout" +* so pending frames are processed +*/ +node_printf (node,"%s domain not attached, dropping\n" , +efc_sm_event_name (evt)); + +efc_node_post_event (node, +EFC_EVT_SHUTDOWN_EXPLICIT_LOGO , +NULL ); +break ; + } +node_printf (node,"%s received, sending reject\n" , +efc_sm_event_name (evt)); + +efc_send_ls_rjt (node,be16_to_cpu (hdr->fh_ox_id), +ELS_RJT_UNAB ,ELS_EXPL_PLOGI_REQD ,0 ); + +break ; + } + +case EFC_EVT_FCP_CMD_RCVD : { +/* note: problem, we're now expecting an ELS REQ completion +* from both the LOGO and PLOGI +*/ +if (!node->nport->domain->attached) { +/* most likely a frame left over from before a +* link down; drop and +* shut node down w/ "explicit logout" so pending +* frames are processed +*/ +node_printf (node,"%s domain not attached, dropping\n" , +efc_sm_event_name (evt)); +efc_node_post_event (node, +EFC_EVT_SHUTDOWN_EXPLICIT_LOGO , +NULL ); +break ; + } + +/* Send LOGO */ +node_printf (node,"FCP_CMND received, send LOGO\n" ); +if (efc_send_logo (node)) { +/* +* failed to send LOGO, go ahead and cleanup node +* anyways +*/ +node_printf (node,"Failed to send LOGO\n" ); +efc_node_post_event (node, +EFC_EVT_SHUTDOWN_EXPLICIT_LOGO , +NULL ); + }else { +/* sent LOGO, wait for response */ +efc_node_transition (node, + __efc_d_wait_logo_rsp,NULL ); + } +break ; + } +case EFC_EVT_DOMAIN_ATTACH_OK : +/* don't care about domain_attach_ok */ +break ; + +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +__efc_d_wait_plogi_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +int rc; +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_PLOGI_RCVD : { +/* T, or I+T */ +/* received PLOGI with svc parms, go ahead and attach node +* when PLOGI that was sent ultimately completes, it'll be a +* no-op +* +* If there is an outstanding PLOGI sent, can we set a flag +* to indicate that we don't want to retry it if it times out? +*/ +efc_node_save_sparms (node, cbdata->payload->dma.virt); +efc_send_ls_acc_after_attach (node, + cbdata->header->dma.virt, +EFC_NODE_SEND_LS_ACC_PLOGI ); +/* sm: domain->attached / efc_node_attach */ + rc =efc_node_attach (node); +efc_node_transition (node, __efc_d_wait_node_attach,NULL ); +if (rc ==EFC_HW_RTN_SUCCESS_SYNC ) +efc_node_post_event (node, +EFC_EVT_NODE_ATTACH_OK ,NULL ); + +break ; + } + +case EFC_EVT_PRLI_RCVD : +/* I, or I+T */ +/* sent PLOGI and before completion was seen, received the +* PRLI from the remote node (WCQEs and RCQEs come in on +* different queues and order of processing cannot be assumed) +* Save OXID so PRLI can be sent after the attach and continue +* to wait for PLOGI response +*/ +efc_process_prli_payload (node, cbdata->payload->dma.virt); +efc_send_ls_acc_after_attach (node, + cbdata->header->dma.virt, +EFC_NODE_SEND_LS_ACC_PRLI ); +efc_node_transition (node, __efc_d_wait_plogi_rsp_recvd_prli, +NULL ); +break ; + +case EFC_EVT_LOGO_RCVD :/* why don't we do a shutdown here?? */ +case EFC_EVT_PRLO_RCVD : +case EFC_EVT_PDISC_RCVD : +case EFC_EVT_FDISC_RCVD : +case EFC_EVT_ADISC_RCVD : +case EFC_EVT_RSCN_RCVD : +case EFC_EVT_SCR_RCVD : { +struct fc_frame_header *hdr = cbdata->header->dma.virt; + +node_printf (node,"%s received, sending reject\n" , +efc_sm_event_name (evt)); + +efc_send_ls_rjt (node,be16_to_cpu (hdr->fh_ox_id), +ELS_RJT_UNAB ,ELS_EXPL_PLOGI_REQD ,0 ); + +break ; + } + +case EFC_EVT_SRRS_ELS_REQ_OK :/* PLOGI response received */ +/* Completion from PLOGI sent */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_PLOGI , + __efc_d_common, __func__)) +return ; + +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / save sparams, efc_node_attach */ +efc_node_save_sparms (node, cbdata->els_rsp.virt); + rc =efc_node_attach (node); +efc_node_transition (node, __efc_d_wait_node_attach,NULL ); +if (rc ==EFC_HW_RTN_SUCCESS_SYNC ) +efc_node_post_event (node, +EFC_EVT_NODE_ATTACH_OK ,NULL ); + +break ; + +case EFC_EVT_SRRS_ELS_REQ_FAIL :/* PLOGI response received */ +/* PLOGI failed, shutdown the node */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_PLOGI , + __efc_d_common, __func__)) +return ; + +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +efc_node_post_event (node,EFC_EVT_SHUTDOWN ,NULL ); +break ; + +case EFC_EVT_SRRS_ELS_REQ_RJT : +/* Our PLOGI was rejected, this is ok in some cases */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_PLOGI , + __efc_d_common, __func__)) +return ; + +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +break ; + +case EFC_EVT_FCP_CMD_RCVD : { +/* not logged in yet and outstanding PLOGI so don't send LOGO, +* just drop +*/ +node_printf (node,"FCP_CMND received, drop\n" ); +break ; + } + +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +__efc_d_wait_plogi_rsp_recvd_prli (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +int rc; +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +/* +* Since we've received a PRLI, we have a port login and will +* just need to wait for the PLOGI response to do the node +* attach and then we can send the LS_ACC for the PRLI. If, +* during this time, we receive FCP_CMNDs (which is possible +* since we've already sent a PRLI and our peer may have +* accepted). At this time, we are not waiting on any other +* unsolicited frames to continue with the login process. Thus, +* it will not hurt to hold frames here. +*/ +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_SRRS_ELS_REQ_OK :/* PLOGI response received */ +/* Completion from PLOGI sent */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_PLOGI , + __efc_d_common, __func__)) +return ; + +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / save sparams, efc_node_attach */ +efc_node_save_sparms (node, cbdata->els_rsp.virt); + rc =efc_node_attach (node); +efc_node_transition (node, __efc_d_wait_node_attach,NULL ); +if (rc ==EFC_HW_RTN_SUCCESS_SYNC ) +efc_node_post_event (node,EFC_EVT_NODE_ATTACH_OK , +NULL ); + +break ; + +case EFC_EVT_SRRS_ELS_REQ_FAIL :/* PLOGI response received */ +case EFC_EVT_SRRS_ELS_REQ_RJT : +/* PLOGI failed, shutdown the node */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_PLOGI , + __efc_d_common, __func__)) +return ; + +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +efc_node_post_event (node,EFC_EVT_SHUTDOWN ,NULL ); +break ; + +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +__efc_d_wait_domain_attach (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +int rc; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_DOMAIN_ATTACH_OK : +WARN_ON (!node->nport->domain->attached); +/* sm: / efc_node_attach */ + rc =efc_node_attach (node); +efc_node_transition (node, __efc_d_wait_node_attach,NULL ); +if (rc ==EFC_HW_RTN_SUCCESS_SYNC ) +efc_node_post_event (node,EFC_EVT_NODE_ATTACH_OK , +NULL ); + +break ; + +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +__efc_d_wait_topology_notify (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +int rc; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_SPORT_TOPOLOGY_NOTIFY : { +enum efc_nport_topology topology = + (enum efc_nport_topology )arg; + +WARN_ON (node->nport->domain->attached); + +WARN_ON (node->send_ls_acc !=EFC_NODE_SEND_LS_ACC_PLOGI ); + +node_printf (node,"topology notification, topology=%d\n" , + topology); + +/* At the time the PLOGI was received, the topology was unknown, +* so we didn't know which node would perform the domain attach: +* 1. The node from which the PLOGI was sent (p2p) or +* 2. The node to which the FLOGI was sent (fabric). +*/ +if (topology ==EFC_SPORT_TOPOLOGY_P2P ) { +/* if this is p2p, need to attach to the domain using +* the d_id from the PLOGI received +*/ +efc_domain_attach (node->nport->domain, + node->ls_acc_did); + } +/* else, if this is fabric, the domain attach +* should be performed by the fabric node (node sending FLOGI); +* just wait for attach to complete +*/ + +efc_node_transition (node, __efc_d_wait_domain_attach,NULL ); +break ; + } +case EFC_EVT_DOMAIN_ATTACH_OK : +WARN_ON (!node->nport->domain->attached); +node_printf (node,"domain attach ok\n" ); +/* sm: / efc_node_attach */ + rc =efc_node_attach (node); +efc_node_transition (node, __efc_d_wait_node_attach,NULL ); +if (rc ==EFC_HW_RTN_SUCCESS_SYNC ) +efc_node_post_event (node, +EFC_EVT_NODE_ATTACH_OK ,NULL ); + +break ; + +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +__efc_d_wait_node_attach (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_NODE_ATTACH_OK : + node->attached = true; +switch (node->send_ls_acc) { +case EFC_NODE_SEND_LS_ACC_PLOGI : { +/* sm: send_plogi_acc is set / send PLOGI acc */ +/* Normal case for T, or I+T */ +efc_send_plogi_acc (node, node->ls_acc_oxid); +efc_node_transition (node, __efc_d_wait_plogi_acc_cmpl, +NULL ); + node->send_ls_acc =EFC_NODE_SEND_LS_ACC_NONE ; + node->ls_acc_io =NULL ; +break ; + } +case EFC_NODE_SEND_LS_ACC_PRLI : { +efc_d_send_prli_rsp (node, node->ls_acc_oxid); + node->send_ls_acc =EFC_NODE_SEND_LS_ACC_NONE ; + node->ls_acc_io =NULL ; +break ; + } +case EFC_NODE_SEND_LS_ACC_NONE : +default : +/* Normal case for I */ +/* sm: send_plogi_acc is not set / send PLOGI acc */ +efc_node_transition (node, + __efc_d_port_logged_in,NULL ); +break ; + } +break ; + +case EFC_EVT_NODE_ATTACH_FAIL : +/* node attach failed, shutdown the node */ + node->attached = false; +node_printf (node,"node attach failed\n" ); + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_node_transition (node, __efc_d_initiate_shutdown,NULL ); +break ; + +/* Handle shutdown events */ +case EFC_EVT_SHUTDOWN : +node_printf (node,"%s received\n" ,efc_sm_event_name (evt)); + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; +efc_node_transition (node, __efc_d_wait_attach_evt_shutdown, +NULL ); +break ; +case EFC_EVT_SHUTDOWN_EXPLICIT_LOGO : +node_printf (node,"%s received\n" ,efc_sm_event_name (evt)); + node->shutdown_reason =EFC_NODE_SHUTDOWN_EXPLICIT_LOGO ; +efc_node_transition (node, __efc_d_wait_attach_evt_shutdown, +NULL ); +break ; +case EFC_EVT_SHUTDOWN_IMPLICIT_LOGO : +node_printf (node,"%s received\n" ,efc_sm_event_name (evt)); + node->shutdown_reason =EFC_NODE_SHUTDOWN_IMPLICIT_LOGO ; +efc_node_transition (node, + __efc_d_wait_attach_evt_shutdown,NULL ); +break ; +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +__efc_d_wait_attach_evt_shutdown (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +/* wait for any of these attach events and then shutdown */ +case EFC_EVT_NODE_ATTACH_OK : + node->attached = true; +node_printf (node,"Attach evt=%s, proceed to shutdown\n" , +efc_sm_event_name (evt)); +efc_node_transition (node, __efc_d_initiate_shutdown,NULL ); +break ; + +case EFC_EVT_NODE_ATTACH_FAIL : +/* node attach failed, shutdown the node */ + node->attached = false; +node_printf (node,"Attach evt=%s, proceed to shutdown\n" , +efc_sm_event_name (evt)); +efc_node_transition (node, __efc_d_initiate_shutdown,NULL ); +break ; + +/* ignore shutdown events as we're already in shutdown path */ +case EFC_EVT_SHUTDOWN : +/* have default shutdown event take precedence */ + node->shutdown_reason =EFC_NODE_SHUTDOWN_DEFAULT ; + fallthrough; + +case EFC_EVT_SHUTDOWN_EXPLICIT_LOGO : +case EFC_EVT_SHUTDOWN_IMPLICIT_LOGO : +node_printf (node,"%s received\n" ,efc_sm_event_name (evt)); +break ; + +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +__efc_d_port_logged_in (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +/* Normal case for I or I+T */ +if (node->nport->enable_ini && + !(node->rnode.fc_id !=FC_FID_DOM_MGR )) { +/* sm: if enable_ini / send PRLI */ +efc_send_prli (node); +/* can now expect ELS_REQ_OK/FAIL/RJT */ + } +break ; + +case EFC_EVT_FCP_CMD_RCVD : { +break ; + } + +case EFC_EVT_PRLI_RCVD : { +/* Normal case for T or I+T */ +struct fc_frame_header *hdr = cbdata->header->dma.virt; +struct { +struct fc_els_prli prli; +struct fc_els_spp sp; + } *pp; + + pp = cbdata->payload->dma.virt; +if (pp->sp.spp_type !=FC_TYPE_FCP ) { +/*Only FCP is supported*/ +efc_send_ls_rjt (node,be16_to_cpu (hdr->fh_ox_id), +ELS_RJT_UNAB ,ELS_EXPL_UNSUPR ,0 ); +break ; + } + +efc_process_prli_payload (node, cbdata->payload->dma.virt); +efc_d_send_prli_rsp (node,be16_to_cpu (hdr->fh_ox_id)); +break ; + } + +case EFC_EVT_NODE_SESS_REG_OK : +if (node->send_ls_acc ==EFC_NODE_SEND_LS_ACC_PRLI ) +efc_send_prli_acc (node, node->ls_acc_oxid); + + node->send_ls_acc =EFC_NODE_SEND_LS_ACC_NONE ; +efc_node_transition (node, __efc_d_device_ready,NULL ); +break ; + +case EFC_EVT_NODE_SESS_REG_FAIL : +efc_send_ls_rjt (node, node->ls_acc_oxid,ELS_RJT_UNAB , +ELS_EXPL_UNSUPR ,0 ); + node->send_ls_acc =EFC_NODE_SEND_LS_ACC_NONE ; +break ; + +case EFC_EVT_SRRS_ELS_REQ_OK : {/* PRLI response */ +/* Normal case for I or I+T */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_PRLI , + __efc_d_common, __func__)) +return ; + +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / process PRLI payload */ +efc_process_prli_payload (node, cbdata->els_rsp.virt); +efc_node_transition (node, __efc_d_device_ready,NULL ); +break ; + } + +case EFC_EVT_SRRS_ELS_REQ_FAIL : {/* PRLI response failed */ +/* I, I+T, assume some link failure, shutdown node */ +if (efc_node_check_els_req (ctx, evt, arg,ELS_PRLI , + __efc_d_common, __func__)) +return ; + +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +efc_node_post_event (node,EFC_EVT_SHUTDOWN ,NULL ); +break ; + } + +case EFC_EVT_SRRS_ELS_REQ_RJT : { +/* PRLI rejected by remote +* Normal for I, I+T (connected to an I) +* Node doesn't want to be a target, stay here and wait for a +* PRLI from the remote node +* if it really wants to connect to us as target +*/ +if (efc_node_check_els_req (ctx, evt, arg,ELS_PRLI , + __efc_d_common, __func__)) +return ; + +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +break ; + } + +case EFC_EVT_SRRS_ELS_CMPL_OK : { +/* Normal T, I+T, target-server rejected the process login */ +/* This would be received only in the case where we sent +* LS_RJT for the PRLI, so +* do nothing. (note: as T only we could shutdown the node) +*/ +WARN_ON (!node->els_cmpl_cnt); + node->els_cmpl_cnt--; +break ; + } + +case EFC_EVT_PLOGI_RCVD : { +/*sm: / save sparams, set send_plogi_acc, +*post implicit logout +* Save plogi parameters +*/ +efc_node_save_sparms (node, cbdata->payload->dma.virt); +efc_send_ls_acc_after_attach (node, + cbdata->header->dma.virt, +EFC_NODE_SEND_LS_ACC_PLOGI ); + +/* Restart node attach with new service parameters, +* and send ACC +*/ +efc_node_post_event (node,EFC_EVT_SHUTDOWN_IMPLICIT_LOGO , +NULL ); +break ; + } + +case EFC_EVT_LOGO_RCVD : { +/* I, T, I+T */ +struct fc_frame_header *hdr = cbdata->header->dma.virt; + +node_printf (node,"%s received attached=%d\n" , +efc_sm_event_name (evt), + node->attached); +/* sm: / send LOGO acc */ +efc_send_logo_acc (node,be16_to_cpu (hdr->fh_ox_id)); +efc_node_transition (node, __efc_d_wait_logo_acc_cmpl,NULL ); +break ; + } + +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +__efc_d_wait_logo_acc_cmpl (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : +efc_node_hold_frames (node); +break ; + +case EFC_EVT_EXIT : +efc_node_accept_frames (node); +break ; + +case EFC_EVT_SRRS_ELS_CMPL_OK : +case EFC_EVT_SRRS_ELS_CMPL_FAIL : +/* sm: / post explicit logout */ +WARN_ON (!node->els_cmpl_cnt); + node->els_cmpl_cnt--; +efc_node_post_event (node, +EFC_EVT_SHUTDOWN_EXPLICIT_LOGO ,NULL ); +break ; +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +__efc_d_device_ready (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; +struct efc *efc = node->efc; + +efc_node_evt_set (ctx, evt, __func__); + +if (evt !=EFC_EVT_FCP_CMD_RCVD ) +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : + node->fcp_enabled = true; +if (node->targ) { +efc_log_info (efc, +"[%s] found (target) WWPN %s WWNN %s\n" , + node->display_name, + node->wwpn, node->wwnn); +if (node->nport->enable_ini) + efc->tt.scsi_new_node (efc, node); + } +break ; + +case EFC_EVT_EXIT : + node->fcp_enabled = false; +break ; + +case EFC_EVT_PLOGI_RCVD : { +/* sm: / save sparams, set send_plogi_acc, post implicit +* logout +* Save plogi parameters +*/ +efc_node_save_sparms (node, cbdata->payload->dma.virt); +efc_send_ls_acc_after_attach (node, + cbdata->header->dma.virt, +EFC_NODE_SEND_LS_ACC_PLOGI ); + +/* +* Restart node attach with new service parameters, +* and send ACC +*/ +efc_node_post_event (node, +EFC_EVT_SHUTDOWN_IMPLICIT_LOGO ,NULL ); +break ; + } + +case EFC_EVT_PRLI_RCVD : { +/* T, I+T: remote initiator is slow to get started */ +struct fc_frame_header *hdr = cbdata->header->dma.virt; +struct { +struct fc_els_prli prli; +struct fc_els_spp sp; + } *pp; + + pp = cbdata->payload->dma.virt; +if (pp->sp.spp_type !=FC_TYPE_FCP ) { +/*Only FCP is supported*/ +efc_send_ls_rjt (node,be16_to_cpu (hdr->fh_ox_id), +ELS_RJT_UNAB ,ELS_EXPL_UNSUPR ,0 ); +break ; + } + +efc_process_prli_payload (node, cbdata->payload->dma.virt); +efc_send_prli_acc (node,be16_to_cpu (hdr->fh_ox_id)); +break ; + } + +case EFC_EVT_PRLO_RCVD : { +struct fc_frame_header *hdr = cbdata->header->dma.virt; +/* sm: / send PRLO acc */ +efc_send_prlo_acc (node,be16_to_cpu (hdr->fh_ox_id)); +/* need implicit logout? */ +break ; + } + +case EFC_EVT_LOGO_RCVD : { +struct fc_frame_header *hdr = cbdata->header->dma.virt; + +node_printf (node,"%s received attached=%d\n" , +efc_sm_event_name (evt), node->attached); +/* sm: / send LOGO acc */ +efc_send_logo_acc (node,be16_to_cpu (hdr->fh_ox_id)); +efc_node_transition (node, __efc_d_wait_logo_acc_cmpl,NULL ); +break ; + } + +case EFC_EVT_ADISC_RCVD : { +struct fc_frame_header *hdr = cbdata->header->dma.virt; +/* sm: / send ADISC acc */ +efc_send_adisc_acc (node,be16_to_cpu (hdr->fh_ox_id)); +break ; + } + +case EFC_EVT_ABTS_RCVD : +/* sm: / process ABTS */ +efc_log_err (efc,"Unexpected event:%s\n" , +efc_sm_event_name (evt)); +break ; + +case EFC_EVT_NODE_ACTIVE_IO_LIST_EMPTY : +break ; + +case EFC_EVT_NODE_REFOUND : +break ; + +case EFC_EVT_NODE_MISSING : +if (node->nport->enable_rscn) +efc_node_transition (node, __efc_d_device_gone,NULL ); + +break ; + +case EFC_EVT_SRRS_ELS_CMPL_OK : +/* T, or I+T, PRLI accept completed ok */ +WARN_ON (!node->els_cmpl_cnt); + node->els_cmpl_cnt--; +break ; + +case EFC_EVT_SRRS_ELS_CMPL_FAIL : +/* T, or I+T, PRLI accept failed to complete */ +WARN_ON (!node->els_cmpl_cnt); + node->els_cmpl_cnt--; +node_printf (node,"Failed to send PRLI LS_ACC\n" ); +break ; + +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +__efc_d_device_gone (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; +struct efc *efc = node->efc; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_ENTER : { +int rc =EFC_SCSI_CALL_COMPLETE ; +int rc_2 =EFC_SCSI_CALL_COMPLETE ; +static char const *labels[] = {"none" ,"initiator" ,"target" , +"initiator+target" }; + +efc_log_info (efc,"[%s] missing (%s) WWPN %s WWNN %s\n" , + node->display_name, + labels[(node->targ <<1 ) | (node->init)], + node->wwpn, node->wwnn); + +switch (efc_node_get_enable (node)) { +case EFC_NODE_ENABLE_T_TO_T : +case EFC_NODE_ENABLE_I_TO_T : +case EFC_NODE_ENABLE_IT_TO_T : + rc = efc->tt.scsi_del_node (efc, node, +EFC_SCSI_TARGET_MISSING ); +break ; + +case EFC_NODE_ENABLE_T_TO_I : +case EFC_NODE_ENABLE_I_TO_I : +case EFC_NODE_ENABLE_IT_TO_I : + rc = efc->tt.scsi_del_node (efc, node, +EFC_SCSI_INITIATOR_MISSING ); +break ; + +case EFC_NODE_ENABLE_T_TO_IT : + rc = efc->tt.scsi_del_node (efc, node, +EFC_SCSI_INITIATOR_MISSING ); +break ; + +case EFC_NODE_ENABLE_I_TO_IT : + rc = efc->tt.scsi_del_node (efc, node, +EFC_SCSI_TARGET_MISSING ); +break ; + +case EFC_NODE_ENABLE_IT_TO_IT : + rc = efc->tt.scsi_del_node (efc, node, +EFC_SCSI_INITIATOR_MISSING ); + rc_2 = efc->tt.scsi_del_node (efc, node, +EFC_SCSI_TARGET_MISSING ); +break ; + +default : + rc =EFC_SCSI_CALL_COMPLETE ; +break ; + } + +if (rc ==EFC_SCSI_CALL_COMPLETE && + rc_2 ==EFC_SCSI_CALL_COMPLETE ) +efc_node_post_event (node,EFC_EVT_SHUTDOWN ,NULL ); + +break ; + } +case EFC_EVT_NODE_REFOUND : +/* two approaches, reauthenticate with PLOGI/PRLI, or ADISC */ + +/* reauthenticate with PLOGI/PRLI */ +/* efc_node_transition(node, __efc_d_discovered, NULL); */ + +/* reauthenticate with ADISC */ +/* sm: / send ADISC */ +efc_send_adisc (node); +efc_node_transition (node, __efc_d_wait_adisc_rsp,NULL ); +break ; + +case EFC_EVT_PLOGI_RCVD : { +/* sm: / save sparams, set send_plogi_acc, post implicit +* logout +* Save plogi parameters +*/ +efc_node_save_sparms (node, cbdata->payload->dma.virt); +efc_send_ls_acc_after_attach (node, + cbdata->header->dma.virt, +EFC_NODE_SEND_LS_ACC_PLOGI ); + +/* +* Restart node attach with new service parameters, and send +* ACC +*/ +efc_node_post_event (node,EFC_EVT_SHUTDOWN_IMPLICIT_LOGO , +NULL ); +break ; + } + +case EFC_EVT_FCP_CMD_RCVD : { +/* most likely a stale frame (received prior to link down), +* if attempt to send LOGO, will probably timeout and eat +* up 20s; thus, drop FCP_CMND +*/ +node_printf (node,"FCP_CMND received, drop\n" ); +break ; + } +case EFC_EVT_LOGO_RCVD : { +/* I, T, I+T */ +struct fc_frame_header *hdr = cbdata->header->dma.virt; + +node_printf (node,"%s received attached=%d\n" , +efc_sm_event_name (evt), node->attached); +/* sm: / send LOGO acc */ +efc_send_logo_acc (node,be16_to_cpu (hdr->fh_ox_id)); +efc_node_transition (node, __efc_d_wait_logo_acc_cmpl,NULL ); +break ; + } +default : +__efc_d_common (__func__, ctx, evt, arg); + } +} + +void +__efc_d_wait_adisc_rsp (struct efc_sm_ctx *ctx, +enum efc_sm_event evt,void *arg) +{ +struct efc_node_cb *cbdata = arg; +struct efc_node *node = ctx->app; + +efc_node_evt_set (ctx, evt, __func__); + +node_sm_trace (); + +switch (evt) { +case EFC_EVT_SRRS_ELS_REQ_OK : +if (efc_node_check_els_req (ctx, evt, arg,ELS_ADISC , + __efc_d_common, __func__)) +return ; + +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +efc_node_transition (node, __efc_d_device_ready,NULL ); +break ; + +case EFC_EVT_SRRS_ELS_REQ_RJT : +/* received an LS_RJT, in this case, send shutdown +* (explicit logo) event which will unregister the node, +* and start over with PLOGI +*/ +if (efc_node_check_els_req (ctx, evt, arg,ELS_ADISC , + __efc_d_common, __func__)) +return ; + +WARN_ON (!node->els_req_cnt); + node->els_req_cnt--; +/* sm: / post explicit logout */ +efc_node_post_event (node, +EFC_EVT_SHUTDOWN_EXPLICIT_LOGO , +NULL ); +break ; + +case EFC_EVT_LOGO_RCVD : { +/* In this case, we have the equivalent of an LS_RJT for +* the ADISC, so we need to abort the ADISC, and re-login +* with PLOGI +*/ +/* sm: / request abort, send LOGO acc */ +struct fc_frame_header *hdr = cbdata->header->dma.virt; + +node_printf (node,"%s received attached=%d\n" , +efc_sm_event_name (evt), node->attached); + +efc_send_logo_acc (node,be16_to_cpu (hdr->fh_ox_id)); +efc_node_transition (node, __efc_d_wait_logo_acc_cmpl,NULL ); +break ; + } +default : +__efc_d_common (__func__, ctx, evt, arg); + } +}
drivers/scsi/elx/libefc/efc_device.h new file +72 -0
72 lines not on this page · raw message
Signature · 1 line
2.26.2
Re: [PATCH v4 14/31] elx: libefc: FC node ELS and state handling
Quoted 12 lines · James Smart
This patch continues the libefc library population.
This patch adds library interface definitions for:
- FC node PRLI handling and state managementCo-developed-by Ram Vegesna <[email protected]>Signed-off-by Ram Vegesna <[email protected]>Signed-off-by James Smart <[email protected]>---
v4:
Replace fall through comment with fallthrough statement.
Quoted 7 lines
--- drivers/scsi/elx/libefc/efc_device.c | 1600 ++++++++++++++++++++++++++ drivers/scsi/elx/libefc/efc_device.h | 72 ++ 2 files changed, 1672 insertions(+)create mode 100644
drivers/scsi/elx/libefc/efc_device.ccreate mode 100644drivers/scsi/elx/libefc/efc_device.h
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
PATCH v4 15/31 elx: libefc: Extended link Service IO handling
In reply to James SmartThis patch continues the libefc library population.
This patch adds library interface definitions for:
Functions to build and send ELS/CT/BLS commands and responses.
---
v4:
New patch added ELS handling to libefc library.
New els_io_req for discovery io object.
--- drivers/scsi/elx/libefc/efc_els.c | 1152 +++++++++++++++++++++++++++++ drivers/scsi/elx/libefc/efc_els.h | 107 +++ 2 files changed, 1259 insertions(+) create mode 100644 drivers/scsi/elx/libefc/efc_els.c create mode 100644 drivers/scsi/elx/libefc/efc_els.h
drivers/scsi/elx/libefc/efc_els.c new file +1152 -0
@@ -0,0 +1,1152 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +/* +* Functions to build and send ELS/CT/BLS commands and responses. +*/ + +#include "efc.h" +#include "efc_els.h" +#include "../libefc_sli/sli4.h" + +#define EFC_LOG_ENABLE_ELS_TRACE (efc) \ + (((efc) != NULL) ? (((efc)->logmask & (1U << 1)) != 0) : 0) + +#define node_els_trace () \ + do { \ + if (EFC_LOG_ENABLE_ELS_TRACE(efc)) \ + efc_log_info(efc, "[%s] %-20s\n", \ + node->display_name, __func__); \ + } while (0) + +#define els_io_printf (els, fmt, ...) \ + efc_log_err((struct efc *)els->node->efc,\ + "[%s] %-8s " fmt, \ + els->node->display_name,\ + els->display_name, ##__VA_ARGS__) + +#define EFC_ELS_RSP_LEN 1024 +#define EFC_ELS_GID_PT_RSP_LEN 8096 + +void +efc_io_alloc_enable (struct efc_node *node) +{ +unsigned long flags =0 ; + +spin_lock_irqsave (&node->els_ios_lock, flags); + node->els_io_enabled = true; +spin_unlock_irqrestore (&node->els_ios_lock, flags); +} + +void +efc_io_alloc_disable (struct efc_node *node) +{ +unsigned long flags =0 ; + +spin_lock_irqsave (&node->els_ios_lock, flags); + node->els_io_enabled = false; +spin_unlock_irqrestore (&node->els_ios_lock, flags); +} + +struct efc_els_io_req * +efc_els_io_alloc (struct efc_node *node,u32 reqlen) +{ +return efc_els_io_alloc_size (node, reqlen,EFC_ELS_RSP_LEN ); +} + +struct efc_els_io_req * +efc_els_io_alloc_size (struct efc_node *node,u32 reqlen,u32 rsplen) +{ +struct efc *efc; +struct efc_els_io_req *els; +unsigned long flags =0 ; + + efc = node->efc; + +spin_lock_irqsave (&node->els_ios_lock, flags); + +if (!node->els_io_enabled) { +efc_log_err (efc,"els io alloc disabled\n" ); +spin_unlock_irqrestore (&node->els_ios_lock, flags); +return NULL ; + } + + els =kzalloc (sizeof (struct efc_els_io_req ),GFP_ATOMIC ); +if (!els) { +atomic_add_return (1 , &efc->els_io_alloc_failed_count); +spin_unlock_irqrestore (&node->els_ios_lock, flags); +return NULL ; + } + +/* initialize refcount */ +kref_init (&els->ref); + els->release = _efc_els_io_free; + +/* populate generic io fields */ + els->node = node; + +/* now allocate DMA for request and response */ + els->io.req.size = reqlen; + els->io.req.virt =dma_alloc_coherent (&efc->pci->dev, els->io.req.size, + &els->io.req.phys,GFP_DMA ); +if (!els->io.req.virt) { +kfree (els); +spin_unlock_irqrestore (&node->els_ios_lock, flags); +return NULL ; + } + + els->io.rsp.size = rsplen; + els->io.rsp.virt =dma_alloc_coherent (&efc->pci->dev, els->io.rsp.size, + &els->io.rsp.phys,GFP_DMA ); +if (!els->io.rsp.virt) { +dma_free_coherent (&efc->pci->dev, els->io.req.size, + els->io.req.virt, els->io.req.phys); +kfree (els); + els =NULL ; + } + +if (els) { +/* initialize fields */ + els->els_retries_remaining =EFC_FC_ELS_DEFAULT_RETRIES ; + +/* add els structure to ELS IO list */ +INIT_LIST_HEAD (&els->list_entry); +list_add_tail (&els->list_entry, &node->els_ios_list); + } + +spin_unlock_irqrestore (&node->els_ios_lock, flags); +return els; +} + +void +efc_els_io_free (struct efc_els_io_req *els) +{ +kref_put (&els->ref, els->release); +} + +void +_efc_els_io_free (struct kref *arg) +{ +struct efc_els_io_req *els = + container_of(arg, struct efc_els_io_req, ref); +struct efc *efc; +struct efc_node *node; +int send_empty_event = false; +unsigned long flags =0 ; + + node = els->node; + efc = node->efc; + +spin_lock_irqsave (&node->els_ios_lock, flags); + +list_del (&els->list_entry); +/* Send list empty event if the IO allocator +* is disabled, and the list is empty +* If node->els_io_enabled was not checked, +* the event would be posted continually +*/ + send_empty_event = (!node->els_io_enabled) && +list_empty (&node->els_ios_list); + +spin_unlock_irqrestore (&node->els_ios_lock, flags); + +/* free ELS request and response buffers */ +dma_free_coherent (&efc->pci->dev, els->io.rsp.size, + els->io.rsp.virt, els->io.rsp.phys); +dma_free_coherent (&efc->pci->dev, els->io.req.size, + els->io.req.virt, els->io.req.phys); + +kfree (els); + +if (send_empty_event) +efc_scsi_io_list_empty (node->efc, node); +} + +static void +efc_els_retry (struct efc_els_io_req *els); + +static void +efc_els_delay_timer_cb (struct timer_list *t) +{ +struct efc_els_io_req *els =from_timer (els, t, delay_timer); + +/* Retry delay timer expired, retry the ELS request */ +efc_els_retry (els); +} + +static int +efc_els_req_cb (void *arg,u32 length,int status,u32 ext_status) +{ +struct efc_els_io_req *els; +struct efc_node *node; +struct efc *efc; +struct efc_node_cb cbdata; +u32 reason_code; + + els = arg; + node = els->node; + efc = node->efc; + +if (status) +els_io_printf (els,"status x%x ext x%x\n" , status, ext_status); + +/* set the response len element of els->rsp */ + els->io.rsp.len = length; + + cbdata.status = status; + cbdata.ext_status = ext_status; + cbdata.header =NULL ; + cbdata.els_rsp = els->io.rsp; + +/* set the response len element of els->rsp */ + cbdata.rsp_len = length; + +/* FW returns the number of bytes received on the link in +* the WCQE, not the amount placed in the buffer; use this info to +* check if there was an overrun. +*/ +if (length > els->io.rsp.size) { +efc_log_warn (efc, +"ELS response returned len=%d > buflen=%zu\n" , + length, els->io.rsp.size); +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_REQ_FAIL , &cbdata); +return EFC_SUCCESS ; + } + +/* Post event to ELS IO object */ +switch (status) { +case SLI4_FC_WCQE_STATUS_SUCCESS : +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_REQ_OK , &cbdata); +break ; + +case SLI4_FC_WCQE_STATUS_LS_RJT : + reason_code = (ext_status >>16 ) &0xff ; + +/* delay and retry if reason code is Logical Busy */ +switch (reason_code) { +case ELS_RJT_BUSY : + els->node->els_req_cnt--; +els_io_printf (els, +"LS_RJT Logical Busy, delay and retry\n" ); +timer_setup (&els->delay_timer, + efc_els_delay_timer_cb,0 ); +mod_timer (&els->delay_timer, + jiffies +msecs_to_jiffies (5000 )); +break ; +default : +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_REQ_RJT , + &cbdata); +break ; + } +break ; + +case SLI4_FC_WCQE_STATUS_LOCAL_REJECT : +switch (ext_status) { +case SLI4_FC_LOCAL_REJECT_SEQUENCE_TIMEOUT : +efc_els_retry (els); +break ; +default : +efc_log_err (efc,"LOCAL_REJECT with ext status:%x\n" , + ext_status); +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_REQ_FAIL , + &cbdata); +break ; + } +break ; +default :/* Other error */ +efc_log_warn (efc,"els req failed status x%x, ext_status x%x\n" , + status, ext_status); +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_REQ_FAIL , &cbdata); +break ; + } + +return EFC_SUCCESS ; +} + +void efc_disc_io_complete (struct efc_disc_io *io,u32 len,u32 status, +u32 ext_status) +{ +struct efc_els_io_req *els = + container_of(io, struct efc_els_io_req, io); + +WARN_ON (!els->cb); + + ((efc_hw_srrs_cb_t ) els->cb) (els, len, status, ext_status); +} + +static void efc_els_send_req (struct efc_node *node,struct efc_els_io_req *els, +enum efc_disc_io_type io_type) +{ +int rc =0 ; +struct efc *efc = node->efc; +struct efc_node_cb cbdata; + +/* update ELS request counter */ + els->node->els_req_cnt++; + +/* Prepare the IO request details */ + els->io.io_type = io_type; + els->io.xmit_len = els->io.req.size; + els->io.rsp_len = els->io.rsp.size; + els->io.rpi = node->rnode.indicator; + els->io.vpi = node->nport->indicator; + els->io.s_id = node->nport->fc_id; + els->io.d_id = node->rnode.fc_id; + +if (node->rnode.attached) + els->io.rpi_registered = true; + + els->cb = efc_els_req_cb; + + rc = efc->tt.send_els (efc, &els->io); +if (!rc) +return ; + + cbdata.status =INT_MAX ; + cbdata.ext_status =INT_MAX ; + cbdata.els_rsp = els->io.rsp; +efc_log_err (efc,"efc_els_send failed: %d\n" , rc); +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_REQ_FAIL , &cbdata); +} + +static void +efc_els_retry (struct efc_els_io_req *els) +{ +struct efc *efc; +struct efc_node_cb cbdata; +u32 rc; + + efc = els->node->efc; + cbdata.status =INT_MAX ; + cbdata.ext_status =INT_MAX ; + cbdata.els_rsp = els->io.rsp; + + +if (els->els_retries_remaining) { + els->els_retries_remaining--; + rc = efc->tt.send_els (efc, &els->io); + }else { + rc =EFC_FAIL ; + } + +if (rc) { +efc_log_err (efc,"ELS retries exhausted\n" ); +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_REQ_FAIL , &cbdata); + } +} + +static int +efc_els_acc_cb (void *arg,u32 length,int status,u32 ext_status) +{ +struct efc_els_io_req *els; +struct efc_node *node; +struct efc *efc; +struct efc_node_cb cbdata; + + els = arg; + node = els->node; + efc = node->efc; + + cbdata.status = status; + cbdata.ext_status = ext_status; + cbdata.header =NULL ; + cbdata.els_rsp = els->io.rsp; + +/* Post node event */ +switch (status) { +case SLI4_FC_WCQE_STATUS_SUCCESS : +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_CMPL_OK , &cbdata); +break ; + +default :/* Other error */ +efc_log_warn (efc,"[%s] %-8s failed status x%x, ext x%x\n" , + node->display_name, els->display_name, + status, ext_status); +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_CMPL_FAIL , &cbdata); +break ; + } + +return EFC_SUCCESS ; +} + +static void +efc_els_send_rsp (struct efc_els_io_req *els,u32 rsplen) +{ +int rc; +struct efc_node_cb cbdata; +struct efc_node *node = els->node; +struct efc *efc = node->efc; + +/* increment ELS completion counter */ + node->els_cmpl_cnt++; + + els->io.io_type =EFC_DISC_IO_ELS_RESP ; + els->cb = efc_els_acc_cb; + +/* Prepare the IO request details */ + els->io.xmit_len = rsplen; + els->io.rsp_len = els->io.rsp.size; + els->io.rpi = node->rnode.indicator; + els->io.vpi = node->nport->indicator; +if (node->nport->fc_id !=U32_MAX ) + els->io.s_id = node->nport->fc_id; +else + els->io.s_id = els->io.iparam.els.s_id; + els->io.d_id = node->rnode.fc_id; + +if (node->attached) + els->io.rpi_registered = true; + + rc = efc->tt.send_els (efc, &els->io); +if (!rc) +return ; + + cbdata.status =INT_MAX ; + cbdata.ext_status =INT_MAX ; + cbdata.els_rsp = els->io.rsp; +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_CMPL_FAIL , &cbdata); +} + +int +efc_send_plogi (struct efc_node *node) +{ +struct efc_els_io_req *els; +struct efc *efc = node->efc; +struct fc_els_flogi *plogi; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*plogi)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + els->display_name ="plogi" ; + +/* Build PLOGI request */ + plogi = els->io.req.virt; + +memcpy (plogi, node->nport->service_params,sizeof (*plogi)); + + plogi->fl_cmd =ELS_PLOGI ; +memset (plogi->_fl_resvd,0 ,sizeof (plogi->_fl_resvd)); + +efc_els_send_req (node, els,EFC_DISC_IO_ELS_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_send_flogi (struct efc_node *node) +{ +struct efc_els_io_req *els; +struct efc *efc; +struct fc_els_flogi *flogi; + + efc = node->efc; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*flogi)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="flogi" ; + +/* Build FLOGI request */ + flogi = els->io.req.virt; + +memcpy (flogi, node->nport->service_params,sizeof (*flogi)); + flogi->fl_cmd =ELS_FLOGI ; +memset (flogi->_fl_resvd,0 ,sizeof (flogi->_fl_resvd)); + +efc_els_send_req (node, els,EFC_DISC_IO_ELS_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_send_fdisc (struct efc_node *node) +{ +struct efc_els_io_req *els; +struct efc *efc; +struct fc_els_flogi *fdisc; + + efc = node->efc; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*fdisc)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="fdisc" ; + +/* Build FDISC request */ + fdisc = els->io.req.virt; + +memcpy (fdisc, node->nport->service_params,sizeof (*fdisc)); + fdisc->fl_cmd =ELS_FDISC ; +memset (fdisc->_fl_resvd,0 ,sizeof (fdisc->_fl_resvd)); + +efc_els_send_req (node, els,EFC_DISC_IO_ELS_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_send_prli (struct efc_node *node) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els; +struct { +struct fc_els_prli prli; +struct fc_els_spp spp; + } *pp; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*pp)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="prli" ; + +/* Build PRLI request */ + pp = els->io.req.virt; + +memset (pp,0 ,sizeof (*pp)); + + pp->prli.prli_cmd =ELS_PRLI ; + pp->prli.prli_spp_len =16 ; + pp->prli.prli_len =cpu_to_be16 (sizeof (*pp)); + pp->spp.spp_type =FC_TYPE_FCP ; + pp->spp.spp_type_ext =0 ; + pp->spp.spp_flags =FC_SPP_EST_IMG_PAIR ; + pp->spp.spp_params =cpu_to_be32 (FCP_SPPF_RD_XRDY_DIS | + (node->nport->enable_ini ? +FCP_SPPF_INIT_FCN :0 ) | + (node->nport->enable_tgt ? +FCP_SPPF_TARG_FCN :0 )); + +efc_els_send_req (node, els,EFC_DISC_IO_ELS_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_send_logo (struct efc_node *node) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els; +struct fc_els_logo *logo; +struct fc_els_flogi *sparams; + +node_els_trace (); + + sparams = (struct fc_els_flogi *)node->nport->service_params; + + els =efc_els_io_alloc (node,sizeof (*logo)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="logo" ; + +/* Build LOGO request */ + + logo = els->io.req.virt; + +memset (logo,0 ,sizeof (*logo)); + logo->fl_cmd =ELS_LOGO ; +hton24 (logo->fl_n_port_id, node->rnode.nport->fc_id); + logo->fl_n_port_wwn = sparams->fl_wwpn; + +efc_els_send_req (node, els,EFC_DISC_IO_ELS_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_send_adisc (struct efc_node *node) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els; +struct fc_els_adisc *adisc; +struct fc_els_flogi *sparams; +struct efc_nport *nport = node->nport; + +node_els_trace (); + + sparams = (struct fc_els_flogi *)node->nport->service_params; + + els =efc_els_io_alloc (node,sizeof (*adisc)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="adisc" ; + +/* Build ADISC request */ + + adisc = els->io.req.virt; + +memset (adisc,0 ,sizeof (*adisc)); + adisc->adisc_cmd =ELS_ADISC ; +hton24 (adisc->adisc_hard_addr, nport->fc_id); + adisc->adisc_wwpn = sparams->fl_wwpn; + adisc->adisc_wwnn = sparams->fl_wwnn; +hton24 (adisc->adisc_port_id, node->rnode.nport->fc_id); + +efc_els_send_req (node, els,EFC_DISC_IO_ELS_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_send_scr (struct efc_node *node) +{ +struct efc_els_io_req *els; +struct efc *efc = node->efc; +struct fc_els_scr *req; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*req)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="scr" ; + + req = els->io.req.virt; + +memset (req,0 ,sizeof (*req)); + req->scr_cmd =ELS_SCR ; + req->scr_reg_func =ELS_SCRF_FULL ; + +efc_els_send_req (node, els,EFC_DISC_IO_ELS_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_send_ls_rjt (struct efc_node *node,u32 ox_id,u32 reason_code, +u32 reason_code_expl,u32 vendor_unique) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els =NULL ; +struct fc_els_ls_rjt *rjt; + + els =efc_els_io_alloc (node,sizeof (*rjt)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + +node_els_trace (); + + els->display_name ="ls_rjt" ; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + + rjt = els->io.req.virt; +memset (rjt,0 ,sizeof (*rjt)); + + rjt->er_cmd =ELS_LS_RJT ; + rjt->er_reason = reason_code; + rjt->er_explan = reason_code_expl; + +efc_els_send_rsp (els,sizeof (*rjt)); + +return EFC_SUCCESS ; +} + +int +efc_send_plogi_acc (struct efc_node *node,u32 ox_id) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els =NULL ; +struct fc_els_flogi *plogi; +struct fc_els_flogi *req = (struct fc_els_flogi *)node->service_params; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*plogi)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="plogi_acc" ; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + + plogi = els->io.req.virt; + +/* copy our port's service parameters to payload */ +memcpy (plogi, node->nport->service_params,sizeof (*plogi)); + plogi->fl_cmd =ELS_LS_ACC ; +memset (plogi->_fl_resvd,0 ,sizeof (plogi->_fl_resvd)); + +/* Set Application header support bit if requested */ +if (req->fl_csp.sp_features &cpu_to_be16 (FC_SP_FT_BCAST )) + plogi->fl_csp.sp_features |=cpu_to_be16 (FC_SP_FT_BCAST ); + +efc_els_send_rsp (els,sizeof (*plogi)); + +return EFC_SUCCESS ; +} + +int +efc_send_flogi_p2p_acc (struct efc_node *node,u32 ox_id,u32 s_id) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els =NULL ; +struct fc_els_flogi *flogi; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*flogi)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="flogi_p2p_acc" ; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + els->io.iparam.els.s_id = s_id; + + flogi = els->io.req.virt; + +/* copy our port's service parameters to payload */ +memcpy (flogi, node->nport->service_params,sizeof (*flogi)); + flogi->fl_cmd =ELS_LS_ACC ; +memset (flogi->_fl_resvd,0 ,sizeof (flogi->_fl_resvd)); + +memset (flogi->fl_cssp,0 ,sizeof (flogi->fl_cssp)); + +efc_els_send_rsp (els,sizeof (*flogi)); + +return EFC_SUCCESS ; +} + +int +efc_send_prli_acc (struct efc_node *node,u32 ox_id) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els =NULL ; +struct { +struct fc_els_prli prli; +struct fc_els_spp spp; + } *pp; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*pp)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="prli_acc" ; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + + pp = els->io.req.virt; +memset (pp,0 ,sizeof (*pp)); + + pp->prli.prli_cmd =ELS_LS_ACC ; + pp->prli.prli_spp_len =0x10 ; + pp->prli.prli_len =cpu_to_be16 (sizeof (*pp)); + pp->spp.spp_type =FC_TYPE_FCP ; + pp->spp.spp_type_ext =0 ; + pp->spp.spp_flags =FC_SPP_EST_IMG_PAIR |FC_SPP_RESP_ACK ; + + pp->spp.spp_params =cpu_to_be32 (FCP_SPPF_RD_XRDY_DIS | + (node->nport->enable_ini ? +FCP_SPPF_INIT_FCN :0 ) | + (node->nport->enable_tgt ? +FCP_SPPF_TARG_FCN :0 )); + +efc_els_send_rsp (els,sizeof (*pp)); + +return EFC_SUCCESS ; +} + +int +efc_send_prlo_acc (struct efc_node *node,u32 ox_id) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els =NULL ; +struct { +struct fc_els_prlo prlo; +struct fc_els_spp spp; + } *pp; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*pp)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="prlo_acc" ; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + + pp = els->io.req.virt; +memset (pp,0 ,sizeof (*pp)); + pp->prlo.prlo_cmd =ELS_LS_ACC ; + pp->prlo.prlo_obs =0x10 ; + pp->prlo.prlo_len =cpu_to_be16 (sizeof (*pp)); + + pp->spp.spp_type =FC_TYPE_FCP ; + pp->spp.spp_type_ext =0 ; + pp->spp.spp_flags =FC_SPP_RESP_ACK ; + +efc_els_send_rsp (els,sizeof (*pp)); + +return EFC_SUCCESS ; +} + +int +efc_send_ls_acc (struct efc_node *node,u32 ox_id) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els =NULL ; +struct fc_els_ls_acc *acc; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*acc)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="ls_acc" ; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + + acc = els->io.req.virt; +memset (acc,0 ,sizeof (*acc)); + + acc->la_cmd =ELS_LS_ACC ; + +efc_els_send_rsp (els,sizeof (*acc)); + +return EFC_SUCCESS ; +} + +int +efc_send_logo_acc (struct efc_node *node,u32 ox_id) +{ +struct efc_els_io_req *els =NULL ; +struct efc *efc = node->efc; +struct fc_els_ls_acc *logo; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*logo)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="logo_acc" ; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + + logo = els->io.req.virt; +memset (logo,0 ,sizeof (*logo)); + + logo->la_cmd =ELS_LS_ACC ; + +efc_els_send_rsp (els,sizeof (*logo)); + +return EFC_SUCCESS ; +} + +int +efc_send_adisc_acc (struct efc_node *node,u32 ox_id) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els =NULL ; +struct fc_els_adisc *adisc; +struct fc_els_flogi *sparams; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*adisc)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="adisc_acc" ; + +/* Go ahead and send the ELS_ACC */ +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + + sparams = (struct fc_els_flogi *)node->nport->service_params; + adisc = els->io.req.virt; +memset (adisc,0 ,sizeof (*adisc)); + adisc->adisc_cmd =ELS_LS_ACC ; + adisc->adisc_wwpn = sparams->fl_wwpn; + adisc->adisc_wwnn = sparams->fl_wwnn; +hton24 (adisc->adisc_port_id, node->rnode.nport->fc_id); + +efc_els_send_rsp (els,sizeof (*adisc)); + +return EFC_SUCCESS ; +} + +static inline void +fcct_build_req_header (struct fc_ct_hdr *hdr,u16 cmd,u16 max_size) +{ + hdr->ct_rev =FC_CT_REV ; + hdr->ct_fs_type =FC_FST_DIR ; + hdr->ct_fs_subtype =FC_NS_SUBTYPE ; + hdr->ct_options =0 ; + hdr->ct_cmd =cpu_to_be16 (cmd); +/* words */ + hdr->ct_mr_size =cpu_to_be16 (max_size / (sizeof (u32))); + hdr->ct_reason =0 ; + hdr->ct_explan =0 ; + hdr->ct_vendor =0 ; +} + +int +efc_ns_send_rftid (struct efc_node *node) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els; +struct { +struct fc_ct_hdr hdr; +struct fc_ns_rft_id rftid; + } *ct; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*ct)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->io.iparam.ct.r_ctl =FC_RCTL_ELS_REQ ; + els->io.iparam.ct.type =FC_TYPE_CT ; + els->io.iparam.ct.df_ctl =0 ; + els->io.iparam.ct.timeout =EFC_FC_ELS_SEND_DEFAULT_TIMEOUT ; + + els->display_name ="rftid" ; + + ct = els->io.req.virt; +memset (ct,0 ,sizeof (*ct)); +fcct_build_req_header (&ct->hdr,FC_NS_RFT_ID , +sizeof (struct fc_ns_rft_id )); + +hton24 (ct->rftid.fr_fid.fp_fid, node->rnode.nport->fc_id); + ct->rftid.fr_fts.ff_type_map[FC_TYPE_FCP /FC_NS_BPW ] = +cpu_to_be32 (1 << (FC_TYPE_FCP %FC_NS_BPW )); + +efc_els_send_req (node, els,EFC_DISC_IO_CT_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_ns_send_rffid (struct efc_node *node) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els; +struct { +struct fc_ct_hdr hdr; +struct fc_ns_rff_id rffid; + } *ct; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*ct)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->io.iparam.ct.r_ctl =FC_RCTL_ELS_REQ ; + els->io.iparam.ct.type =FC_TYPE_CT ; + els->io.iparam.ct.df_ctl =0 ; + els->io.iparam.ct.timeout =EFC_FC_ELS_SEND_DEFAULT_TIMEOUT ; + + els->display_name ="rffid" ; + ct = els->io.req.virt; + +memset (ct,0 ,sizeof (*ct)); +fcct_build_req_header (&ct->hdr,FC_NS_RFF_ID , +sizeof (struct fc_ns_rff_id )); + +hton24 (ct->rffid.fr_fid.fp_fid, node->rnode.nport->fc_id); +if (node->nport->enable_ini) + ct->rffid.fr_feat |=FCP_FEAT_INIT ; +if (node->nport->enable_tgt) + ct->rffid.fr_feat |=FCP_FEAT_TARG ; + ct->rffid.fr_type =FC_TYPE_FCP ; + +efc_els_send_req (node, els,EFC_DISC_IO_CT_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_ns_send_gidpt (struct efc_node *node) +{ +struct efc_els_io_req *els =NULL ; +struct efc *efc = node->efc; +struct { +struct fc_ct_hdr hdr; +struct fc_ns_gid_pt gidpt; + } *ct; + +node_els_trace (); + + els =efc_els_io_alloc_size (node,sizeof (*ct),EFC_ELS_GID_PT_RSP_LEN ); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->io.iparam.ct.r_ctl =FC_RCTL_ELS_REQ ; + els->io.iparam.ct.type =FC_TYPE_CT ; + els->io.iparam.ct.df_ctl =0 ; + els->io.iparam.ct.timeout =EFC_FC_ELS_SEND_DEFAULT_TIMEOUT ; + + els->display_name ="gidpt" ; + + ct = els->io.req.virt; + +memset (ct,0 ,sizeof (*ct)); +fcct_build_req_header (&ct->hdr,FC_NS_GID_PT , +sizeof (struct fc_ns_gid_pt )); + + ct->gidpt.fn_pt_type =FC_TYPE_FCP ; + +efc_els_send_req (node, els,EFC_DISC_IO_CT_REQ ); + +return EFC_SUCCESS ; +} + +void +efc_els_io_cleanup (struct efc_els_io_req *els, +enum efc_hw_node_els_event node_evt,void *arg) +{ +/* don't want further events that could come; e.g. abort requests +* from the node state machine; thus, disable state machine +*/ + els->els_req_free = true; +efc_node_post_els_resp (els->node, node_evt, arg); + +efc_els_io_free (els); +} + +static int +efc_ct_acc_cb (void *arg,u32 length,int status,u32 ext_status) +{ +struct efc_els_io_req *els = arg; + +efc_els_io_free (els); + +return EFC_SUCCESS ; +} + +int +efc_send_ct_rsp (struct efc *efc,struct efc_node *node,u16 ox_id, +struct fc_ct_hdr *ct_hdr,u32 cmd_rsp_code, +u32 reason_code,u32 reason_code_explanation) +{ +struct efc_els_io_req *els =NULL ; +struct fc_ct_hdr *rsp =NULL ; + + els =efc_els_io_alloc (node,256 ); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + rsp = els->io.rsp.virt; + + *rsp = *ct_hdr; + +fcct_build_req_header (rsp, cmd_rsp_code,0 ); + rsp->ct_reason = reason_code; + rsp->ct_explan = reason_code_explanation; + + els->display_name ="ct_rsp" ; + els->cb = efc_ct_acc_cb; + +/* Prepare the IO request details */ + els->io.io_type =EFC_DISC_IO_CT_RESP ; + els->io.xmit_len =sizeof (*rsp); + + els->io.rpi = node->rnode.indicator; + els->io.d_id = node->rnode.fc_id; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + + els->io.iparam.ct.ox_id = ox_id; + els->io.iparam.ct.r_ctl =3 ; + els->io.iparam.ct.type =FC_TYPE_CT ; + els->io.iparam.ct.df_ctl =0 ; + els->io.iparam.ct.timeout =5 ; + +if (efc->tt.send_els (efc, &els->io)) { +efc_els_io_free (els); +return EFC_FAIL ; + } +return EFC_SUCCESS ; +} + +int +efc_send_bls_acc (struct efc_node *node,struct fc_frame_header *hdr) +{ +struct sli_bls_params bls; +struct fc_ba_acc *acc; +struct efc *efc = node->efc; + +memset (&bls,0 ,sizeof (bls)); + bls.ox_id =be16_to_cpu (hdr->fh_ox_id); + bls.rx_id =be16_to_cpu (hdr->fh_rx_id); + bls.s_id =ntoh24 (hdr->fh_d_id); + bls.d_id = node->rnode.fc_id; + bls.rpi = node->rnode.indicator; + bls.vpi = node->nport->indicator; + + acc = (void *)bls.payload; + acc->ba_ox_id =cpu_to_be16 (bls.ox_id); + acc->ba_rx_id =cpu_to_be16 (bls.rx_id); + acc->ba_high_seq_cnt =cpu_to_be16 (U16_MAX ); + +return efc->tt.send_bls (efc,FC_RCTL_BA_ACC , &bls); +}
drivers/scsi/elx/libefc/efc_els.h new file +107 -0
107 lines not on this page · raw message
Signature · 1 line
2.26.2
Re: [PATCH v4 15/31] elx: libefc: Extended link Service IO handling
Quoted 69 lines · James Smart
This patch continues the libefc library population.
This patch adds library interface definitions for:
Functions to build and send ELS/CT/BLS commands and responses.Co-developed-by Ram Vegesna <[email protected]>Signed-off-by Ram Vegesna <[email protected]>Signed-off-by James Smart <[email protected]>---
v4:
New patch added ELS handling to libefc library. Newels_io_reqfor discovery io object.--- drivers/scsi/elx/libefc/efc_els.c | 1152 +++++++++++++++++++++++++++++ drivers/scsi/elx/libefc/efc_els.h | 107 +++ 2 files changed, 1259 insertions(+)create mode 100644
drivers/scsi/elx/libefc/efc_els.ccreate mode 100644drivers/scsi/elx/libefc/efc_els.hdrivers/scsi/elx/libefc/efc_els.c new file +43
-0@@ -0,0 +1,1152 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +/* +* Functions to build and send ELS/CT/BLS commands and responses. +*/ + +#include "efc.h" +#include "efc_els.h" +#include "../libefc_sli/sli4.h" + +#define EFC_LOG_ENABLE_ELS_TRACE (efc) \ + (((efc) != NULL) ? (((efc)->logmask & (1U << 1)) != 0) : 0) + +#define node_els_trace () \ + do { \ + if (EFC_LOG_ENABLE_ELS_TRACE(efc)) \ + efc_log_info(efc, "[%s] %-20s\n", \ + node->display_name, __func__); \ + } while (0) + +#define els_io_printf (els, fmt, ...) \ + efc_log_err((struct efc *)els->node->efc,\ + "[%s] %-8s " fmt, \ + els->node->display_name,\ + els->display_name, ##__VA_ARGS__) + +#define EFC_ELS_RSP_LEN 1024 +#define EFC_ELS_GID_PT_RSP_LEN 8096 + +void +efc_io_alloc_enable (struct efc_node *node) +{ +unsigned long flags =0 ; + +spin_lock_irqsave (&node->els_ios_lock, flags); + node->els_io_enabled = true; +spin_unlock_irqrestore (&node->els_ios_lock, flags); +} +
drivers/scsi/elx/libefc/efc_els.c line 53
Quoted 10 lines
drivers/scsi/elx/libefc/efc_els.c new file +10
-0+void +efc_io_alloc_disable (struct efc_node *node) +{ +unsigned long flags =0 ; + +spin_lock_irqsave (&node->els_ios_lock, flags); + node->els_io_enabled = false; +spin_unlock_irqrestore (&node->els_ios_lock, flags); +} +
These spinlocks are pretty much pointless.
Please use WRITE_ONCE()/READ_ONCE().
Quoted 37 lines
drivers/scsi/elx/libefc/efc_els.c new file +37
-0+struct efc_els_io_req * +efc_els_io_alloc (struct efc_node *node,u32 reqlen) +{ +return efc_els_io_alloc_size (node, reqlen,EFC_ELS_RSP_LEN ); +} + +struct efc_els_io_req * +efc_els_io_alloc_size (struct efc_node *node,u32 reqlen,u32 rsplen) +{ +struct efc *efc; +struct efc_els_io_req *els; +unsigned long flags =0 ; + + efc = node->efc; + +spin_lock_irqsave (&node->els_ios_lock, flags); + +if (!node->els_io_enabled) { +efc_log_err (efc,"els io alloc disabled\n" ); +spin_unlock_irqrestore (&node->els_ios_lock, flags); +return NULL ; + } + + els =kzalloc (sizeof (struct efc_els_io_req ),GFP_ATOMIC ); +if (!els) { +atomic_add_return (1 , &efc->els_io_alloc_failed_count); +spin_unlock_irqrestore (&node->els_ios_lock, flags); +return NULL ; + } + +/* initialize refcount */ +kref_init (&els->ref); + els->release = _efc_els_io_free; + +/* populate generic io fields */ + els->node = node; +
drivers/scsi/elx/libefc/efc_els.c line 100
Quoted 10 lines
drivers/scsi/elx/libefc/efc_els.c new file +10
-0+/* now allocate DMA for request and response */ + els->io.req.size = reqlen; + els->io.req.virt =dma_alloc_coherent (&efc->pci->dev, els->io.req.size, + &els->io.req.phys,GFP_DMA ); +if (!els->io.req.virt) { +kfree (els); +spin_unlock_irqrestore (&node->els_ios_lock, flags); +return NULL ; + } +
Hmm. I would've thought that sending ELS is a pretty regular occurrence.
Wouldn't it be more sensible to switch to a mempool here instead of allocating memory separately for each ELS frame?
Quoted 199 lines
drivers/scsi/elx/libefc/efc_els.c new file +199
-0+ els->io.rsp.size = rsplen; + els->io.rsp.virt =dma_alloc_coherent (&efc->pci->dev, els->io.rsp.size, + &els->io.rsp.phys,GFP_DMA ); +if (!els->io.rsp.virt) { +dma_free_coherent (&efc->pci->dev, els->io.req.size, + els->io.req.virt, els->io.req.phys); +kfree (els); + els =NULL ; + } + +if (els) { +/* initialize fields */ + els->els_retries_remaining =EFC_FC_ELS_DEFAULT_RETRIES ; + +/* add els structure to ELS IO list */ +INIT_LIST_HEAD (&els->list_entry); +list_add_tail (&els->list_entry, &node->els_ios_list); + } + +spin_unlock_irqrestore (&node->els_ios_lock, flags); +return els; +} + +void +efc_els_io_free (struct efc_els_io_req *els) +{ +kref_put (&els->ref, els->release); +} + +void +_efc_els_io_free (struct kref *arg) +{ +struct efc_els_io_req *els = + container_of(arg, struct efc_els_io_req, ref); +struct efc *efc; +struct efc_node *node; +int send_empty_event = false; +unsigned long flags =0 ; + + node = els->node; + efc = node->efc; + +spin_lock_irqsave (&node->els_ios_lock, flags); + +list_del (&els->list_entry); +/* Send list empty event if the IO allocator +* is disabled, and the list is empty +* If node->els_io_enabled was not checked, +* the event would be posted continually +*/ + send_empty_event = (!node->els_io_enabled) && +list_empty (&node->els_ios_list); + +spin_unlock_irqrestore (&node->els_ios_lock, flags); + +/* free ELS request and response buffers */ +dma_free_coherent (&efc->pci->dev, els->io.rsp.size, + els->io.rsp.virt, els->io.rsp.phys); +dma_free_coherent (&efc->pci->dev, els->io.req.size, + els->io.req.virt, els->io.req.phys); + +kfree (els); + +if (send_empty_event) +efc_scsi_io_list_empty (node->efc, node); +} + +static void +efc_els_retry (struct efc_els_io_req *els); + +static void +efc_els_delay_timer_cb (struct timer_list *t) +{ +struct efc_els_io_req *els =from_timer (els, t, delay_timer); + +/* Retry delay timer expired, retry the ELS request */ +efc_els_retry (els); +} + +static int +efc_els_req_cb (void *arg,u32 length,int status,u32 ext_status) +{ +struct efc_els_io_req *els; +struct efc_node *node; +struct efc *efc; +struct efc_node_cb cbdata; +u32 reason_code; + + els = arg; + node = els->node; + efc = node->efc; + +if (status) +els_io_printf (els,"status x%x ext x%x\n" , status, ext_status); + +/* set the response len element of els->rsp */ + els->io.rsp.len = length; + + cbdata.status = status; + cbdata.ext_status = ext_status; + cbdata.header =NULL ; + cbdata.els_rsp = els->io.rsp; + +/* set the response len element of els->rsp */ + cbdata.rsp_len = length; + +/* FW returns the number of bytes received on the link in +* the WCQE, not the amount placed in the buffer; use this info to +* check if there was an overrun. +*/ +if (length > els->io.rsp.size) { +efc_log_warn (efc, +"ELS response returned len=%d > buflen=%zu\n" , + length, els->io.rsp.size); +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_REQ_FAIL , &cbdata); +return EFC_SUCCESS ; + } + +/* Post event to ELS IO object */ +switch (status) { +case SLI4_FC_WCQE_STATUS_SUCCESS : +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_REQ_OK , &cbdata); +break ; + +case SLI4_FC_WCQE_STATUS_LS_RJT : + reason_code = (ext_status >>16 ) &0xff ; + +/* delay and retry if reason code is Logical Busy */ +switch (reason_code) { +case ELS_RJT_BUSY : + els->node->els_req_cnt--; +els_io_printf (els, +"LS_RJT Logical Busy, delay and retry\n" ); +timer_setup (&els->delay_timer, + efc_els_delay_timer_cb,0 ); +mod_timer (&els->delay_timer, + jiffies +msecs_to_jiffies (5000 )); +break ; +default : +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_REQ_RJT , + &cbdata); +break ; + } +break ; + +case SLI4_FC_WCQE_STATUS_LOCAL_REJECT : +switch (ext_status) { +case SLI4_FC_LOCAL_REJECT_SEQUENCE_TIMEOUT : +efc_els_retry (els); +break ; +default : +efc_log_err (efc,"LOCAL_REJECT with ext status:%x\n" , + ext_status); +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_REQ_FAIL , + &cbdata); +break ; + } +break ; +default :/* Other error */ +efc_log_warn (efc,"els req failed status x%x, ext_status x%x\n" , + status, ext_status); +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_REQ_FAIL , &cbdata); +break ; + } + +return EFC_SUCCESS ; +} + +void efc_disc_io_complete (struct efc_disc_io *io,u32 len,u32 status, +u32 ext_status) +{ +struct efc_els_io_req *els = + container_of(io, struct efc_els_io_req, io); + +WARN_ON (!els->cb); + + ((efc_hw_srrs_cb_t ) els->cb) (els, len, status, ext_status); +} + +static void efc_els_send_req (struct efc_node *node,struct efc_els_io_req *els, +enum efc_disc_io_type io_type) +{ +int rc =0 ; +struct efc *efc = node->efc; +struct efc_node_cb cbdata; + +/* update ELS request counter */ + els->node->els_req_cnt++; + +/* Prepare the IO request details */ + els->io.io_type = io_type; + els->io.xmit_len = els->io.req.size; + els->io.rsp_len = els->io.rsp.size; + els->io.rpi = node->rnode.indicator; + els->io.vpi = node->nport->indicator; + els->io.s_id = node->nport->fc_id; + els->io.d_id = node->rnode.fc_id; + +if (node->rnode.attached)
drivers/scsi/elx/libefc/efc_els.c line 309
Quoted 10 lines
drivers/scsi/elx/libefc/efc_els.c new file +10
-0+ els->io.rpi_registered = true; + + els->cb = efc_els_req_cb; + + rc = efc->tt.send_els (efc, &els->io); +if (!rc) +return ; + + cbdata.status =INT_MAX ; + cbdata.ext_status =INT_MAX ;
INT_MAX?
Sure it's not UINT_MAX?
And it might be an idea to use a #define here to specify what you intend with this setting, namely setting it to an invalid value.
Quoted 947 lines
drivers/scsi/elx/libefc/efc_els.c new file +843
-0+ cbdata.els_rsp = els->io.rsp; +efc_log_err (efc,"efc_els_send failed: %d\n" , rc); +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_REQ_FAIL , &cbdata); +} + +static void +efc_els_retry (struct efc_els_io_req *els) +{ +struct efc *efc; +struct efc_node_cb cbdata; +u32 rc; + + efc = els->node->efc; + cbdata.status =INT_MAX ; + cbdata.ext_status =INT_MAX ; + cbdata.els_rsp = els->io.rsp; + + +if (els->els_retries_remaining) { + els->els_retries_remaining--; + rc = efc->tt.send_els (efc, &els->io); + }else { + rc =EFC_FAIL ; + } + +if (rc) { +efc_log_err (efc,"ELS retries exhausted\n" ); +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_REQ_FAIL , &cbdata); + } +} + +static int +efc_els_acc_cb (void *arg,u32 length,int status,u32 ext_status) +{ +struct efc_els_io_req *els; +struct efc_node *node; +struct efc *efc; +struct efc_node_cb cbdata; + + els = arg; + node = els->node; + efc = node->efc; + + cbdata.status = status; + cbdata.ext_status = ext_status; + cbdata.header =NULL ; + cbdata.els_rsp = els->io.rsp; + +/* Post node event */ +switch (status) { +case SLI4_FC_WCQE_STATUS_SUCCESS : +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_CMPL_OK , &cbdata); +break ; + +default :/* Other error */ +efc_log_warn (efc,"[%s] %-8s failed status x%x, ext x%x\n" , + node->display_name, els->display_name, + status, ext_status); +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_CMPL_FAIL , &cbdata); +break ; + } + +return EFC_SUCCESS ; +} + +static void +efc_els_send_rsp (struct efc_els_io_req *els,u32 rsplen) +{ +int rc; +struct efc_node_cb cbdata; +struct efc_node *node = els->node; +struct efc *efc = node->efc; + +/* increment ELS completion counter */ + node->els_cmpl_cnt++; + + els->io.io_type =EFC_DISC_IO_ELS_RESP ; + els->cb = efc_els_acc_cb; + +/* Prepare the IO request details */ + els->io.xmit_len = rsplen; + els->io.rsp_len = els->io.rsp.size; + els->io.rpi = node->rnode.indicator; + els->io.vpi = node->nport->indicator; +if (node->nport->fc_id !=U32_MAX ) + els->io.s_id = node->nport->fc_id; +else + els->io.s_id = els->io.iparam.els.s_id; + els->io.d_id = node->rnode.fc_id; + +if (node->attached) + els->io.rpi_registered = true; + + rc = efc->tt.send_els (efc, &els->io); +if (!rc) +return ; + + cbdata.status =INT_MAX ; + cbdata.ext_status =INT_MAX ; + cbdata.els_rsp = els->io.rsp; +efc_els_io_cleanup (els,EFC_HW_SRRS_ELS_CMPL_FAIL , &cbdata); +} + +int +efc_send_plogi (struct efc_node *node) +{ +struct efc_els_io_req *els; +struct efc *efc = node->efc; +struct fc_els_flogi *plogi; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*plogi)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + els->display_name ="plogi" ; + +/* Build PLOGI request */ + plogi = els->io.req.virt; + +memcpy (plogi, node->nport->service_params,sizeof (*plogi)); + + plogi->fl_cmd =ELS_PLOGI ; +memset (plogi->_fl_resvd,0 ,sizeof (plogi->_fl_resvd)); + +efc_els_send_req (node, els,EFC_DISC_IO_ELS_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_send_flogi (struct efc_node *node) +{ +struct efc_els_io_req *els; +struct efc *efc; +struct fc_els_flogi *flogi; + + efc = node->efc; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*flogi)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="flogi" ; + +/* Build FLOGI request */ + flogi = els->io.req.virt; + +memcpy (flogi, node->nport->service_params,sizeof (*flogi)); + flogi->fl_cmd =ELS_FLOGI ; +memset (flogi->_fl_resvd,0 ,sizeof (flogi->_fl_resvd)); + +efc_els_send_req (node, els,EFC_DISC_IO_ELS_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_send_fdisc (struct efc_node *node) +{ +struct efc_els_io_req *els; +struct efc *efc; +struct fc_els_flogi *fdisc; + + efc = node->efc; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*fdisc)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="fdisc" ; + +/* Build FDISC request */ + fdisc = els->io.req.virt; + +memcpy (fdisc, node->nport->service_params,sizeof (*fdisc)); + fdisc->fl_cmd =ELS_FDISC ; +memset (fdisc->_fl_resvd,0 ,sizeof (fdisc->_fl_resvd)); + +efc_els_send_req (node, els,EFC_DISC_IO_ELS_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_send_prli (struct efc_node *node) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els; +struct { +struct fc_els_prli prli; +struct fc_els_spp spp; + } *pp; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*pp)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="prli" ; + +/* Build PRLI request */ + pp = els->io.req.virt; + +memset (pp,0 ,sizeof (*pp)); + + pp->prli.prli_cmd =ELS_PRLI ; + pp->prli.prli_spp_len =16 ; + pp->prli.prli_len =cpu_to_be16 (sizeof (*pp)); + pp->spp.spp_type =FC_TYPE_FCP ; + pp->spp.spp_type_ext =0 ; + pp->spp.spp_flags =FC_SPP_EST_IMG_PAIR ; + pp->spp.spp_params =cpu_to_be32 (FCP_SPPF_RD_XRDY_DIS | + (node->nport->enable_ini ? +FCP_SPPF_INIT_FCN :0 ) | + (node->nport->enable_tgt ? +FCP_SPPF_TARG_FCN :0 )); + +efc_els_send_req (node, els,EFC_DISC_IO_ELS_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_send_logo (struct efc_node *node) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els; +struct fc_els_logo *logo; +struct fc_els_flogi *sparams; + +node_els_trace (); + + sparams = (struct fc_els_flogi *)node->nport->service_params; + + els =efc_els_io_alloc (node,sizeof (*logo)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="logo" ; + +/* Build LOGO request */ + + logo = els->io.req.virt; + +memset (logo,0 ,sizeof (*logo)); + logo->fl_cmd =ELS_LOGO ; +hton24 (logo->fl_n_port_id, node->rnode.nport->fc_id); + logo->fl_n_port_wwn = sparams->fl_wwpn; + +efc_els_send_req (node, els,EFC_DISC_IO_ELS_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_send_adisc (struct efc_node *node) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els; +struct fc_els_adisc *adisc; +struct fc_els_flogi *sparams; +struct efc_nport *nport = node->nport; + +node_els_trace (); + + sparams = (struct fc_els_flogi *)node->nport->service_params; + + els =efc_els_io_alloc (node,sizeof (*adisc)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="adisc" ; + +/* Build ADISC request */ + + adisc = els->io.req.virt; + +memset (adisc,0 ,sizeof (*adisc)); + adisc->adisc_cmd =ELS_ADISC ; +hton24 (adisc->adisc_hard_addr, nport->fc_id); + adisc->adisc_wwpn = sparams->fl_wwpn; + adisc->adisc_wwnn = sparams->fl_wwnn; +hton24 (adisc->adisc_port_id, node->rnode.nport->fc_id); + +efc_els_send_req (node, els,EFC_DISC_IO_ELS_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_send_scr (struct efc_node *node) +{ +struct efc_els_io_req *els; +struct efc *efc = node->efc; +struct fc_els_scr *req; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*req)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="scr" ; + + req = els->io.req.virt; + +memset (req,0 ,sizeof (*req)); + req->scr_cmd =ELS_SCR ; + req->scr_reg_func =ELS_SCRF_FULL ; + +efc_els_send_req (node, els,EFC_DISC_IO_ELS_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_send_ls_rjt (struct efc_node *node,u32 ox_id,u32 reason_code, +u32 reason_code_expl,u32 vendor_unique) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els =NULL ; +struct fc_els_ls_rjt *rjt; + + els =efc_els_io_alloc (node,sizeof (*rjt)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + +node_els_trace (); + + els->display_name ="ls_rjt" ; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + + rjt = els->io.req.virt; +memset (rjt,0 ,sizeof (*rjt)); + + rjt->er_cmd =ELS_LS_RJT ; + rjt->er_reason = reason_code; + rjt->er_explan = reason_code_expl; + +efc_els_send_rsp (els,sizeof (*rjt)); + +return EFC_SUCCESS ; +} + +int +efc_send_plogi_acc (struct efc_node *node,u32 ox_id) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els =NULL ; +struct fc_els_flogi *plogi; +struct fc_els_flogi *req = (struct fc_els_flogi *)node->service_params; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*plogi)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="plogi_acc" ; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + + plogi = els->io.req.virt; + +/* copy our port's service parameters to payload */ +memcpy (plogi, node->nport->service_params,sizeof (*plogi)); + plogi->fl_cmd =ELS_LS_ACC ; +memset (plogi->_fl_resvd,0 ,sizeof (plogi->_fl_resvd)); + +/* Set Application header support bit if requested */ +if (req->fl_csp.sp_features &cpu_to_be16 (FC_SP_FT_BCAST )) + plogi->fl_csp.sp_features |=cpu_to_be16 (FC_SP_FT_BCAST ); + +efc_els_send_rsp (els,sizeof (*plogi)); + +return EFC_SUCCESS ; +} + +int +efc_send_flogi_p2p_acc (struct efc_node *node,u32 ox_id,u32 s_id) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els =NULL ; +struct fc_els_flogi *flogi; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*flogi)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="flogi_p2p_acc" ; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + els->io.iparam.els.s_id = s_id; + + flogi = els->io.req.virt; + +/* copy our port's service parameters to payload */ +memcpy (flogi, node->nport->service_params,sizeof (*flogi)); + flogi->fl_cmd =ELS_LS_ACC ; +memset (flogi->_fl_resvd,0 ,sizeof (flogi->_fl_resvd)); + +memset (flogi->fl_cssp,0 ,sizeof (flogi->fl_cssp)); + +efc_els_send_rsp (els,sizeof (*flogi)); + +return EFC_SUCCESS ; +} + +int +efc_send_prli_acc (struct efc_node *node,u32 ox_id) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els =NULL ; +struct { +struct fc_els_prli prli; +struct fc_els_spp spp; + } *pp; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*pp)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="prli_acc" ; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + + pp = els->io.req.virt; +memset (pp,0 ,sizeof (*pp)); + + pp->prli.prli_cmd =ELS_LS_ACC ; + pp->prli.prli_spp_len =0x10 ; + pp->prli.prli_len =cpu_to_be16 (sizeof (*pp)); + pp->spp.spp_type =FC_TYPE_FCP ; + pp->spp.spp_type_ext =0 ; + pp->spp.spp_flags =FC_SPP_EST_IMG_PAIR |FC_SPP_RESP_ACK ; + + pp->spp.spp_params =cpu_to_be32 (FCP_SPPF_RD_XRDY_DIS | + (node->nport->enable_ini ? +FCP_SPPF_INIT_FCN :0 ) | + (node->nport->enable_tgt ? +FCP_SPPF_TARG_FCN :0 )); + +efc_els_send_rsp (els,sizeof (*pp)); + +return EFC_SUCCESS ; +} + +int +efc_send_prlo_acc (struct efc_node *node,u32 ox_id) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els =NULL ; +struct { +struct fc_els_prlo prlo; +struct fc_els_spp spp; + } *pp; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*pp)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="prlo_acc" ; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + + pp = els->io.req.virt; +memset (pp,0 ,sizeof (*pp)); + pp->prlo.prlo_cmd =ELS_LS_ACC ; + pp->prlo.prlo_obs =0x10 ; + pp->prlo.prlo_len =cpu_to_be16 (sizeof (*pp)); + + pp->spp.spp_type =FC_TYPE_FCP ; + pp->spp.spp_type_ext =0 ; + pp->spp.spp_flags =FC_SPP_RESP_ACK ; + +efc_els_send_rsp (els,sizeof (*pp)); + +return EFC_SUCCESS ; +} + +int +efc_send_ls_acc (struct efc_node *node,u32 ox_id) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els =NULL ; +struct fc_els_ls_acc *acc; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*acc)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="ls_acc" ; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + + acc = els->io.req.virt; +memset (acc,0 ,sizeof (*acc)); + + acc->la_cmd =ELS_LS_ACC ; + +efc_els_send_rsp (els,sizeof (*acc)); + +return EFC_SUCCESS ; +} + +int +efc_send_logo_acc (struct efc_node *node,u32 ox_id) +{ +struct efc_els_io_req *els =NULL ; +struct efc *efc = node->efc; +struct fc_els_ls_acc *logo; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*logo)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="logo_acc" ; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + + logo = els->io.req.virt; +memset (logo,0 ,sizeof (*logo)); + + logo->la_cmd =ELS_LS_ACC ; + +efc_els_send_rsp (els,sizeof (*logo)); + +return EFC_SUCCESS ; +} + +int +efc_send_adisc_acc (struct efc_node *node,u32 ox_id) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els =NULL ; +struct fc_els_adisc *adisc; +struct fc_els_flogi *sparams; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*adisc)); +if (!els) { +efc_log_err (efc,"els IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->display_name ="adisc_acc" ; + +/* Go ahead and send the ELS_ACC */ +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + els->io.iparam.els.ox_id = ox_id; + + sparams = (struct fc_els_flogi *)node->nport->service_params; + adisc = els->io.req.virt; +memset (adisc,0 ,sizeof (*adisc)); + adisc->adisc_cmd =ELS_LS_ACC ; + adisc->adisc_wwpn = sparams->fl_wwpn; + adisc->adisc_wwnn = sparams->fl_wwnn; +hton24 (adisc->adisc_port_id, node->rnode.nport->fc_id); + +efc_els_send_rsp (els,sizeof (*adisc)); + +return EFC_SUCCESS ; +} + +static inline void +fcct_build_req_header (struct fc_ct_hdr *hdr,u16 cmd,u16 max_size) +{ + hdr->ct_rev =FC_CT_REV ; + hdr->ct_fs_type =FC_FST_DIR ; + hdr->ct_fs_subtype =FC_NS_SUBTYPE ; + hdr->ct_options =0 ; + hdr->ct_cmd =cpu_to_be16 (cmd); +/* words */ + hdr->ct_mr_size =cpu_to_be16 (max_size / (sizeof (u32))); + hdr->ct_reason =0 ; + hdr->ct_explan =0 ; + hdr->ct_vendor =0 ; +} + +int +efc_ns_send_rftid (struct efc_node *node) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els; +struct { +struct fc_ct_hdr hdr; +struct fc_ns_rft_id rftid; + } *ct; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*ct)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->io.iparam.ct.r_ctl =FC_RCTL_ELS_REQ ; + els->io.iparam.ct.type =FC_TYPE_CT ; + els->io.iparam.ct.df_ctl =0 ; + els->io.iparam.ct.timeout =EFC_FC_ELS_SEND_DEFAULT_TIMEOUT ; + + els->display_name ="rftid" ; + + ct = els->io.req.virt; +memset (ct,0 ,sizeof (*ct)); +fcct_build_req_header (&ct->hdr,FC_NS_RFT_ID , +sizeof (struct fc_ns_rft_id )); + +hton24 (ct->rftid.fr_fid.fp_fid, node->rnode.nport->fc_id); + ct->rftid.fr_fts.ff_type_map[FC_TYPE_FCP /FC_NS_BPW ] = +cpu_to_be32 (1 << (FC_TYPE_FCP %FC_NS_BPW )); + +efc_els_send_req (node, els,EFC_DISC_IO_CT_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_ns_send_rffid (struct efc_node *node) +{ +struct efc *efc = node->efc; +struct efc_els_io_req *els; +struct { +struct fc_ct_hdr hdr; +struct fc_ns_rff_id rffid; + } *ct; + +node_els_trace (); + + els =efc_els_io_alloc (node,sizeof (*ct)); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->io.iparam.ct.r_ctl =FC_RCTL_ELS_REQ ; + els->io.iparam.ct.type =FC_TYPE_CT ; + els->io.iparam.ct.df_ctl =0 ; + els->io.iparam.ct.timeout =EFC_FC_ELS_SEND_DEFAULT_TIMEOUT ; + + els->display_name ="rffid" ; + ct = els->io.req.virt; + +memset (ct,0 ,sizeof (*ct)); +fcct_build_req_header (&ct->hdr,FC_NS_RFF_ID , +sizeof (struct fc_ns_rff_id )); + +hton24 (ct->rffid.fr_fid.fp_fid, node->rnode.nport->fc_id); +if (node->nport->enable_ini) + ct->rffid.fr_feat |=FCP_FEAT_INIT ; +if (node->nport->enable_tgt) + ct->rffid.fr_feat |=FCP_FEAT_TARG ; + ct->rffid.fr_type =FC_TYPE_FCP ; + +efc_els_send_req (node, els,EFC_DISC_IO_CT_REQ ); + +return EFC_SUCCESS ; +} + +int +efc_ns_send_gidpt (struct efc_node *node) +{ +struct efc_els_io_req *els =NULL ; +struct efc *efc = node->efc; +struct { +struct fc_ct_hdr hdr; +struct fc_ns_gid_pt gidpt; + } *ct; + +node_els_trace (); + + els =efc_els_io_alloc_size (node,sizeof (*ct),EFC_ELS_GID_PT_RSP_LEN ); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + els->io.iparam.ct.r_ctl =FC_RCTL_ELS_REQ ; + els->io.iparam.ct.type =FC_TYPE_CT ; + els->io.iparam.ct.df_ctl =0 ; + els->io.iparam.ct.timeout =EFC_FC_ELS_SEND_DEFAULT_TIMEOUT ; + + els->display_name ="gidpt" ; + + ct = els->io.req.virt; + +memset (ct,0 ,sizeof (*ct)); +fcct_build_req_header (&ct->hdr,FC_NS_GID_PT , +sizeof (struct fc_ns_gid_pt )); + + ct->gidpt.fn_pt_type =FC_TYPE_FCP ; + +efc_els_send_req (node, els,EFC_DISC_IO_CT_REQ ); + +return EFC_SUCCESS ; +} + +void +efc_els_io_cleanup (struct efc_els_io_req *els, +enum efc_hw_node_els_event node_evt,void *arg) +{ +/* don't want further events that could come; e.g. abort requests +* from the node state machine; thus, disable state machine +*/ + els->els_req_free = true; +efc_node_post_els_resp (els->node, node_evt, arg); + +efc_els_io_free (els); +} + +static int +efc_ct_acc_cb (void *arg,u32 length,int status,u32 ext_status) +{ +struct efc_els_io_req *els = arg; + +efc_els_io_free (els); + +return EFC_SUCCESS ; +} + +int +efc_send_ct_rsp (struct efc *efc,struct efc_node *node,u16 ox_id, +struct fc_ct_hdr *ct_hdr,u32 cmd_rsp_code, +u32 reason_code,u32 reason_code_explanation) +{ +struct efc_els_io_req *els =NULL ; +struct fc_ct_hdr *rsp =NULL ; + + els =efc_els_io_alloc (node,256 ); +if (!els) { +efc_log_err (efc,"IO alloc failed\n" ); +return EFC_FAIL ; + } + + rsp = els->io.rsp.virt; + + *rsp = *ct_hdr; + +fcct_build_req_header (rsp, cmd_rsp_code,0 ); + rsp->ct_reason = reason_code; + rsp->ct_explan = reason_code_explanation; + + els->display_name ="ct_rsp" ; + els->cb = efc_ct_acc_cb; + +/* Prepare the IO request details */ + els->io.io_type =EFC_DISC_IO_CT_RESP ; + els->io.xmit_len =sizeof (*rsp); + + els->io.rpi = node->rnode.indicator; + els->io.d_id = node->rnode.fc_id; + +memset (&els->io.iparam,0 ,sizeof (els->io.iparam)); + + els->io.iparam.ct.ox_id = ox_id; + els->io.iparam.ct.r_ctl =3 ; + els->io.iparam.ct.type =FC_TYPE_CT ; + els->io.iparam.ct.df_ctl =0 ; + els->io.iparam.ct.timeout =5 ; + +if (efc->tt.send_els (efc, &els->io)) { +efc_els_io_free (els); +return EFC_FAIL ; + } +return EFC_SUCCESS ; +} + +int +efc_send_bls_acc (struct efc_node *node,struct fc_frame_header *hdr) +{ +struct sli_bls_params bls; +struct fc_ba_acc *acc; +struct efc *efc = node->efc; + +memset (&bls,0 ,sizeof (bls)); + bls.ox_id =be16_to_cpu (hdr->fh_ox_id); + bls.rx_id =be16_to_cpu (hdr->fh_rx_id); + bls.s_id =ntoh24 (hdr->fh_d_id); + bls.d_id = node->rnode.fc_id; + bls.rpi = node->rnode.indicator; + bls.vpi = node->nport->indicator; + + acc = (void *)bls.payload; + acc->ba_ox_id =cpu_to_be16 (bls.ox_id); + acc->ba_rx_id =cpu_to_be16 (bls.rx_id); + acc->ba_high_seq_cnt =cpu_to_be16 (U16_MAX ); + +return efc->tt.send_bls (efc,FC_RCTL_BA_ACC , &bls); +}drivers/scsi/elx/libefc/efc_els.h new file +97
-0@@ -0,0 +1,107 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +#ifndef __EFC_ELS_H__ +#define __EFC_ELS_H__ + +struct efc_els_io_req { +struct list_head list_entry; +struct kref ref; +void (*release)(struct kref *arg); +struct efc_node *node; +void *cb; +uint32_t els_retries_remaining; +bool els_req_free; +struct timer_list delay_timer; + +const char *display_name; + +struct efc_disc_io io; +}; + +typedef int (*efc_hw_srrs_cb_t )(void *arg,u32 length,int status, +u32 ext_status); + +void efc_io_alloc_enable (struct efc_node *node); +void efc_io_alloc_disable (struct efc_node *node); +void _efc_els_io_free (struct kref *arg); +struct efc_els_io_req * +efc_els_io_alloc (struct efc_node *node,u32 reqlen); +struct efc_els_io_req * +efc_els_io_alloc_size (struct efc_node *node,u32 reqlen,u32 rsplen); +void efc_els_io_free (struct efc_els_io_req *els); + +/* ELS command send */ +typedef void (*els_cb_t )(struct efc_node *node, +struct efc_node_cb *cbdata,void *arg); +int +efc_send_plogi (struct efc_node *node); +int +efc_send_flogi (struct efc_node *node); +int +efc_send_fdisc (struct efc_node *node); +int +efc_send_prli (struct efc_node *node); +int +efc_send_prlo (struct efc_node *node); +int +efc_send_logo (struct efc_node *node); +int +efc_send_adisc (struct efc_node *node); +int +efc_send_pdisc (struct efc_node *node); +int +efc_send_scr (struct efc_node *node); +int +efc_ns_send_rftid (struct efc_node *node); +int +efc_ns_send_rffid (struct efc_node *node); +int +efc_ns_send_gidpt (struct efc_node *node); +void +efc_els_io_cleanup (struct efc_els_io_req *els,enum efc_hw_node_els_event , +void *arg); + +/* ELS acc send */ +int +efc_send_ls_acc (struct efc_node *node,u32 ox_id); +int +efc_send_ls_rjt (struct efc_node *node,u32 ox_id,u32 reason_cod, +u32 reason_code_expl,u32 vendor_unique); +int +efc_send_flogi_p2p_acc (struct efc_node *node,u32 ox_id,u32 s_id); +int +efc_send_flogi_acc (struct efc_node *node,u32 ox_id,u32 is_fport); +int +efc_send_plogi_acc (struct efc_node *node,u32 ox_id); +int +efc_send_prli_acc (struct efc_node *node,u32 ox_id); +int +efc_send_logo_acc (struct efc_node *node,u32 ox_id); +int +efc_send_prlo_acc (struct efc_node *node,u32 ox_id); +int +efc_send_adisc_acc (struct efc_node *node,u32 ox_id); + +int +efc_bls_send_acc_hdr (struct efc *efc,struct efc_node *node, +struct fc_frame_header *hdr); +int +efc_bls_send_rjt_hdr (struct efc_els_io_req *io,struct fc_frame_header *hdr); + +int +efc_els_io_list_empty (struct efc_node *node,struct list_head *list); +
drivers/scsi/elx/libefc/efc_els.h line 107
Quoted 10 lines
drivers/scsi/elx/libefc/efc_els.h new file +10
-0+/* CT */ +int +efc_send_ct_rsp (struct efc *efc,struct efc_node *node,u16 ox_id, +struct fc_ct_hdr *ct_hdr,u32 cmd_rsp_code,u32 reason_code, +u32 reason_code_explanation); + +int +efc_send_bls_acc (struct efc_node *node,struct fc_frame_header *hdr); + +#endif /* __EFC_ELS_H__ */
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
PATCH v4 16/31 elx: libefc: Register discovery objects with hardware
In reply to James SmartThis patch continues the libefc library population.
This patch adds library interface definitions for:
-Registrations for VFI, VPI and RPI.
---
v4:
New patch cmds to register VFI, VPI and RPI.
Removed all hw related template calls and added issue_mbox_rqst
template call.
Populate all the mbox related cmds in discovery library into efc_cmds.c. Removed allocation of command buffer for mailbox, use stack variable
--- drivers/scsi/elx/libefc/efc_cmds.c | 877 +++++++++++++++++++++++++++++ drivers/scsi/elx/libefc/efc_cmds.h | 34 ++ 2 files changed, 911 insertions(+) create mode 100644 drivers/scsi/elx/libefc/efc_cmds.c create mode 100644 drivers/scsi/elx/libefc/efc_cmds.h
drivers/scsi/elx/libefc/efc_cmds.c new file +877 -0
@@ -0,0 +1,877 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +#include "efclib.h" +#include "../libefc_sli/sli4.h" +#include "efc_cmds.h" + +static void +efc_nport_free_resources (struct efc_nport *nport,int evt,void *data) +{ +struct efc *efc = nport->efc; + +/* Clear the nport attached flag */ + nport->attached = false; + +/* Free the service parameters buffer */ +if (nport->dma.virt) { +dma_free_coherent (&efc->pci->dev, nport->dma.size, + nport->dma.virt, nport->dma.phys); +memset (&nport->dma,0 ,sizeof (struct efc_dma )); + } + +/* Free the SLI resources */ +sli_resource_free (efc->sli,SLI4_RSRC_VPI , nport->indicator); + +efc_nport_cb (efc, evt, nport); +} + +static int +efc_nport_get_mbox_status (struct efc_nport *nport,u8 *mqe,int status) +{ +struct efc *efc = nport->efc; +struct sli4_mbox_command_header *hdr = + (struct sli4_mbox_command_header *)mqe; +int rc =0 ; + +if (status ||le16_to_cpu (hdr->status)) { +efc_log_debug (efc,"bad status vpi=%#x st=%x hdr=%x\n" , + nport->indicator, status,le16_to_cpu (hdr->status)); + rc =-1 ; + } + +return rc; +} + +static int +efc_nport_free_unreg_vpi_cb (struct efc *efc,int status,u8 *mqe,void *arg) +{ +struct efc_nport *nport = arg; +int evt =EFC_HW_PORT_FREE_OK ; +int rc =0 ; + + rc =efc_nport_get_mbox_status (nport, mqe, status); +if (rc) { + evt =EFC_HW_PORT_FREE_FAIL ; + rc =-1 ; + } + +efc_nport_free_resources (nport, evt, mqe); +return rc; +} + +static void +efc_nport_free_unreg_vpi (struct efc_nport *nport) +{ +struct efc *efc = nport->efc; +int rc; +u8 data[SLI4_BMBX_SIZE ]; + + rc =sli_cmd_unreg_vpi (efc->sli, data, nport->indicator, +SLI4_UNREG_TYPE_PORT ); +if (rc) { +efc_log_err (efc,"UNREG_VPI format failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_FREE_FAIL , data); +return ; + } + + rc = efc->tt.issue_mbox_rqst (efc->base, data, + efc_nport_free_unreg_vpi_cb, nport); +if (rc) { +efc_log_err (efc,"UNREG_VPI command failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_FREE_FAIL , data); + } +} + +static void +efc_nport_send_evt (struct efc_nport *nport,int evt,void *data) +{ +struct efc *efc = nport->efc; + +/* Now inform the registered callbacks */ +efc_nport_cb (efc, evt, nport); + +/* Set the nport attached flag */ +if (evt ==EFC_HW_PORT_ATTACH_OK ) + nport->attached = true; + +/* If there is a pending free request, then handle it now */ +if (nport->free_req_pending) +efc_nport_free_unreg_vpi (nport); +} + +static int +efc_nport_alloc_init_vpi_cb (struct efc *efc,int status,u8 *mqe,void *arg) +{ +struct efc_nport *nport = arg; +int rc; + + rc =efc_nport_get_mbox_status (nport, mqe, status); +if (rc) { +efc_nport_free_resources (nport,EFC_HW_PORT_ALLOC_FAIL , mqe); +return EFC_FAIL ; + } + +efc_nport_send_evt (nport,EFC_HW_PORT_ALLOC_OK , mqe); +return EFC_SUCCESS ; +} + +static void +efc_nport_alloc_init_vpi (struct efc_nport *nport) +{ +struct efc *efc = nport->efc; +u8 data[SLI4_BMBX_SIZE ]; +int rc; + +/* If there is a pending free request, then handle it now */ +if (nport->free_req_pending) { +efc_nport_free_resources (nport,EFC_HW_PORT_FREE_OK , data); +return ; + } + + rc =sli_cmd_init_vpi (efc->sli, data, + nport->indicator, nport->domain->indicator); +if (rc) { +efc_log_err (efc,"INIT_VPI format failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_ALLOC_FAIL , data); +return ; + } + + rc = efc->tt.issue_mbox_rqst (efc->base, data, + efc_nport_alloc_init_vpi_cb, nport); +if (rc) { +efc_log_err (efc,"INIT_VPI command failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_ALLOC_FAIL , data); + } +} + +static int +efc_nport_alloc_read_sparm64_cb (struct efc *efc,int status,u8 *mqe,void *arg) +{ +struct efc_nport *nport = arg; +u8 *payload =NULL ; +int rc; + + rc =efc_nport_get_mbox_status (nport, mqe, status); +if (rc) { +efc_nport_free_resources (nport,EFC_HW_PORT_ALLOC_FAIL , mqe); +return EFC_FAIL ; + } + + payload = nport->dma.virt; + +memcpy (&nport->sli_wwpn, payload +SLI4_READ_SPARM64_WWPN_OFFSET , +sizeof (nport->sli_wwpn)); +memcpy (&nport->sli_wwnn, payload +SLI4_READ_SPARM64_WWNN_OFFSET , +sizeof (nport->sli_wwnn)); + +dma_free_coherent (&efc->pci->dev, nport->dma.size, nport->dma.virt, + nport->dma.phys); +memset (&nport->dma,0 ,sizeof (struct efc_dma )); +efc_nport_alloc_init_vpi (nport); +return EFC_SUCCESS ; +} + +static void +efc_nport_alloc_read_sparm64 (struct efc *efc,struct efc_nport *nport) +{ +u8 data[SLI4_BMBX_SIZE ]; +int rc; + +/* Allocate memory for the service parameters */ + nport->dma.size =112 ; + nport->dma.virt =dma_alloc_coherent (&efc->pci->dev, + nport->dma.size, &nport->dma.phys, +GFP_DMA ); +if (!nport->dma.virt) { +efc_log_err (efc,"Failed to allocate DMA memory\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_ALLOC_FAIL , data); +return ; + } + + rc =sli_cmd_read_sparm64 (efc->sli, data, + &nport->dma, nport->indicator); +if (rc) { +efc_log_err (efc,"READ_SPARM64 format failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_ALLOC_FAIL , data); +return ; + } + + rc = efc->tt.issue_mbox_rqst (efc->base, data, + efc_nport_alloc_read_sparm64_cb, nport); +if (rc) { +efc_log_err (efc,"READ_SPARM64 command failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_ALLOC_FAIL , data); + } +} + +int +efc_cmd_nport_alloc (struct efc *efc,struct efc_nport *nport, +struct efc_domain *domain,u8 *wwpn) +{ +u32 rc =EFC_SUCCESS ; +u32 index; + + nport->indicator =U32_MAX ; + nport->free_req_pending = false; + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc,"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + +if (wwpn) +memcpy (&nport->sli_wwpn, wwpn,sizeof (nport->sli_wwpn)); + +/* +* allocate a VPI object for the port and stores it in the +* indicator field of the port object. +*/ +if (sli_resource_alloc (efc->sli,SLI4_RSRC_VPI , + &nport->indicator, &index)) { +efc_log_err (efc,"VPI allocation failure\n" ); +return EFC_FAIL ; + } + +if (domain) { +/* +* If the WWPN is NULL, fetch the default +* WWPN and WWNN before initializing the VPI +*/ +if (!wwpn) +efc_nport_alloc_read_sparm64 (efc, nport); +else +efc_nport_alloc_init_vpi (nport); + }else if (!wwpn) { +/* This is the convention for the HW, not SLI */ +efc_log_err (efc,"need WWN for physical port\n" ); + rc =EFC_FAIL ; + } + +/* domain NULL and wwpn non-NULL */ +if (rc) +sli_resource_free (efc->sli,SLI4_RSRC_VPI , nport->indicator); + +return rc; +} + +static int +efc_nport_attach_reg_vpi_cb (struct efc *efc,int status,u8 *mqe, +void *arg) +{ +struct efc_nport *nport = arg; +int rc; + + rc =efc_nport_get_mbox_status (nport, mqe, status); +if (rc) { +efc_nport_free_resources (nport,EFC_HW_PORT_ATTACH_FAIL , mqe); +return EFC_FAIL ; + } + +efc_nport_send_evt (nport,EFC_HW_PORT_ATTACH_OK , mqe); +return EFC_SUCCESS ; +} + +int +efc_cmd_nport_attach (struct efc *efc,struct efc_nport *nport,u32 fc_id) +{ +u8 buf[SLI4_BMBX_SIZE ]; +int rc =EFC_SUCCESS ; + +if (!nport) { +efc_log_err (efc,"bad param(s) nport=%p\n" , nport); +return EFC_FAIL ; + } + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc, +"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + + nport->fc_id = fc_id; + +/* register previously-allocated VPI with the device */ + rc =sli_cmd_reg_vpi (efc->sli, buf, nport->fc_id, + nport->sli_wwpn, nport->indicator, + nport->domain->indicator, false); +if (rc) { +efc_log_err (efc,"REG_VPI format failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_ATTACH_FAIL , buf); +return rc; + } + + rc = efc->tt.issue_mbox_rqst (efc->base, buf, + efc_nport_attach_reg_vpi_cb, nport); +if (rc) { +efc_log_err (efc,"REG_VPI command failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_ATTACH_FAIL , buf); + } + +return rc; +} + +int +efc_cmd_nport_free (struct efc *efc,struct efc_nport *nport) +{ +if (!nport) { +efc_log_err (efc,"bad parameter(s) nport=%p\n" , nport); +return EFC_FAIL ; + } + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc, +"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + +/* Issue the UNREG_VPI command to free the assigned VPI context */ +if (nport->attached) +efc_nport_free_unreg_vpi (nport); +else + nport->free_req_pending = true; + +return EFC_SUCCESS ; +} + +static int +efc_domain_get_mbox_status (struct efc_domain *domain,u8 *mqe,int status) +{ +struct efc *efc = domain->efc; +struct sli4_mbox_command_header *hdr = + (struct sli4_mbox_command_header *)mqe; +int rc =0 ; + +if (status ||le16_to_cpu (hdr->status)) { +efc_log_debug (efc,"bad status vfi=%#x st=%x hdr=%x\n" , + domain->indicator, status, +le16_to_cpu (hdr->status)); + rc =-1 ; + } + +return rc; +} + +static void +efc_domain_free_resources (struct efc_domain *domain,int evt,void *data) +{ +struct efc *efc = domain->efc; + +/* Free the service parameters buffer */ +if (domain->dma.virt) { +dma_free_coherent (&efc->pci->dev, + domain->dma.size, domain->dma.virt, + domain->dma.phys); +memset (&domain->dma,0 ,sizeof (struct efc_dma )); + } + +/* Free the SLI resources */ +sli_resource_free (efc->sli,SLI4_RSRC_VFI , domain->indicator); + +efc_domain_cb (efc, evt, domain); +} + +static void +efc_domain_send_nport_evt (struct efc_domain *domain, +int port_evt,int domain_evt,void *data) +{ +struct efc *efc = domain->efc; + +/* Send alloc/attach ok to the physical nport */ +efc_nport_send_evt (domain->nport, port_evt,NULL ); + +/* Now inform the registered callbacks */ +efc_domain_cb (efc, domain_evt, domain); +} + +static int +efc_domain_alloc_read_sparm64_cb (struct efc *efc,int status,u8 *mqe, +void *arg) +{ +struct efc_domain *domain = arg; +int rc; + + rc =efc_domain_get_mbox_status (domain, mqe, status); +if (rc) { +efc_domain_free_resources (domain, +EFC_HW_DOMAIN_ALLOC_FAIL , mqe); +return EFC_FAIL ; + } + +efc_domain_send_nport_evt (domain,EFC_HW_PORT_ALLOC_OK , +EFC_HW_DOMAIN_ALLOC_OK , mqe); +return EFC_SUCCESS ; +} + +static void +efc_domain_alloc_read_sparm64 (struct efc_domain *domain) +{ +struct efc *efc = domain->efc; +u8 data[SLI4_BMBX_SIZE ]; +int rc; + + rc =sli_cmd_read_sparm64 (efc->sli, data, &domain->dma,0 ); +if (rc) { +efc_log_err (efc,"READ_SPARM64 format failure\n" ); +efc_domain_free_resources (domain, +EFC_HW_DOMAIN_ALLOC_FAIL , data); +return ; + } + + rc = efc->tt.issue_mbox_rqst (efc->base, data, + efc_domain_alloc_read_sparm64_cb, domain); +if (rc) { +efc_log_err (efc,"READ_SPARM64 command failure\n" ); +efc_domain_free_resources (domain, +EFC_HW_DOMAIN_ALLOC_FAIL , data); + } +} + +static int +efc_domain_alloc_init_vfi_cb (struct efc *efc,int status,u8 *mqe, +void *arg) +{ +struct efc_domain *domain = arg; +int rc; + + rc =efc_domain_get_mbox_status (domain, mqe, status); +if (rc) { +efc_domain_free_resources (domain, +EFC_HW_DOMAIN_ALLOC_FAIL , mqe); +return EFC_FAIL ; + } + +efc_domain_alloc_read_sparm64 (domain); +return EFC_SUCCESS ; +} + +static void +efc_domain_alloc_init_vfi (struct efc_domain *domain) +{ +struct efc *efc = domain->efc; +struct efc_nport *nport = domain->nport; +u8 data[SLI4_BMBX_SIZE ]; +int rc; + +/* +* For FC, the HW alread registered an FCFI. +* Copy FCF information into the domain and jump to INIT_VFI. +*/ + domain->fcf_indicator = efc->fcfi; + rc =sli_cmd_init_vfi (efc->sli, data, domain->indicator, + domain->fcf_indicator, nport->indicator); +if (rc) { +efc_log_err (efc,"INIT_VFI format failure\n" ); +efc_domain_free_resources (domain, +EFC_HW_DOMAIN_ALLOC_FAIL , data); +return ; + } + +efc_log_err (efc,"%s issue mbox\n" , __func__); + rc = efc->tt.issue_mbox_rqst (efc->base, data, + efc_domain_alloc_init_vfi_cb, domain); +if (rc) { +efc_log_err (efc,"INIT_VFI command failure\n" ); +efc_domain_free_resources (domain, +EFC_HW_DOMAIN_ALLOC_FAIL , data); + } +} + +int +efc_cmd_domain_alloc (struct efc *efc,struct efc_domain *domain,u32 fcf) +{ +u32 index; + +if (!domain || !domain->nport) { +efc_log_err (efc,"bad parameter(s) domain=%p nport=%p\n" , + domain, domain ? domain->nport :NULL ); +return EFC_FAIL ; + } + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc, +"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + +/* allocate memory for the service parameters */ + domain->dma.size =112 ; + domain->dma.virt =dma_alloc_coherent (&efc->pci->dev, + domain->dma.size, + &domain->dma.phys,GFP_DMA ); +if (!domain->dma.virt) { +efc_log_err (efc,"Failed to allocate DMA memory\n" ); +return EFC_FAIL ; + } + + domain->fcf = fcf; + domain->fcf_indicator =U32_MAX ; + domain->indicator =U32_MAX ; + +if (sli_resource_alloc (efc->sli,SLI4_RSRC_VFI , &domain->indicator, + &index)) { +efc_log_err (efc,"VFI allocation failure\n" ); + +dma_free_coherent (&efc->pci->dev, + domain->dma.size, domain->dma.virt, + domain->dma.phys); +memset (&domain->dma,0 ,sizeof (struct efc_dma )); + +return EFC_FAIL ; + } + +efc_domain_alloc_init_vfi (domain); +return EFC_SUCCESS ; +} + +static int +efc_domain_attach_reg_vfi_cb (struct efc *efc,int status,u8 *mqe, +void *arg) +{ +struct efc_domain *domain = arg; +int rc; + + rc =efc_domain_get_mbox_status (domain, mqe, status); +if (rc) { +//hw->domain = NULL; +efc_domain_free_resources (domain, +EFC_HW_DOMAIN_ATTACH_FAIL , mqe); +return EFC_FAIL ; + } + +efc_domain_send_nport_evt (domain,EFC_HW_PORT_ATTACH_OK , +EFC_HW_DOMAIN_ATTACH_OK , mqe); +return EFC_SUCCESS ; +} + +int +efc_cmd_domain_attach (struct efc *efc,struct efc_domain *domain,u32 fc_id) +{ +u8 buf[SLI4_BMBX_SIZE ]; +int rc =EFC_SUCCESS ; + +if (!domain) { +efc_log_err (efc,"bad param(s) domain=%p\n" , domain); +return EFC_FAIL ; + } + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc, +"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + + domain->nport->fc_id = fc_id; + + rc =sli_cmd_reg_vfi (efc->sli, buf,SLI4_BMBX_SIZE , domain->indicator, + domain->fcf_indicator, domain->dma, + domain->nport->indicator, domain->nport->sli_wwpn, + domain->nport->fc_id); +if (rc) { +efc_log_err (efc,"REG_VFI format failure\n" ); + goto cleanup; + } + + rc = efc->tt.issue_mbox_rqst (efc->base, buf, + efc_domain_attach_reg_vfi_cb, domain); +if (rc) { +efc_log_err (efc,"REG_VFI command failure\n" ); + goto cleanup; + } + +return rc; + +cleanup: +efc_domain_free_resources (domain,EFC_HW_DOMAIN_ATTACH_FAIL , buf); + +return rc; +} + +static int +efc_domain_free_unreg_vfi_cb (struct efc *efc,int status,u8 *mqe,void *arg) +{ +struct efc_domain *domain = arg; +int evt =EFC_HW_DOMAIN_FREE_OK ; +int rc =0 ; + + rc =efc_domain_get_mbox_status (domain, mqe, status); +if (rc) { + evt =EFC_HW_DOMAIN_FREE_FAIL ; + rc =-1 ; + } + +efc_domain_free_resources (domain, evt, mqe); +return rc; +} + +static void +efc_domain_free_unreg_vfi (struct efc_domain *domain) +{ +struct efc *efc = domain->efc; +int rc; +u8 data[SLI4_BMBX_SIZE ]; + + rc =sli_cmd_unreg_vfi (efc->sli, data, domain->indicator, +SLI4_UNREG_TYPE_DOMAIN ); +if (rc) { +efc_log_err (efc,"UNREG_VFI format failure\n" ); + goto cleanup; + } + + rc = efc->tt.issue_mbox_rqst (efc->base, data, + efc_domain_free_unreg_vfi_cb, domain); +if (rc) { +efc_log_err (efc,"UNREG_VFI command failure\n" ); + goto cleanup; + } + +return ; + +cleanup: +efc_domain_free_resources (domain,EFC_HW_DOMAIN_FREE_FAIL , data); +} + +int +efc_cmd_domain_free (struct efc *efc,struct efc_domain *domain) +{ +int rc =EFC_SUCCESS ; + +if (!domain) { +efc_log_err (efc,"bad parameter(s) domain=%p\n" , domain); +return EFC_FAIL ; + } + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc, +"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + +efc_domain_free_unreg_vfi (domain); +return rc; +} + +int +efc_cmd_node_alloc (struct efc *efc,struct efc_remote_node *rnode,u32 fc_addr, +struct efc_nport *nport) +{ +/* Check for invalid indicator */ +if (rnode->indicator !=U32_MAX ) { +efc_log_err (efc, +"RPI allocation failure addr=%#x rpi=%#x\n" , + fc_addr, rnode->indicator); +return EFC_FAIL ; + } + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc, +"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + +/* NULL SLI port indicates an unallocated remote node */ + rnode->nport =NULL ; + +if (sli_resource_alloc (efc->sli,SLI4_RSRC_RPI , + &rnode->indicator, &rnode->index)) { +efc_log_err (efc,"RPI allocation failure addr=%#x\n" , + fc_addr); +return EFC_FAIL ; + } + + rnode->fc_id = fc_addr; + rnode->nport = nport; + +return EFC_SUCCESS ; +} + +static int +efc_cmd_node_attach_cb (struct efc *efc,int status,u8 *mqe,void *arg) +{ +struct efc_remote_node *rnode = arg; +struct sli4_mbox_command_header *hdr = + (struct sli4_mbox_command_header *)mqe; +enum efc_hw_remote_node_event evt =0 ; + +if (status ||le16_to_cpu (hdr->status)) { +efc_log_debug (efc,"bad status cqe=%#x mqe=%#x\n" , status, +le16_to_cpu (hdr->status)); + rnode->attached = false; + evt =EFC_HW_NODE_ATTACH_FAIL ; + }else { + rnode->attached = true; + evt =EFC_HW_NODE_ATTACH_OK ; + } + +efc_remote_node_cb (efc, evt, rnode); + +return EFC_SUCCESS ; +} + +int +efc_cmd_node_attach (struct efc *efc,struct efc_remote_node *rnode, +struct efc_dma *sparms) +{ +int rc =EFC_FAIL ; +u8 buf[SLI4_BMBX_SIZE ]; + +if (!rnode || !sparms) { +efc_log_err (efc,"bad parameter(s) rnode=%p sparms=%p\n" , + rnode, sparms); +return EFC_FAIL ; + } + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc,"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + +/* +* If the attach count is non-zero, this RPI has already been reg'd. +* Otherwise, register the RPI +*/ +if (rnode->index ==U32_MAX ) { +efc_log_err (efc,"bad parameter rnode->index invalid\n" ); +return EFC_FAIL ; + } + +/* Update a remote node object with the remote port's service params */ +if (!sli_cmd_reg_rpi (efc->sli, buf, rnode->indicator, + rnode->nport->indicator, rnode->fc_id, sparms,0 ,0 )) + rc = efc->tt.issue_mbox_rqst (efc->base, buf, + efc_cmd_node_attach_cb, rnode); + +return rc; +} + +int +efc_node_free_resources (struct efc *efc,struct efc_remote_node *rnode) +{ +int rc =EFC_SUCCESS ; + +if (!rnode) { +efc_log_err (efc,"bad parameter rnode=%p\n" , rnode); +return EFC_FAIL ; + } + +if (rnode->nport) { +if (rnode->attached) { +efc_log_err (efc,"Err: rnode is still attached\n" ); +return EFC_FAIL ; + } +if (rnode->indicator !=U32_MAX ) { +if (sli_resource_free (efc->sli,SLI4_RSRC_RPI , + rnode->indicator)) { +efc_log_err (efc, +"RPI free fail RPI %d addr=%#x\n" , + rnode->indicator, rnode->fc_id); + rc =EFC_FAIL ; + }else { + rnode->indicator =U32_MAX ; + rnode->index =U32_MAX ; + } + } + } + +return rc; +} + +static int +efc_cmd_node_free_cb (struct efc *efc,int status,u8 *mqe,void *arg) +{ +struct efc_remote_node *rnode = arg; +struct sli4_mbox_command_header *hdr = + (struct sli4_mbox_command_header *)mqe; +enum efc_hw_remote_node_event evt =EFC_HW_NODE_FREE_FAIL ; +int rc =0 ; + +if (status ||le16_to_cpu (hdr->status)) { +efc_log_debug (efc,"bad status cqe=%#x mqe=%#x\n" , status, +le16_to_cpu (hdr->status)); + +/* +* In certain cases, a non-zero MQE status is OK (all must be +* true): +* - node is attached +* - status is 0x1400 +*/ +if (!rnode->attached || + (le16_to_cpu (hdr->status) !=SLI4_MBX_STATUS_RPI_NOT_REG )) + rc =EFC_FAIL ; + } + +if (!rc) { + rnode->attached = false; + evt =EFC_HW_NODE_FREE_OK ; + } + +efc_remote_node_cb (efc, evt, rnode); + +return rc; +} + +int +efc_cmd_node_detach (struct efc *efc,struct efc_remote_node *rnode) +{ +u8 buf[SLI4_BMBX_SIZE ]; +int rc =EFC_FAIL ; + +if (!rnode) { +efc_log_err (efc,"bad parameter rnode=%p\n" , rnode); +return EFC_FAIL ; + } + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc,"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + +if (rnode->nport) { +if (!rnode->attached) +return EFC_FAIL ; + + rc =EFC_FAIL ; + +if (!sli_cmd_unreg_rpi (efc->sli, buf, rnode->indicator, +SLI4_RSRC_RPI ,U32_MAX )) + rc = efc->tt.issue_mbox_rqst (efc->base, buf, + efc_cmd_node_free_cb, rnode); + +if (rc !=EFC_SUCCESS ) { +efc_log_err (efc,"UNREG_RPI failed\n" ); + rc =EFC_FAIL ; + } + } + +return rc; +}
drivers/scsi/elx/libefc/efc_cmds.h new file +34 -0
@@ -0,0 +1,34 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +#ifndef __EFC_CMDS_H__ +#define __EFC_CMDS_H__ + +int +efc_cmd_nport_alloc (struct efc *efc,struct efc_nport *nport, +struct efc_domain *domain,u8 *wwpn); +int +efc_cmd_nport_attach (struct efc *efc,struct efc_nport *nport,u32 fc_id); +int +efc_cmd_nport_free (struct efc *efc,struct efc_nport *nport); +int +efc_cmd_domain_alloc (struct efc *efc,struct efc_domain *domain,u32 fcf); +int +efc_cmd_domain_attach (struct efc *efc,struct efc_domain *domain,u32 fc_id); +int +efc_cmd_domain_free (struct efc *efc,struct efc_domain *domain); +int +efc_cmd_node_detach (struct efc *efc,struct efc_remote_node *rnode); +int +efc_node_free_resources (struct efc *efc,struct efc_remote_node *rnode); +int +efc_cmd_node_attach (struct efc *efc,struct efc_remote_node *rnode, +struct efc_dma *sparms); +int +efc_cmd_node_alloc (struct efc *efc,struct efc_remote_node *rnode,u32 fc_addr, +struct efc_nport *nport); + +#endif /* __EFC_CMDS_H */
Signature · 1 line
2.26.2
Re: [PATCH v4 16/31] elx: libefc: Register discovery objects with hardware
Quoted 204 lines · James Smart
This patch continues the libefc library population.
This patch adds library interface definitions for:
-Registrations for VFI, VPI and RPI.Co-developed-by Ram Vegesna <[email protected]>Signed-off-by Ram Vegesna <[email protected]>Signed-off-by James Smart <[email protected]>---
v4:
New patch cmds to register VFI, VPI and RPI.
Removed all hw related template calls and addedissue_mbox_rqst
template call.
Populate all the mbox related cmds in discovery library intoefc_cmds.c. Removed allocation of command buffer for mailbox, use stack variable--- drivers/scsi/elx/libefc/efc_cmds.c | 877 +++++++++++++++++++++++++++++ drivers/scsi/elx/libefc/efc_cmds.h | 34 ++ 2 files changed, 911 insertions(+)create mode 100644
drivers/scsi/elx/libefc/efc_cmds.ccreate mode 100644drivers/scsi/elx/libefc/efc_cmds.hdrivers/scsi/elx/libefc/efc_cmds.c new file +175
-0@@ -0,0 +1,877 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +#include "efclib.h" +#include "../libefc_sli/sli4.h" +#include "efc_cmds.h" + +static void +efc_nport_free_resources (struct efc_nport *nport,int evt,void *data) +{ +struct efc *efc = nport->efc; + +/* Clear the nport attached flag */ + nport->attached = false; + +/* Free the service parameters buffer */ +if (nport->dma.virt) { +dma_free_coherent (&efc->pci->dev, nport->dma.size, + nport->dma.virt, nport->dma.phys); +memset (&nport->dma,0 ,sizeof (struct efc_dma )); + } + +/* Free the SLI resources */ +sli_resource_free (efc->sli,SLI4_RSRC_VPI , nport->indicator); + +efc_nport_cb (efc, evt, nport); +} + +static int +efc_nport_get_mbox_status (struct efc_nport *nport,u8 *mqe,int status) +{ +struct efc *efc = nport->efc; +struct sli4_mbox_command_header *hdr = + (struct sli4_mbox_command_header *)mqe; +int rc =0 ; + +if (status ||le16_to_cpu (hdr->status)) { +efc_log_debug (efc,"bad status vpi=%#x st=%x hdr=%x\n" , + nport->indicator, status,le16_to_cpu (hdr->status)); + rc =-1 ; + } + +return rc; +} + +static int +efc_nport_free_unreg_vpi_cb (struct efc *efc,int status,u8 *mqe,void *arg) +{ +struct efc_nport *nport = arg; +int evt =EFC_HW_PORT_FREE_OK ; +int rc =0 ; + + rc =efc_nport_get_mbox_status (nport, mqe, status); +if (rc) { + evt =EFC_HW_PORT_FREE_FAIL ; + rc =-1 ; + } + +efc_nport_free_resources (nport, evt, mqe); +return rc; +} + +static void +efc_nport_free_unreg_vpi (struct efc_nport *nport) +{ +struct efc *efc = nport->efc; +int rc; +u8 data[SLI4_BMBX_SIZE ]; + + rc =sli_cmd_unreg_vpi (efc->sli, data, nport->indicator, +SLI4_UNREG_TYPE_PORT ); +if (rc) { +efc_log_err (efc,"UNREG_VPI format failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_FREE_FAIL , data); +return ; + } + + rc = efc->tt.issue_mbox_rqst (efc->base, data, + efc_nport_free_unreg_vpi_cb, nport); +if (rc) { +efc_log_err (efc,"UNREG_VPI command failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_FREE_FAIL , data); + } +} + +static void +efc_nport_send_evt (struct efc_nport *nport,int evt,void *data) +{ +struct efc *efc = nport->efc; + +/* Now inform the registered callbacks */ +efc_nport_cb (efc, evt, nport); + +/* Set the nport attached flag */ +if (evt ==EFC_HW_PORT_ATTACH_OK ) + nport->attached = true; + +/* If there is a pending free request, then handle it now */ +if (nport->free_req_pending) +efc_nport_free_unreg_vpi (nport); +} + +static int +efc_nport_alloc_init_vpi_cb (struct efc *efc,int status,u8 *mqe,void *arg) +{ +struct efc_nport *nport = arg; +int rc; + + rc =efc_nport_get_mbox_status (nport, mqe, status); +if (rc) { +efc_nport_free_resources (nport,EFC_HW_PORT_ALLOC_FAIL , mqe); +return EFC_FAIL ; + } + +efc_nport_send_evt (nport,EFC_HW_PORT_ALLOC_OK , mqe); +return EFC_SUCCESS ; +} + +static void +efc_nport_alloc_init_vpi (struct efc_nport *nport) +{ +struct efc *efc = nport->efc; +u8 data[SLI4_BMBX_SIZE ]; +int rc; + +/* If there is a pending free request, then handle it now */ +if (nport->free_req_pending) { +efc_nport_free_resources (nport,EFC_HW_PORT_FREE_OK , data); +return ; + } + + rc =sli_cmd_init_vpi (efc->sli, data, + nport->indicator, nport->domain->indicator); +if (rc) { +efc_log_err (efc,"INIT_VPI format failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_ALLOC_FAIL , data); +return ; + } + + rc = efc->tt.issue_mbox_rqst (efc->base, data, + efc_nport_alloc_init_vpi_cb, nport); +if (rc) { +efc_log_err (efc,"INIT_VPI command failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_ALLOC_FAIL , data); + } +} + +static int +efc_nport_alloc_read_sparm64_cb (struct efc *efc,int status,u8 *mqe,void *arg) +{ +struct efc_nport *nport = arg; +u8 *payload =NULL ; +int rc; + + rc =efc_nport_get_mbox_status (nport, mqe, status); +if (rc) { +efc_nport_free_resources (nport,EFC_HW_PORT_ALLOC_FAIL , mqe); +return EFC_FAIL ; + } + + payload = nport->dma.virt; + +memcpy (&nport->sli_wwpn, payload +SLI4_READ_SPARM64_WWPN_OFFSET , +sizeof (nport->sli_wwpn)); +memcpy (&nport->sli_wwnn, payload +SLI4_READ_SPARM64_WWNN_OFFSET , +sizeof (nport->sli_wwnn)); + +dma_free_coherent (&efc->pci->dev, nport->dma.size, nport->dma.virt, + nport->dma.phys); +memset (&nport->dma,0 ,sizeof (struct efc_dma )); +efc_nport_alloc_init_vpi (nport); +return EFC_SUCCESS ;
drivers/scsi/elx/libefc/efc_cmds.c line 185
Quoted 10 lines
drivers/scsi/elx/libefc/efc_cmds.c new file +10
-0+} + +static void +efc_nport_alloc_read_sparm64 (struct efc *efc,struct efc_nport *nport) +{ +u8 data[SLI4_BMBX_SIZE ]; +int rc; + +/* Allocate memory for the service parameters */ + nport->dma.size =112 ;
Please use a define here for the size.
Quoted 318 lines
drivers/scsi/elx/libefc/efc_cmds.c new file +318
-0+ nport->dma.virt =dma_alloc_coherent (&efc->pci->dev, + nport->dma.size, &nport->dma.phys, +GFP_DMA ); +if (!nport->dma.virt) { +efc_log_err (efc,"Failed to allocate DMA memory\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_ALLOC_FAIL , data); +return ; + } + + rc =sli_cmd_read_sparm64 (efc->sli, data, + &nport->dma, nport->indicator); +if (rc) { +efc_log_err (efc,"READ_SPARM64 format failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_ALLOC_FAIL , data); +return ; + } + + rc = efc->tt.issue_mbox_rqst (efc->base, data, + efc_nport_alloc_read_sparm64_cb, nport); +if (rc) { +efc_log_err (efc,"READ_SPARM64 command failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_ALLOC_FAIL , data); + } +} + +int +efc_cmd_nport_alloc (struct efc *efc,struct efc_nport *nport, +struct efc_domain *domain,u8 *wwpn) +{ +u32 rc =EFC_SUCCESS ; +u32 index; + + nport->indicator =U32_MAX ; + nport->free_req_pending = false; + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc,"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + +if (wwpn) +memcpy (&nport->sli_wwpn, wwpn,sizeof (nport->sli_wwpn)); + +/* +* allocate a VPI object for the port and stores it in the +* indicator field of the port object. +*/ +if (sli_resource_alloc (efc->sli,SLI4_RSRC_VPI , + &nport->indicator, &index)) { +efc_log_err (efc,"VPI allocation failure\n" ); +return EFC_FAIL ; + } + +if (domain) { +/* +* If the WWPN is NULL, fetch the default +* WWPN and WWNN before initializing the VPI +*/ +if (!wwpn) +efc_nport_alloc_read_sparm64 (efc, nport); +else +efc_nport_alloc_init_vpi (nport); + }else if (!wwpn) { +/* This is the convention for the HW, not SLI */ +efc_log_err (efc,"need WWN for physical port\n" ); + rc =EFC_FAIL ; + } + +/* domain NULL and wwpn non-NULL */ +if (rc) +sli_resource_free (efc->sli,SLI4_RSRC_VPI , nport->indicator); + +return rc; +} + +static int +efc_nport_attach_reg_vpi_cb (struct efc *efc,int status,u8 *mqe, +void *arg) +{ +struct efc_nport *nport = arg; +int rc; + + rc =efc_nport_get_mbox_status (nport, mqe, status); +if (rc) { +efc_nport_free_resources (nport,EFC_HW_PORT_ATTACH_FAIL , mqe); +return EFC_FAIL ; + } + +efc_nport_send_evt (nport,EFC_HW_PORT_ATTACH_OK , mqe); +return EFC_SUCCESS ; +} + +int +efc_cmd_nport_attach (struct efc *efc,struct efc_nport *nport,u32 fc_id) +{ +u8 buf[SLI4_BMBX_SIZE ]; +int rc =EFC_SUCCESS ; + +if (!nport) { +efc_log_err (efc,"bad param(s) nport=%p\n" , nport); +return EFC_FAIL ; + } + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc, +"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + + nport->fc_id = fc_id; + +/* register previously-allocated VPI with the device */ + rc =sli_cmd_reg_vpi (efc->sli, buf, nport->fc_id, + nport->sli_wwpn, nport->indicator, + nport->domain->indicator, false); +if (rc) { +efc_log_err (efc,"REG_VPI format failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_ATTACH_FAIL , buf); +return rc; + } + + rc = efc->tt.issue_mbox_rqst (efc->base, buf, + efc_nport_attach_reg_vpi_cb, nport); +if (rc) { +efc_log_err (efc,"REG_VPI command failure\n" ); +efc_nport_free_resources (nport,EFC_HW_PORT_ATTACH_FAIL , buf); + } + +return rc; +} + +int +efc_cmd_nport_free (struct efc *efc,struct efc_nport *nport) +{ +if (!nport) { +efc_log_err (efc,"bad parameter(s) nport=%p\n" , nport); +return EFC_FAIL ; + } + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc, +"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + +/* Issue the UNREG_VPI command to free the assigned VPI context */ +if (nport->attached) +efc_nport_free_unreg_vpi (nport); +else + nport->free_req_pending = true; + +return EFC_SUCCESS ; +} + +static int +efc_domain_get_mbox_status (struct efc_domain *domain,u8 *mqe,int status) +{ +struct efc *efc = domain->efc; +struct sli4_mbox_command_header *hdr = + (struct sli4_mbox_command_header *)mqe; +int rc =0 ; + +if (status ||le16_to_cpu (hdr->status)) { +efc_log_debug (efc,"bad status vfi=%#x st=%x hdr=%x\n" , + domain->indicator, status, +le16_to_cpu (hdr->status)); + rc =-1 ; + } + +return rc; +} + +static void +efc_domain_free_resources (struct efc_domain *domain,int evt,void *data) +{ +struct efc *efc = domain->efc; + +/* Free the service parameters buffer */ +if (domain->dma.virt) { +dma_free_coherent (&efc->pci->dev, + domain->dma.size, domain->dma.virt, + domain->dma.phys); +memset (&domain->dma,0 ,sizeof (struct efc_dma )); + } + +/* Free the SLI resources */ +sli_resource_free (efc->sli,SLI4_RSRC_VFI , domain->indicator); + +efc_domain_cb (efc, evt, domain); +} + +static void +efc_domain_send_nport_evt (struct efc_domain *domain, +int port_evt,int domain_evt,void *data) +{ +struct efc *efc = domain->efc; + +/* Send alloc/attach ok to the physical nport */ +efc_nport_send_evt (domain->nport, port_evt,NULL ); + +/* Now inform the registered callbacks */ +efc_domain_cb (efc, domain_evt, domain); +} + +static int +efc_domain_alloc_read_sparm64_cb (struct efc *efc,int status,u8 *mqe, +void *arg) +{ +struct efc_domain *domain = arg; +int rc; + + rc =efc_domain_get_mbox_status (domain, mqe, status); +if (rc) { +efc_domain_free_resources (domain, +EFC_HW_DOMAIN_ALLOC_FAIL , mqe); +return EFC_FAIL ; + } + +efc_domain_send_nport_evt (domain,EFC_HW_PORT_ALLOC_OK , +EFC_HW_DOMAIN_ALLOC_OK , mqe); +return EFC_SUCCESS ; +} + +static void +efc_domain_alloc_read_sparm64 (struct efc_domain *domain) +{ +struct efc *efc = domain->efc; +u8 data[SLI4_BMBX_SIZE ]; +int rc; + + rc =sli_cmd_read_sparm64 (efc->sli, data, &domain->dma,0 ); +if (rc) { +efc_log_err (efc,"READ_SPARM64 format failure\n" ); +efc_domain_free_resources (domain, +EFC_HW_DOMAIN_ALLOC_FAIL , data); +return ; + } + + rc = efc->tt.issue_mbox_rqst (efc->base, data, + efc_domain_alloc_read_sparm64_cb, domain); +if (rc) { +efc_log_err (efc,"READ_SPARM64 command failure\n" ); +efc_domain_free_resources (domain, +EFC_HW_DOMAIN_ALLOC_FAIL , data); + } +} + +static int +efc_domain_alloc_init_vfi_cb (struct efc *efc,int status,u8 *mqe, +void *arg) +{ +struct efc_domain *domain = arg; +int rc; + + rc =efc_domain_get_mbox_status (domain, mqe, status); +if (rc) { +efc_domain_free_resources (domain, +EFC_HW_DOMAIN_ALLOC_FAIL , mqe); +return EFC_FAIL ; + } + +efc_domain_alloc_read_sparm64 (domain); +return EFC_SUCCESS ; +} + +static void +efc_domain_alloc_init_vfi (struct efc_domain *domain) +{ +struct efc *efc = domain->efc; +struct efc_nport *nport = domain->nport; +u8 data[SLI4_BMBX_SIZE ]; +int rc; + +/* +* For FC, the HW alread registered an FCFI. +* Copy FCF information into the domain and jump to INIT_VFI. +*/ + domain->fcf_indicator = efc->fcfi; + rc =sli_cmd_init_vfi (efc->sli, data, domain->indicator, + domain->fcf_indicator, nport->indicator); +if (rc) { +efc_log_err (efc,"INIT_VFI format failure\n" ); +efc_domain_free_resources (domain, +EFC_HW_DOMAIN_ALLOC_FAIL , data); +return ; + } + +efc_log_err (efc,"%s issue mbox\n" , __func__); + rc = efc->tt.issue_mbox_rqst (efc->base, data, + efc_domain_alloc_init_vfi_cb, domain); +if (rc) { +efc_log_err (efc,"INIT_VFI command failure\n" ); +efc_domain_free_resources (domain, +EFC_HW_DOMAIN_ALLOC_FAIL , data); + } +} + +int +efc_cmd_domain_alloc (struct efc *efc,struct efc_domain *domain,u32 fcf) +{ +u32 index; + +if (!domain || !domain->nport) { +efc_log_err (efc,"bad parameter(s) domain=%p nport=%p\n" , + domain, domain ? domain->nport :NULL ); +return EFC_FAIL ; + } + +/*
drivers/scsi/elx/libefc/efc_cmds.c line 513
Quoted 10 lines
drivers/scsi/elx/libefc/efc_cmds.c new file +10
-0+* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc, +"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + +/* allocate memory for the service parameters */ + domain->dma.size =112 ;
Same here.
Quoted 28 lines
drivers/scsi/elx/libefc/efc_cmds.c new file +28
-0+ domain->dma.virt =dma_alloc_coherent (&efc->pci->dev, + domain->dma.size, + &domain->dma.phys,GFP_DMA ); +if (!domain->dma.virt) { +efc_log_err (efc,"Failed to allocate DMA memory\n" ); +return EFC_FAIL ; + } + + domain->fcf = fcf; + domain->fcf_indicator =U32_MAX ; + domain->indicator =U32_MAX ; + +if (sli_resource_alloc (efc->sli,SLI4_RSRC_VFI , &domain->indicator, + &index)) { +efc_log_err (efc,"VFI allocation failure\n" ); + +dma_free_coherent (&efc->pci->dev, + domain->dma.size, domain->dma.virt, + domain->dma.phys); +memset (&domain->dma,0 ,sizeof (struct efc_dma )); + +return EFC_FAIL ; + } + +efc_domain_alloc_init_vfi (domain); +return EFC_SUCCESS ; +} +
drivers/scsi/elx/libefc/efc_cmds.c line 551
Quoted 10 lines
drivers/scsi/elx/libefc/efc_cmds.c new file +10
-0+static int +efc_domain_attach_reg_vfi_cb (struct efc *efc,int status,u8 *mqe, +void *arg) +{ +struct efc_domain *domain = arg; +int rc; + + rc =efc_domain_get_mbox_status (domain, mqe, status); +if (rc) { +//hw->domain = NULL;
Huh? Left-over debugging code?
Quoted 57 lines
drivers/scsi/elx/libefc/efc_cmds.c new file +57
-0+efc_domain_free_resources (domain, +EFC_HW_DOMAIN_ATTACH_FAIL , mqe); +return EFC_FAIL ; + } + +efc_domain_send_nport_evt (domain,EFC_HW_PORT_ATTACH_OK , +EFC_HW_DOMAIN_ATTACH_OK , mqe); +return EFC_SUCCESS ; +} + +int +efc_cmd_domain_attach (struct efc *efc,struct efc_domain *domain,u32 fc_id) +{ +u8 buf[SLI4_BMBX_SIZE ]; +int rc =EFC_SUCCESS ; + +if (!domain) { +efc_log_err (efc,"bad param(s) domain=%p\n" , domain); +return EFC_FAIL ; + } + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc, +"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + + domain->nport->fc_id = fc_id; + + rc =sli_cmd_reg_vfi (efc->sli, buf,SLI4_BMBX_SIZE , domain->indicator, + domain->fcf_indicator, domain->dma, + domain->nport->indicator, domain->nport->sli_wwpn, + domain->nport->fc_id); +if (rc) { +efc_log_err (efc,"REG_VFI format failure\n" ); + goto cleanup; + } + + rc = efc->tt.issue_mbox_rqst (efc->base, buf, + efc_domain_attach_reg_vfi_cb, domain); +if (rc) { +efc_log_err (efc,"REG_VFI command failure\n" ); + goto cleanup; + } + +return rc; + +cleanup: +efc_domain_free_resources (domain,EFC_HW_DOMAIN_ATTACH_FAIL , buf); + +return rc; +} + +static int
drivers/scsi/elx/libefc/efc_cmds.c line 618
Quoted 10 lines
drivers/scsi/elx/libefc/efc_cmds.c new file +10
-0+efc_domain_free_unreg_vfi_cb(struct efc *efc, int status, u8 *mqe, void *arg) +{ + struct efc_domain *domain = arg; +int evt =EFC_HW_DOMAIN_FREE_OK ; +int rc =0 ; + + rc =efc_domain_get_mbox_status (domain, mqe, status); +if (rc) { + evt =EFC_HW_DOMAIN_FREE_FAIL ; + rc =-1 ;
What happened to EFC_FAIL?
Quoted 290 lines
drivers/scsi/elx/libefc/efc_cmds.c new file +259
-0+ } + +efc_domain_free_resources (domain, evt, mqe); +return rc; +} + +static void +efc_domain_free_unreg_vfi (struct efc_domain *domain) +{ +struct efc *efc = domain->efc; +int rc; +u8 data[SLI4_BMBX_SIZE ]; + + rc =sli_cmd_unreg_vfi (efc->sli, data, domain->indicator, +SLI4_UNREG_TYPE_DOMAIN ); +if (rc) { +efc_log_err (efc,"UNREG_VFI format failure\n" ); + goto cleanup; + } + + rc = efc->tt.issue_mbox_rqst (efc->base, data, + efc_domain_free_unreg_vfi_cb, domain); +if (rc) { +efc_log_err (efc,"UNREG_VFI command failure\n" ); + goto cleanup; + } + +return ; + +cleanup: +efc_domain_free_resources (domain,EFC_HW_DOMAIN_FREE_FAIL , data); +} + +int +efc_cmd_domain_free (struct efc *efc,struct efc_domain *domain) +{ +int rc =EFC_SUCCESS ; + +if (!domain) { +efc_log_err (efc,"bad parameter(s) domain=%p\n" , domain); +return EFC_FAIL ; + } + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc, +"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + +efc_domain_free_unreg_vfi (domain); +return rc; +} + +int +efc_cmd_node_alloc (struct efc *efc,struct efc_remote_node *rnode,u32 fc_addr, +struct efc_nport *nport) +{ +/* Check for invalid indicator */ +if (rnode->indicator !=U32_MAX ) { +efc_log_err (efc, +"RPI allocation failure addr=%#x rpi=%#x\n" , + fc_addr, rnode->indicator); +return EFC_FAIL ; + } + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc, +"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + +/* NULL SLI port indicates an unallocated remote node */ + rnode->nport =NULL ; + +if (sli_resource_alloc (efc->sli,SLI4_RSRC_RPI , + &rnode->indicator, &rnode->index)) { +efc_log_err (efc,"RPI allocation failure addr=%#x\n" , + fc_addr); +return EFC_FAIL ; + } + + rnode->fc_id = fc_addr; + rnode->nport = nport; + +return EFC_SUCCESS ; +} + +static int +efc_cmd_node_attach_cb (struct efc *efc,int status,u8 *mqe,void *arg) +{ +struct efc_remote_node *rnode = arg; +struct sli4_mbox_command_header *hdr = + (struct sli4_mbox_command_header *)mqe; +enum efc_hw_remote_node_event evt =0 ; + +if (status ||le16_to_cpu (hdr->status)) { +efc_log_debug (efc,"bad status cqe=%#x mqe=%#x\n" , status, +le16_to_cpu (hdr->status)); + rnode->attached = false; + evt =EFC_HW_NODE_ATTACH_FAIL ; + }else { + rnode->attached = true; + evt =EFC_HW_NODE_ATTACH_OK ; + } + +efc_remote_node_cb (efc, evt, rnode); + +return EFC_SUCCESS ; +} + +int +efc_cmd_node_attach (struct efc *efc,struct efc_remote_node *rnode, +struct efc_dma *sparms) +{ +int rc =EFC_FAIL ; +u8 buf[SLI4_BMBX_SIZE ]; + +if (!rnode || !sparms) { +efc_log_err (efc,"bad parameter(s) rnode=%p sparms=%p\n" , + rnode, sparms); +return EFC_FAIL ; + } + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc,"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + +/* +* If the attach count is non-zero, this RPI has already been reg'd. +* Otherwise, register the RPI +*/ +if (rnode->index ==U32_MAX ) { +efc_log_err (efc,"bad parameter rnode->index invalid\n" ); +return EFC_FAIL ; + } + +/* Update a remote node object with the remote port's service params */ +if (!sli_cmd_reg_rpi (efc->sli, buf, rnode->indicator, + rnode->nport->indicator, rnode->fc_id, sparms,0 ,0 )) + rc = efc->tt.issue_mbox_rqst (efc->base, buf, + efc_cmd_node_attach_cb, rnode); + +return rc; +} + +int +efc_node_free_resources (struct efc *efc,struct efc_remote_node *rnode) +{ +int rc =EFC_SUCCESS ; + +if (!rnode) { +efc_log_err (efc,"bad parameter rnode=%p\n" , rnode); +return EFC_FAIL ; + } + +if (rnode->nport) { +if (rnode->attached) { +efc_log_err (efc,"Err: rnode is still attached\n" ); +return EFC_FAIL ; + } +if (rnode->indicator !=U32_MAX ) { +if (sli_resource_free (efc->sli,SLI4_RSRC_RPI , + rnode->indicator)) { +efc_log_err (efc, +"RPI free fail RPI %d addr=%#x\n" , + rnode->indicator, rnode->fc_id); + rc =EFC_FAIL ; + }else { + rnode->indicator =U32_MAX ; + rnode->index =U32_MAX ; + } + } + } + +return rc; +} + +static int +efc_cmd_node_free_cb (struct efc *efc,int status,u8 *mqe,void *arg) +{ +struct efc_remote_node *rnode = arg; +struct sli4_mbox_command_header *hdr = + (struct sli4_mbox_command_header *)mqe; +enum efc_hw_remote_node_event evt =EFC_HW_NODE_FREE_FAIL ; +int rc =0 ; + +if (status ||le16_to_cpu (hdr->status)) { +efc_log_debug (efc,"bad status cqe=%#x mqe=%#x\n" , status, +le16_to_cpu (hdr->status)); + +/* +* In certain cases, a non-zero MQE status is OK (all must be +* true): +* - node is attached +* - status is 0x1400 +*/ +if (!rnode->attached || + (le16_to_cpu (hdr->status) !=SLI4_MBX_STATUS_RPI_NOT_REG )) + rc =EFC_FAIL ; + } + +if (!rc) { + rnode->attached = false; + evt =EFC_HW_NODE_FREE_OK ; + } + +efc_remote_node_cb (efc, evt, rnode); + +return rc; +} + +int +efc_cmd_node_detach (struct efc *efc,struct efc_remote_node *rnode) +{ +u8 buf[SLI4_BMBX_SIZE ]; +int rc =EFC_FAIL ; + +if (!rnode) { +efc_log_err (efc,"bad parameter rnode=%p\n" , rnode); +return EFC_FAIL ; + } + +/* +* Check if the chip is in an error state (UE'd) before proceeding. +*/ +if (sli_fw_error_status (efc->sli) >0 ) { +efc_log_crit (efc,"Chip is in an error state - reset needed\n" ); +return EFC_FAIL ; + } + +if (rnode->nport) { +if (!rnode->attached) +return EFC_FAIL ; + + rc =EFC_FAIL ; + +if (!sli_cmd_unreg_rpi (efc->sli, buf, rnode->indicator, +SLI4_RSRC_RPI ,U32_MAX )) + rc = efc->tt.issue_mbox_rqst (efc->base, buf, + efc_cmd_node_free_cb, rnode); + +if (rc !=EFC_SUCCESS ) { +efc_log_err (efc,"UNREG_RPI failed\n" ); + rc =EFC_FAIL ; + } + } + +return rc; +}drivers/scsi/elx/libefc/efc_cmds.h new file +24
-0@@ -0,0 +1,34 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +#ifndef __EFC_CMDS_H__ +#define __EFC_CMDS_H__ + +int +efc_cmd_nport_alloc (struct efc *efc,struct efc_nport *nport, +struct efc_domain *domain,u8 *wwpn); +int +efc_cmd_nport_attach (struct efc *efc,struct efc_nport *nport,u32 fc_id); +int +efc_cmd_nport_free (struct efc *efc,struct efc_nport *nport); +int +efc_cmd_domain_alloc (struct efc *efc,struct efc_domain *domain,u32 fcf); +int +efc_cmd_domain_attach (struct efc *efc,struct efc_domain *domain,u32 fc_id); +int +efc_cmd_domain_free (struct efc *efc,struct efc_domain *domain); +int +efc_cmd_node_detach (struct efc *efc,struct efc_remote_node *rnode);
drivers/scsi/elx/libefc/efc_cmds.h line 34
Quoted 10 lines
drivers/scsi/elx/libefc/efc_cmds.h new file +10
-0+int +efc_node_free_resources (struct efc *efc,struct efc_remote_node *rnode); +int +efc_cmd_node_attach (struct efc *efc,struct efc_remote_node *rnode, +struct efc_dma *sparms); +int +efc_cmd_node_alloc (struct efc *efc,struct efc_remote_node *rnode,u32 fc_addr, +struct efc_nport *nport); + +#endif /* __EFC_CMDS_H */
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
PATCH v4 17/31 elx: efct: Data structures and defines for hw operations
In reply to James SmartThis patch starts the population of the efct target mode driver. The driver is contained in the drivers/scsi/elx/efct subdirectory.
This patch creates the efct directory and starts population of the driver by adding SLI-4 configuration parameters, data structures for configuring SLI-4 queues, converting from os to SLI-4 IO requests, and handling async events.
--- drivers/scsi/elx/efct/efct_hw.h | 603 ++++++++++++++++++++++++++++++++ 1 file changed, 603 insertions(+) create mode 100644 drivers/scsi/elx/efct/efct_hw.h
drivers/scsi/elx/efct/efct_hw.h new file +603 -0
@@ -0,0 +1,603 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +#ifndef _EFCT_HW_H +#define _EFCT_HW_H + +#include "../libefc_sli/sli4.h" + +/* +* EFCT PCI IDs +*/ +#define EFCT_VENDOR_ID 0x10df +/* LightPulse 16Gb x 4 FC (lancer-g6) */ +#define EFCT_DEVICE_LANCER_G6 0xe307 +/* LightPulse 32Gb x 4 FC (lancer-g7) */ +#define EFCT_DEVICE_LANCER_G7 0xf407 + +/*Default RQ entries len used by driver*/ +#define EFCT_HW_RQ_ENTRIES_MIN 512 +#define EFCT_HW_RQ_ENTRIES_DEF 1024 +#define EFCT_HW_RQ_ENTRIES_MAX 4096 + +/*Defines the size of the RQ buffers used for each RQ*/ +#define EFCT_HW_RQ_SIZE_HDR 128 +#define EFCT_HW_RQ_SIZE_PAYLOAD 1024 + +/*Define the maximum number of multi-receive queues*/ +#define EFCT_HW_MAX_MRQS 8 + +/* +* Define count of when to set the WQEC bit in a submitted +* WQE, causing a consummed/released completion to be posted. +*/ +#define EFCT_HW_WQEC_SET_COUNT 32 + +/*Send frame timeout in seconds*/ +#define EFCT_HW_SEND_FRAME_TIMEOUT 10 + +/* +* FDT Transfer Hint value, reads greater than this value +* will be segmented to implement fairness. A value of zero disables +* the feature. +*/ +#define EFCT_HW_FDT_XFER_HINT 8192 + +#define EFCT_HW_TIMECHECK_ITERATIONS 100 +#define EFCT_HW_MAX_NUM_MQ 1 +#define EFCT_HW_MAX_NUM_RQ 32 +#define EFCT_HW_MAX_NUM_EQ 16 +#define EFCT_HW_MAX_NUM_WQ 32 +#define EFCT_HW_DEF_NUM_EQ 1 + +#define OCE_HW_MAX_NUM_MRQ_PAIRS 16 + +#define EFCT_HW_MQ_DEPTH 128 +#define EFCT_HW_EQ_DEPTH 1024 + +/* +* A CQ will be assinged to each WQ +* (CQ must have 2X entries of the WQ for abort +* processing), plus a separate one for each RQ PAIR and one for MQ +*/ +#define EFCT_HW_MAX_NUM_CQ \ + ((EFCT_HW_MAX_NUM_WQ * 2) + 1 + (OCE_HW_MAX_NUM_MRQ_PAIRS * 2)) + +#define EFCT_HW_Q_HASH_SIZE 128 +#define EFCT_HW_RQ_HEADER_SIZE 128 +#define EFCT_HW_RQ_HEADER_INDEX 0 + +#define EFCT_HW_REQUE_XRI_REGTAG 65534 + +/* Options for efct_hw_command() */ +enum efct_cmd_opts { +/* command executes synchronously and busy-waits for completion */ +EFCT_CMD_POLL , +/* command executes asynchronously. Uses callback */ +EFCT_CMD_NOWAIT , +}; + +enum efct_hw_rtn { +EFCT_HW_RTN_SUCCESS =0 , +EFCT_HW_RTN_SUCCESS_SYNC =1 , +EFCT_HW_RTN_ERROR =-1 , +EFCT_HW_RTN_NO_RESOURCES =-2 , +EFCT_HW_RTN_NO_MEMORY =-3 , +EFCT_HW_RTN_IO_NOT_ACTIVE =-4 , +EFCT_HW_RTN_IO_ABORT_IN_PROGRESS =-5 , +EFCT_HW_RTN_IO_PORT_OWNED_ALREADY_ABORTED =-6 , +EFCT_HW_RTN_INVALID_ARG =-7 , +}; + +#define EFCT_HW_RTN_IS_ERROR (e) ((e) < 0) + +enum efct_hw_reset { +EFCT_HW_RESET_FUNCTION , +EFCT_HW_RESET_FIRMWARE , +EFCT_HW_RESET_MAX +}; + +enum efct_hw_topo { +EFCT_HW_TOPOLOGY_AUTO , +EFCT_HW_TOPOLOGY_NPORT , +EFCT_HW_TOPOLOGY_LOOP , +EFCT_HW_TOPOLOGY_NONE , +EFCT_HW_TOPOLOGY_MAX +}; + +/* pack fw revision values into a single uint64_t */ +#define HW_FWREV (a, b, c, d) (((uint64_t)(a) << 48) | ((uint64_t)(b) << 32) \ + | ((uint64_t)(c) << 16) | ((uint64_t)(d))) + +#define EFCT_FW_VER_STR (a, b, c, d) (#a "." #b "." #c "." #d) + +enum efct_hw_io_type { +EFCT_HW_ELS_REQ , +EFCT_HW_ELS_RSP , +EFCT_HW_FC_CT , +EFCT_HW_FC_CT_RSP , +EFCT_HW_BLS_ACC , +EFCT_HW_BLS_RJT , +EFCT_HW_IO_TARGET_READ , +EFCT_HW_IO_TARGET_WRITE , +EFCT_HW_IO_TARGET_RSP , +EFCT_HW_IO_DNRX_REQUEUE , +EFCT_HW_IO_MAX , +}; + +enum efct_hw_io_state { +EFCT_HW_IO_STATE_FREE , +EFCT_HW_IO_STATE_INUSE , +EFCT_HW_IO_STATE_WAIT_FREE , +EFCT_HW_IO_STATE_WAIT_SEC_HIO , +}; + +#define EFCT_TARGET_WRITE_SKIPS 1 +#define EFCT_TARGET_READ_SKIPS 2 + +struct efct_hw ; +struct efct_io ; + +#define EFCT_CMD_CTX_POOL_SZ 32 +/** +* HW command context. +* Stores the state for the asynchronous commands sent to the hardware. +*/ +struct efct_command_ctx { +struct list_head list_entry; +int (*cb)(struct efct_hw *hw,int status,u8 *mqe,void *arg); +void *arg;/* Argument for callback */ +/* buffer holding command / results */ +u8 buf[SLI4_BMBX_SIZE ]; +void *ctx;/* upper layer context */ +}; + +struct efct_hw_sgl { +uintptr_t addr; +size_t len; +}; + +union efct_hw_io_param_u { +struct sli_bls_params bls; +struct sli_els_params els; +struct sli_ct_params fc_ct; +struct sli_fcp_tgt_params fcp_tgt; +}; + +/* WQ steering mode */ +enum efct_hw_wq_steering { +EFCT_HW_WQ_STEERING_CLASS , +EFCT_HW_WQ_STEERING_REQUEST , +EFCT_HW_WQ_STEERING_CPU , +}; + +/* HW wqe object */ +struct efct_hw_wqe { +struct list_head list_entry; +bool abort_wqe_submit_needed; +bool send_abts; +u32 id; +u32 abort_reqtag; +u8 *wqebuf; +}; + +struct efct_hw_io ; +/* Typedef for HW "done" callback */ +typedef int (*efct_hw_done_t )(struct efct_hw_io *,u32 len,int status, +u32 ext,void *ul_arg); + +/** +* HW IO object. +* +* Stores the per-IO information necessary +* for both SLI and efct. +* @ref: reference counter for hw io object +* @state: state of IO: free, busy, wait_free +* @list_entry used for busy, wait_free, free lists +* @wqe Work queue object, with link for pending +* @hw pointer back to hardware context +* @xfer_rdy transfer ready data +* @type IO type +* @xbusy Exchange is active in FW +* @abort_in_progress if TRUE, abort is in progress +* @status_saved if TRUE, latched status should be returned +* @wq_class WQ class if steering mode is Class +* @reqtag request tag for this HW IO +* @wq WQ assigned to the exchange +* @done Function called on IO completion +* @arg argument passed to IO done callback +* @abort_done Function called on abort completion +* @abort_arg argument passed to abort done callback +* @wq_steering WQ steering mode request +* @saved_status Saved status +* @saved_len Status length +* @saved_ext Saved extended status +* @eq EQ on which this HIO came up +* @sge_offset SGE data offset +* @def_sgl_count Count of SGEs in default SGL +* @abort_reqtag request tag for an abort of this HW IO +* @indicator Exchange indicator +* @def_sgl default SGL +* @sgl pointer to current active SGL +* @sgl_count count of SGEs in io->sgl +* @first_data_sge index of first data SGE +* @n_sge number of active SGEs +*/ +struct efct_hw_io { +struct kref ref; +enum efct_hw_io_state state; +void (*release)(struct kref *arg); +struct list_head list_entry; +struct efct_hw_wqe wqe; + +struct efct_hw *hw; +struct efc_dma xfer_rdy; +u16 type; +bool xbusy; +bool abort_in_progress; +bool status_saved; +u8 wq_class; +u16 reqtag; + +struct hw_wq *wq; +efct_hw_done_t done; +void *arg; +efct_hw_done_t abort_done; +void *abort_arg; + +enum efct_hw_wq_steering wq_steering; + +u32 saved_status; +u32 saved_len; +u32 saved_ext; + +struct hw_eq *eq; +u32 sge_offset; +u32 def_sgl_count; +u32 abort_reqtag; +u32 indicator; +struct efc_dma def_sgl; +struct efc_dma *sgl; +u32 sgl_count; +u32 first_data_sge; +u32 n_sge; +}; + + +enum efct_hw_port { +EFCT_HW_PORT_INIT , +EFCT_HW_PORT_SHUTDOWN , +}; + +/* Node group rpi reference */ +struct efct_hw_rpi_ref { +atomic_t rpi_count; +atomic_t rpi_attached; +}; + +enum efct_hw_link_stat { +EFCT_HW_LINK_STAT_LINK_FAILURE_COUNT , +EFCT_HW_LINK_STAT_LOSS_OF_SYNC_COUNT , +EFCT_HW_LINK_STAT_LOSS_OF_SIGNAL_COUNT , +EFCT_HW_LINK_STAT_PRIMITIVE_SEQ_COUNT , +EFCT_HW_LINK_STAT_INVALID_XMIT_WORD_COUNT , +EFCT_HW_LINK_STAT_CRC_COUNT , +EFCT_HW_LINK_STAT_PRIMITIVE_SEQ_TIMEOUT_COUNT , +EFCT_HW_LINK_STAT_ELASTIC_BUFFER_OVERRUN_COUNT , +EFCT_HW_LINK_STAT_ARB_TIMEOUT_COUNT , +EFCT_HW_LINK_STAT_ADVERTISED_RCV_B2B_CREDIT , +EFCT_HW_LINK_STAT_CURR_RCV_B2B_CREDIT , +EFCT_HW_LINK_STAT_ADVERTISED_XMIT_B2B_CREDIT , +EFCT_HW_LINK_STAT_CURR_XMIT_B2B_CREDIT , +EFCT_HW_LINK_STAT_RCV_EOFA_COUNT , +EFCT_HW_LINK_STAT_RCV_EOFDTI_COUNT , +EFCT_HW_LINK_STAT_RCV_EOFNI_COUNT , +EFCT_HW_LINK_STAT_RCV_SOFF_COUNT , +EFCT_HW_LINK_STAT_RCV_DROPPED_NO_AER_COUNT , +EFCT_HW_LINK_STAT_RCV_DROPPED_NO_RPI_COUNT , +EFCT_HW_LINK_STAT_RCV_DROPPED_NO_XRI_COUNT , +EFCT_HW_LINK_STAT_MAX , +}; + +enum efct_hw_host_stat { +EFCT_HW_HOST_STAT_TX_KBYTE_COUNT , +EFCT_HW_HOST_STAT_RX_KBYTE_COUNT , +EFCT_HW_HOST_STAT_TX_FRAME_COUNT , +EFCT_HW_HOST_STAT_RX_FRAME_COUNT , +EFCT_HW_HOST_STAT_TX_SEQ_COUNT , +EFCT_HW_HOST_STAT_RX_SEQ_COUNT , +EFCT_HW_HOST_STAT_TOTAL_EXCH_ORIG , +EFCT_HW_HOST_STAT_TOTAL_EXCH_RESP , +EFCT_HW_HOSY_STAT_RX_P_BSY_COUNT , +EFCT_HW_HOST_STAT_RX_F_BSY_COUNT , +EFCT_HW_HOST_STAT_DROP_FRM_DUE_TO_NO_RQ_BUF_COUNT , +EFCT_HW_HOST_STAT_EMPTY_RQ_TIMEOUT_COUNT , +EFCT_HW_HOST_STAT_DROP_FRM_DUE_TO_NO_XRI_COUNT , +EFCT_HW_HOST_STAT_EMPTY_XRI_POOL_COUNT , +EFCT_HW_HOST_STAT_MAX , +}; + +enum efct_hw_state { +EFCT_HW_STATE_UNINITIALIZED , +EFCT_HW_STATE_QUEUES_ALLOCATED , +EFCT_HW_STATE_ACTIVE , +EFCT_HW_STATE_RESET_IN_PROGRESS , +EFCT_HW_STATE_TEARDOWN_IN_PROGRESS , +}; + +struct efct_hw_link_stat_counts { +u8 overflow; +u32 counter; +}; + +struct efct_hw_host_stat_counts { +u32 counter; +}; + +/* Structure used for the hash lookup of queue IDs */ +struct efct_queue_hash { +bool in_use; +u16 id; +u16 index; +}; + +/* WQ callback object */ +struct hw_wq_callback { +u16 instance_index;/* use for request tag */ +void (*callback)(void *arg,u8 *cqe,int status); +void *arg; +struct list_head list_entry; +}; + +struct reqtag_pool { +spinlock_t lock;/* pool lock */ +struct hw_wq_callback *tags[U16_MAX ]; +struct list_head freelist; +}; + +struct efct_hw_config { +u32 n_eq; +u32 n_cq; +u32 n_mq; +u32 n_rq; +u32 n_wq; +u32 n_io; +u32 n_sgl; +u32 speed; +u32 topology; +/* size of the buffers for first burst */ +u32 rq_default_buffer_size; +u8 esoc; +/* MRQ RQ selection policy */ +u8 rq_selection_policy; +/* RQ quanta if rq_selection_policy == 2 */ +u8 rr_quanta; +u32 filter_def[SLI4_CMD_REG_FCFI_NUM_RQ_CFG ]; +}; + +struct efct_hw { +struct efct *os; +struct sli4 sli; +u16 ulp_start; +u16 ulp_max; +u32 dump_size; +enum efct_hw_state state; +bool hw_setup_called; +u8 sliport_healthcheck; +u16 fcf_indicator; + +/* HW configuration */ +struct efct_hw_config config; + +/* calculated queue sizes for each type */ +u32 num_qentries[SLI4_QTYPE_MAX ]; + +/* Storage for SLI queue objects */ +struct sli4_queue wq[EFCT_HW_MAX_NUM_WQ ]; +struct sli4_queue rq[EFCT_HW_MAX_NUM_RQ ]; +u16 hw_rq_lookup[EFCT_HW_MAX_NUM_RQ ]; +struct sli4_queue mq[EFCT_HW_MAX_NUM_MQ ]; +struct sli4_queue cq[EFCT_HW_MAX_NUM_CQ ]; +struct sli4_queue eq[EFCT_HW_MAX_NUM_EQ ]; + +/* HW queue */ +u32 eq_count; +u32 cq_count; +u32 mq_count; +u32 wq_count; +u32 rq_count; +u32 cmd_head_count; +struct list_head eq_list; + +struct efct_queue_hash cq_hash[EFCT_HW_Q_HASH_SIZE ]; +struct efct_queue_hash rq_hash[EFCT_HW_Q_HASH_SIZE ]; +struct efct_queue_hash wq_hash[EFCT_HW_Q_HASH_SIZE ]; + +/* Storage for HW queue objects */ +struct hw_wq *hw_wq[EFCT_HW_MAX_NUM_WQ ]; +struct hw_rq *hw_rq[EFCT_HW_MAX_NUM_RQ ]; +struct hw_mq *hw_mq[EFCT_HW_MAX_NUM_MQ ]; +struct hw_cq *hw_cq[EFCT_HW_MAX_NUM_CQ ]; +struct hw_eq *hw_eq[EFCT_HW_MAX_NUM_EQ ]; +/* count of hw_rq[] entries */ +u32 hw_rq_count; +/* count of multirq RQs */ +u32 hw_mrq_count; + +struct hw_wq *wq_cpu_array[128 ]; + +/* Sequence objects used in incoming frame processing */ +struct efc_hw_sequence *seq_pool; + +/* Maintain an ordered, linked list of outstanding HW commands. */ +struct mutex bmbx_lock; +spinlock_t cmd_lock; +struct list_head cmd_head; +struct list_head cmd_pending; +mempool_t *cmd_ctx_pool; +mempool_t *mbox_rqst_pool; + +struct sli4_link_event link; + +/* pointer array of IO objects */ +struct efct_hw_io **io; +/* array of WQE buffs mapped to IO objects */ +u8 *wqe_buffs; + +/* IO lock to synchronize list access */ +spinlock_t io_lock; +/* IO lock to synchronize IO aborting */ +spinlock_t io_abort_lock; +/* List of IO objects in use */ +struct list_head io_inuse; +/* List of IO objects waiting to be freed */ +struct list_head io_wait_free; +/* List of IO objects available for allocation */ +struct list_head io_free; + +struct efc_dma loop_map; + +struct efc_dma xfer_rdy; + +struct efc_dma rnode_mem; + +atomic_t io_alloc_failed_count; + +/* stat: wq sumbit count */ +u32 tcmd_wq_submit[EFCT_HW_MAX_NUM_WQ ]; +/* stat: wq complete count */ +u32 tcmd_wq_complete[EFCT_HW_MAX_NUM_WQ ]; + +atomic_t send_frame_seq_id; +struct reqtag_pool *wq_reqtag_pool; +}; + +enum efct_hw_io_count_type { +EFCT_HW_IO_INUSE_COUNT , +EFCT_HW_IO_FREE_COUNT , +EFCT_HW_IO_WAIT_FREE_COUNT , +EFCT_HW_IO_N_TOTAL_IO_COUNT , +}; + +/* HW queue data structures */ +struct hw_eq { +struct list_head list_entry; +enum sli4_qtype type; +u32 instance; +u32 entry_count; +u32 entry_size; +struct efct_hw *hw; +struct sli4_queue *queue; +struct list_head cq_list; +u32 use_count; +}; + +struct hw_cq { +struct list_head list_entry; +enum sli4_qtype type; +u32 instance; +u32 entry_count; +u32 entry_size; +struct hw_eq *eq; +struct sli4_queue *queue; +struct list_head q_list; +u32 use_count; +}; + +struct hw_q { +struct list_head list_entry; +enum sli4_qtype type; +}; + +struct hw_mq { +struct list_head list_entry; +enum sli4_qtype type; +u32 instance; + +u32 entry_count; +u32 entry_size; +struct hw_cq *cq; +struct sli4_queue *queue; + +u32 use_count; +}; + +struct hw_wq { +struct list_head list_entry; +enum sli4_qtype type; +u32 instance; +struct efct_hw *hw; + +u32 entry_count; +u32 entry_size; +struct hw_cq *cq; +struct sli4_queue *queue; +u32 class; + +/* WQ consumed */ +u32 wqec_set_count; +u32 wqec_count; +u32 free_count; +u32 total_submit_count; +struct list_head pending_list; + +/* HW IO allocated for use with Send Frame */ +struct efct_hw_io *send_frame_io; + +/* Stats */ +u32 use_count; +u32 wq_pending_count; +}; + +struct hw_rq { +struct list_head list_entry; +enum sli4_qtype type; +u32 instance; + +u32 entry_count; +u32 use_count; +u32 hdr_entry_size; +u32 first_burst_entry_size; +u32 data_entry_size; +bool is_mrq; +u32 base_mrq_id; + +struct hw_cq *cq; + +u8 filter_mask; +struct sli4_queue *hdr; +struct sli4_queue *first_burst; +struct sli4_queue *data; + +struct efc_hw_rq_buffer *hdr_buf; +struct efc_hw_rq_buffer *fb_buf; +struct efc_hw_rq_buffer *payload_buf; +/* RQ tracker for this RQ */ +struct efc_hw_sequence **rq_tracker; +}; + +struct efct_hw_send_frame_context { +struct efct_hw *hw; +struct hw_wq_callback *wqcb; +struct efct_hw_wqe wqe; +void (*callback)(int status,void *arg); +void *arg; + +/* General purpose elements */ +struct efc_hw_sequence *seq; +struct efc_dma payload; +}; + +struct efct_hw_grp_hdr { +u32 size; +__be32 magic_number; +u32 word2; +u8 rev_name[128 ]; +u8 date[12 ]; +u8 revision[32 ]; +}; + +#endif /* __EFCT_H__ */
Signature · 1 line
2.26.2
Re: [PATCH v4 17/31] elx: efct: Data structures and defines for hw operations
Quoted 9 lines · James Smart
This patch starts the population of the efct target mode driver. The driver is contained in the
drivers/scsi/elx/efctsubdirectory.This patch creates the efct directory and starts population of the driver by adding SLI-4 configuration parameters, data structures for configuring SLI-4 queues, converting from os to SLI-4 IO requests, and handling async events.
Quoted 8 lines
Co-developed-by Ram Vegesna <[email protected]>Signed-off-by Ram Vegesna <[email protected]>Signed-off-by James Smart <[email protected]>--- drivers/scsi/elx/efct/efct_hw.h | 603 ++++++++++++++++++++++++++++++++ 1 file changed, 603 insertions(+)create mode 100644
drivers/scsi/elx/efct/efct_hw.h
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
PATCH v4 18/31 elx: efct: Driver initialization routines
In reply to James SmartThis patch continues the efct driver population.
This patch adds driver definitions for:
Emulex FC Target driver init, attach and hardware setup routines.
---
v4:
New library Template registration and associated functions Muti-RQ support, configure mrq.
Support for Multi RQ/EQ.
Configure filter to send all ELS traffic to one RQ and remaining IOs to
all RQs.
CPU based WQ scaling.
Allocate loop map during initialisation
Remove redundant includes in efc_driver.h
--- drivers/scsi/elx/efct/efct_driver.c | 810 +++++++++++++++++++ drivers/scsi/elx/efct/efct_driver.h | 109 +++ drivers/scsi/elx/efct/efct_hw.c | 1166 +++++++++++++++++++++++++++ drivers/scsi/elx/efct/efct_hw.h | 15 + drivers/scsi/elx/efct/efct_xport.c | 519 ++++++++++++ drivers/scsi/elx/efct/efct_xport.h | 186 +++++ 6 files changed, 2805 insertions(+) create mode 100644 drivers/scsi/elx/efct/efct_driver.c create mode 100644 drivers/scsi/elx/efct/efct_driver.h create mode 100644 drivers/scsi/elx/efct/efct_hw.c create mode 100644 drivers/scsi/elx/efct/efct_xport.c create mode 100644 drivers/scsi/elx/efct/efct_xport.h
drivers/scsi/elx/efct/efct_driver.c new file +810 -0
@@ -0,0 +1,810 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +#include "efct_driver.h" + +#include "efct_hw.h" +#include "efct_unsol.h" +#include "efct_scsi.h" + +struct efct *efct_devices[MAX_EFCT_DEVICES ]; + +static int logmask; +module_param (logmask, int,0444 ); +MODULE_PARM_DESC (logmask,"logging bitmask (default 0)" ); + +static struct libefc_function_template efct_libefc_templ = { + .issue_mbox_rqst = efct_issue_mbox_rqst, + .send_els = efct_els_hw_srrs_send, + .send_bls = efct_efc_bls_send, + + .new_nport = efct_scsi_tgt_new_nport, + .del_nport = efct_scsi_tgt_del_nport, + .scsi_new_node = efct_scsi_new_initiator, + .scsi_del_node = efct_scsi_del_initiator, + .hw_seq_free = efct_efc_hw_sequence_free, +}; + +static int +efct_device_init (void ) +{ +int rc; + +/* driver-wide init for target-server */ + rc =efct_scsi_tgt_driver_init (); +if (rc) { +pr_err ("efct_scsi_tgt_init failed rc=%d\n" , + rc); +return rc; + } + + rc =efct_scsi_reg_fc_transport (); +if (rc) { +pr_err ("failed to register to FC host\n" ); +return rc; + } + +return EFC_SUCCESS ; +} + +static void +efct_device_shutdown (void ) +{ +efct_scsi_release_fc_transport (); + +efct_scsi_tgt_driver_exit (); +} + +static void * +efct_device_alloc (u32 nid) +{ +struct efct *efct =NULL ; +u32 i; + + efct =kzalloc_node (sizeof (*efct),GFP_KERNEL , nid); +if (!efct) +return efct; + +for (i =0 ; i <ARRAY_SIZE (efct_devices); i++) { +if (!efct_devices[i]) { + efct->instance_index = i; + efct_devices[i] = efct; +break ; + } + } + +if (i ==ARRAY_SIZE (efct_devices)) { +pr_err ("Exceeded max supported devices.\n" ); +kfree (efct); + efct =NULL ; + } + +return efct; +} + +static void +efct_teardown_msix (struct efct *efct) +{ +u32 i; + +for (i =0 ; i < efct->n_msix_vec; i++) { +free_irq (pci_irq_vector (efct->pci, i), + &efct->intr_context[i]); + } + +pci_free_irq_vectors (efct->pci); +} + +static int +efct_efclib_config (struct efct *efct,struct libefc_function_template *tt) +{ +struct efc *efc; +struct sli4 *sli; +int rc =EFC_SUCCESS ; + + efc =kzalloc (sizeof (*efc),GFP_KERNEL ); +if (!efc) +return EFC_FAIL ; + + efct->efcport = efc; + +memcpy (&efc->tt, tt,sizeof (*tt)); + efc->base = efct; + efc->pci = efct->pci; + + efc->def_wwnn =efct_get_wwnn (&efct->hw); + efc->def_wwpn =efct_get_wwpn (&efct->hw); + efc->enable_tgt =1 ; + efc->log_level =EFC_LOG_LIB ; + + sli = &efct->hw.sli; + efc->max_xfer_size = sli->sge_supported_length * +sli_get_max_sgl (&efct->hw.sli); + efc->sli = sli; + efc->fcfi = efct->hw.fcf_indicator; + + rc =efcport_init (efc); +if (rc) +efc_log_err (efc,"efcport_init failed\n" ); + +return rc; +} + +static int efct_request_firmware_update (struct efct *efct); + +static const char * +efct_pci_model (u16 device) +{ +switch (device) { +case EFCT_DEVICE_LANCER_G6 :return "LPE31004" ; +case EFCT_DEVICE_LANCER_G7 :return "LPE36000" ; +default :return "unknown" ; + } +} + +static int +efct_device_attach (struct efct *efct) +{ +u32 rc =0 , i =0 ; + +if (efct->attached) { +efc_log_err (efct,"Device is already attached\n" ); +return EFC_FAIL ; + } + +snprintf (efct->name,sizeof (efct->name),"[%s%d] " ,"fc" , + efct->instance_index); + + efct->logmask = logmask; + efct->filter_def =EFCT_DEFAULT_FILTER ; + efct->max_isr_time_msec =EFCT_OS_MAX_ISR_TIME_MSEC ; + + efct->model =efct_pci_model (efct->pci->device); + + efct->efct_req_fw_upgrade = true; + +/* Allocate transport object and bring online */ + efct->xport =efct_xport_alloc (efct); +if (!efct->xport) { +efc_log_err (efct,"failed to allocate transport object\n" ); + rc = -ENOMEM ; + goto out; + } + + rc =efct_xport_attach (efct->xport); +if (rc) { +efc_log_err (efct,"failed to attach transport object\n" ); + goto xport_out; + } + + rc =efct_xport_initialize (efct->xport); +if (rc) { +efc_log_err (efct,"failed to initialize transport object\n" ); + goto xport_out; + } + + rc =efct_efclib_config (efct, &efct_libefc_templ); +if (rc) { +efc_log_err (efct,"failed to init efclib\n" ); + goto efclib_out; + } + +for (i =0 ; i < efct->n_msix_vec; i++) { +efc_log_debug (efct,"irq %d enabled\n" , i); +enable_irq (pci_irq_vector (efct->pci, i)); + } + + efct->attached = true; + +if (efct->efct_req_fw_upgrade) +efct_request_firmware_update (efct); + +return rc; + +efclib_out: +efct_xport_detach (efct->xport); +xport_out: +if (efct->xport) { +efct_xport_free (efct->xport); + efct->xport =NULL ; + } +out: +return rc; +} + +static int +efct_device_detach (struct efct *efct) +{ +int i; + +if (!efct || !efct->attached) { +efc_log_warn (efct,"Device is not attached\n" ); +return EFC_FAIL ; + } + +if (efct_xport_control (efct->xport,EFCT_XPORT_SHUTDOWN )) +efc_log_err (efct,"Transport Shutdown timed out\n" ); + +for (i =0 ; i < efct->n_msix_vec; i++) +disable_irq (pci_irq_vector (efct->pci, i)); + +if (efct_xport_detach (efct->xport) !=0 ) +efc_log_err (efct,"Transport detach failed\n" ); + +efct_xport_free (efct->xport); + efct->xport =NULL ; + +efcport_destroy (efct->efcport); +kfree (efct->efcport); + + efct->attached = false; + +return EFC_SUCCESS ; +} + +static void +efct_fw_write_cb (int status,u32 actual_write_length, +u32 change_status,void *arg) +{ +struct efct_fw_write_result *result = arg; + + result->status = status; + result->actual_xfer = actual_write_length; + result->change_status = change_status; + +complete (&result->done); +} + +static int +efct_firmware_write (struct efct *efct,const u8 *buf,size_t buf_len, +u8 *change_status) +{ +int rc =0 ; +u32 bytes_left; +u32 xfer_size; +u32 offset; +struct efc_dma dma; +int last =0 ; +struct efct_fw_write_result result; + +init_completion (&result.done); + + bytes_left = buf_len; + offset =0 ; + + dma.size =FW_WRITE_BUFSIZE ; + dma.virt =dma_alloc_coherent (&efct->pci->dev, + dma.size, &dma.phys,GFP_DMA ); +if (!dma.virt) +return -ENOMEM ; + +while (bytes_left >0 ) { +if (bytes_left >FW_WRITE_BUFSIZE ) + xfer_size =FW_WRITE_BUFSIZE ; +else + xfer_size = bytes_left; + +memcpy (dma.virt, buf + offset, xfer_size); + +if (bytes_left == xfer_size) + last =1 ; + +efct_hw_firmware_write (&efct->hw, &dma, xfer_size, offset, + last, efct_fw_write_cb, &result); + +if (wait_for_completion_interruptible (&result.done) !=0 ) { + rc = -ENXIO ; +break ; + } + +if (result.actual_xfer ==0 || result.status !=0 ) { + rc = -EFAULT ; +break ; + } + +if (last) + *change_status = result.change_status; + + bytes_left -= result.actual_xfer; + offset += result.actual_xfer; + } + +dma_free_coherent (&efct->pci->dev, dma.size, dma.virt, dma.phys); +return rc; +} + +static int +efct_fw_reset (struct efct *efct) +{ +int rc =0 ; + +/* +* Firmware reset to activate the new firmware. +* Function 0 will update and load the new firmware +* during attach. +*/ +if (timer_pending (&efct->xport->stats_timer)) +del_timer (&efct->xport->stats_timer); + +if (efct_hw_reset (&efct->hw,EFCT_HW_RESET_FIRMWARE )) { +efc_log_info (efct,"failed to reset firmware\n" ); + rc =-1 ; + }else { +efc_log_info (efct, +"successfully reset firmware.Now resetting port\n" ); + +efct_device_detach (efct); + rc =efct_device_attach (efct); + } +return rc; +} + +static int +efct_request_firmware_update (struct efct *efct) +{ +int rc =0 ; +u8 file_name[256 ], fw_change_status =0 ; +const struct firmware *fw; +struct efct_hw_grp_hdr *fw_image; + +snprintf (file_name,256 ,"%s.grp" , efct->model); + + rc =request_firmware (&fw, file_name, &efct->pci->dev); +if (rc) { +efc_log_debug (efct,"Firmware file(%s) not found.\n" , + file_name); +return rc; + } + + fw_image = (struct efct_hw_grp_hdr *)fw->data; + +if (!strncmp (efct->hw.sli.fw_name[0 ], fw_image->revision, +strnlen (fw_image->revision,16 ))) { +efc_log_debug (efct, +"Skipped update. Firmware is already up to date.\n" ); + goto exit; + } + +efc_log_info (efct,"Firmware update is initiated. %s -> %s\n" , + efct->hw.sli.fw_name[0 ], fw_image->revision); + + rc =efct_firmware_write (efct, fw->data, fw->size, &fw_change_status); +if (rc) { +efc_log_err (efct, +"Firmware update failed. Return code = %d\n" , rc); + goto exit; + } + +efc_log_info (efct,"Firmware updated successfully\n" ); +switch (fw_change_status) { +case 0x00 : +efc_log_info (efct,"New firmware is active.\n" ); +break ; +case 0x01 : +efc_log_info (efct, +"System reboot needed to activate the new firmware\n" ); +break ; +case 0x02 : +case 0x03 : +efc_log_info (efct, +"firmware is resetting to activate the new firmware\n" ); +efct_fw_reset (efct); +break ; +default : +efc_log_info (efct, +"Unexected value change_status:%d\n" , fw_change_status); +break ; + } + +exit: +release_firmware (fw); + +return rc; +} + +static void +efct_device_free (struct efct *efct) +{ +if (efct) { + efct_devices[efct->instance_index] =NULL ; + +kfree (efct); + } +} + +static int +efct_device_interrupts_required (struct efct *efct) +{ +if (efct_hw_setup (&efct->hw, efct, efct->pci) !=EFCT_HW_RTN_SUCCESS ) +return -1 ; + +return efct->hw.config.n_eq; +} + +static irqreturn_t +efct_intr_thread (int irq,void *handle) +{ +struct efct_intr_context *intr_ctx = handle; +struct efct *efct = intr_ctx->efct; + +efct_hw_process (&efct->hw, intr_ctx->index, efct->max_isr_time_msec); +return IRQ_HANDLED ; +} + +static irqreturn_t +efct_intr_msix (int irq,void *handle) +{ +return IRQ_WAKE_THREAD ; +} + +static int +efct_setup_msix (struct efct *efct,u32 num_intrs) +{ +int rc =0 , i; + +if (!pci_find_capability (efct->pci,PCI_CAP_ID_MSIX )) { +dev_err (&efct->pci->dev, +"%s : MSI-X not available\n" , __func__); +return -EINVAL ; + } + + efct->n_msix_vec = num_intrs; + + rc =pci_alloc_irq_vectors (efct->pci, num_intrs, num_intrs, +PCI_IRQ_MSIX |PCI_IRQ_AFFINITY ); + +if (rc <0 ) { +dev_err (&efct->pci->dev,"Failed to alloc irq : %d\n" , rc); +return rc; + } + +for (i =0 ; i < num_intrs; i++) { +struct efct_intr_context *intr_ctx =NULL ; + + intr_ctx = &efct->intr_context[i]; + intr_ctx->efct = efct; + intr_ctx->index = i; + + rc =request_threaded_irq (pci_irq_vector (efct->pci, i), + efct_intr_msix, efct_intr_thread,0 , +EFCT_DRIVER_NAME , intr_ctx); +if (rc) { +dev_err (&efct->pci->dev, +"Failed to register %d vector: %d\n" , i, rc); + goto out; + } + } + +return rc; + +out: +while (--i >=0 ) +free_irq (pci_irq_vector (efct->pci, i), + &efct->intr_context[i]); + +pci_free_irq_vectors (efct->pci); +return rc; +} + +static struct pci_device_id efct_pci_table[] = { + {PCI_DEVICE (EFCT_VENDOR_ID ,EFCT_DEVICE_LANCER_G6 ),0 }, + {PCI_DEVICE (EFCT_VENDOR_ID ,EFCT_DEVICE_LANCER_G7 ),0 }, + {}/* terminate list */ +}; + +static int +efct_pci_probe (struct pci_dev *pdev,const struct pci_device_id *ent) +{ +struct efct *efct =NULL ; +int rc; +u32 i, r; +int num_interrupts =0 ; +int nid; + +dev_info (&pdev->dev,"%s\n" ,EFCT_DRIVER_NAME ); + + rc =pci_enable_device_mem (pdev); +if (rc) +return rc; + +pci_set_master (pdev); + + rc =pci_set_mwi (pdev); +if (rc) { +dev_info (&pdev->dev,"pci_set_mwi returned %d\n" , rc); + goto mwi_out; + } + + rc =pci_request_regions (pdev,EFCT_DRIVER_NAME ); +if (rc) { +dev_err (&pdev->dev,"pci_request_regions failed %d\n" , rc); + goto req_regions_out; + } + +/* Fetch the Numa node id for this device */ + nid =dev_to_node (&pdev->dev); +if (nid <0 ) { +dev_err (&pdev->dev,"Warning Numa node ID is %d\n" , nid); + nid =0 ; + } + +/* Allocate efct */ + efct =efct_device_alloc (nid); +if (!efct) { +dev_err (&pdev->dev,"Failed to allocate efct\n" ); + rc = -ENOMEM ; + goto alloc_out; + } + + efct->pci = pdev; + efct->numa_node = nid; + +/* Map all memory BARs */ +for (i =0 , r =0 ; i <EFCT_PCI_MAX_REGS ; i++) { +if (pci_resource_flags (pdev, i) &IORESOURCE_MEM ) { + efct->reg[r] =ioremap (pci_resource_start (pdev, i), +pci_resource_len (pdev, i)); + r++; + } + +/* +* If the 64-bit attribute is set, both this BAR and the +* next form the complete address. Skip processing the +* next BAR. +*/ +if (pci_resource_flags (pdev, i) &IORESOURCE_MEM_64 ) + i++; + } + +pci_set_drvdata (pdev, efct); + +if (pci_set_dma_mask (pdev,DMA_BIT_MASK (64 )) !=0 || +pci_set_consistent_dma_mask (pdev,DMA_BIT_MASK (64 )) !=0 ) { +dev_warn (&pdev->dev,"trying DMA_BIT_MASK(32)\n" ); +if (pci_set_dma_mask (pdev,DMA_BIT_MASK (32 )) !=0 || +pci_set_consistent_dma_mask (pdev,DMA_BIT_MASK (32 )) !=0 ) { +dev_err (&pdev->dev,"setting DMA_BIT_MASK failed\n" ); + rc =-1 ; + goto dma_mask_out; + } + } + + num_interrupts =efct_device_interrupts_required (efct); +if (num_interrupts <0 ) { +efc_log_err (efct,"efct_device_interrupts_required failed\n" ); + rc =-1 ; + goto dma_mask_out; + } + +/* +* Initialize MSIX interrupts, note, +* efct_setup_msix() enables the interrupt +*/ + rc =efct_setup_msix (efct, num_interrupts); +if (rc) { +dev_err (&pdev->dev,"Can't setup msix\n" ); + goto dma_mask_out; + } +/* Disable interrupt for now */ +for (i =0 ; i < efct->n_msix_vec; i++) { +efc_log_debug (efct,"irq %d disabled\n" , i); +disable_irq (pci_irq_vector (efct->pci, i)); + } + + rc =efct_device_attach (efct); +if (rc) + goto attach_out; + +return EFC_SUCCESS ; + +attach_out: +efct_teardown_msix (efct); +dma_mask_out: +pci_set_drvdata (pdev,NULL ); + +for (i =0 ; i <EFCT_PCI_MAX_REGS ; i++) { +if (efct->reg[i]) +iounmap (efct->reg[i]); + } +efct_device_free (efct); +alloc_out: +pci_release_regions (pdev); +req_regions_out: +pci_clear_mwi (pdev); +mwi_out: +pci_disable_device (pdev); +return rc; +} + +static void +efct_pci_remove (struct pci_dev *pdev) +{ +struct efct *efct =pci_get_drvdata (pdev); +u32 i; + +if (!efct) +return ; + +efct_device_detach (efct); + +efct_teardown_msix (efct); + +for (i =0 ; i <EFCT_PCI_MAX_REGS ; i++) { +if (efct->reg[i]) +iounmap (efct->reg[i]); + } + +pci_set_drvdata (pdev,NULL ); + + efct_devices[efct->instance_index] =NULL ; + +efct_device_free (efct); + +pci_release_regions (pdev); + +pci_disable_device (pdev); +} + +static void +efct_device_prep_for_reset (struct efct *efct,struct pci_dev *pdev) +{ +if (efct) { +efc_log_debug (efct, +"PCI channel disable preparing for reset\n" ); +efct_device_detach (efct); +/* Disable interrupt and pci device */ +efct_teardown_msix (efct); + } +pci_disable_device (pdev); +} + +static void +efct_device_prep_for_recover (struct efct *efct) +{ +if (efct) { +efc_log_debug (efct,"PCI channel preparing for recovery\n" ); +efct_hw_io_abort_all (&efct->hw); + } +} + +/** +* efct_pci_io_error_detected - method for handling PCI I/O error +* @pdev: pointer to PCI device. +* @state: the current PCI connection state. +* +* This routine is registered to the PCI subsystem for error handling. This +* function is called by the PCI subsystem after a PCI bus error affecting +* this device has been detected. When this routine is invoked, it dispatches +* device error detected handling routine, which will perform the proper +* error detected operation. +* +* Return codes +* PCI_ERS_RESULT_NEED_RESET - need to reset before recovery +* PCI_ERS_RESULT_DISCONNECT - device could not be recovered +*/ +static pci_ers_result_t +efct_pci_io_error_detected (struct pci_dev *pdev,pci_channel_state_t state) +{ +struct efct *efct =pci_get_drvdata (pdev); +pci_ers_result_t rc; + +switch (state) { +case pci_channel_io_normal: +efct_device_prep_for_recover (efct); + rc =PCI_ERS_RESULT_CAN_RECOVER ; +break ; +case pci_channel_io_frozen: +efct_device_prep_for_reset (efct, pdev); + rc =PCI_ERS_RESULT_NEED_RESET ; +break ; +case pci_channel_io_perm_failure: +efct_device_detach (efct); + rc =PCI_ERS_RESULT_DISCONNECT ; +break ; +default : +efc_log_debug (efct,"Unknown PCI error state:0x%x\n" , + state); +efct_device_prep_for_reset (efct, pdev); + rc =PCI_ERS_RESULT_NEED_RESET ; +break ; + } + +return rc; +} + +static pci_ers_result_t +efct_pci_io_slot_reset (struct pci_dev *pdev) +{ +int rc; +struct efct *efct =pci_get_drvdata (pdev); + + rc =pci_enable_device_mem (pdev); +if (rc) { +efc_log_err (efct, +"failed to re-enable PCI device after reset.\n" ); +return PCI_ERS_RESULT_DISCONNECT ; + } + +/* +* As the new kernel behavior of pci_restore_state() API call clears +* device saved_state flag, need to save the restored state again. +*/ + +pci_save_state (pdev); + +pci_set_master (pdev); + + rc =efct_setup_msix (efct, efct->n_msix_vec); +if (rc) +efc_log_err (efct,"rc %d returned, IRQ allocation failed\n" , + rc); + +/* Perform device reset */ +efct_device_detach (efct); +/* Bring device to online*/ +efct_device_attach (efct); + +return PCI_ERS_RESULT_RECOVERED ; +} + +static void +efct_pci_io_resume (struct pci_dev *pdev) +{ +struct efct *efct =pci_get_drvdata (pdev); + +/* Perform device reset */ +efct_device_detach (efct); +/* Bring device to online*/ +efct_device_attach (efct); +} + +MODULE_DEVICE_TABLE (pci, efct_pci_table); + +static struct pci_error_handlers efct_pci_err_handler = { + .error_detected = efct_pci_io_error_detected, + .slot_reset = efct_pci_io_slot_reset, + .resume = efct_pci_io_resume, +}; + +static struct pci_driver efct_pci_driver = { + .name =EFCT_DRIVER_NAME , + .id_table = efct_pci_table, + .probe = efct_pci_probe, + .remove = efct_pci_remove, + .err_handler = &efct_pci_err_handler, +}; + +static +int __init efct_init (void ) +{ +int rc; + + rc =efct_device_init (); +if (rc) { +pr_err ("efct_device_init failed rc=%d\n" , rc); +return rc; + } + + rc =pci_register_driver (&efct_pci_driver); +if (rc) { +pr_err ("pci_register_driver failed rc=%d\n" , rc); +efct_device_shutdown (); + } + +return rc; +} + +static void __exit efct_exit(void) +{ +pci_unregister_driver (&efct_pci_driver); +efct_device_shutdown (); +} + +module_init (efct_init); +module_exit (efct_exit); +MODULE_VERSION (EFCT_DRIVER_VERSION ); +MODULE_LICENSE ("GPL" ); +MODULE_AUTHOR ("Broadcom" );
drivers/scsi/elx/efct/efct_driver.h new file +109 -0
109 lines not on this page · raw message
drivers/scsi/elx/efct/efct_hw.c new file +1166 -0
1,166 lines not on this page · raw message
drivers/scsi/elx/efct/efct_hw.h +15 -0
@@ -600,4 +600,19 @@ struct efct_hw_grp_hdr { u8 revision[32]; }; +static inline int +efct_hw_get_link_speed (struct efct_hw *hw) { +return hw->link.speed; +} + +enum efct_hw_rtn +efct_hw_setup (struct efct_hw *hw,void *os,struct pci_dev *pdev); +enum efct_hw_rtn efct_hw_init (struct efct_hw *hw); +enum efct_hw_rtn +efct_hw_parse_filter (struct efct_hw *hw,void *value); +uint64_t +efct_get_wwnn (struct efct_hw *hw); +uint64_t +efct_get_wwpn (struct efct_hw *hw); +#endif /* __EFCT_H__ */
drivers/scsi/elx/efct/efct_xport.c new file +519 -0
519 lines not on this page · raw message
drivers/scsi/elx/efct/efct_xport.h new file +186 -0
186 lines not on this page · raw message
Signature · 1 line
2.26.2
Re: [PATCH v4 18/31] elx: efct: Driver initialization routines
Quoted 113 lines · James Smart
This patch continues the efct driver population.
This patch adds driver definitions for:
Emulex FC Target driver init, attach and hardware setup routines.Co-developed-by Ram Vegesna <[email protected]>Signed-off-by Ram Vegesna <[email protected]>Signed-off-by James Smart <[email protected]>---
v4:
New library Template registration and associated functions Muti-RQ support, configure mrq.
Support for Multi RQ/EQ.
Configure filter to send all ELS traffic to one RQ and remaining IOs to
all RQs.
CPU based WQ scaling.
Allocate loop map during initialisation
Remove redundant includes inefc_driver.h--- drivers/scsi/elx/efct/efct_driver.c | 810 +++++++++++++++++++ drivers/scsi/elx/efct/efct_driver.h | 109 +++ drivers/scsi/elx/efct/efct_hw.c | 1166 +++++++++++++++++++++++++++ drivers/scsi/elx/efct/efct_hw.h | 15 + drivers/scsi/elx/efct/efct_xport.c | 519 ++++++++++++ drivers/scsi/elx/efct/efct_xport.h | 186 +++++ 6 files changed, 2805 insertions(+)create mode 100644
drivers/scsi/elx/efct/efct_driver.ccreate mode 100644drivers/scsi/elx/efct/efct_driver.hcreate mode 100644drivers/scsi/elx/efct/efct_hw.ccreate mode 100644drivers/scsi/elx/efct/efct_xport.ccreate mode 100644drivers/scsi/elx/efct/efct_xport.hdrivers/scsi/elx/efct/efct_driver.c new file +74
-0@@ -0,0 +1,810 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +#include "efct_driver.h" + +#include "efct_hw.h" +#include "efct_unsol.h" +#include "efct_scsi.h" + +struct efct *efct_devices[MAX_EFCT_DEVICES ]; + +static int logmask; +module_param (logmask, int,0444 ); +MODULE_PARM_DESC (logmask,"logging bitmask (default 0)" ); + +static struct libefc_function_template efct_libefc_templ = { + .issue_mbox_rqst = efct_issue_mbox_rqst, + .send_els = efct_els_hw_srrs_send, + .send_bls = efct_efc_bls_send, + + .new_nport = efct_scsi_tgt_new_nport, + .del_nport = efct_scsi_tgt_del_nport, + .scsi_new_node = efct_scsi_new_initiator, + .scsi_del_node = efct_scsi_del_initiator, + .hw_seq_free = efct_efc_hw_sequence_free, +}; + +static int +efct_device_init (void ) +{ +int rc; + +/* driver-wide init for target-server */ + rc =efct_scsi_tgt_driver_init (); +if (rc) { +pr_err ("efct_scsi_tgt_init failed rc=%d\n" , + rc); +return rc; + } + + rc =efct_scsi_reg_fc_transport (); +if (rc) { +pr_err ("failed to register to FC host\n" ); +return rc; + } + +return EFC_SUCCESS ; +} + +static void +efct_device_shutdown (void ) +{ +efct_scsi_release_fc_transport (); + +efct_scsi_tgt_driver_exit (); +} + +static void * +efct_device_alloc (u32 nid) +{ +struct efct *efct =NULL ; +u32 i; + + efct =kzalloc_node (sizeof (*efct),GFP_KERNEL , nid); +if (!efct) +return efct; + +for (i =0 ; i <ARRAY_SIZE (efct_devices); i++) { +if (!efct_devices[i]) { + efct->instance_index = i; + efct_devices[i] = efct;
drivers/scsi/elx/efct/efct_driver.c line 84
Quoted 10 lines
drivers/scsi/elx/efct/efct_driver.c new file +10
-0+break ; + } + } + +if (i ==ARRAY_SIZE (efct_devices)) { +pr_err ("Exceeded max supported devices.\n" ); +kfree (efct); + efct =NULL ; + } +
Why not simply using lists here?
That would avoid having to have a hard number of devices... Or even XArray, if you insist on having an array-like structure...
Quoted 447 lines
drivers/scsi/elx/efct/efct_driver.c new file +447
-0+return efct; +} + +static void +efct_teardown_msix (struct efct *efct) +{ +u32 i; + +for (i =0 ; i < efct->n_msix_vec; i++) { +free_irq (pci_irq_vector (efct->pci, i), + &efct->intr_context[i]); + } + +pci_free_irq_vectors (efct->pci); +} + +static int +efct_efclib_config (struct efct *efct,struct libefc_function_template *tt) +{ +struct efc *efc; +struct sli4 *sli; +int rc =EFC_SUCCESS ; + + efc =kzalloc (sizeof (*efc),GFP_KERNEL ); +if (!efc) +return EFC_FAIL ; + + efct->efcport = efc; + +memcpy (&efc->tt, tt,sizeof (*tt)); + efc->base = efct; + efc->pci = efct->pci; + + efc->def_wwnn =efct_get_wwnn (&efct->hw); + efc->def_wwpn =efct_get_wwpn (&efct->hw); + efc->enable_tgt =1 ; + efc->log_level =EFC_LOG_LIB ; + + sli = &efct->hw.sli; + efc->max_xfer_size = sli->sge_supported_length * +sli_get_max_sgl (&efct->hw.sli); + efc->sli = sli; + efc->fcfi = efct->hw.fcf_indicator; + + rc =efcport_init (efc); +if (rc) +efc_log_err (efc,"efcport_init failed\n" ); + +return rc; +} + +static int efct_request_firmware_update (struct efct *efct); + +static const char * +efct_pci_model (u16 device) +{ +switch (device) { +case EFCT_DEVICE_LANCER_G6 :return "LPE31004" ; +case EFCT_DEVICE_LANCER_G7 :return "LPE36000" ; +default :return "unknown" ; + } +} + +static int +efct_device_attach (struct efct *efct) +{ +u32 rc =0 , i =0 ; + +if (efct->attached) { +efc_log_err (efct,"Device is already attached\n" ); +return EFC_FAIL ; + } + +snprintf (efct->name,sizeof (efct->name),"[%s%d] " ,"fc" , + efct->instance_index); + + efct->logmask = logmask; + efct->filter_def =EFCT_DEFAULT_FILTER ; + efct->max_isr_time_msec =EFCT_OS_MAX_ISR_TIME_MSEC ; + + efct->model =efct_pci_model (efct->pci->device); + + efct->efct_req_fw_upgrade = true; + +/* Allocate transport object and bring online */ + efct->xport =efct_xport_alloc (efct); +if (!efct->xport) { +efc_log_err (efct,"failed to allocate transport object\n" ); + rc = -ENOMEM ; + goto out; + } + + rc =efct_xport_attach (efct->xport); +if (rc) { +efc_log_err (efct,"failed to attach transport object\n" ); + goto xport_out; + } + + rc =efct_xport_initialize (efct->xport); +if (rc) { +efc_log_err (efct,"failed to initialize transport object\n" ); + goto xport_out; + } + + rc =efct_efclib_config (efct, &efct_libefc_templ); +if (rc) { +efc_log_err (efct,"failed to init efclib\n" ); + goto efclib_out; + } + +for (i =0 ; i < efct->n_msix_vec; i++) { +efc_log_debug (efct,"irq %d enabled\n" , i); +enable_irq (pci_irq_vector (efct->pci, i)); + } + + efct->attached = true; + +if (efct->efct_req_fw_upgrade) +efct_request_firmware_update (efct); + +return rc; + +efclib_out: +efct_xport_detach (efct->xport); +xport_out: +if (efct->xport) { +efct_xport_free (efct->xport); + efct->xport =NULL ; + } +out: +return rc; +} + +static int +efct_device_detach (struct efct *efct) +{ +int i; + +if (!efct || !efct->attached) { +efc_log_warn (efct,"Device is not attached\n" ); +return EFC_FAIL ; + } + +if (efct_xport_control (efct->xport,EFCT_XPORT_SHUTDOWN )) +efc_log_err (efct,"Transport Shutdown timed out\n" ); + +for (i =0 ; i < efct->n_msix_vec; i++) +disable_irq (pci_irq_vector (efct->pci, i)); + +if (efct_xport_detach (efct->xport) !=0 ) +efc_log_err (efct,"Transport detach failed\n" ); + +efct_xport_free (efct->xport); + efct->xport =NULL ; + +efcport_destroy (efct->efcport); +kfree (efct->efcport); + + efct->attached = false; + +return EFC_SUCCESS ; +} + +static void +efct_fw_write_cb (int status,u32 actual_write_length, +u32 change_status,void *arg) +{ +struct efct_fw_write_result *result = arg; + + result->status = status; + result->actual_xfer = actual_write_length; + result->change_status = change_status; + +complete (&result->done); +} + +static int +efct_firmware_write (struct efct *efct,const u8 *buf,size_t buf_len, +u8 *change_status) +{ +int rc =0 ; +u32 bytes_left; +u32 xfer_size; +u32 offset; +struct efc_dma dma; +int last =0 ; +struct efct_fw_write_result result; + +init_completion (&result.done); + + bytes_left = buf_len; + offset =0 ; + + dma.size =FW_WRITE_BUFSIZE ; + dma.virt =dma_alloc_coherent (&efct->pci->dev, + dma.size, &dma.phys,GFP_DMA ); +if (!dma.virt) +return -ENOMEM ; + +while (bytes_left >0 ) { +if (bytes_left >FW_WRITE_BUFSIZE ) + xfer_size =FW_WRITE_BUFSIZE ; +else + xfer_size = bytes_left; + +memcpy (dma.virt, buf + offset, xfer_size); + +if (bytes_left == xfer_size) + last =1 ; + +efct_hw_firmware_write (&efct->hw, &dma, xfer_size, offset, + last, efct_fw_write_cb, &result); + +if (wait_for_completion_interruptible (&result.done) !=0 ) { + rc = -ENXIO ; +break ; + } + +if (result.actual_xfer ==0 || result.status !=0 ) { + rc = -EFAULT ; +break ; + } + +if (last) + *change_status = result.change_status; + + bytes_left -= result.actual_xfer; + offset += result.actual_xfer; + } + +dma_free_coherent (&efct->pci->dev, dma.size, dma.virt, dma.phys); +return rc; +} + +static int +efct_fw_reset (struct efct *efct) +{ +int rc =0 ; + +/* +* Firmware reset to activate the new firmware. +* Function 0 will update and load the new firmware +* during attach. +*/ +if (timer_pending (&efct->xport->stats_timer)) +del_timer (&efct->xport->stats_timer); + +if (efct_hw_reset (&efct->hw,EFCT_HW_RESET_FIRMWARE )) { +efc_log_info (efct,"failed to reset firmware\n" ); + rc =-1 ; + }else { +efc_log_info (efct, +"successfully reset firmware.Now resetting port\n" ); + +efct_device_detach (efct); + rc =efct_device_attach (efct); + } +return rc; +} + +static int +efct_request_firmware_update (struct efct *efct) +{ +int rc =0 ; +u8 file_name[256 ], fw_change_status =0 ; +const struct firmware *fw; +struct efct_hw_grp_hdr *fw_image; + +snprintf (file_name,256 ,"%s.grp" , efct->model); + + rc =request_firmware (&fw, file_name, &efct->pci->dev); +if (rc) { +efc_log_debug (efct,"Firmware file(%s) not found.\n" , + file_name); +return rc; + } + + fw_image = (struct efct_hw_grp_hdr *)fw->data; + +if (!strncmp (efct->hw.sli.fw_name[0 ], fw_image->revision, +strnlen (fw_image->revision,16 ))) { +efc_log_debug (efct, +"Skipped update. Firmware is already up to date.\n" ); + goto exit; + } + +efc_log_info (efct,"Firmware update is initiated. %s -> %s\n" , + efct->hw.sli.fw_name[0 ], fw_image->revision); + + rc =efct_firmware_write (efct, fw->data, fw->size, &fw_change_status); +if (rc) { +efc_log_err (efct, +"Firmware update failed. Return code = %d\n" , rc); + goto exit; + } + +efc_log_info (efct,"Firmware updated successfully\n" ); +switch (fw_change_status) { +case 0x00 : +efc_log_info (efct,"New firmware is active.\n" ); +break ; +case 0x01 : +efc_log_info (efct, +"System reboot needed to activate the new firmware\n" ); +break ; +case 0x02 : +case 0x03 : +efc_log_info (efct, +"firmware is resetting to activate the new firmware\n" ); +efct_fw_reset (efct); +break ; +default : +efc_log_info (efct, +"Unexected value change_status:%d\n" , fw_change_status); +break ; + } + +exit: +release_firmware (fw); + +return rc; +} + +static void +efct_device_free (struct efct *efct) +{ +if (efct) { + efct_devices[efct->instance_index] =NULL ; + +kfree (efct); + } +} + +static int +efct_device_interrupts_required (struct efct *efct) +{ +if (efct_hw_setup (&efct->hw, efct, efct->pci) !=EFCT_HW_RTN_SUCCESS ) +return -1 ; + +return efct->hw.config.n_eq; +} + +static irqreturn_t +efct_intr_thread (int irq,void *handle) +{ +struct efct_intr_context *intr_ctx = handle; +struct efct *efct = intr_ctx->efct; + +efct_hw_process (&efct->hw, intr_ctx->index, efct->max_isr_time_msec); +return IRQ_HANDLED ; +} + +static irqreturn_t +efct_intr_msix (int irq,void *handle) +{ +return IRQ_WAKE_THREAD ; +} + +static int +efct_setup_msix (struct efct *efct,u32 num_intrs) +{ +int rc =0 , i; + +if (!pci_find_capability (efct->pci,PCI_CAP_ID_MSIX )) { +dev_err (&efct->pci->dev, +"%s : MSI-X not available\n" , __func__); +return -EINVAL ; + } + + efct->n_msix_vec = num_intrs; + + rc =pci_alloc_irq_vectors (efct->pci, num_intrs, num_intrs, +PCI_IRQ_MSIX |PCI_IRQ_AFFINITY ); + +if (rc <0 ) { +dev_err (&efct->pci->dev,"Failed to alloc irq : %d\n" , rc); +return rc; + } + +for (i =0 ; i < num_intrs; i++) { +struct efct_intr_context *intr_ctx =NULL ; + + intr_ctx = &efct->intr_context[i]; + intr_ctx->efct = efct; + intr_ctx->index = i; + + rc =request_threaded_irq (pci_irq_vector (efct->pci, i), + efct_intr_msix, efct_intr_thread,0 , +EFCT_DRIVER_NAME , intr_ctx); +if (rc) { +dev_err (&efct->pci->dev, +"Failed to register %d vector: %d\n" , i, rc); + goto out; + } + } + +return rc; + +out: +while (--i >=0 ) +free_irq (pci_irq_vector (efct->pci, i), + &efct->intr_context[i]); + +pci_free_irq_vectors (efct->pci); +return rc; +} + +static struct pci_device_id efct_pci_table[] = { + {PCI_DEVICE (EFCT_VENDOR_ID ,EFCT_DEVICE_LANCER_G6 ),0 }, + {PCI_DEVICE (EFCT_VENDOR_ID ,EFCT_DEVICE_LANCER_G7 ),0 }, + {}/* terminate list */ +}; + +static int +efct_pci_probe (struct pci_dev *pdev,const struct pci_device_id *ent) +{ +struct efct *efct =NULL ; +int rc; +u32 i, r; +int num_interrupts =0 ; +int nid; + +dev_info (&pdev->dev,"%s\n" ,EFCT_DRIVER_NAME ); + + rc =pci_enable_device_mem (pdev); +if (rc) +return rc; + +pci_set_master (pdev); + + rc =pci_set_mwi (pdev); +if (rc) { +dev_info (&pdev->dev,"pci_set_mwi returned %d\n" , rc); + goto mwi_out; + } + + rc =pci_request_regions (pdev,EFCT_DRIVER_NAME ); +if (rc) { +dev_err (&pdev->dev,"pci_request_regions failed %d\n" , rc); + goto req_regions_out; + } + +/* Fetch the Numa node id for this device */ + nid =dev_to_node (&pdev->dev); +if (nid <0 ) { +dev_err (&pdev->dev,"Warning Numa node ID is %d\n" , nid); + nid =0 ;
drivers/scsi/elx/efct/efct_driver.c line 541
Quoted 10 lines
drivers/scsi/elx/efct/efct_driver.c new file +10
-0+ } + +/* Allocate efct */ + efct =efct_device_alloc (nid); +if (!efct) { +dev_err (&pdev->dev,"Failed to allocate efct\n" ); + rc = -ENOMEM ; + goto alloc_out; + } +
How very curious.
So you are allocating one device per NUMA node ID? Very laudable, but what happens if you put two cards in?
Quoted 513 lines
drivers/scsi/elx/efct/efct_driver.c new file +269
-0+ efct->pci = pdev; + efct->numa_node = nid; + +/* Map all memory BARs */ +for (i =0 , r =0 ; i <EFCT_PCI_MAX_REGS ; i++) { +if (pci_resource_flags (pdev, i) &IORESOURCE_MEM ) { + efct->reg[r] =ioremap (pci_resource_start (pdev, i), +pci_resource_len (pdev, i)); + r++; + } + +/* +* If the 64-bit attribute is set, both this BAR and the +* next form the complete address. Skip processing the +* next BAR. +*/ +if (pci_resource_flags (pdev, i) &IORESOURCE_MEM_64 ) + i++; + } + +pci_set_drvdata (pdev, efct); + +if (pci_set_dma_mask (pdev,DMA_BIT_MASK (64 )) !=0 || +pci_set_consistent_dma_mask (pdev,DMA_BIT_MASK (64 )) !=0 ) { +dev_warn (&pdev->dev,"trying DMA_BIT_MASK(32)\n" ); +if (pci_set_dma_mask (pdev,DMA_BIT_MASK (32 )) !=0 || +pci_set_consistent_dma_mask (pdev,DMA_BIT_MASK (32 )) !=0 ) { +dev_err (&pdev->dev,"setting DMA_BIT_MASK failed\n" ); + rc =-1 ; + goto dma_mask_out; + } + } + + num_interrupts =efct_device_interrupts_required (efct); +if (num_interrupts <0 ) { +efc_log_err (efct,"efct_device_interrupts_required failed\n" ); + rc =-1 ; + goto dma_mask_out; + } + +/* +* Initialize MSIX interrupts, note, +* efct_setup_msix() enables the interrupt +*/ + rc =efct_setup_msix (efct, num_interrupts); +if (rc) { +dev_err (&pdev->dev,"Can't setup msix\n" ); + goto dma_mask_out; + } +/* Disable interrupt for now */ +for (i =0 ; i < efct->n_msix_vec; i++) { +efc_log_debug (efct,"irq %d disabled\n" , i); +disable_irq (pci_irq_vector (efct->pci, i)); + } + + rc =efct_device_attach (efct); +if (rc) + goto attach_out; + +return EFC_SUCCESS ; + +attach_out: +efct_teardown_msix (efct); +dma_mask_out: +pci_set_drvdata (pdev,NULL ); + +for (i =0 ; i <EFCT_PCI_MAX_REGS ; i++) { +if (efct->reg[i]) +iounmap (efct->reg[i]); + } +efct_device_free (efct); +alloc_out: +pci_release_regions (pdev); +req_regions_out: +pci_clear_mwi (pdev); +mwi_out: +pci_disable_device (pdev); +return rc; +} + +static void +efct_pci_remove (struct pci_dev *pdev) +{ +struct efct *efct =pci_get_drvdata (pdev); +u32 i; + +if (!efct) +return ; + +efct_device_detach (efct); + +efct_teardown_msix (efct); + +for (i =0 ; i <EFCT_PCI_MAX_REGS ; i++) { +if (efct->reg[i]) +iounmap (efct->reg[i]); + } + +pci_set_drvdata (pdev,NULL ); + + efct_devices[efct->instance_index] =NULL ; + +efct_device_free (efct); + +pci_release_regions (pdev); + +pci_disable_device (pdev); +} + +static void +efct_device_prep_for_reset (struct efct *efct,struct pci_dev *pdev) +{ +if (efct) { +efc_log_debug (efct, +"PCI channel disable preparing for reset\n" ); +efct_device_detach (efct); +/* Disable interrupt and pci device */ +efct_teardown_msix (efct); + } +pci_disable_device (pdev); +} + +static void +efct_device_prep_for_recover (struct efct *efct) +{ +if (efct) { +efc_log_debug (efct,"PCI channel preparing for recovery\n" ); +efct_hw_io_abort_all (&efct->hw); + } +} + +/** +* efct_pci_io_error_detected - method for handling PCI I/O error +* @pdev: pointer to PCI device. +* @state: the current PCI connection state. +* +* This routine is registered to the PCI subsystem for error handling. This +* function is called by the PCI subsystem after a PCI bus error affecting +* this device has been detected. When this routine is invoked, it dispatches +* device error detected handling routine, which will perform the proper +* error detected operation. +* +* Return codes +* PCI_ERS_RESULT_NEED_RESET - need to reset before recovery +* PCI_ERS_RESULT_DISCONNECT - device could not be recovered +*/ +static pci_ers_result_t +efct_pci_io_error_detected (struct pci_dev *pdev,pci_channel_state_t state) +{ +struct efct *efct =pci_get_drvdata (pdev); +pci_ers_result_t rc; + +switch (state) { +case pci_channel_io_normal: +efct_device_prep_for_recover (efct); + rc =PCI_ERS_RESULT_CAN_RECOVER ; +break ; +case pci_channel_io_frozen: +efct_device_prep_for_reset (efct, pdev); + rc =PCI_ERS_RESULT_NEED_RESET ; +break ; +case pci_channel_io_perm_failure: +efct_device_detach (efct); + rc =PCI_ERS_RESULT_DISCONNECT ; +break ; +default : +efc_log_debug (efct,"Unknown PCI error state:0x%x\n" , + state); +efct_device_prep_for_reset (efct, pdev); + rc =PCI_ERS_RESULT_NEED_RESET ; +break ; + } + +return rc; +} + +static pci_ers_result_t +efct_pci_io_slot_reset (struct pci_dev *pdev) +{ +int rc; +struct efct *efct =pci_get_drvdata (pdev); + + rc =pci_enable_device_mem (pdev); +if (rc) { +efc_log_err (efct, +"failed to re-enable PCI device after reset.\n" ); +return PCI_ERS_RESULT_DISCONNECT ; + } + +/* +* As the new kernel behavior of pci_restore_state() API call clears +* device saved_state flag, need to save the restored state again. +*/ + +pci_save_state (pdev); + +pci_set_master (pdev); + + rc =efct_setup_msix (efct, efct->n_msix_vec); +if (rc) +efc_log_err (efct,"rc %d returned, IRQ allocation failed\n" , + rc); + +/* Perform device reset */ +efct_device_detach (efct); +/* Bring device to online*/ +efct_device_attach (efct); + +return PCI_ERS_RESULT_RECOVERED ; +} + +static void +efct_pci_io_resume (struct pci_dev *pdev) +{ +struct efct *efct =pci_get_drvdata (pdev); + +/* Perform device reset */ +efct_device_detach (efct); +/* Bring device to online*/ +efct_device_attach (efct); +} + +MODULE_DEVICE_TABLE (pci, efct_pci_table); + +static struct pci_error_handlers efct_pci_err_handler = { + .error_detected = efct_pci_io_error_detected, + .slot_reset = efct_pci_io_slot_reset, + .resume = efct_pci_io_resume, +}; + +static struct pci_driver efct_pci_driver = { + .name =EFCT_DRIVER_NAME , + .id_table = efct_pci_table, + .probe = efct_pci_probe, + .remove = efct_pci_remove, + .err_handler = &efct_pci_err_handler, +}; + +static +int __init efct_init (void ) +{ +int rc; + + rc =efct_device_init (); +if (rc) { +pr_err ("efct_device_init failed rc=%d\n" , rc); +return rc; + } + + rc =pci_register_driver (&efct_pci_driver); +if (rc) { +pr_err ("pci_register_driver failed rc=%d\n" , rc); +efct_device_shutdown (); + } + +return rc; +} + +static void __exit efct_exit(void) +{ +pci_unregister_driver (&efct_pci_driver); +efct_device_shutdown (); +} + +module_init (efct_init); +module_exit (efct_exit); +MODULE_VERSION (EFCT_DRIVER_VERSION ); +MODULE_LICENSE ("GPL" ); +MODULE_AUTHOR ("Broadcom" );drivers/scsi/elx/efct/efct_driver.h new file +109
-0@@ -0,0 +1,109 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +#if !defined(__EFCT_DRIVER_H__) +#define __EFCT_DRIVER_H__ + +/*************************************************************************** +* OS specific includes +*/ +#include <stdarg.h> +#include <linux/module.h> +#include <linux/debugfs.h> +#include <linux/firmware.h> +#include "../include/efc_common.h" +#include "../libefc/efclib.h" +#include "efct_hw.h" +#include "efct_io.h" +#include "efct_xport.h" + +#define EFCT_DRIVER_NAME "efct" +#define EFCT_DRIVER_VERSION "1.0.0.0" + +/* EFCT_DEFAULT_FILTER- +* MRQ filter to segregate the IO flow. +*/ +#define EFCT_DEFAULT_FILTER "0x01ff22ff,0,0,0" + +/* EFCT_OS_MAX_ISR_TIME_MSEC - +* maximum time driver code should spend in an interrupt +* or kernel thread context without yielding +*/ +#define EFCT_OS_MAX_ISR_TIME_MSEC 1000 + +#define EFCT_FC_MAX_SGL 64 +#define EFCT_FC_DIF_SEED 0 + +/* Watermark */ +#define EFCT_WATERMARK_HIGH_PCT 90 +#define EFCT_WATERMARK_LOW_PCT 80 +#define EFCT_IO_WATERMARK_PER_INITIATOR 8 + +#define EFCT_PCI_MAX_REGS 6 +#define MAX_PCI_INTERRUPTS 16 + +struct efct_intr_context { +struct efct *efct; +u32 index; +}; + +struct efct { +struct pci_dev *pci; +void __iomem *reg[EFCT_PCI_MAX_REGS ]; + +u32 n_msix_vec; +bool attached; +bool soft_wwn_enable; +u8 efct_req_fw_upgrade; +struct efct_intr_context intr_context[MAX_PCI_INTERRUPTS ]; +u32 numa_node; + +char name[EFC_NAME_LENGTH ]; +u32 instance_index; +struct efct_scsi_tgt tgt_efct; +struct efct_xport *xport; +struct efc *efcport; +struct Scsi_Host *shost; +int logmask; +u32 max_isr_time_msec; + +const char *desc; + +const char *model; + +struct efct_hw hw; + +u32 rq_selection_policy; +char *filter_def; +int topology; + +/* Look up for target node */ +struct xarray lookup; + +/* +* Target IO timer value: +* Zero: target command timeout disabled. +* Non-zero: Timeout value, in seconds, for target commands +*/ +u32 target_io_timer_sec; + +int speed; +struct dentry *sess_debugfs_dir; +}; + +#define FW_WRITE_BUFSIZE (64 * 1024) + +struct efct_fw_write_result { +struct completion done; +int status; +u32 actual_xfer; +u32 change_status; +}; + +#define MAX_EFCT_DEVICES 64 +extern struct efct *efct_devices[MAX_EFCT_DEVICES ]; + +#endif /* __EFCT_DRIVER_H__ */ drivers/scsi/elx/efct/efct_hw.c new file +123
-0@@ -0,0 +1,1166 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +#include "efct_driver.h" +#include "efct_hw.h" +#include "efct_unsol.h" + +struct efct_mbox_rqst_ctx { +int (*callback)(struct efc *efc,int status,u8 *mqe,void *arg); +void *arg; +}; + +static enum efct_hw_rtn +efct_hw_link_event_init (struct efct_hw *hw) +{ + hw->link.status =SLI4_LINK_STATUS_MAX ; + hw->link.topology =SLI4_LINK_TOPO_NONE ; + hw->link.medium =SLI4_LINK_MEDIUM_MAX ; + hw->link.speed =0 ; + hw->link.loop_map =NULL ; + hw->link.fc_id =U32_MAX ; + +return EFCT_HW_RTN_SUCCESS ; +} + +static enum efct_hw_rtn +efct_hw_read_max_dump_size (struct efct_hw *hw) +{ +u8 buf[SLI4_BMBX_SIZE ]; +struct efct *efct = hw->os; +int rc =EFCT_HW_RTN_SUCCESS ; +struct sli4_rsp_cmn_set_dump_location *rsp; + +/* attempt to detemine the dump size for function 0 only. */ +if (PCI_FUNC (efct->pci->devfn) !=0 ) +return rc; + +if (sli_cmd_common_set_dump_location (&hw->sli, buf,1 ,0 ,NULL ,0 )) +return EFC_FAIL ; + + rsp = (struct sli4_rsp_cmn_set_dump_location *) + (buf + offsetof(struct sli4_cmd_sli_config, payload.embed)); + + rc =efct_hw_command (hw, buf,EFCT_CMD_POLL ,NULL ,NULL ); +if (rc !=EFCT_HW_RTN_SUCCESS ) { +efc_log_test (hw->os,"set dump location cmd failed\n" ); +return rc; + } + + hw->dump_size = +le32_to_cpu (rsp->buffer_length_dword) &SLI4_CMN_SET_DUMP_BUFFER_LEN ; + +efc_log_debug (hw->os,"Dump size %x\n" , hw->dump_size); + +return rc; +} + +static int +__efct_read_topology_cb (struct efct_hw *hw,int status,u8 *mqe,void *arg) +{ +struct sli4_cmd_read_topology *read_topo = + (struct sli4_cmd_read_topology *)mqe; +u8 speed; +struct efc_domain_record drec = {0 }; +struct efct *efct = hw->os; + +if (status ||le16_to_cpu (read_topo->hdr.status)) { +efc_log_debug (hw->os,"bad status cqe=%#x mqe=%#x\n" , + status, +le16_to_cpu (read_topo->hdr.status)); +return EFC_FAIL ; + } + +switch (le32_to_cpu (read_topo->dw2_attentype) & +SLI4_READTOPO_ATTEN_TYPE ) { +case SLI4_READ_TOPOLOGY_LINK_UP : + hw->link.status =SLI4_LINK_STATUS_UP ; +break ; +case SLI4_READ_TOPOLOGY_LINK_DOWN : + hw->link.status =SLI4_LINK_STATUS_DOWN ; +break ; +case SLI4_READ_TOPOLOGY_LINK_NO_ALPA : + hw->link.status =SLI4_LINK_STATUS_NO_ALPA ; +break ; +default : + hw->link.status =SLI4_LINK_STATUS_MAX ; +break ; + } + +switch (read_topo->topology) { +case SLI4_READ_TOPOLOGY_NPORT : + hw->link.topology =SLI4_LINK_TOPO_NPORT ; +break ; +case SLI4_READ_TOPOLOGY_FC_AL : + hw->link.topology =SLI4_LINK_TOPO_LOOP ; +if (hw->link.status ==SLI4_LINK_STATUS_UP ) + hw->link.loop_map = hw->loop_map.virt; + hw->link.fc_id = read_topo->acquired_al_pa; +break ; +default : + hw->link.topology =SLI4_LINK_TOPO_MAX ; +break ; + } + + hw->link.medium =SLI4_LINK_MEDIUM_FC ; + + speed = (le32_to_cpu (read_topo->currlink_state) & +SLI4_READTOPO_LINKSTATE_SPEED ) >>8 ; +switch (speed) { +case SLI4_READ_TOPOLOGY_SPEED_1G : + hw->link.speed =1 *1000 ; +break ; +case SLI4_READ_TOPOLOGY_SPEED_2G : + hw->link.speed =2 *1000 ; +break ; +case SLI4_READ_TOPOLOGY_SPEED_4G : + hw->link.speed =4 *1000 ; +break ; +case SLI4_READ_TOPOLOGY_SPEED_8G : + hw->link.speed =8 *1000 ;
drivers/scsi/elx/efct/efct_hw.c line 133
Quoted 10 lines
drivers/scsi/elx/efct/efct_hw.c new file +10
-0+break ; +case SLI4_READ_TOPOLOGY_SPEED_16G : + hw->link.speed =16 *1000 ; + hw->link.loop_map =NULL ; +break ; +case SLI4_READ_TOPOLOGY_SPEED_32G : + hw->link.speed =32 *1000 ; + hw->link.loop_map =NULL ; +break ; + }
More speeds?
I was under the impression that 64G is pretty much specified by now...
Quoted 185 lines
drivers/scsi/elx/efct/efct_hw.c new file +185
-0+ + drec.speed = hw->link.speed; + drec.fc_id = hw->link.fc_id; + drec.is_nport = true; +efc_domain_cb (efct->efcport,EFC_HW_DOMAIN_FOUND , &drec); + +return EFC_SUCCESS ; +} + +static int +efct_hw_cb_link (void *ctx,void *e) +{ +struct efct_hw *hw = ctx; +struct sli4_link_event *event = e; +struct efc_domain *d =NULL ; +int rc =EFCT_HW_RTN_ERROR ; +struct efct *efct = hw->os; + +efct_hw_link_event_init (hw); + +switch (event->status) { +case SLI4_LINK_STATUS_UP : + + hw->link = *event; + efct->efcport->link_status =EFC_LINK_STATUS_UP ; + +if (event->topology ==SLI4_LINK_TOPO_NPORT ) { +struct efc_domain_record drec = {0 }; + +efc_log_info (hw->os,"Link Up, NPORT, speed is %d\n" , + event->speed); + drec.speed = event->speed; + drec.fc_id = event->fc_id; + drec.is_nport = true; +efc_domain_cb (efct->efcport,EFC_HW_DOMAIN_FOUND , + &drec); + }else if (event->topology ==SLI4_LINK_TOPO_LOOP ) { +u8 buf[SLI4_BMBX_SIZE ]; + +efc_log_info (hw->os,"Link Up, LOOP, speed is %d\n" , + event->speed); + +if (!sli_cmd_read_topology (&hw->sli, buf, + &hw->loop_map)) { + rc =efct_hw_command (hw, buf,EFCT_CMD_NOWAIT , + __efct_read_topology_cb,NULL ); + } + +if (rc) +efc_log_test (hw->os,"READ_TOPOLOGY failed\n" ); + }else { +efc_log_info (hw->os,"%s(%#x), speed is %d\n" , +"Link Up, unsupported topology " , + event->topology, event->speed); + } +break ; +case SLI4_LINK_STATUS_DOWN : +efc_log_info (hw->os,"Link down\n" ); + + hw->link.status = event->status; + efct->efcport->link_status =EFC_LINK_STATUS_DOWN ; + + d = efct->efcport->domain; +if (d) +efc_domain_cb (efct->efcport,EFC_HW_DOMAIN_LOST , d); +break ; +default : +efc_log_test (hw->os,"unhandled link status %#x\n" , + event->status); +break ; + } + +return EFC_SUCCESS ; +} + +enum efct_hw_rtn +efct_hw_setup (struct efct_hw *hw,void *os,struct pci_dev *pdev) +{ +u32 i, max_sgl, cpus; + +if (hw->hw_setup_called) +return EFCT_HW_RTN_SUCCESS ; + +/* +* efct_hw_init() relies on NULL pointers indicating that a structure +* needs allocation. If a structure is non-NULL, efct_hw_init() won't +* free/realloc that memory +*/ +memset (hw,0 ,sizeof (struct efct_hw )); + + hw->hw_setup_called = true; + + hw->os = os; + +mutex_init (&hw->bmbx_lock); +spin_lock_init (&hw->cmd_lock); +INIT_LIST_HEAD (&hw->cmd_head); +INIT_LIST_HEAD (&hw->cmd_pending); + hw->cmd_head_count =0 ; + +/* Create mailbox command ctx pool */ + hw->cmd_ctx_pool =mempool_create_kmalloc_pool (EFCT_CMD_CTX_POOL_SZ , +sizeof (struct efct_command_ctx )); +if (!hw->cmd_ctx_pool) { +efc_log_err (hw->os,"failed to allocate mailbox buffer pool\n" ); +return EFCT_HW_RTN_ERROR ; + } + +/* Create mailbox request ctx pool for library callback */ + hw->mbox_rqst_pool =mempool_create_kmalloc_pool (EFCT_CMD_CTX_POOL_SZ , +sizeof (struct efct_mbox_rqst_ctx )); +if (!hw->mbox_rqst_pool) { +efc_log_err (hw->os,"failed to allocate mbox request pool\n" ); +return EFCT_HW_RTN_ERROR ; + } + +spin_lock_init (&hw->io_lock); +spin_lock_init (&hw->io_abort_lock); + +atomic_set (&hw->io_alloc_failed_count,0 ); + + hw->config.speed =SLI4_LINK_SPEED_AUTO_16_8_4 ; +if (sli_setup (&hw->sli, hw->os, pdev, ((struct efct *)os)->reg)) { +efc_log_err (hw->os,"SLI setup failed\n" ); +return EFCT_HW_RTN_ERROR ; + } + +efct_hw_link_event_init (hw); + +sli_callback (&hw->sli,SLI4_CB_LINK , efct_hw_cb_link, hw); + +/* +* Set all the queue sizes to the maximum allowed. +*/ +for (i =0 ; i <ARRAY_SIZE (hw->num_qentries); i++) + hw->num_qentries[i] = hw->sli.qinfo.max_qentries[i]; +/* +* Adjust the size of the WQs so that the CQ is twice as big as +* the WQ to allow for 2 completions per IO. This allows us to +* handle multi-phase as well as aborts. +*/ + hw->num_qentries[SLI4_QTYPE_WQ ] = hw->num_qentries[SLI4_QTYPE_CQ ] /2 ; + +/* +* The RQ assignment for RQ pair mode. +*/ + + hw->config.rq_default_buffer_size =EFCT_HW_RQ_SIZE_PAYLOAD ; + hw->config.n_io = hw->sli.ext[SLI4_RSRC_XRI ].size; + + cpus =num_possible_cpus (); + hw->config.n_eq = cpus >EFCT_HW_MAX_NUM_EQ ?EFCT_HW_MAX_NUM_EQ : cpus; + + max_sgl =sli_get_max_sgl (&hw->sli) -SLI4_SGE_MAX_RESERVED ; + max_sgl = (max_sgl >EFCT_FC_MAX_SGL ) ?EFCT_FC_MAX_SGL : max_sgl; + hw->config.n_sgl = max_sgl; + + (void )efct_hw_read_max_dump_size (hw); + +return EFCT_HW_RTN_SUCCESS ; +} + +static void +efct_logfcfi (struct efct_hw *hw,u32 j,u32 i,u32 id) +{ +efc_log_info (hw->os, +"REG_FCFI: filter[%d] %08X -> RQ[%d] id=%d\n" , + j, hw->config.filter_def[j], i, id); +} + +static inline void +efct_hw_init_free_io (struct efct_hw_io *io) +{ +/* +* Set io->done to NULL, to avoid any callbacks, should +* a completion be received for one of these IOs +*/ + io->done =NULL ; + io->abort_done =NULL ; + io->status_saved = false; + io->abort_in_progress = false; + io->type =0xFFFF ; + io->wq =NULL ; +} +
drivers/scsi/elx/efct/efct_hw.c line 328
Quoted 10 lines
drivers/scsi/elx/efct/efct_hw.c new file +10
-0+static u8 efct_hw_iotype_is_originator (u16 io_type) +{ +switch (io_type) { +case EFCT_HW_FC_CT : +case EFCT_HW_ELS_REQ : +return 1 ; +default : +return EFC_SUCCESS ; + } +}
Shudder.
Returning '1' and 'EFC_SUCCESS'?
Consider making this a 'bool' function.
Quoted 1,570 lines
drivers/scsi/elx/efct/efct_hw.c new file +838
-0+ +static void +efct_hw_io_restore_sgl (struct efct_hw *hw,struct efct_hw_io *io) +{ +/* Restore the default */ + io->sgl = &io->def_sgl; + io->sgl_count = io->def_sgl_count; +} + +static void +efct_hw_wq_process_io (void *arg,u8 *cqe,int status) +{ +struct efct_hw_io *io = arg; +struct efct_hw *hw = io->hw; +struct sli4_fc_wcqe *wcqe = (void *)cqe; +u32 len =0 ; +u32 ext =0 ; + +/* clear xbusy flag if WCQE[XB] is clear */ +if (io->xbusy && (wcqe->flags &SLI4_WCQE_XB ) ==0 ) + io->xbusy = false; + +/* get extended CQE status */ +switch (io->type) { +case EFCT_HW_BLS_ACC : +case EFCT_HW_BLS_RJT : +break ; +case EFCT_HW_ELS_REQ : +sli_fc_els_did (&hw->sli, cqe, &ext); + len =sli_fc_response_length (&hw->sli, cqe); +break ; +case EFCT_HW_ELS_RSP : +case EFCT_HW_FC_CT_RSP : +break ; +case EFCT_HW_FC_CT : + len =sli_fc_response_length (&hw->sli, cqe); +break ; +case EFCT_HW_IO_TARGET_WRITE : + len =sli_fc_io_length (&hw->sli, cqe); +break ; +case EFCT_HW_IO_TARGET_READ : + len =sli_fc_io_length (&hw->sli, cqe); +break ; +case EFCT_HW_IO_TARGET_RSP : +break ; +case EFCT_HW_IO_DNRX_REQUEUE : +/* release the count for re-posting the buffer */ +/* efct_hw_io_free(hw, io); */ +break ; +default : +efc_log_err (hw->os,"unhandled io type %#x for XRI 0x%x\n" , + io->type, io->indicator); +break ; + } +if (status) { + ext =sli_fc_ext_status (&hw->sli, cqe); +/* +* If we're not an originator IO, and XB is set, then issue +* abort for the IO from within the HW +*/ +if ((!efct_hw_iotype_is_originator (io->type)) && + wcqe->flags &SLI4_WCQE_XB ) { +enum efct_hw_rtn rc; + +efc_log_debug (hw->os,"aborting xri=%#x tag=%#x\n" , + io->indicator, io->reqtag); + +/* +* Because targets may send a response when the IO +* completes using the same XRI, we must wait for the +* XRI_ABORTED CQE to issue the IO callback +*/ + rc =efct_hw_io_abort (hw, io, false,NULL ,NULL ); +if (rc ==EFCT_HW_RTN_SUCCESS ) { +/* +* latch status to return after abort is +* complete +*/ + io->status_saved = true; + io->saved_status = status; + io->saved_ext = ext; + io->saved_len = len; + goto exit_efct_hw_wq_process_io; + }else if (rc ==EFCT_HW_RTN_IO_ABORT_IN_PROGRESS ) { +/* +* Already being aborted by someone else (ABTS +* perhaps). Just return original +* error. +*/ +efc_log_debug (hw->os,"%s%#x tag=%#x\n" , +"abort in progress xri=" , + io->indicator, io->reqtag); + + }else { +/* Failed to abort for some other reason, log +* error +*/ +efc_log_test (hw->os,"%s%#x tag=%#x rc=%d\n" , +"Failed to abort xri=" , + io->indicator, io->reqtag, rc); + } + } + } + +if (io->done) { +efct_hw_done_t done = io->done; + + io->done =NULL ; + +if (io->status_saved) { +/* use latched status if exists */ + status = io->saved_status; + len = io->saved_len; + ext = io->saved_ext; + io->status_saved = false; + } + +/* Restore default SGL */ +efct_hw_io_restore_sgl (hw, io); +done (io, len, status, ext, io->arg); + } + +exit_efct_hw_wq_process_io: +return ; +} + +static enum efct_hw_rtn +efct_hw_setup_io (struct efct_hw *hw) +{ +u32 i =0 ; +struct efct_hw_io *io =NULL ; +uintptr_t xfer_virt =0 ; +uintptr_t xfer_phys =0 ; +u32 index; +bool new_alloc = true; +struct efc_dma *dma; +struct efct *efct = hw->os; + +if (!hw->io) { + hw->io =kmalloc_array (hw->config.n_io,sizeof (io), +GFP_KERNEL ); + +if (!hw->io) +return EFCT_HW_RTN_NO_MEMORY ; + +memset (hw->io,0 , hw->config.n_io *sizeof (io)); + +for (i =0 ; i < hw->config.n_io; i++) { + hw->io[i] =kzalloc (sizeof (*io),GFP_KERNEL ); +if (!hw->io[i]) + goto error; + } + +/* Create WQE buffs for IO */ + hw->wqe_buffs =kzalloc ((hw->config.n_io * hw->sli.wqe_size), +GFP_KERNEL ); +if (!hw->wqe_buffs) { +kfree (hw->io); +return EFCT_HW_RTN_NO_MEMORY ; + } + + }else { +/* re-use existing IOs, including SGLs */ + new_alloc = false; + } + +if (new_alloc) { + dma = &hw->xfer_rdy; + dma->size =sizeof (struct fcp_txrdy ) * hw->config.n_io; + dma->virt =dma_alloc_coherent (&efct->pci->dev, + dma->size, &dma->phys,GFP_DMA ); +if (!dma->virt) +return EFCT_HW_RTN_NO_MEMORY ; + } + xfer_virt = (uintptr_t )hw->xfer_rdy.virt; + xfer_phys = hw->xfer_rdy.phys; + +/* Initialize the pool of HW IO objects */ +for (i =0 ; i < hw->config.n_io; i++) { +struct hw_wq_callback *wqcb; + + io = hw->io[i]; + +/* initialize IO fields */ + io->hw = hw; + +/* Assign a WQE buff */ + io->wqe.wqebuf = &hw->wqe_buffs[i * hw->sli.wqe_size]; + +/* Allocate the request tag for this IO */ + wqcb =efct_hw_reqtag_alloc (hw, efct_hw_wq_process_io, io); +if (!wqcb) { +efc_log_err (hw->os,"can't allocate request tag\n" ); +return EFCT_HW_RTN_NO_RESOURCES ; + } + io->reqtag = wqcb->instance_index; + +/* Now for the fields that are initialized on each free */ +efct_hw_init_free_io (io); + +/* The XB flag isn't cleared on IO free, so init to zero */ + io->xbusy =0 ; + +if (sli_resource_alloc (&hw->sli,SLI4_RSRC_XRI , + &io->indicator, &index)) { +efc_log_err (hw->os, +"sli_resource_alloc failed @ %d\n" , i); +return EFCT_HW_RTN_NO_MEMORY ; + } +if (new_alloc) { + dma = &io->def_sgl; + dma->size = hw->config.n_sgl * +sizeof (struct sli4_sge ); + dma->virt =dma_alloc_coherent (&efct->pci->dev, + dma->size, &dma->phys, +GFP_DMA ); +if (!dma->virt) { +efc_log_err (hw->os,"dma_alloc fail %d\n" , i); +memset (&io->def_sgl,0 , +sizeof (struct efc_dma )); +return EFCT_HW_RTN_NO_MEMORY ; + } + } + io->def_sgl_count = hw->config.n_sgl; + io->sgl = &io->def_sgl; + io->sgl_count = io->def_sgl_count; + +if (hw->xfer_rdy.size) { + io->xfer_rdy.virt = (void *)xfer_virt; + io->xfer_rdy.phys = xfer_phys; + io->xfer_rdy.size =sizeof (struct fcp_txrdy ); + + xfer_virt +=sizeof (struct fcp_txrdy ); + xfer_phys +=sizeof (struct fcp_txrdy ); + } + } + +return EFCT_HW_RTN_SUCCESS ; +error: +for (i =0 ; i < hw->config.n_io && hw->io[i]; i++) { +kfree (hw->io[i]); + hw->io[i] =NULL ; + } + +kfree (hw->io); + hw->io =NULL ; + +return EFCT_HW_RTN_NO_MEMORY ; +} + + +static enum efct_hw_rtn +efct_hw_init_prereg_io (struct efct_hw *hw) +{ +u32 i, idx =0 ; +struct efct_hw_io *io =NULL ; +u8 cmd[SLI4_BMBX_SIZE ]; +enum efct_hw_rtn rc =EFCT_HW_RTN_SUCCESS ; +u32 n_rem; +u32 n =0 ; +u32 sgls_per_request =256 ; +struct efc_dma **sgls =NULL ; +struct efc_dma req; +struct efct *efct = hw->os; + + sgls =kmalloc_array (sgls_per_request,sizeof (*sgls),GFP_KERNEL ); +if (!sgls) +return EFCT_HW_RTN_NO_MEMORY ; + +memset (&req,0 ,sizeof (struct efc_dma )); + req.size =32 + sgls_per_request *16 ; + req.virt =dma_alloc_coherent (&efct->pci->dev, req.size, &req.phys, +GFP_DMA ); +if (!req.virt) { +kfree (sgls); +return EFCT_HW_RTN_NO_MEMORY ; + } + +for (n_rem = hw->config.n_io; n_rem; n_rem -= n) { +/* Copy address of SGL's into local sgls[] array, break +* out if the xri is not contiguous. +*/ +u32 min = (sgls_per_request < n_rem) ? sgls_per_request : n_rem; + +for (n =0 ; n < min; n++) { +/* Check that we have contiguous xri values */ +if (n >0 ) { +if (hw->io[idx + n]->indicator != + hw->io[idx + n -1 ]->indicator +1 ) +break ; + } + + sgls[n] = hw->io[idx + n]->sgl; + } + +if (sli_cmd_post_sgl_pages (&hw->sli, cmd, + hw->io[idx]->indicator, n, sgls,NULL , &req)) { + rc =EFCT_HW_RTN_ERROR ; +break ; + } + +if (efct_hw_command (hw, cmd,EFCT_CMD_POLL ,NULL ,NULL )) { + rc =EFCT_HW_RTN_ERROR ; +efc_log_err (hw->os,"SGL post failed\n" ); +break ; + } + +/* Add to tail if successful */ +for (i =0 ; i < n; i++, idx++) { + io = hw->io[idx]; + io->state =EFCT_HW_IO_STATE_FREE ; +INIT_LIST_HEAD (&io->list_entry); +list_add_tail (&io->list_entry, &hw->io_free); + } + } + +dma_free_coherent (&efct->pci->dev, req.size, req.virt, req.phys); +memset (&req,0 ,sizeof (struct efc_dma )); +kfree (sgls); + +return rc; +} + +static enum efct_hw_rtn +efct_hw_init_io (struct efct_hw *hw) +{ +u32 i, idx =0 ; +bool prereg = false; +struct efct_hw_io *io =NULL ; +enum efct_hw_rtn rc =EFCT_HW_RTN_SUCCESS ; + + prereg = hw->sli.params.sgl_pre_registered; + +if (prereg) +return efct_hw_init_prereg_io (hw); + +for (i =0 ; i < hw->config.n_io; i++, idx++) { + io = hw->io[idx]; + io->state =EFCT_HW_IO_STATE_FREE ; +INIT_LIST_HEAD (&io->list_entry); +list_add_tail (&io->list_entry, &hw->io_free); + } + +return rc; +} + +static enum efct_hw_rtn +efct_hw_config_set_fdt_xfer_hint (struct efct_hw *hw,u32 fdt_xfer_hint) +{ +enum efct_hw_rtn rc =EFCT_HW_RTN_SUCCESS ; +u8 buf[SLI4_BMBX_SIZE ]; +struct sli4_rqst_cmn_set_features_set_fdt_xfer_hint param; + +memset (¶m,0 ,sizeof (param)); + param.fdt_xfer_hint =cpu_to_le32 (fdt_xfer_hint); +/* build the set_features command */ +sli_cmd_common_set_features (&hw->sli, buf, +SLI4_SET_FEATURES_SET_FTD_XFER_HINT ,sizeof (param), ¶m); + + rc =efct_hw_command (hw, buf,EFCT_CMD_POLL ,NULL ,NULL ); +if (rc) +efc_log_warn (hw->os,"set FDT hint %d failed: %d\n" , + fdt_xfer_hint, rc); +else +efc_log_info (hw->os,"Set FTD transfer hint to %d\n" , +le32_to_cpu (param.fdt_xfer_hint)); + +return rc; +} + +static int +efct_hw_config_rq (struct efct_hw *hw) +{ +u32 min_rq_count, i, rc; +struct sli4_cmd_rq_cfg rq_cfg[SLI4_CMD_REG_FCFI_NUM_RQ_CFG ]; +u8 buf[SLI4_BMBX_SIZE ]; + +efc_log_info (hw->os,"using REG_FCFI standard\n" ); + +/* +* Set the filter match/mask values from hw's +* filter_def values +*/ +for (i =0 ; i <SLI4_CMD_REG_FCFI_NUM_RQ_CFG ; i++) { + rq_cfg[i].rq_id =cpu_to_le16 (0xffff ); + rq_cfg[i].r_ctl_mask = (u8 )hw->config.filter_def[i]; + rq_cfg[i].r_ctl_match = (u8)(hw->config.filter_def[i] >>8 ); + rq_cfg[i].type_mask = (u8)(hw->config.filter_def[i] >>16 ); + rq_cfg[i].type_match = (u8)(hw->config.filter_def[i] >>24 ); + } + +/* +* Update the rq_id's of the FCF configuration +* (don't update more than the number of rq_cfg +* elements) +*/ + min_rq_count = (hw->hw_rq_count <SLI4_CMD_REG_FCFI_NUM_RQ_CFG ) ? + hw->hw_rq_count :SLI4_CMD_REG_FCFI_NUM_RQ_CFG ; +for (i =0 ; i < min_rq_count; i++) { +struct hw_rq *rq = hw->hw_rq[i]; +u32 j; + +for (j =0 ; j <SLI4_CMD_REG_FCFI_NUM_RQ_CFG ; j++) { +u32 mask = (rq->filter_mask !=0 ) ? + rq->filter_mask :1 ; + +if (!(mask & (1U << j))) +continue ; + + rq_cfg[i].rq_id =cpu_to_le16 (rq->hdr->id); +efct_logfcfi (hw, j, i, rq->hdr->id); + } + } + + rc =EFCT_HW_RTN_ERROR ; +if (!sli_cmd_reg_fcfi (&hw->sli, buf,0 , rq_cfg)) { + rc =efct_hw_command (hw, buf,EFCT_CMD_POLL , +NULL ,NULL ); + } + +if (rc !=EFCT_HW_RTN_SUCCESS ) { +efc_log_err (hw->os, +"FCFI registration failed\n" ); +return rc; + } + hw->fcf_indicator = +le16_to_cpu (((struct sli4_cmd_reg_fcfi *)buf)->fcfi); + +return rc; +} + +static int32_t +efct_hw_config_mrq (struct efct_hw *hw,uint8_t mode,uint16_t fcf_index) +{ +u8 buf[SLI4_BMBX_SIZE ], mrq_bitmask =0 ; +struct hw_rq *rq; +struct sli4_cmd_reg_fcfi_mrq *rsp =NULL ; +struct sli4_cmd_rq_cfg rq_filter[SLI4_CMD_REG_FCFI_MRQ_NUM_RQ_CFG ]; +u32 rc, i; + +if (mode ==SLI4_CMD_REG_FCFI_SET_FCFI_MODE ) + goto issue_cmd; + +/* Set the filter match/mask values from hw's filter_def values */ +for (i =0 ; i <SLI4_CMD_REG_FCFI_NUM_RQ_CFG ; i++) { + rq_filter[i].rq_id =cpu_to_le16 (0xffff ); + rq_filter[i].type_mask = (u8 )hw->config.filter_def[i]; + rq_filter[i].type_match = (u8)(hw->config.filter_def[i] >>8 ); + rq_filter[i].r_ctl_mask = (u8)(hw->config.filter_def[i] >>16 ); + rq_filter[i].r_ctl_match = (u8)(hw->config.filter_def[i] >>24 ); + } + + rq = hw->hw_rq[0 ]; + rq_filter[0 ].rq_id =cpu_to_le16 (rq->hdr->id); + rq_filter[1 ].rq_id =cpu_to_le16 (rq->hdr->id); + + mrq_bitmask =0x2 ; +issue_cmd: +efc_log_debug (hw->os,"Issue reg_fcfi_mrq count:%d policy:%d mode:%d\n" , + hw->hw_rq_count, hw->config.rq_selection_policy, mode); +/* Invoke REG_FCFI_MRQ */ + rc =sli_cmd_reg_fcfi_mrq (&hw->sli, buf, mode, fcf_index, + hw->config.rq_selection_policy, mrq_bitmask, + hw->hw_mrq_count, rq_filter); +if (rc) { +efc_log_err (hw->os,"sli_cmd_reg_fcfi_mrq() failed\n" ); +return EFC_FAIL ; + } + + rc =efct_hw_command (hw, buf,EFCT_CMD_POLL ,NULL ,NULL ); + + rsp = (struct sli4_cmd_reg_fcfi_mrq *)buf; + +if ((rc) || (le16_to_cpu (rsp->hdr.status))) { +efc_log_err (hw->os,"FCFI MRQ reg failed. cmd=%x status=%x\n" , + rsp->hdr.command,le16_to_cpu (rsp->hdr.status)); +return EFCT_HW_RTN_ERROR ; + } + +if (mode ==SLI4_CMD_REG_FCFI_SET_FCFI_MODE ) + hw->fcf_indicator =le16_to_cpu (rsp->fcfi); +return 0 ; +} + +static void +efct_hw_queue_hash_add (struct efct_queue_hash *hash, +u16 id,u16 index) +{ +u32 hash_index = id & (EFCT_HW_Q_HASH_SIZE -1 ); + +/* +* Since the hash is always bigger than the number of queues, then we +* never have to worry about an infinite loop. +*/ +while (hash[hash_index].in_use) + hash_index = (hash_index +1 ) & (EFCT_HW_Q_HASH_SIZE -1 ); + +/* not used, claim the entry */ + hash[hash_index].id = id; + hash[hash_index].in_use = true; + hash[hash_index].index = index; +} + +static enum efct_hw_rtn +efct_hw_config_sli_port_health_check (struct efct_hw *hw,u8 query,u8 enable) +{ +enum efct_hw_rtn rc =EFCT_HW_RTN_SUCCESS ; +u8 buf[SLI4_BMBX_SIZE ]; +struct sli4_rqst_cmn_set_features_health_check param; +u32 health_check_flag =0 ; + +memset (¶m,0 ,sizeof (param)); + +if (enable) + health_check_flag |=SLI4_RQ_HEALTH_CHECK_ENABLE ; + +if (query) + health_check_flag |=SLI4_RQ_HEALTH_CHECK_QUERY ; + + param.health_check_dword =cpu_to_le32 (health_check_flag); + +/* build the set_features command */ +sli_cmd_common_set_features (&hw->sli, buf, +SLI4_SET_FEATURES_SLI_PORT_HEALTH_CHECK ,sizeof (param), ¶m); + + rc =efct_hw_command (hw, buf,EFCT_CMD_POLL ,NULL ,NULL ); +if (rc) +efc_log_err (hw->os,"efct_hw_command returns %d\n" , rc); +else +efc_log_test (hw->os,"SLI Port Health Check is enabled\n" ); + +return rc; +} + +enum efct_hw_rtn +efct_hw_init (struct efct_hw *hw) +{ +enum efct_hw_rtn rc; +u32 i =0 ; +int rem_count; +unsigned long flags =0 ; +struct efct_hw_io *temp; +struct efc_dma *dma; + +/* +* Make sure the command lists are empty. If this is start-of-day, +* they'll be empty since they were just initialized in efct_hw_setup. +* If we've just gone through a reset, the command and command pending +* lists should have been cleaned up as part of the reset +* (efct_hw_reset()). +*/ +spin_lock_irqsave (&hw->cmd_lock, flags); +if (!list_empty (&hw->cmd_head)) { +spin_unlock_irqrestore (&hw->cmd_lock, flags); +efc_log_err (hw->os,"command found on cmd list\n" ); +return EFCT_HW_RTN_ERROR ; + } +if (!list_empty (&hw->cmd_pending)) { +spin_unlock_irqrestore (&hw->cmd_lock, flags); +efc_log_err (hw->os,"command found on pending list\n" ); +return EFCT_HW_RTN_ERROR ; + } +spin_unlock_irqrestore (&hw->cmd_lock, flags); + +/* Free RQ buffers if prevously allocated */ +efct_hw_rx_free (hw); + +/* +* The IO queues must be initialized here for the reset case. The +* efct_hw_init_io() function will re-add the IOs to the free list. +* The cmd_head list should be OK since we free all entries in +* efct_hw_command_cancel() that is called in the efct_hw_reset(). +*/ + +/* If we are in this function due to a reset, there may be stale items +* on lists that need to be removed. Clean them up. +*/ + rem_count =0 ; +if (hw->io_wait_free.next) { +while ((!list_empty (&hw->io_wait_free))) { + rem_count++; + temp =list_first_entry (&hw->io_wait_free, + struct efct_hw_io, + list_entry); +list_del (&temp->list_entry); + } +if (rem_count >0 ) { +efc_log_debug (hw->os, +"rmvd %d items from io_wait_free list\n" , + rem_count); + } + } + rem_count =0 ; +if (hw->io_inuse.next) { +while ((!list_empty (&hw->io_inuse))) { + rem_count++; + temp =list_first_entry (&hw->io_inuse, + struct efct_hw_io, + list_entry); +list_del (&temp->list_entry); + } +if (rem_count >0 ) +efc_log_debug (hw->os, +"rmvd %d items from io_inuse list\n" , + rem_count); + } + rem_count =0 ; +if (hw->io_free.next) { +while ((!list_empty (&hw->io_free))) { + rem_count++; + temp =list_first_entry (&hw->io_free, + struct efct_hw_io, + list_entry); +list_del (&temp->list_entry); + } +if (rem_count >0 ) +efc_log_debug (hw->os, +"rmvd %d items from io_free list\n" , + rem_count); + } + +INIT_LIST_HEAD (&hw->io_inuse); +INIT_LIST_HEAD (&hw->io_free); +INIT_LIST_HEAD (&hw->io_wait_free); + +/* If MRQ not required, Make sure we dont request feature. */ +if (hw->config.n_rq ==1 ) + hw->sli.features &= (~SLI4_REQFEAT_MRQP ); + +if (sli_init (&hw->sli)) { +efc_log_err (hw->os,"SLI failed to initialize\n" ); +return EFCT_HW_RTN_ERROR ; + } + +if (hw->sliport_healthcheck) { + rc =efct_hw_config_sli_port_health_check (hw,0 ,1 ); +if (rc !=EFCT_HW_RTN_SUCCESS ) { +efc_log_err (hw->os,"Enable port Health check fail\n" ); +return rc; + } + } + +/* +* Set FDT transfer hint, only works on Lancer +*/ +if (hw->sli.if_type ==SLI4_INTF_IF_TYPE_2 ) { +/* +* Non-fatal error. In particular, we can disregard failure to +* set EFCT_HW_FDT_XFER_HINT on devices with legacy firmware +* that do not support EFCT_HW_FDT_XFER_HINT feature. +*/ +efct_hw_config_set_fdt_xfer_hint (hw,EFCT_HW_FDT_XFER_HINT ); + } + +/* zero the hashes */ +memset (hw->cq_hash,0 ,sizeof (hw->cq_hash)); +efc_log_debug (hw->os,"Max CQs %d, hash size = %d\n" , +EFCT_HW_MAX_NUM_CQ ,EFCT_HW_Q_HASH_SIZE ); + +memset (hw->rq_hash,0 ,sizeof (hw->rq_hash)); +efc_log_debug (hw->os,"Max RQs %d, hash size = %d\n" , +EFCT_HW_MAX_NUM_RQ ,EFCT_HW_Q_HASH_SIZE ); + +memset (hw->wq_hash,0 ,sizeof (hw->wq_hash)); +efc_log_debug (hw->os,"Max WQs %d, hash size = %d\n" , +EFCT_HW_MAX_NUM_WQ ,EFCT_HW_Q_HASH_SIZE ); + + rc =efct_hw_init_queues (hw); +if (rc) +return rc; + +efct_hw_map_wq_cpu (hw); + +/* Allocate and p_st RQ buffers */ + rc =efct_hw_rx_allocate (hw); +if (rc) { +efc_log_err (hw->os,"rx_allocate failed\n" ); +return rc; + } + + rc =efct_hw_rx_post (hw); +if (rc) { +efc_log_err (hw->os,"WARNING - error posting RQ buffers\n" ); +return rc; + } + +if (hw->config.n_eq ==1 ) { + rc =efct_hw_config_rq (hw); +if (rc) { +efc_log_err (hw->os,"config rq failed %d\n" , rc); +return rc; + } + }else { + rc =efct_hw_config_mrq (hw,SLI4_CMD_REG_FCFI_SET_FCFI_MODE ,0 ); +if (rc !=EFCT_HW_RTN_SUCCESS ) { +efc_log_err (hw->os,"REG_FCFI_MRQ FCFI reg failed\n" ); +return rc; + } + + rc =efct_hw_config_mrq (hw,SLI4_CMD_REG_FCFI_SET_MRQ_MODE ,0 ); +if (rc !=EFCT_HW_RTN_SUCCESS ) { +efc_log_err (hw->os,"REG_FCFI_MRQ MRQ reg failed\n" ); +return rc; + } + + } + +/* +* Allocate the WQ request tag pool, if not previously allocated +* (the request tag value is 16 bits, thus the pool allocation size +* of 64k) +*/ + hw->wq_reqtag_pool =efct_hw_reqtag_pool_alloc (hw); +if (!hw->wq_reqtag_pool) { +efc_log_err (hw->os,"efct_hw_reqtag_init failed %d\n" , rc); +return rc; + } + + rc =efct_hw_setup_io (hw); +if (rc) { +efc_log_err (hw->os,"IO allocation failure\n" ); +return rc; + } + + rc =efct_hw_init_io (hw); +if (rc) { +efc_log_err (hw->os,"IO initialization failure\n" ); +return rc; + } + + dma = &hw->loop_map; + dma->size =SLI4_MIN_LOOP_MAP_BYTES ; + dma->virt =dma_alloc_coherent (&hw->os->pci->dev, dma->size, &dma->phys, +GFP_DMA ); +if (!dma->virt) +return EFCT_HW_RTN_ERROR ; + +/* +* Arming the EQ allows (e.g.) interrupts when CQ completions write EQ +* entries +*/ +for (i =0 ; i < hw->eq_count; i++) +sli_queue_arm (&hw->sli, &hw->eq[i], true); + +/* +* Initialize RQ hash +*/ +for (i =0 ; i < hw->rq_count; i++) +efct_hw_queue_hash_add (hw->rq_hash, hw->rq[i].id, i); + +/* +* Initialize WQ hash +*/ +for (i =0 ; i < hw->wq_count; i++) +efct_hw_queue_hash_add (hw->wq_hash, hw->wq[i].id, i); + +/* +* Arming the CQ allows (e.g.) MQ completions to write CQ entries +*/ +for (i =0 ; i < hw->cq_count; i++) { +efct_hw_queue_hash_add (hw->cq_hash, hw->cq[i].id, i); +sli_queue_arm (&hw->sli, &hw->cq[i], true); + } + +/* Set RQ process limit*/ +for (i =0 ; i < hw->hw_rq_count; i++) { +struct hw_rq *rq = hw->hw_rq[i]; + + hw->cq[rq->cq->instance].proc_limit = hw->config.n_io /2 ; + } + +/* record the fact that the queues are functional */ + hw->state =EFCT_HW_STATE_ACTIVE ; +/* +* Allocate a HW IOs for send frame. +*/ + hw->hw_wq[0 ]->send_frame_io =efct_hw_io_alloc (hw); +if (!hw->hw_wq[0 ]->send_frame_io) +efc_log_err (hw->os,"alloc for send_frame_io failed\n" ); + +/* Initialize send frame sequence id */ +atomic_set (&hw->send_frame_seq_id,0 ); + +return EFCT_HW_RTN_SUCCESS ; +} + +enum efct_hw_rtn +efct_hw_parse_filter (struct efct_hw *hw,void *value) +{ +enum efct_hw_rtn rc =EFCT_HW_RTN_SUCCESS ; +char *p =NULL ; +char *token; +u32 idx =0 ; + +for (idx =0 ; idx <ARRAY_SIZE (hw->config.filter_def); idx++) + hw->config.filter_def[idx] =0 ; + + p =kstrdup (value,GFP_KERNEL ); +if (!p || !*p) { +efc_log_err (hw->os,"p is NULL\n" ); +return EFCT_HW_RTN_NO_MEMORY ; + } + + idx =0 ; +while ((token =strsep (&p,"," )) && *token) { +if (kstrtou32 (token,0 , &hw->config.filter_def[idx++])) +efc_log_err (hw->os,"kstrtoint failed\n" ); + +if (!p || !*p) +break ; + +if (idx ==ARRAY_SIZE (hw->config.filter_def)) +break ; + } +kfree (p); + +return rc; +} + +u64 +efct_get_wwnn (struct efct_hw *hw) +{ +struct sli4 *sli = &hw->sli; +u8 p[8 ]; + +memcpy (p, sli->wwnn,sizeof (p)); +return get_unaligned_be64 (p); +} + +u64 +efct_get_wwpn (struct efct_hw *hw) +{ +struct sli4 *sli = &hw->sli; +u8 p[8 ]; + +memcpy (p, sli->wwpn,sizeof (p)); +return get_unaligned_be64 (p); +}drivers/scsi/elx/efct/efct_hw.h +15
-0@@ -600,4 +600,19 @@ struct efct_hw_grp_hdr { u8 revision[32]; }; +static inline int +efct_hw_get_link_speed (struct efct_hw *hw) { +return hw->link.speed; +} + +enum efct_hw_rtn +efct_hw_setup (struct efct_hw *hw,void *os,struct pci_dev *pdev); +enum efct_hw_rtn efct_hw_init (struct efct_hw *hw); +enum efct_hw_rtn +efct_hw_parse_filter (struct efct_hw *hw,void *value); +uint64_t +efct_get_wwnn (struct efct_hw *hw); +uint64_t +efct_get_wwpn (struct efct_hw *hw); +#endif /* __EFCT_H__ */ drivers/scsi/elx/efct/efct_xport.c new file +519
-0@@ -0,0 +1,519 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +#include "efct_driver.h" +#include "efct_unsol.h" + +struct efct_xport_post_node_event { +struct completion done; +atomic_t refcnt; +struct efc_node *node; +u32 evt; +void *context; +}; + +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 ); +if (!efct_debugfs_root) { +efc_log_err (efct,"failed to create debugfs entry\n" ); + goto debugfs_fail; + } + } + +/* Create a directory for sessions in root */ +if (!efct->sess_debugfs_dir) { + efct->sess_debugfs_dir =debugfs_create_dir ("sessions" ,NULL ); +if (!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 EFC_SUCCESS ; + +debugfs_fail: +return EFC_FAIL ; +} + +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 EFC_FAIL ; + } + +return EFC_SUCCESS ; +} + +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) +{ +u32 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 =0 ; +else + result->value =1 ; + rc =0 ; +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_test (efct,"sem wait failed\n" ); + rc =EFC_FAIL ; +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_test (efct,"sem wait failed\n" ); + rc =EFC_FAIL ; +break ; + } +break ; + } +default : + rc =EFC_FAIL ; +break ; + } + +return rc; +} + +int +efct_scsi_new_device (struct efct *efct) +{ +struct Scsi_Host *shost =NULL ; +int error =0 ; +struct efct_vport *vport =NULL ; +union efct_xport_stats_u speed; +u32 supported_speeds =0 ; + + shost =scsi_host_alloc (&efct_template,sizeof (*vport)); +if (!shost) { +efc_log_err (efct,"failed to allocate Scsi_Host struct\n" ); +return EFC_FAIL ; + } + +/* 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_test (efct,"failed scsi_add_host_with_dma\n" ); +return EFC_FAIL ; + } + +/* 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 ; + + speed.value =1000 ; +if (efct_xport_status (efct->xport,EFCT_XPORT_IS_SUPPORTED_LINK_SPEED , + &speed)) { + supported_speeds |=FC_PORTSPEED_1GBIT ; + } + speed.value =2000 ; +if (efct_xport_status (efct->xport,EFCT_XPORT_IS_SUPPORTED_LINK_SPEED , + &speed)) { + supported_speeds |=FC_PORTSPEED_2GBIT ; + } + speed.value =4000 ; +if (efct_xport_status (efct->xport,EFCT_XPORT_IS_SUPPORTED_LINK_SPEED , + &speed)) { + supported_speeds |=FC_PORTSPEED_4GBIT ; + } + speed.value =8000 ; +if (efct_xport_status (efct->xport,EFCT_XPORT_IS_SUPPORTED_LINK_SPEED , + &speed)) { + supported_speeds |=FC_PORTSPEED_8GBIT ; + } + speed.value =10000 ; +if (efct_xport_status (efct->xport,EFCT_XPORT_IS_SUPPORTED_LINK_SPEED , + &speed)) { + supported_speeds |=FC_PORTSPEED_10GBIT ; + } + speed.value =16000 ; +if (efct_xport_status (efct->xport,EFCT_XPORT_IS_SUPPORTED_LINK_SPEED , + &speed)) { + supported_speeds |=FC_PORTSPEED_16GBIT ; + } + speed.value =32000 ; +if (efct_xport_status (efct->xport,EFCT_XPORT_IS_SUPPORTED_LINK_SPEED , + &speed)) { + supported_speeds |=FC_PORTSPEED_32GBIT ; + } + +fc_host_supported_speeds (shost) = supported_speeds; + +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 EFC_SUCCESS ; +} + +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 EFC_FAIL ; + } + + 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 EFC_FAIL ; + } + +return EFC_SUCCESS ; +} + +int +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 ; + +return EFC_SUCCESS ; +}drivers/scsi/elx/efct/efct_xport.h new file +176
-0@@ -0,0 +1,186 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +#if !defined(__EFCT_XPORT_H__) +#define __EFCT_XPORT_H__ + +enum efct_xport_ctrl { +EFCT_XPORT_PORT_ONLINE =1 , +EFCT_XPORT_PORT_OFFLINE , +EFCT_XPORT_SHUTDOWN , +EFCT_XPORT_POST_NODE_EVENT , +EFCT_XPORT_WWNN_SET , +EFCT_XPORT_WWPN_SET , +}; + +enum efct_xport_status { +EFCT_XPORT_PORT_STATUS , +EFCT_XPORT_CONFIG_PORT_STATUS , +EFCT_XPORT_LINK_SPEED , +EFCT_XPORT_IS_SUPPORTED_LINK_SPEED , +EFCT_XPORT_LINK_STATISTICS , +EFCT_XPORT_LINK_STAT_RESET , +EFCT_XPORT_IS_QUIESCED +}; + +struct efct_xport_link_stats { +bool rec; +bool gec; +bool w02of; +bool w03of; +bool w04of; +bool w05of; +bool w06of; +bool w07of; +bool w08of; +bool w09of; +bool w10of; +bool w11of; +bool w12of; +bool w13of; +bool w14of; +bool w15of; +bool w16of; +bool w17of; +bool w18of; +bool w19of; +bool w20of; +bool w21of; +bool clrc; +bool clof1; +u32 link_failure_error_count; +u32 loss_of_sync_error_count; +u32 loss_of_signal_error_count; +u32 primitive_sequence_error_count; +u32 invalid_transmission_word_error_count; +u32 crc_error_count; +u32 primitive_sequence_event_timeout_count; +u32 elastic_buffer_overrun_error_count; +u32 arbitration_fc_al_timeout_count; +u32 advertised_receive_bufftor_to_buffer_credit; +u32 current_receive_buffer_to_buffer_credit; +u32 advertised_transmit_buffer_to_buffer_credit; +u32 current_transmit_buffer_to_buffer_credit; +u32 received_eofa_count; +u32 received_eofdti_count; +u32 received_eofni_count; +u32 received_soff_count; +u32 received_dropped_no_aer_count; +u32 received_dropped_no_available_rpi_resources_count; +u32 received_dropped_no_available_xri_resources_count; +}; + +struct efct_xport_host_stats { +bool cc; +u32 transmit_kbyte_count; +u32 receive_kbyte_count; +u32 transmit_frame_count; +u32 receive_frame_count; +u32 transmit_sequence_count; +u32 receive_sequence_count; +u32 total_exchanges_originator; +u32 total_exchanges_responder; +u32 receive_p_bsy_count; +u32 receive_f_bsy_count; +u32 dropped_frames_due_to_no_rq_buffer_count; +u32 empty_rq_timeout_count; +u32 dropped_frames_due_to_no_xri_count; +u32 empty_xri_pool_count; +}; + +struct efct_xport_host_statistics { +struct completion done; +struct efct_xport_link_stats link_stats; +struct efct_xport_host_stats host_stats; +}; + +union efct_xport_stats_u { +u32 value; +struct efct_xport_host_statistics stats; +}; + +struct efct_xport_fcp_stats { +u64 input_bytes; +u64 output_bytes; +u64 input_requests; +u64 output_requests; +u64 control_requests; +}; + +struct efct_xport { +struct efct *efct; +/* wwpn requested by user for primary nport */ +u64 req_wwpn; +/* wwnn requested by user for primary nport */ +u64 req_wwnn; + +/* Nodes */ +/* number of allocated nodes */ +u32 nodes_count; +/* used to track how often IO pool is empty */ +atomic_t io_alloc_failed_count; +/* array of pointers to nodes */ +struct efc_node **nodes; + +/* Io pool and counts */ +/* pointer to IO pool */ +struct efct_io_pool *io_pool; +/* lock for io_pending_list */ +spinlock_t io_pending_lock; +/* list of IOs waiting for HW resources +* lock: xport->io_pending_lock +* link: efct_io_s->io_pending_link +*/ +struct list_head io_pending_list; +/* count of totals IOS allocated */ +atomic_t io_total_alloc; +/* count of totals IOS free'd */ +atomic_t io_total_free; +/* count of totals IOS that were pended */ +atomic_t io_total_pending; +/* count of active IOS */ +atomic_t io_active_count; +/* count of pending IOS */ +atomic_t io_pending_count; +/* non-zero if efct_scsi_check_pending is executing */ +atomic_t io_pending_recursing; + +/* Port */ +/* requested link state */ +u32 configured_link_state; + +/* Timer for Statistics */ +struct timer_list stats_timer; +union efct_xport_stats_u fc_xport_stats; +struct efct_xport_fcp_stats fcp_stats; +}; + +struct efct_rport_data { +struct efc_node *node; +}; + +struct efct_xport * +efct_xport_alloc (struct efct *efct); +int +efct_xport_attach (struct efct_xport *xport); +int +efct_xport_initialize (struct efct_xport *xport); +int +efct_xport_detach (struct efct_xport *xport); +int +efct_xport_control (struct efct_xport *xport,enum efct_xport_ctrl cmd, ...); +int +efct_xport_status(struct efct_xport *xport, enum efct_xport_status cmd,
drivers/scsi/elx/efct/efct_xport.h line 186
Quoted 10 lines
drivers/scsi/elx/efct/efct_xport.h new file +10
-0+ union efct_xport_stats_u *result); +void +efct_xport_free (struct efct_xport *xport); + +struct scsi_transport_template *efct_attach_fc_transport (void ); +struct scsi_transport_template *efct_attach_vport_fc_transport (void ); +void +efct_release_fc_transport (struct scsi_transport_template *transport_template); + +#endif /* __EFCT_XPORT_H__ */
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
PATCH v4 19/31 elx: efct: Hardware queues creation and deletion
In reply to James SmartThis patch continues the efct driver population.
This patch adds driver definitions for:
Routines for queue creation, deletion, and configuration.
---
v4:
Changes for MRQ support.
Mbox request API.
--- drivers/scsi/elx/efct/efct_hw.h | 4 + drivers/scsi/elx/efct/efct_hw_queues.c | 677 +++++++++++++++++++++++++ 2 files changed, 681 insertions(+) create mode 100644 drivers/scsi/elx/efct/efct_hw_queues.c
drivers/scsi/elx/efct/efct_hw.h +4 -0
@@ -610,6 +610,10 @@ efct_hw_setup(struct efct_hw *hw, void *os, struct pci_dev *pdev);enum efct_hw_rtn efct_hw_init (struct efct_hw *hw);enum efct_hw_rtn efct_hw_parse_filter (struct efct_hw *hw,void *value); +enum efct_hw_rtn +efct_hw_init_queues (struct efct_hw *hw); +void +efct_hw_map_wq_cpu (struct efct_hw *hw);uint64_t efct_get_wwnn (struct efct_hw *hw);uint64_t
drivers/scsi/elx/efct/efct_hw_queues.c new file +677 -0
677 lines not on this page · raw message
Signature · 1 line
2.26.2
Re: [PATCH v4 19/31] elx: efct: Hardware queues creation and deletion
Quoted 13 lines · James Smart
This patch continues the efct driver population.
This patch adds driver definitions for:
Routines for queue creation, deletion, and configuration.Co-developed-by Ram Vegesna <[email protected]>Signed-off-by Ram Vegesna <[email protected]>Signed-off-by James Smart <[email protected]>---
v4:
Changes for MRQ support.
Mbox request API.
Quoted 6 lines
--- drivers/scsi/elx/efct/efct_hw.h | 4 + drivers/scsi/elx/efct/efct_hw_queues.c | 677 +++++++++++++++++++++++++ 2 files changed, 681 insertions(+)create mode 100644
drivers/scsi/elx/efct/efct_hw_queues.c
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
PATCH v4 20/31 elx: efct: RQ buffer, memory pool allocation and deallocation APIs
In reply to James SmartThis patch continues the efct driver population.
This patch adds driver definitions for:
RQ data buffer allocation and deallocate. Memory pool allocation and deallocation APIs. Mailbox command submission and completion routines.
--- drivers/scsi/elx/efct/efct_hw.c | 411 ++++++++++++++++++++++++++++++++ drivers/scsi/elx/efct/efct_hw.h | 9 + 2 files changed, 420 insertions(+)
drivers/scsi/elx/efct/efct_hw.c +411 -0
@@ -1164,3 +1164,414 @@ efct_get_wwpn(struct efct_hw *hw)memcpy (p, sli->wwpn,sizeof (p));return get_unaligned_be64 (p); } + +static struct efc_hw_rq_buffer * +efct_hw_rx_buffer_alloc (struct efct_hw *hw,u32 rqindex,u32 count, +u32 size) +{ +struct efct *efct = hw->os; +struct efc_hw_rq_buffer *rq_buf =NULL ; +struct efc_hw_rq_buffer *prq; +u32 i; + +if (count !=0 ) { + rq_buf =kmalloc_array (count,sizeof (*rq_buf),GFP_KERNEL ); +if (!rq_buf) +return NULL ; +memset (rq_buf,0 ,sizeof (*rq_buf) * count); + +for (i =0 , prq = rq_buf; i < count; i ++, prq++) { + prq->rqindex = rqindex; + prq->dma.size = size; + prq->dma.virt =dma_alloc_coherent (&efct->pci->dev, + prq->dma.size, + &prq->dma.phys, +GFP_DMA ); +if (!prq->dma.virt) { +efc_log_err (hw->os,"DMA allocation failed\n" ); +kfree (rq_buf); + rq_buf =NULL ; +break ; + } + } + } +return rq_buf; +} + +static void +efct_hw_rx_buffer_free (struct efct_hw *hw, +struct efc_hw_rq_buffer *rq_buf, +u32 count) +{ +struct efct *efct = hw->os; +u32 i; +struct efc_hw_rq_buffer *prq; + +if (rq_buf) { +for (i =0 , prq = rq_buf; i < count; i++, prq++) { +dma_free_coherent (&efct->pci->dev, + prq->dma.size, prq->dma.virt, + prq->dma.phys); +memset (&prq->dma,0 ,sizeof (struct efc_dma )); + } + +kfree (rq_buf); + } +} + +enum efct_hw_rtn +efct_hw_rx_allocate (struct efct_hw *hw) +{ +struct efct *efct = hw->os; +u32 i; +int rc =EFCT_HW_RTN_SUCCESS ; +u32 rqindex =0 ; +u32 hdr_size =EFCT_HW_RQ_SIZE_HDR ; +u32 payload_size = hw->config.rq_default_buffer_size; + + rqindex =0 ; + +for (i =0 ; i < hw->hw_rq_count; i++) { +struct hw_rq *rq = hw->hw_rq[i]; + +/* Allocate header buffers */ + rq->hdr_buf =efct_hw_rx_buffer_alloc (hw, rqindex, + rq->entry_count, + hdr_size); +if (!rq->hdr_buf) { +efc_log_err (efct, +"efct_hw_rx_buffer_alloc hdr_buf failed\n" ); + rc =EFCT_HW_RTN_ERROR ; +break ; + } + +efc_log_debug (hw->os, +"rq[%2d] rq_id %02d header %4d by %4d bytes\n" , + i, rq->hdr->id, rq->entry_count, hdr_size); + + rqindex++; + +/* Allocate payload buffers */ + rq->payload_buf =efct_hw_rx_buffer_alloc (hw, rqindex, + rq->entry_count, + payload_size); +if (!rq->payload_buf) { +efc_log_err (efct, +"efct_hw_rx_buffer_alloc fb_buf failed\n" ); + rc =EFCT_HW_RTN_ERROR ; +break ; + } +efc_log_debug (hw->os, +"rq[%2d] rq_id %02d default %4d by %4d bytes\n" , + i, rq->data->id, rq->entry_count, payload_size); + rqindex++; + } + +return rc ?EFCT_HW_RTN_ERROR :EFCT_HW_RTN_SUCCESS ; +} + +enum efct_hw_rtn +efct_hw_rx_post (struct efct_hw *hw) +{ +u32 i; +u32 idx; +u32 rq_idx; +int rc =0 ; + +if (!hw->seq_pool) { +u32 count =0 ; + +for (i =0 ; i < hw->hw_rq_count; i++) + count += hw->hw_rq[i]->entry_count; + + hw->seq_pool =kmalloc_array (count, +sizeof (struct efc_hw_sequence ),GFP_KERNEL ); +if (!hw->seq_pool) +return EFCT_HW_RTN_NO_MEMORY ; + } + +/* +* In RQ pair mode, we MUST post the header and payload buffer at the +* same time. +*/ +for (rq_idx =0 , idx =0 ; rq_idx < hw->hw_rq_count; rq_idx++) { +struct hw_rq *rq = hw->hw_rq[rq_idx]; + +for (i =0 ; i < rq->entry_count -1 ; i++) { +struct efc_hw_sequence *seq; + + seq = hw->seq_pool + idx; +if (!seq) { + rc =-1 ; +break ; + } + idx++; + seq->header = &rq->hdr_buf[i]; + seq->payload = &rq->payload_buf[i]; + rc =efct_hw_sequence_free (hw, seq); +if (rc) +break ; + } +if (rc) +break ; + } + +if (rc && hw->seq_pool) +kfree (hw->seq_pool); + +return rc; +} + +void +efct_hw_rx_free (struct efct_hw *hw) +{ +u32 i; + +/* Free hw_rq buffers */ +for (i =0 ; i < hw->hw_rq_count; i++) { +struct hw_rq *rq = hw->hw_rq[i]; + +if (rq) { +efct_hw_rx_buffer_free (hw, rq->hdr_buf, + rq->entry_count); + rq->hdr_buf =NULL ; +efct_hw_rx_buffer_free (hw, rq->payload_buf, + rq->entry_count); + rq->payload_buf =NULL ; + } + } +} + +static int +efct_hw_cmd_submit_pending (struct efct_hw *hw) +{ +struct efct_command_ctx *ctx =NULL ; +int rc =0 ; + +/* Assumes lock held */ + +/* Only submit MQE if there's room */ +while (hw->cmd_head_count < (EFCT_HW_MQ_DEPTH -1 ) && + !list_empty (&hw->cmd_pending)) { + ctx =list_first_entry (&hw->cmd_pending, + struct efct_command_ctx, list_entry); +if (!ctx) +break ; + +list_del (&ctx->list_entry); + +INIT_LIST_HEAD (&ctx->list_entry); +list_add_tail (&ctx->list_entry, &hw->cmd_head); + hw->cmd_head_count++; +if (sli_mq_write (&hw->sli, hw->mq, ctx->buf) <0 ) { +efc_log_test (hw->os, +"sli_queue_write failed: %d\n" , rc); + rc =-1 ; +break ; + } + } +return rc; +} + +enum efct_hw_rtn +efct_hw_command (struct efct_hw *hw,u8 *cmd,u32 opts,void *cb,void *arg) +{ +enum efct_hw_rtn rc =EFCT_HW_RTN_ERROR ; +unsigned long flags =0 ; +void *bmbx =NULL ; + +/* +* If the chip is in an error state (UE'd) then reject this mailbox +* command. +*/ +if (sli_fw_error_status (&hw->sli) >0 ) { +efc_log_crit (hw->os, +"Chip is in an error state - reset needed\n" ); +efc_log_crit (hw->os, +"status=%#x error1=%#x error2=%#x\n" , +sli_reg_read_status (&hw->sli), +sli_reg_read_err1 (&hw->sli), +sli_reg_read_err2 (&hw->sli)); + +return EFCT_HW_RTN_ERROR ; + } + +/* +* Send a mailbox command to the hardware, and either wait for +* a completion (EFCT_CMD_POLL) or get an optional asynchronous +* completion (EFCT_CMD_NOWAIT). +*/ + +if (opts ==EFCT_CMD_POLL ) { +mutex_lock (&hw->bmbx_lock); + bmbx = hw->sli.bmbx.virt; + +memset (bmbx,0 ,SLI4_BMBX_SIZE ); +memcpy (bmbx, cmd,SLI4_BMBX_SIZE ); + +if (sli_bmbx_command (&hw->sli) ==0 ) { + rc =EFCT_HW_RTN_SUCCESS ; +memcpy (cmd, bmbx,SLI4_BMBX_SIZE ); + } +mutex_unlock (&hw->bmbx_lock); + }else if (opts ==EFCT_CMD_NOWAIT ) { +struct efct_command_ctx *ctx =NULL ; + +if (hw->state !=EFCT_HW_STATE_ACTIVE ) { +efc_log_err (hw->os, +"Can't send command, HW state=%d\n" , + hw->state); +return EFCT_HW_RTN_ERROR ; + } + + ctx =mempool_alloc (hw->cmd_ctx_pool,GFP_ATOMIC ); +if (!ctx) +return EFCT_HW_RTN_NO_RESOURCES ; + +memset (ctx,0 ,sizeof (struct efct_command_ctx )); + +if (cb) { + ctx->cb = cb; + ctx->arg = arg; + } + +memcpy (ctx->buf, cmd,SLI4_BMBX_SIZE ); + ctx->ctx = hw; + +spin_lock_irqsave (&hw->cmd_lock, flags); + +/* Add to pending list */ +INIT_LIST_HEAD (&ctx->list_entry); +list_add_tail (&ctx->list_entry, &hw->cmd_pending); + +/* Submit as much of the pending list as we can */ + rc =efct_hw_cmd_submit_pending (hw); + +spin_unlock_irqrestore (&hw->cmd_lock, flags); + } + +return rc; +} + +static int +efct_hw_command_process (struct efct_hw *hw,int status,u8 *mqe, +size_t size) +{ +struct efct_command_ctx *ctx =NULL ; +unsigned long flags =0 ; + +spin_lock_irqsave (&hw->cmd_lock, flags); +if (!list_empty (&hw->cmd_head)) { + ctx =list_first_entry (&hw->cmd_head, + struct efct_command_ctx, list_entry); +list_del (&ctx->list_entry); + } +if (!ctx) { +efc_log_err (hw->os,"no command context?!?\n" ); +spin_unlock_irqrestore (&hw->cmd_lock, flags); +return EFC_FAIL ; + } + + hw->cmd_head_count--; + +/* Post any pending requests */ +efct_hw_cmd_submit_pending (hw); + +spin_unlock_irqrestore (&hw->cmd_lock, flags); + +if (ctx->cb) { +if (ctx->buf) +memcpy (ctx->buf, mqe, size); + + ctx->cb (hw, status, ctx->buf, ctx->arg); + } + +mempool_free (ctx, hw->cmd_ctx_pool); + +return EFC_SUCCESS ; +} + +static int +efct_hw_mq_process (struct efct_hw *hw, +int status,struct sli4_queue *mq) +{ +u8 mqe[SLI4_BMBX_SIZE ]; + +if (!sli_mq_read (&hw->sli, mq, mqe)) +efct_hw_command_process (hw, status, mqe, mq->size); + +return EFC_SUCCESS ; +} + +static int +efct_hw_command_cancel (struct efct_hw *hw) +{ +unsigned long flags =0 ; + +spin_lock_irqsave (&hw->cmd_lock, flags); + +/* +* Manually clean up remaining commands. Note: since this calls +* efct_hw_command_process(), we'll also process the cmd_pending +* list, so no need to manually clean that out. +*/ +while (!list_empty (&hw->cmd_head)) { +u8 mqe[SLI4_BMBX_SIZE ] = {0 }; +struct efct_command_ctx *ctx = + list_first_entry(&hw->cmd_head, struct efct_command_ctx, list_entry); + +efc_log_test (hw->os,"hung command %08x\n" , + !ctx ?U32_MAX : + (!ctx->buf ?U32_MAX : + *((u32 *)ctx->buf))); +spin_unlock_irqrestore (&hw->cmd_lock, flags); +efct_hw_command_process (hw,-1 , mqe,SLI4_BMBX_SIZE ); +spin_lock_irqsave (&hw->cmd_lock, flags); + } + +spin_unlock_irqrestore (&hw->cmd_lock, flags); + +return EFC_SUCCESS ; +} + +static void +efct_mbox_rsp_cb (struct efct_hw *hw,int status,u8 *mqe,void *arg) +{ +struct efct_mbox_rqst_ctx *ctx = arg; + +if (ctx) { +if (ctx->callback) + (*ctx->callback)(hw->os->efcport, status, mqe, + ctx->arg); + +mempool_free (ctx, hw->mbox_rqst_pool); + } +} + +int +efct_issue_mbox_rqst (void *base,void *cmd,void *cb,void *arg) +{ +int rc =0 ; +struct efct_mbox_rqst_ctx *ctx; +struct efct *efct = base; +struct efct_hw *hw = &efct->hw; + +/* +* Allocate a callback context (which includes the mbox cmd buffer), +* we need this to be persistent as the mbox cmd submission may be +* queued and executed later execution. +*/ + ctx =mempool_alloc (hw->mbox_rqst_pool,GFP_ATOMIC ); +if (!ctx) +return EFC_FAIL ; + + ctx->callback = cb; + ctx->arg = arg; + +if (efct_hw_command (hw, cmd,EFCT_CMD_NOWAIT , efct_mbox_rsp_cb, ctx)) { +efc_log_err (efct,"issue mbox rqst failure\n" ); +mempool_free (ctx, hw->mbox_rqst_pool); + rc =-1 ; + } +return rc; +}
drivers/scsi/elx/efct/efct_hw.h +9 -0
@@ -619,4 +619,13 @@ efct_get_wwnn(struct efct_hw *hw);uint64_t efct_get_wwpn (struct efct_hw *hw); +enum efct_hw_rtn efct_hw_rx_allocate (struct efct_hw *hw); +enum efct_hw_rtn efct_hw_rx_post (struct efct_hw *hw); +void efct_hw_rx_free (struct efct_hw *hw); +enum efct_hw_rtn +efct_hw_command (struct efct_hw *hw,u8 *cmd,u32 opts,void *cb, +void *arg); +int +efct_issue_mbox_rqst (void *base,void *cmd,void *cb,void *arg); +#endif /* __EFCT_H__ */
Signature · 1 line
2.26.2
Re: [PATCH v4 20/31] elx: efct: RQ buffer, memory pool allocation and deallocation APIs
Quoted 377 lines · James Smart
This patch continues the efct driver population.
This patch adds driver definitions for:
RQ data buffer allocation and deallocate. Memory pool allocation and deallocation APIs. Mailbox command submission and completion routines.Co-developed-by Ram Vegesna <[email protected]>Signed-off-by Ram Vegesna <[email protected]>Signed-off-by James Smart <[email protected]>--- drivers/scsi/elx/efct/efct_hw.c | 411 ++++++++++++++++++++++++++++++++ drivers/scsi/elx/efct/efct_hw.h | 9 + 2 files changed, 420 insertions(+)drivers/scsi/elx/efct/efct_hw.c +354
-0@@ -1164,3 +1164,414 @@ efct_get_wwpn(struct efct_hw *hw)memcpy (p, sli->wwpn,sizeof (p));return get_unaligned_be64 (p); } + +static struct efc_hw_rq_buffer * +efct_hw_rx_buffer_alloc (struct efct_hw *hw,u32 rqindex,u32 count, +u32 size) +{ +struct efct *efct = hw->os; +struct efc_hw_rq_buffer *rq_buf =NULL ; +struct efc_hw_rq_buffer *prq; +u32 i; + +if (count !=0 ) { + rq_buf =kmalloc_array (count,sizeof (*rq_buf),GFP_KERNEL ); +if (!rq_buf) +return NULL ; +memset (rq_buf,0 ,sizeof (*rq_buf) * count); + +for (i =0 , prq = rq_buf; i < count; i ++, prq++) { + prq->rqindex = rqindex; + prq->dma.size = size; + prq->dma.virt =dma_alloc_coherent (&efct->pci->dev, + prq->dma.size, + &prq->dma.phys, +GFP_DMA ); +if (!prq->dma.virt) { +efc_log_err (hw->os,"DMA allocation failed\n" ); +kfree (rq_buf); + rq_buf =NULL ; +break ; + } + } + } +return rq_buf; +} + +static void +efct_hw_rx_buffer_free (struct efct_hw *hw, +struct efc_hw_rq_buffer *rq_buf, +u32 count) +{ +struct efct *efct = hw->os; +u32 i; +struct efc_hw_rq_buffer *prq; + +if (rq_buf) { +for (i =0 , prq = rq_buf; i < count; i++, prq++) { +dma_free_coherent (&efct->pci->dev, + prq->dma.size, prq->dma.virt, + prq->dma.phys); +memset (&prq->dma,0 ,sizeof (struct efc_dma )); + } + +kfree (rq_buf); + } +} + +enum efct_hw_rtn +efct_hw_rx_allocate (struct efct_hw *hw) +{ +struct efct *efct = hw->os; +u32 i; +int rc =EFCT_HW_RTN_SUCCESS ; +u32 rqindex =0 ; +u32 hdr_size =EFCT_HW_RQ_SIZE_HDR ; +u32 payload_size = hw->config.rq_default_buffer_size; + + rqindex =0 ; + +for (i =0 ; i < hw->hw_rq_count; i++) { +struct hw_rq *rq = hw->hw_rq[i]; + +/* Allocate header buffers */ + rq->hdr_buf =efct_hw_rx_buffer_alloc (hw, rqindex, + rq->entry_count, + hdr_size); +if (!rq->hdr_buf) { +efc_log_err (efct, +"efct_hw_rx_buffer_alloc hdr_buf failed\n" ); + rc =EFCT_HW_RTN_ERROR ; +break ; + } + +efc_log_debug (hw->os, +"rq[%2d] rq_id %02d header %4d by %4d bytes\n" , + i, rq->hdr->id, rq->entry_count, hdr_size); + + rqindex++; + +/* Allocate payload buffers */ + rq->payload_buf =efct_hw_rx_buffer_alloc (hw, rqindex, + rq->entry_count, + payload_size); +if (!rq->payload_buf) { +efc_log_err (efct, +"efct_hw_rx_buffer_alloc fb_buf failed\n" ); + rc =EFCT_HW_RTN_ERROR ; +break ; + } +efc_log_debug (hw->os, +"rq[%2d] rq_id %02d default %4d by %4d bytes\n" , + i, rq->data->id, rq->entry_count, payload_size); + rqindex++; + } + +return rc ?EFCT_HW_RTN_ERROR :EFCT_HW_RTN_SUCCESS ; +} + +enum efct_hw_rtn +efct_hw_rx_post (struct efct_hw *hw) +{ +u32 i; +u32 idx; +u32 rq_idx; +int rc =0 ; + +if (!hw->seq_pool) { +u32 count =0 ; + +for (i =0 ; i < hw->hw_rq_count; i++) + count += hw->hw_rq[i]->entry_count; + + hw->seq_pool =kmalloc_array (count, +sizeof (struct efc_hw_sequence ),GFP_KERNEL ); +if (!hw->seq_pool) +return EFCT_HW_RTN_NO_MEMORY ; + } + +/* +* In RQ pair mode, we MUST post the header and payload buffer at the +* same time. +*/ +for (rq_idx =0 , idx =0 ; rq_idx < hw->hw_rq_count; rq_idx++) { +struct hw_rq *rq = hw->hw_rq[rq_idx]; + +for (i =0 ; i < rq->entry_count -1 ; i++) { +struct efc_hw_sequence *seq; + + seq = hw->seq_pool + idx; +if (!seq) { + rc =-1 ; +break ; + } + idx++; + seq->header = &rq->hdr_buf[i]; + seq->payload = &rq->payload_buf[i]; + rc =efct_hw_sequence_free (hw, seq); +if (rc) +break ; + } +if (rc) +break ; + } + +if (rc && hw->seq_pool) +kfree (hw->seq_pool); + +return rc; +} + +void +efct_hw_rx_free (struct efct_hw *hw) +{ +u32 i; + +/* Free hw_rq buffers */ +for (i =0 ; i < hw->hw_rq_count; i++) { +struct hw_rq *rq = hw->hw_rq[i]; + +if (rq) { +efct_hw_rx_buffer_free (hw, rq->hdr_buf, + rq->entry_count); + rq->hdr_buf =NULL ; +efct_hw_rx_buffer_free (hw, rq->payload_buf, + rq->entry_count); + rq->payload_buf =NULL ; + } + } +} + +static int +efct_hw_cmd_submit_pending (struct efct_hw *hw) +{ +struct efct_command_ctx *ctx =NULL ; +int rc =0 ; + +/* Assumes lock held */ + +/* Only submit MQE if there's room */ +while (hw->cmd_head_count < (EFCT_HW_MQ_DEPTH -1 ) && + !list_empty (&hw->cmd_pending)) { + ctx =list_first_entry (&hw->cmd_pending, + struct efct_command_ctx, list_entry); +if (!ctx) +break ; + +list_del (&ctx->list_entry); + +INIT_LIST_HEAD (&ctx->list_entry); +list_add_tail (&ctx->list_entry, &hw->cmd_head); + hw->cmd_head_count++; +if (sli_mq_write (&hw->sli, hw->mq, ctx->buf) <0 ) { +efc_log_test (hw->os, +"sli_queue_write failed: %d\n" , rc); + rc =-1 ; +break ; + } + } +return rc; +} + +enum efct_hw_rtn +efct_hw_command (struct efct_hw *hw,u8 *cmd,u32 opts,void *cb,void *arg) +{ +enum efct_hw_rtn rc =EFCT_HW_RTN_ERROR ; +unsigned long flags =0 ; +void *bmbx =NULL ; + +/* +* If the chip is in an error state (UE'd) then reject this mailbox +* command. +*/ +if (sli_fw_error_status (&hw->sli) >0 ) { +efc_log_crit (hw->os, +"Chip is in an error state - reset needed\n" ); +efc_log_crit (hw->os, +"status=%#x error1=%#x error2=%#x\n" , +sli_reg_read_status (&hw->sli), +sli_reg_read_err1 (&hw->sli), +sli_reg_read_err2 (&hw->sli)); + +return EFCT_HW_RTN_ERROR ; + } + +/* +* Send a mailbox command to the hardware, and either wait for +* a completion (EFCT_CMD_POLL) or get an optional asynchronous +* completion (EFCT_CMD_NOWAIT). +*/ + +if (opts ==EFCT_CMD_POLL ) { +mutex_lock (&hw->bmbx_lock); + bmbx = hw->sli.bmbx.virt; + +memset (bmbx,0 ,SLI4_BMBX_SIZE ); +memcpy (bmbx, cmd,SLI4_BMBX_SIZE ); + +if (sli_bmbx_command (&hw->sli) ==0 ) { + rc =EFCT_HW_RTN_SUCCESS ; +memcpy (cmd, bmbx,SLI4_BMBX_SIZE ); + } +mutex_unlock (&hw->bmbx_lock); + }else if (opts ==EFCT_CMD_NOWAIT ) { +struct efct_command_ctx *ctx =NULL ; + +if (hw->state !=EFCT_HW_STATE_ACTIVE ) { +efc_log_err (hw->os, +"Can't send command, HW state=%d\n" , + hw->state); +return EFCT_HW_RTN_ERROR ; + } + + ctx =mempool_alloc (hw->cmd_ctx_pool,GFP_ATOMIC ); +if (!ctx) +return EFCT_HW_RTN_NO_RESOURCES ; + +memset (ctx,0 ,sizeof (struct efct_command_ctx )); + +if (cb) { + ctx->cb = cb; + ctx->arg = arg; + } + +memcpy (ctx->buf, cmd,SLI4_BMBX_SIZE ); + ctx->ctx = hw; + +spin_lock_irqsave (&hw->cmd_lock, flags); + +/* Add to pending list */ +INIT_LIST_HEAD (&ctx->list_entry); +list_add_tail (&ctx->list_entry, &hw->cmd_pending); + +/* Submit as much of the pending list as we can */ + rc =efct_hw_cmd_submit_pending (hw); + +spin_unlock_irqrestore (&hw->cmd_lock, flags); + } + +return rc; +} + +static int +efct_hw_command_process (struct efct_hw *hw,int status,u8 *mqe, +size_t size) +{ +struct efct_command_ctx *ctx =NULL ; +unsigned long flags =0 ; + +spin_lock_irqsave (&hw->cmd_lock, flags); +if (!list_empty (&hw->cmd_head)) { + ctx =list_first_entry (&hw->cmd_head, + struct efct_command_ctx, list_entry); +list_del (&ctx->list_entry); + } +if (!ctx) { +efc_log_err (hw->os,"no command context?!?\n" ); +spin_unlock_irqrestore (&hw->cmd_lock, flags); +return EFC_FAIL ; + } + + hw->cmd_head_count--; + +/* Post any pending requests */ +efct_hw_cmd_submit_pending (hw); + +spin_unlock_irqrestore (&hw->cmd_lock, flags); + +if (ctx->cb) { +if (ctx->buf) +memcpy (ctx->buf, mqe, size); + + ctx->cb (hw, status, ctx->buf, ctx->arg); + } + +mempool_free (ctx, hw->cmd_ctx_pool); + +return EFC_SUCCESS ; +} + +static int +efct_hw_mq_process (struct efct_hw *hw, +int status,struct sli4_queue *mq) +{ +u8 mqe[SLI4_BMBX_SIZE ]; + +if (!sli_mq_read (&hw->sli, mq, mqe)) +efct_hw_command_process (hw, status, mqe, mq->size); + +return EFC_SUCCESS ; +} + +static int +efct_hw_command_cancel (struct efct_hw *hw) +{ +unsigned long flags =0 ; + +spin_lock_irqsave (&hw->cmd_lock, flags); + +/* +* Manually clean up remaining commands. Note: since this calls +* efct_hw_command_process(), we'll also process the cmd_pending +* list, so no need to manually clean that out. +*/ +while (!list_empty (&hw->cmd_head)) { +u8 mqe[SLI4_BMBX_SIZE ] = {0 }; + struct efct_command_ctx *ctx =
drivers/scsi/elx/efct/efct_hw.c efct_get_wwpn(struct efct_hw *hw) · line 1530
Quoted 10 lines
drivers/scsi/elx/efct/efct_hw.c +10
-0+ list_first_entry(&hw->cmd_head, struct efct_command_ctx, list_entry); + +efc_log_test (hw->os,"hung command %08x\n" , + !ctx ?U32_MAX : + (!ctx->buf ?U32_MAX : + *((u32 *)ctx->buf))); +spin_unlock_irqrestore (&hw->cmd_lock, flags); +efct_hw_command_process (hw,-1 , mqe,SLI4_BMBX_SIZE ); +spin_lock_irqsave (&hw->cmd_lock, flags); + }
Now that is an odd loop.
What is preventing this loop from spinning forever? IOW, how do you ensure 'hw->cmd_head' is updated on each round?
Quoted 56 lines
drivers/scsi/elx/efct/efct_hw.c +47
-0+ +spin_unlock_irqrestore (&hw->cmd_lock, flags); + +return EFC_SUCCESS ; +} + +static void +efct_mbox_rsp_cb (struct efct_hw *hw,int status,u8 *mqe,void *arg) +{ +struct efct_mbox_rqst_ctx *ctx = arg; + +if (ctx) { +if (ctx->callback) + (*ctx->callback)(hw->os->efcport, status, mqe, + ctx->arg); + +mempool_free (ctx, hw->mbox_rqst_pool); + } +} + +int +efct_issue_mbox_rqst (void *base,void *cmd,void *cb,void *arg) +{ +int rc =0 ; +struct efct_mbox_rqst_ctx *ctx; +struct efct *efct = base; +struct efct_hw *hw = &efct->hw; + +/* +* Allocate a callback context (which includes the mbox cmd buffer), +* we need this to be persistent as the mbox cmd submission may be +* queued and executed later execution. +*/ + ctx =mempool_alloc (hw->mbox_rqst_pool,GFP_ATOMIC ); +if (!ctx) +return EFC_FAIL ; + + ctx->callback = cb; + ctx->arg = arg; + +if (efct_hw_command (hw, cmd,EFCT_CMD_NOWAIT , efct_mbox_rsp_cb, ctx)) { +efc_log_err (efct,"issue mbox rqst failure\n" ); +mempool_free (ctx, hw->mbox_rqst_pool); + rc =-1 ; + } +return rc; +}drivers/scsi/elx/efct/efct_hw.h +0
-0@@ -619,4 +619,13 @@ efct_get_wwnn(struct efct_hw *hw);uint64_t efct_get_wwpn (struct efct_hw *hw);
drivers/scsi/elx/efct/efct_hw.h efct_get_wwnn(struct efct_hw *hw); · line 631
Quoted 10 lines
drivers/scsi/elx/efct/efct_hw.h +9
-0+enum efct_hw_rtn efct_hw_rx_allocate (struct efct_hw *hw); +enum efct_hw_rtn efct_hw_rx_post (struct efct_hw *hw); +void efct_hw_rx_free (struct efct_hw *hw); +enum efct_hw_rtn +efct_hw_command (struct efct_hw *hw,u8 *cmd,u32 opts,void *cb, +void *arg); +int +efct_issue_mbox_rqst (void *base,void *cmd,void *cb,void *arg); +#endif /* __EFCT_H__ */
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
PATCH v4 21/31 elx: efct: Hardware IO and SGL initialization
In reply to James SmartThis patch continues the efct driver population.
This patch adds driver definitions for:
Routines to create IO interfaces (wqs, etc), SGL initialization, and configure hardware features.
--- drivers/scsi/elx/efct/efct_hw.c | 590 ++++++++++++++++++++++++++++++++ drivers/scsi/elx/efct/efct_hw.h | 41 +++ 2 files changed, 631 insertions(+)
drivers/scsi/elx/efct/efct_hw.c +590 -0
@@ -1575,3 +1575,593 @@ efct_issue_mbox_rqst(void *base, void *cmd, void *cb, void *arg) }return rc; } + +static inline struct efct_hw_io * +_efct_hw_io_alloc (struct efct_hw *hw) +{ +struct efct_hw_io *io =NULL ; + +if (!list_empty (&hw->io_free)) { + io = list_first_entry(&hw->io_free, struct efct_hw_io, + list_entry); +list_del (&io->list_entry); + } +if (io) { +INIT_LIST_HEAD (&io->list_entry); +list_add_tail (&io->list_entry, &hw->io_inuse); + io->state =EFCT_HW_IO_STATE_INUSE ; + io->abort_reqtag =U32_MAX ; + io->wq = hw->wq_cpu_array[raw_smp_processor_id ()]; +if (!io->wq) { +efc_log_err (hw->os,"WQ not assigned for cpu:%d\n" , +raw_smp_processor_id ()); + io->wq = hw->hw_wq[0 ]; + } +kref_init (&io->ref); + io->release = efct_hw_io_free_internal; + }else { +atomic_add_return (1 , &hw->io_alloc_failed_count); + } + +return io; +} + +struct efct_hw_io * +efct_hw_io_alloc (struct efct_hw *hw) +{ +struct efct_hw_io *io =NULL ; +unsigned long flags =0 ; + +spin_lock_irqsave (&hw->io_lock, flags); + io =_efct_hw_io_alloc (hw); +spin_unlock_irqrestore (&hw->io_lock, flags); + +return io; +} + +static void +efct_hw_io_free_move_correct_list (struct efct_hw *hw, +struct efct_hw_io *io) +{ + +/* +* When an IO is freed, depending on the exchange busy flag, +* move it to the correct list. +*/ +if (io->xbusy) { +/* +* add to wait_free list and wait for XRI_ABORTED CQEs to clean +* up +*/ +INIT_LIST_HEAD (&io->list_entry); +list_add_tail (&io->list_entry, &hw->io_wait_free); + io->state =EFCT_HW_IO_STATE_WAIT_FREE ; + }else { +/* IO not busy, add to free list */ +INIT_LIST_HEAD (&io->list_entry); +list_add_tail (&io->list_entry, &hw->io_free); + io->state =EFCT_HW_IO_STATE_FREE ; + } +} + +static inline void +efct_hw_io_free_common (struct efct_hw *hw,struct efct_hw_io *io) +{ +/* initialize IO fields */ +efct_hw_init_free_io (io); + +/* Restore default SGL */ +efct_hw_io_restore_sgl (hw, io); +} + +void +efct_hw_io_free_internal (struct kref *arg) +{ +unsigned long flags =0 ; + struct efct_hw_io *io = container_of(arg, struct efct_hw_io, ref); +struct efct_hw *hw = io->hw; + +/* perform common cleanup */ +efct_hw_io_free_common (hw, io); + +spin_lock_irqsave (&hw->io_lock, flags); +/* remove from in-use list */ +if (io->list_entry.next && !list_empty (&hw->io_inuse)) { +list_del (&io->list_entry); +efct_hw_io_free_move_correct_list (hw, io); + } +spin_unlock_irqrestore (&hw->io_lock, flags); +} + +int +efct_hw_io_free (struct efct_hw *hw,struct efct_hw_io *io) +{ +return kref_put (&io->ref, io->release); +} + +struct efct_hw_io * +efct_hw_io_lookup (struct efct_hw *hw,u32 xri) +{ +u32 ioindex; + + ioindex = xri - hw->sli.ext[SLI4_RSRC_XRI ].base[0 ]; +return hw->io[ioindex]; +} + +enum efct_hw_rtn +efct_hw_io_init_sges (struct efct_hw *hw,struct efct_hw_io *io, +enum efct_hw_io_type type) +{ +struct sli4_sge *data =NULL ; +u32 i =0 ; +u32 skips =0 ; +u32 sge_flags =0 ; + +if (!io) { +efc_log_err (hw->os, +"bad parameter hw=%p io=%p\n" , hw, io); +return EFCT_HW_RTN_ERROR ; + } + +/* Clear / reset the scatter-gather list */ + io->sgl = &io->def_sgl; + io->sgl_count = io->def_sgl_count; + io->first_data_sge =0 ; + +memset (io->sgl->virt,0 ,2 *sizeof (struct sli4_sge )); + io->n_sge =0 ; + io->sge_offset =0 ; + + io->type = type; + + data = io->sgl->virt; + +/* +* Some IO types have underlying hardware requirements on the order +* of SGEs. Process all special entries here. +*/ +switch (type) { +case EFCT_HW_IO_TARGET_WRITE : + +/* populate host resident XFER_RDY buffer */ + sge_flags =le32_to_cpu (data->dw2_flags); + sge_flags &= (~SLI4_SGE_TYPE_MASK ); + sge_flags |= (SLI4_SGE_TYPE_DATA <<SLI4_SGE_TYPE_SHIFT ); + data->buffer_address_high = +cpu_to_le32 (upper_32_bits (io->xfer_rdy.phys)); + data->buffer_address_low = +cpu_to_le32 (lower_32_bits (io->xfer_rdy.phys)); + data->buffer_length =cpu_to_le32 (io->xfer_rdy.size); + data->dw2_flags =cpu_to_le32 (sge_flags); + data++; + + skips =EFCT_TARGET_WRITE_SKIPS ; + + io->n_sge =1 ; +break ; +case EFCT_HW_IO_TARGET_READ : +/* +* For FCP_TSEND64, the first 2 entries are SKIP SGE's +*/ + skips =EFCT_TARGET_READ_SKIPS ; +break ; +case EFCT_HW_IO_TARGET_RSP : +/* +* No skips, etc. for FCP_TRSP64 +*/ +break ; +default : +efc_log_err (hw->os,"unsupported IO type %#x\n" , type); +return EFCT_HW_RTN_ERROR ; + } + +/* +* Write skip entries +*/ +for (i =0 ; i < skips; i++) { + sge_flags =le32_to_cpu (data->dw2_flags); + sge_flags &= (~SLI4_SGE_TYPE_MASK ); + sge_flags |= (SLI4_SGE_TYPE_SKIP <<SLI4_SGE_TYPE_SHIFT ); + data->dw2_flags =cpu_to_le32 (sge_flags); + data++; + } + + io->n_sge += skips; + +/* +* Set last +*/ + sge_flags =le32_to_cpu (data->dw2_flags); + sge_flags |=SLI4_SGE_LAST ; + data->dw2_flags =cpu_to_le32 (sge_flags); + +return EFCT_HW_RTN_SUCCESS ; +} + +enum efct_hw_rtn +efct_hw_io_add_sge (struct efct_hw *hw,struct efct_hw_io *io, +uintptr_t addr,u32 length) +{ +struct sli4_sge *data =NULL ; +u32 sge_flags =0 ; + +if (!io || !addr || !length) { +efc_log_err (hw->os, +"bad parameter hw=%p io=%p addr=%lx length=%u\n" , + hw, io, addr, length); +return EFCT_HW_RTN_ERROR ; + } + +if (length > hw->sli.sge_supported_length) { +efc_log_err (hw->os, +"length of SGE %d bigger than allowed %d\n" , + length, hw->sli.sge_supported_length); +return EFCT_HW_RTN_ERROR ; + } + + data = io->sgl->virt; + data += io->n_sge; + + sge_flags =le32_to_cpu (data->dw2_flags); + sge_flags &= ~SLI4_SGE_TYPE_MASK ; + sge_flags |=SLI4_SGE_TYPE_DATA <<SLI4_SGE_TYPE_SHIFT ; + sge_flags &= ~SLI4_SGE_DATA_OFFSET_MASK ; + sge_flags |=SLI4_SGE_DATA_OFFSET_MASK & io->sge_offset; + + data->buffer_address_high =cpu_to_le32 (upper_32_bits (addr)); + data->buffer_address_low =cpu_to_le32 (lower_32_bits (addr)); + data->buffer_length =cpu_to_le32 (length); + +/* +* Always assume this is the last entry and mark as such. +* If this is not the first entry unset the "last SGE" +* indication for the previous entry +*/ + sge_flags |=SLI4_SGE_LAST ; + data->dw2_flags =cpu_to_le32 (sge_flags); + +if (io->n_sge) { + sge_flags =le32_to_cpu (data[-1 ].dw2_flags); + sge_flags &= ~SLI4_SGE_LAST ; + data[-1 ].dw2_flags =cpu_to_le32 (sge_flags); + } + +/* Set first_data_bde if not previously set */ +if (io->first_data_sge ==0 ) + io->first_data_sge = io->n_sge; + + io->sge_offset += length; + io->n_sge++; + +return EFCT_HW_RTN_SUCCESS ; +} + +void +efct_hw_io_abort_all (struct efct_hw *hw) +{ +struct efct_hw_io *io_to_abort =NULL ; +struct efct_hw_io *next_io =NULL ; + +list_for_each_entry_safe (io_to_abort, next_io, + &hw->io_inuse, list_entry) { +efct_hw_io_abort (hw, io_to_abort, true,NULL ,NULL ); + } +} + +static void +efct_hw_wq_process_abort (void *arg,u8 *cqe,int status) +{ +struct efct_hw_io *io = arg; +struct efct_hw *hw = io->hw; +u32 ext =0 ; +u32 len =0 ; +struct hw_wq_callback *wqcb; +unsigned long flags =0 ; + +/* +* For IOs that were aborted internally, we may need to issue the +* callback here depending on whether a XRI_ABORTED CQE is expected ot +* not. If the status is Local Reject/No XRI, then +* issue the callback now. +*/ + ext =sli_fc_ext_status (&hw->sli, cqe); +if (status ==SLI4_FC_WCQE_STATUS_LOCAL_REJECT && + ext ==SLI4_FC_LOCAL_REJECT_NO_XRI && io->done) { +efct_hw_done_t done = io->done; + + io->done =NULL ; + +/* +* Use latched status as this is always saved for an internal +* abort Note: We wont have both a done and abort_done +* function, so don't worry about +* clobbering the len, status and ext fields. +*/ + status = io->saved_status; + len = io->saved_len; + ext = io->saved_ext; + io->status_saved = false; +done (io, len, status, ext, io->arg); + } + +if (io->abort_done) { +efct_hw_done_t done = io->abort_done; + + io->abort_done =NULL ; +done (io, len, status, ext, io->abort_arg); + } +spin_lock_irqsave (&hw->io_abort_lock, flags); +/* clear abort bit to indicate abort is complete */ + io->abort_in_progress = false; +spin_unlock_irqrestore (&hw->io_abort_lock, flags); + +/* Free the WQ callback */ +if (io->abort_reqtag ==U32_MAX ) { +efc_log_err (hw->os,"HW IO already freed\n" ); +return ; + } + + wqcb =efct_hw_reqtag_get_instance (hw, io->abort_reqtag); +efct_hw_reqtag_free (hw, wqcb); + +/* +* Call efct_hw_io_free() because this releases the WQ reservation as +* well as doing the refcount put. Don't duplicate the code here. +*/ + (void )efct_hw_io_free (hw, io); +} + +static void +efct_hw_fill_abort_wqe (struct efct_hw *hw,struct efct_hw_wqe *wqe) +{ +struct sli4_abort_wqe *abort = (void *)wqe->wqebuf; + +memset (abort,0 , hw->sli.wqe_size); + + abort->criteria =SLI4_ABORT_CRITERIA_XRI_TAG ; + abort->ia_ir_byte |= wqe->send_abts ?0 :1 ; + +/* Suppress ABTS retries */ + abort->ia_ir_byte |=SLI4_ABRT_WQE_IR ; + + abort->t_tag =cpu_to_le32 (wqe->id); + abort->command =SLI4_WQE_ABORT ; + abort->request_tag =cpu_to_le16 (wqe->abort_reqtag); + + abort->dw10w0_flags =cpu_to_le16 (SLI4_ABRT_WQE_QOSD ); + + abort->cq_id =cpu_to_le16 (SLI4_CQ_DEFAULT ); +} + +enum efct_hw_rtn +efct_hw_io_abort (struct efct_hw *hw,struct efct_hw_io *io_to_abort, +bool send_abts,void *cb,void *arg) +{ +struct hw_wq_callback *wqcb; +unsigned long flags =0 ; + +if (!io_to_abort) { +efc_log_err (hw->os, +"bad parameter hw=%p io=%p\n" , + hw, io_to_abort); +return EFCT_HW_RTN_ERROR ; + } + +if (hw->state !=EFCT_HW_STATE_ACTIVE ) { +efc_log_err (hw->os,"cannot send IO abort, HW state=%d\n" , + hw->state); +return EFCT_HW_RTN_ERROR ; + } + +/* take a reference on IO being aborted */ +if (kref_get_unless_zero (&io_to_abort->ref) ==0 ) { +/* command no longer active */ +efc_log_test (hw->os, +"io not active xri=0x%x tag=0x%x\n" , + io_to_abort->indicator, io_to_abort->reqtag); +return EFCT_HW_RTN_IO_NOT_ACTIVE ; + } + +/* Must have a valid WQ reference */ +if (!io_to_abort->wq) { +efc_log_test (hw->os,"io_to_abort xri=0x%x not active on WQ\n" , + io_to_abort->indicator); +/* efct_ref_get(): same function */ +kref_put (&io_to_abort->ref, io_to_abort->release); +return EFCT_HW_RTN_IO_NOT_ACTIVE ; + } + +/* +* Validation checks complete; now check to see if already being +* aborted +*/ +spin_lock_irqsave (&hw->io_abort_lock, flags); +if (io_to_abort->abort_in_progress) { +spin_unlock_irqrestore (&hw->io_abort_lock, flags); +/* efct_ref_get(): same function */ +kref_put (&io_to_abort->ref, io_to_abort->release); +efc_log_debug (hw->os, +"io already being aborted xri=0x%x tag=0x%x\n" , + io_to_abort->indicator, io_to_abort->reqtag); +return EFCT_HW_RTN_IO_ABORT_IN_PROGRESS ; + } + +/* +* This IO is not already being aborted. Set flag so we won't try to +* abort it again. After all, we only have one abort_done callback. +*/ + io_to_abort->abort_in_progress = true; +spin_unlock_irqrestore (&hw->io_abort_lock, flags); + +/* +* If we got here, the possibilities are: +* - host owned xri +* - io_to_abort->wq_index != U32_MAX +* - submit ABORT_WQE to same WQ +* - port owned xri: +* - rxri: io_to_abort->wq_index == U32_MAX +* - submit ABORT_WQE to any WQ +* - non-rxri +* - io_to_abort->index != U32_MAX +* - submit ABORT_WQE to same WQ +* - io_to_abort->index == U32_MAX +* - submit ABORT_WQE to any WQ +*/ + io_to_abort->abort_done = cb; + io_to_abort->abort_arg = arg; + +/* Allocate a request tag for the abort portion of this IO */ + wqcb =efct_hw_reqtag_alloc (hw, efct_hw_wq_process_abort, io_to_abort); +if (!wqcb) { +efc_log_err (hw->os,"can't allocate request tag\n" ); +return EFCT_HW_RTN_NO_RESOURCES ; + } + + io_to_abort->abort_reqtag = wqcb->instance_index; + io_to_abort->wqe.send_abts = send_abts; + io_to_abort->wqe.id = io_to_abort->indicator; + io_to_abort->wqe.abort_reqtag = io_to_abort->abort_reqtag; + +/* +* If the wqe is on the pending list, then set this wqe to be +* aborted when the IO's wqe is removed from the list. +*/ +if (io_to_abort->wq) { +spin_lock_irqsave (&io_to_abort->wq->queue->lock, flags); +if (io_to_abort->wqe.list_entry.next) { + io_to_abort->wqe.abort_wqe_submit_needed = true; +spin_unlock_irqrestore (&io_to_abort->wq->queue->lock, + flags); +return EFC_SUCCESS ; + } +spin_unlock_irqrestore (&io_to_abort->wq->queue->lock, flags); + } + +efct_hw_fill_abort_wqe (hw, &io_to_abort->wqe); + +/* ABORT_WQE does not actually utilize an XRI on the Port, +* therefore, keep xbusy as-is to track the exchange's state, +* not the ABORT_WQE's state +*/ +if (efct_hw_wq_write (io_to_abort->wq, &io_to_abort->wqe)) { +spin_lock_irqsave (&hw->io_abort_lock, flags); + io_to_abort->abort_in_progress = false; +spin_unlock_irqrestore (&hw->io_abort_lock, flags); +/* efct_ref_get(): same function */ +kref_put (&io_to_abort->ref, io_to_abort->release); +return EFC_FAIL ; + } + +return EFC_SUCCESS ; +} + +void +efct_hw_reqtag_pool_free (struct efct_hw *hw) +{ +u32 i; +struct reqtag_pool *reqtag_pool = hw->wq_reqtag_pool; +struct hw_wq_callback *wqcb =NULL ; + +if (reqtag_pool) { +for (i =0 ; i <U16_MAX ; i++) { + wqcb = reqtag_pool->tags[i]; +if (!wqcb) +continue ; + +kfree (wqcb); + } +kfree (reqtag_pool); + hw->wq_reqtag_pool =NULL ; + } +} + +struct reqtag_pool * +efct_hw_reqtag_pool_alloc (struct efct_hw *hw) +{ +u32 i =0 ; +struct reqtag_pool *reqtag_pool; +struct hw_wq_callback *wqcb; + + reqtag_pool =kzalloc (sizeof (*reqtag_pool),GFP_KERNEL ); +if (!reqtag_pool) +return NULL ; + +INIT_LIST_HEAD (&reqtag_pool->freelist); +/* initialize reqtag pool lock */ +spin_lock_init (&reqtag_pool->lock); +for (i =0 ; i <U16_MAX ; i++) { + wqcb =kmalloc (sizeof (*wqcb),GFP_KERNEL ); +if (!wqcb) +break ; + + reqtag_pool->tags[i] = wqcb; + wqcb->instance_index = i; + wqcb->callback =NULL ; + wqcb->arg =NULL ; +INIT_LIST_HEAD (&wqcb->list_entry); +list_add_tail (&wqcb->list_entry, &reqtag_pool->freelist); + } + +return reqtag_pool; +} + +struct hw_wq_callback * +efct_hw_reqtag_alloc (struct efct_hw *hw, +void (*callback)(void *arg,u8 *cqe,int status), +void *arg) +{ +struct hw_wq_callback *wqcb =NULL ; +struct reqtag_pool *reqtag_pool = hw->wq_reqtag_pool; +unsigned long flags =0 ; + +if (!callback) +return wqcb; + +spin_lock_irqsave (&reqtag_pool->lock, flags); + +if (!list_empty (&reqtag_pool->freelist)) { + wqcb =list_first_entry (&reqtag_pool->freelist, + struct hw_wq_callback, list_entry); + } + +if (wqcb) { +list_del (&wqcb->list_entry); +spin_unlock_irqrestore (&reqtag_pool->lock, flags); + wqcb->callback = callback; + wqcb->arg = arg; + }else { +spin_unlock_irqrestore (&reqtag_pool->lock, flags); + } + +return wqcb; +} + +void +efct_hw_reqtag_free (struct efct_hw *hw,struct hw_wq_callback *wqcb) +{ +unsigned long flags =0 ; +struct reqtag_pool *reqtag_pool = hw->wq_reqtag_pool; + +if (!wqcb->callback) +efc_log_err (hw->os,"WQCB is already freed\n" ); + +spin_lock_irqsave (&reqtag_pool->lock, flags); + wqcb->callback =NULL ; + wqcb->arg =NULL ; +INIT_LIST_HEAD (&wqcb->list_entry); +list_add (&wqcb->list_entry, &hw->wq_reqtag_pool->freelist); +spin_unlock_irqrestore (&reqtag_pool->lock, flags); +} + +struct hw_wq_callback * +efct_hw_reqtag_get_instance (struct efct_hw *hw,u32 instance_index) +{ +struct hw_wq_callback *wqcb; + + wqcb = hw->wq_reqtag_pool->tags[instance_index]; +if (!wqcb) +efc_log_err (hw->os,"wqcb for instance %d is null\n" , + instance_index); + +return wqcb; +}
drivers/scsi/elx/efct/efct_hw.h +41 -0
45 lines not on this page · raw message
Signature · 1 line
2.26.2
Re: [PATCH v4 21/31] elx: efct: Hardware IO and SGL initialization
Quoted 110 lines · James Smart
This patch continues the efct driver population.
This patch adds driver definitions for:
Routines to create IO interfaces (wqs, etc), SGL initialization, and configure hardware features.Co-developed-by Ram Vegesna <[email protected]>Signed-off-by Ram Vegesna <[email protected]>Signed-off-by James Smart <[email protected]>--- drivers/scsi/elx/efct/efct_hw.c | 590 ++++++++++++++++++++++++++++++++ drivers/scsi/elx/efct/efct_hw.h | 41 +++ 2 files changed, 631 insertions(+)drivers/scsi/elx/efct/efct_hw.c +88
-0@@ -1575,3 +1575,593 @@ efct_issue_mbox_rqst(void *base, void *cmd, void *cb, void *arg) }return rc; } + +static inline struct efct_hw_io * +_efct_hw_io_alloc (struct efct_hw *hw) +{ +struct efct_hw_io *io =NULL ; + +if (!list_empty (&hw->io_free)) { + io = list_first_entry(&hw->io_free, struct efct_hw_io, + list_entry); +list_del (&io->list_entry); + } +if (io) { +INIT_LIST_HEAD (&io->list_entry); +list_add_tail (&io->list_entry, &hw->io_inuse); + io->state =EFCT_HW_IO_STATE_INUSE ; + io->abort_reqtag =U32_MAX ; + io->wq = hw->wq_cpu_array[raw_smp_processor_id ()]; +if (!io->wq) { +efc_log_err (hw->os,"WQ not assigned for cpu:%d\n" , +raw_smp_processor_id ()); + io->wq = hw->hw_wq[0 ]; + } +kref_init (&io->ref); + io->release = efct_hw_io_free_internal; + }else { +atomic_add_return (1 , &hw->io_alloc_failed_count); + } + +return io; +} + +struct efct_hw_io * +efct_hw_io_alloc (struct efct_hw *hw) +{ +struct efct_hw_io *io =NULL ; +unsigned long flags =0 ; + +spin_lock_irqsave (&hw->io_lock, flags); + io =_efct_hw_io_alloc (hw); +spin_unlock_irqrestore (&hw->io_lock, flags); + +return io; +} + +static void +efct_hw_io_free_move_correct_list (struct efct_hw *hw, +struct efct_hw_io *io) +{ + +/* +* When an IO is freed, depending on the exchange busy flag, +* move it to the correct list. +*/ +if (io->xbusy) { +/* +* add to wait_free list and wait for XRI_ABORTED CQEs to clean +* up +*/ +INIT_LIST_HEAD (&io->list_entry); +list_add_tail (&io->list_entry, &hw->io_wait_free); + io->state =EFCT_HW_IO_STATE_WAIT_FREE ; + }else { +/* IO not busy, add to free list */ +INIT_LIST_HEAD (&io->list_entry); +list_add_tail (&io->list_entry, &hw->io_free); + io->state =EFCT_HW_IO_STATE_FREE ; + } +} + +static inline void +efct_hw_io_free_common (struct efct_hw *hw,struct efct_hw_io *io) +{ +/* initialize IO fields */ +efct_hw_init_free_io (io); + +/* Restore default SGL */ +efct_hw_io_restore_sgl (hw, io); +} + +void +efct_hw_io_free_internal (struct kref *arg) +{ +unsigned long flags =0 ; + struct efct_hw_io *io = container_of(arg, struct efct_hw_io, ref); +struct efct_hw *hw = io->hw; + +/* perform common cleanup */ +efct_hw_io_free_common (hw, io);
drivers/scsi/elx/efct/efct_hw.c efct_issue_mbox_rqst(void *base, void *cmd, void *cb, void *arg) · line 1675
Quoted 10 lines
drivers/scsi/elx/efct/efct_hw.c +10
-0+ +spin_lock_irqsave (&hw->io_lock, flags); +/* remove from in-use list */ +if (io->list_entry.next && !list_empty (&hw->io_inuse)) { +list_del (&io->list_entry); +efct_hw_io_free_move_correct_list (hw, io); + } +spin_unlock_irqrestore (&hw->io_lock, flags); +} +
You don't really believe in list_del_init(), do you?
I would consider checking all instances of 'list_del()' on whether it'd be better to use 'list_del_init()', seeing that then one could do a 'list_empty' check on the element to figure out if it's queued or not...
Quoted 482 lines
drivers/scsi/elx/efct/efct_hw.c +482
-0+int +efct_hw_io_free (struct efct_hw *hw,struct efct_hw_io *io) +{ +return kref_put (&io->ref, io->release); +} + +struct efct_hw_io * +efct_hw_io_lookup (struct efct_hw *hw,u32 xri) +{ +u32 ioindex; + + ioindex = xri - hw->sli.ext[SLI4_RSRC_XRI ].base[0 ]; +return hw->io[ioindex]; +} + +enum efct_hw_rtn +efct_hw_io_init_sges (struct efct_hw *hw,struct efct_hw_io *io, +enum efct_hw_io_type type) +{ +struct sli4_sge *data =NULL ; +u32 i =0 ; +u32 skips =0 ; +u32 sge_flags =0 ; + +if (!io) { +efc_log_err (hw->os, +"bad parameter hw=%p io=%p\n" , hw, io); +return EFCT_HW_RTN_ERROR ; + } + +/* Clear / reset the scatter-gather list */ + io->sgl = &io->def_sgl; + io->sgl_count = io->def_sgl_count; + io->first_data_sge =0 ; + +memset (io->sgl->virt,0 ,2 *sizeof (struct sli4_sge )); + io->n_sge =0 ; + io->sge_offset =0 ; + + io->type = type; + + data = io->sgl->virt; + +/* +* Some IO types have underlying hardware requirements on the order +* of SGEs. Process all special entries here. +*/ +switch (type) { +case EFCT_HW_IO_TARGET_WRITE : + +/* populate host resident XFER_RDY buffer */ + sge_flags =le32_to_cpu (data->dw2_flags); + sge_flags &= (~SLI4_SGE_TYPE_MASK ); + sge_flags |= (SLI4_SGE_TYPE_DATA <<SLI4_SGE_TYPE_SHIFT ); + data->buffer_address_high = +cpu_to_le32 (upper_32_bits (io->xfer_rdy.phys)); + data->buffer_address_low = +cpu_to_le32 (lower_32_bits (io->xfer_rdy.phys)); + data->buffer_length =cpu_to_le32 (io->xfer_rdy.size); + data->dw2_flags =cpu_to_le32 (sge_flags); + data++; + + skips =EFCT_TARGET_WRITE_SKIPS ; + + io->n_sge =1 ; +break ; +case EFCT_HW_IO_TARGET_READ : +/* +* For FCP_TSEND64, the first 2 entries are SKIP SGE's +*/ + skips =EFCT_TARGET_READ_SKIPS ; +break ; +case EFCT_HW_IO_TARGET_RSP : +/* +* No skips, etc. for FCP_TRSP64 +*/ +break ; +default : +efc_log_err (hw->os,"unsupported IO type %#x\n" , type); +return EFCT_HW_RTN_ERROR ; + } + +/* +* Write skip entries +*/ +for (i =0 ; i < skips; i++) { + sge_flags =le32_to_cpu (data->dw2_flags); + sge_flags &= (~SLI4_SGE_TYPE_MASK ); + sge_flags |= (SLI4_SGE_TYPE_SKIP <<SLI4_SGE_TYPE_SHIFT ); + data->dw2_flags =cpu_to_le32 (sge_flags); + data++; + } + + io->n_sge += skips; + +/* +* Set last +*/ + sge_flags =le32_to_cpu (data->dw2_flags); + sge_flags |=SLI4_SGE_LAST ; + data->dw2_flags =cpu_to_le32 (sge_flags); + +return EFCT_HW_RTN_SUCCESS ; +} + +enum efct_hw_rtn +efct_hw_io_add_sge (struct efct_hw *hw,struct efct_hw_io *io, +uintptr_t addr,u32 length) +{ +struct sli4_sge *data =NULL ; +u32 sge_flags =0 ; + +if (!io || !addr || !length) { +efc_log_err (hw->os, +"bad parameter hw=%p io=%p addr=%lx length=%u\n" , + hw, io, addr, length); +return EFCT_HW_RTN_ERROR ; + } + +if (length > hw->sli.sge_supported_length) { +efc_log_err (hw->os, +"length of SGE %d bigger than allowed %d\n" , + length, hw->sli.sge_supported_length); +return EFCT_HW_RTN_ERROR ; + } + + data = io->sgl->virt; + data += io->n_sge; + + sge_flags =le32_to_cpu (data->dw2_flags); + sge_flags &= ~SLI4_SGE_TYPE_MASK ; + sge_flags |=SLI4_SGE_TYPE_DATA <<SLI4_SGE_TYPE_SHIFT ; + sge_flags &= ~SLI4_SGE_DATA_OFFSET_MASK ; + sge_flags |=SLI4_SGE_DATA_OFFSET_MASK & io->sge_offset; + + data->buffer_address_high =cpu_to_le32 (upper_32_bits (addr)); + data->buffer_address_low =cpu_to_le32 (lower_32_bits (addr)); + data->buffer_length =cpu_to_le32 (length); + +/* +* Always assume this is the last entry and mark as such. +* If this is not the first entry unset the "last SGE" +* indication for the previous entry +*/ + sge_flags |=SLI4_SGE_LAST ; + data->dw2_flags =cpu_to_le32 (sge_flags); + +if (io->n_sge) { + sge_flags =le32_to_cpu (data[-1 ].dw2_flags); + sge_flags &= ~SLI4_SGE_LAST ; + data[-1 ].dw2_flags =cpu_to_le32 (sge_flags); + } + +/* Set first_data_bde if not previously set */ +if (io->first_data_sge ==0 ) + io->first_data_sge = io->n_sge; + + io->sge_offset += length; + io->n_sge++; + +return EFCT_HW_RTN_SUCCESS ; +} + +void +efct_hw_io_abort_all (struct efct_hw *hw) +{ +struct efct_hw_io *io_to_abort =NULL ; +struct efct_hw_io *next_io =NULL ; + +list_for_each_entry_safe (io_to_abort, next_io, + &hw->io_inuse, list_entry) { +efct_hw_io_abort (hw, io_to_abort, true,NULL ,NULL ); + } +} + +static void +efct_hw_wq_process_abort (void *arg,u8 *cqe,int status) +{ +struct efct_hw_io *io = arg; +struct efct_hw *hw = io->hw; +u32 ext =0 ; +u32 len =0 ; +struct hw_wq_callback *wqcb; +unsigned long flags =0 ; + +/* +* For IOs that were aborted internally, we may need to issue the +* callback here depending on whether a XRI_ABORTED CQE is expected ot +* not. If the status is Local Reject/No XRI, then +* issue the callback now. +*/ + ext =sli_fc_ext_status (&hw->sli, cqe); +if (status ==SLI4_FC_WCQE_STATUS_LOCAL_REJECT && + ext ==SLI4_FC_LOCAL_REJECT_NO_XRI && io->done) { +efct_hw_done_t done = io->done; + + io->done =NULL ; + +/* +* Use latched status as this is always saved for an internal +* abort Note: We wont have both a done and abort_done +* function, so don't worry about +* clobbering the len, status and ext fields. +*/ + status = io->saved_status; + len = io->saved_len; + ext = io->saved_ext; + io->status_saved = false; +done (io, len, status, ext, io->arg); + } + +if (io->abort_done) { +efct_hw_done_t done = io->abort_done; + + io->abort_done =NULL ; +done (io, len, status, ext, io->abort_arg); + } +spin_lock_irqsave (&hw->io_abort_lock, flags); +/* clear abort bit to indicate abort is complete */ + io->abort_in_progress = false; +spin_unlock_irqrestore (&hw->io_abort_lock, flags); + +/* Free the WQ callback */ +if (io->abort_reqtag ==U32_MAX ) { +efc_log_err (hw->os,"HW IO already freed\n" ); +return ; + } + + wqcb =efct_hw_reqtag_get_instance (hw, io->abort_reqtag); +efct_hw_reqtag_free (hw, wqcb); + +/* +* Call efct_hw_io_free() because this releases the WQ reservation as +* well as doing the refcount put. Don't duplicate the code here. +*/ + (void )efct_hw_io_free (hw, io); +} + +static void +efct_hw_fill_abort_wqe (struct efct_hw *hw,struct efct_hw_wqe *wqe) +{ +struct sli4_abort_wqe *abort = (void *)wqe->wqebuf; + +memset (abort,0 , hw->sli.wqe_size); + + abort->criteria =SLI4_ABORT_CRITERIA_XRI_TAG ; + abort->ia_ir_byte |= wqe->send_abts ?0 :1 ; + +/* Suppress ABTS retries */ + abort->ia_ir_byte |=SLI4_ABRT_WQE_IR ; + + abort->t_tag =cpu_to_le32 (wqe->id); + abort->command =SLI4_WQE_ABORT ; + abort->request_tag =cpu_to_le16 (wqe->abort_reqtag); + + abort->dw10w0_flags =cpu_to_le16 (SLI4_ABRT_WQE_QOSD ); + + abort->cq_id =cpu_to_le16 (SLI4_CQ_DEFAULT ); +} + +enum efct_hw_rtn +efct_hw_io_abort (struct efct_hw *hw,struct efct_hw_io *io_to_abort, +bool send_abts,void *cb,void *arg) +{ +struct hw_wq_callback *wqcb; +unsigned long flags =0 ; + +if (!io_to_abort) { +efc_log_err (hw->os, +"bad parameter hw=%p io=%p\n" , + hw, io_to_abort); +return EFCT_HW_RTN_ERROR ; + } + +if (hw->state !=EFCT_HW_STATE_ACTIVE ) { +efc_log_err (hw->os,"cannot send IO abort, HW state=%d\n" , + hw->state); +return EFCT_HW_RTN_ERROR ; + } + +/* take a reference on IO being aborted */ +if (kref_get_unless_zero (&io_to_abort->ref) ==0 ) { +/* command no longer active */ +efc_log_test (hw->os, +"io not active xri=0x%x tag=0x%x\n" , + io_to_abort->indicator, io_to_abort->reqtag); +return EFCT_HW_RTN_IO_NOT_ACTIVE ; + } + +/* Must have a valid WQ reference */ +if (!io_to_abort->wq) { +efc_log_test (hw->os,"io_to_abort xri=0x%x not active on WQ\n" , + io_to_abort->indicator); +/* efct_ref_get(): same function */ +kref_put (&io_to_abort->ref, io_to_abort->release); +return EFCT_HW_RTN_IO_NOT_ACTIVE ; + } + +/* +* Validation checks complete; now check to see if already being +* aborted +*/ +spin_lock_irqsave (&hw->io_abort_lock, flags); +if (io_to_abort->abort_in_progress) { +spin_unlock_irqrestore (&hw->io_abort_lock, flags); +/* efct_ref_get(): same function */ +kref_put (&io_to_abort->ref, io_to_abort->release); +efc_log_debug (hw->os, +"io already being aborted xri=0x%x tag=0x%x\n" , + io_to_abort->indicator, io_to_abort->reqtag); +return EFCT_HW_RTN_IO_ABORT_IN_PROGRESS ; + } + +/* +* This IO is not already being aborted. Set flag so we won't try to +* abort it again. After all, we only have one abort_done callback. +*/ + io_to_abort->abort_in_progress = true; +spin_unlock_irqrestore (&hw->io_abort_lock, flags); + +/* +* If we got here, the possibilities are: +* - host owned xri +* - io_to_abort->wq_index != U32_MAX +* - submit ABORT_WQE to same WQ +* - port owned xri: +* - rxri: io_to_abort->wq_index == U32_MAX +* - submit ABORT_WQE to any WQ +* - non-rxri +* - io_to_abort->index != U32_MAX +* - submit ABORT_WQE to same WQ +* - io_to_abort->index == U32_MAX +* - submit ABORT_WQE to any WQ +*/ + io_to_abort->abort_done = cb; + io_to_abort->abort_arg = arg; + +/* Allocate a request tag for the abort portion of this IO */ + wqcb =efct_hw_reqtag_alloc (hw, efct_hw_wq_process_abort, io_to_abort); +if (!wqcb) { +efc_log_err (hw->os,"can't allocate request tag\n" ); +return EFCT_HW_RTN_NO_RESOURCES ; + } + + io_to_abort->abort_reqtag = wqcb->instance_index; + io_to_abort->wqe.send_abts = send_abts; + io_to_abort->wqe.id = io_to_abort->indicator; + io_to_abort->wqe.abort_reqtag = io_to_abort->abort_reqtag; + +/* +* If the wqe is on the pending list, then set this wqe to be +* aborted when the IO's wqe is removed from the list. +*/ +if (io_to_abort->wq) { +spin_lock_irqsave (&io_to_abort->wq->queue->lock, flags); +if (io_to_abort->wqe.list_entry.next) { + io_to_abort->wqe.abort_wqe_submit_needed = true; +spin_unlock_irqrestore (&io_to_abort->wq->queue->lock, + flags); +return EFC_SUCCESS ; + } +spin_unlock_irqrestore (&io_to_abort->wq->queue->lock, flags); + } + +efct_hw_fill_abort_wqe (hw, &io_to_abort->wqe); + +/* ABORT_WQE does not actually utilize an XRI on the Port, +* therefore, keep xbusy as-is to track the exchange's state, +* not the ABORT_WQE's state +*/ +if (efct_hw_wq_write (io_to_abort->wq, &io_to_abort->wqe)) { +spin_lock_irqsave (&hw->io_abort_lock, flags); + io_to_abort->abort_in_progress = false; +spin_unlock_irqrestore (&hw->io_abort_lock, flags); +/* efct_ref_get(): same function */ +kref_put (&io_to_abort->ref, io_to_abort->release); +return EFC_FAIL ; + } + +return EFC_SUCCESS ; +} + +void +efct_hw_reqtag_pool_free (struct efct_hw *hw) +{ +u32 i; +struct reqtag_pool *reqtag_pool = hw->wq_reqtag_pool; +struct hw_wq_callback *wqcb =NULL ; + +if (reqtag_pool) { +for (i =0 ; i <U16_MAX ; i++) { + wqcb = reqtag_pool->tags[i]; +if (!wqcb) +continue ; + +kfree (wqcb); + } +kfree (reqtag_pool); + hw->wq_reqtag_pool =NULL ; + } +} + +struct reqtag_pool * +efct_hw_reqtag_pool_alloc (struct efct_hw *hw) +{ +u32 i =0 ; +struct reqtag_pool *reqtag_pool; +struct hw_wq_callback *wqcb; + + reqtag_pool =kzalloc (sizeof (*reqtag_pool),GFP_KERNEL ); +if (!reqtag_pool) +return NULL ; + +INIT_LIST_HEAD (&reqtag_pool->freelist); +/* initialize reqtag pool lock */ +spin_lock_init (&reqtag_pool->lock); +for (i =0 ; i <U16_MAX ; i++) { + wqcb =kmalloc (sizeof (*wqcb),GFP_KERNEL ); +if (!wqcb) +break ; + + reqtag_pool->tags[i] = wqcb; + wqcb->instance_index = i; + wqcb->callback =NULL ; + wqcb->arg =NULL ; +INIT_LIST_HEAD (&wqcb->list_entry); +list_add_tail (&wqcb->list_entry, &reqtag_pool->freelist); + } + +return reqtag_pool; +} + +struct hw_wq_callback * +efct_hw_reqtag_alloc (struct efct_hw *hw, +void (*callback)(void *arg,u8 *cqe,int status), +void *arg) +{ +struct hw_wq_callback *wqcb =NULL ; +struct reqtag_pool *reqtag_pool = hw->wq_reqtag_pool; +unsigned long flags =0 ; + +if (!callback) +return wqcb; + +spin_lock_irqsave (&reqtag_pool->lock, flags); + +if (!list_empty (&reqtag_pool->freelist)) { + wqcb =list_first_entry (&reqtag_pool->freelist, + struct hw_wq_callback, list_entry); + } + +if (wqcb) { +list_del (&wqcb->list_entry); +spin_unlock_irqrestore (&reqtag_pool->lock, flags); + wqcb->callback = callback; + wqcb->arg = arg; + }else { +spin_unlock_irqrestore (&reqtag_pool->lock, flags); + } + +return wqcb; +} + +void +efct_hw_reqtag_free (struct efct_hw *hw,struct hw_wq_callback *wqcb) +{ +unsigned long flags =0 ; +struct reqtag_pool *reqtag_pool = hw->wq_reqtag_pool; + +if (!wqcb->callback) +efc_log_err (hw->os,"WQCB is already freed\n" ); + +spin_lock_irqsave (&reqtag_pool->lock, flags); + wqcb->callback =NULL ; + wqcb->arg =NULL ; +INIT_LIST_HEAD (&wqcb->list_entry); +list_add (&wqcb->list_entry, &hw->wq_reqtag_pool->freelist); +spin_unlock_irqrestore (&reqtag_pool->lock, flags); +} + +struct hw_wq_callback * +efct_hw_reqtag_get_instance (struct efct_hw *hw,u32 instance_index)
drivers/scsi/elx/efct/efct_hw.c efct_issue_mbox_rqst(void *base, void *cmd, void *cb, void *arg) · line 2167
Quoted 10 lines
drivers/scsi/elx/efct/efct_hw.c +10
-0+{ +struct hw_wq_callback *wqcb; + + wqcb = hw->wq_reqtag_pool->tags[instance_index]; +if (!wqcb) +efc_log_err (hw->os,"wqcb for instance %d is null\n" , + instance_index); + +return wqcb; +}
Have you considered using sbitmap for tracking the 'reqtag' instances?
Quoted 41 lines
drivers/scsi/elx/efct/efct_hw.h +32
-0@@ -628,4 +628,45 @@ efct_hw_command(struct efct_hw *hw, u8 *cmd, u32 opts, void *cb,int efct_issue_mbox_rqst (void *base,void *cmd,void *cb,void *arg); +struct efct_hw_io *efct_hw_io_alloc (struct efct_hw *hw); +int efct_hw_io_free (struct efct_hw *hw,struct efct_hw_io *io); +u8 efct_hw_io_inuse (struct efct_hw *hw,struct efct_hw_io *io); +enum efct_hw_rtn +efct_hw_io_send (struct efct_hw *hw,enum efct_hw_io_type type, +struct efct_hw_io *io,union efct_hw_io_param_u *iparam, +void *cb,void *arg); +enum efct_hw_rtn +efct_hw_io_register_sgl (struct efct_hw *hw,struct efct_hw_io *io, +struct efc_dma *sgl, +u32 sgl_count); +enum efct_hw_rtn +efct_hw_io_init_sges (struct efct_hw *hw, +struct efct_hw_io *io,enum efct_hw_io_type type); + +enum efct_hw_rtn +efct_hw_io_add_sge (struct efct_hw *hw,struct efct_hw_io *io, +uintptr_t addr,u32 length); +enum efct_hw_rtn +efct_hw_io_abort (struct efct_hw *hw,struct efct_hw_io *io_to_abort, +bool send_abts,void *cb,void *arg); +u32 +efct_hw_io_get_count (struct efct_hw *hw, +enum efct_hw_io_count_type io_count_type); +struct efct_hw_io +*efct_hw_io_lookup (struct efct_hw *hw,u32 indicator); +void efct_hw_io_abort_all (struct efct_hw *hw); +void efct_hw_io_free_internal (struct kref *arg); + +/* HW WQ request tag API */ +struct reqtag_pool *efct_hw_reqtag_pool_alloc (struct efct_hw *hw); +void efct_hw_reqtag_pool_free (struct efct_hw *hw);
drivers/scsi/elx/efct/efct_hw.h efct_hw_command(struct efct_hw *hw, u8 *cmd, u32 opts, void *cb, · line 672
Quoted 10 lines
drivers/scsi/elx/efct/efct_hw.h +9
-0+struct hw_wq_callback +*efct_hw_reqtag_alloc (struct efct_hw *hw, +void (*callback)(void *arg,u8 *cqe, +int status),void *arg); +void +efct_hw_reqtag_free (struct efct_hw *hw,struct hw_wq_callback *wqcb); +struct hw_wq_callback +*efct_hw_reqtag_get_instance (struct efct_hw *hw,u32 instance_index); +#endif /* __EFCT_H__ */
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
PATCH v4 22/31 elx: efct: Hardware queues processing
In reply to James SmartThis patch continues the efct driver population.
This patch adds driver definitions for:
Routines for EQ, CQ, WQ and RQ processing. Routines for IO object pool allocation and deallocation.
---
v4:
Remove els entries from scsi io object, as discovery IO object handles
all els.
scsi io takes efct_node object refernce and releases when IO is done.
--- drivers/scsi/elx/efct/efct_hw.c | 366 ++++++++++++++++++++++++++++++++ drivers/scsi/elx/efct/efct_hw.h | 38 ++++ drivers/scsi/elx/efct/efct_io.c | 191 +++++++++++++++++ drivers/scsi/elx/efct/efct_io.h | 166 +++++++++++++++ 4 files changed, 761 insertions(+) create mode 100644 drivers/scsi/elx/efct/efct_io.c create mode 100644 drivers/scsi/elx/efct/efct_io.h
drivers/scsi/elx/efct/efct_hw.c +366 -0
@@ -2165,3 +2165,369 @@ efct_hw_reqtag_get_instance(struct efct_hw *hw, u32 instance_index)return wqcb; } + +int +efct_hw_queue_hash_find (struct efct_queue_hash *hash,u16 id) +{ +int index =-1 ; +int i = id & (EFCT_HW_Q_HASH_SIZE -1 ); + +/* +* Since the hash is always bigger than the maximum number of Qs, then +* we never have to worry about an infinite loop. We will always find +* an unused entry. +*/ +do { +if (hash[i].in_use && hash[i].id == id) + index = hash[i].index; +else + i = (i +1 ) & (EFCT_HW_Q_HASH_SIZE -1 ); + }while (index ==-1 && hash[i].in_use); + +return index; +} + +int +efct_hw_process (struct efct_hw *hw,u32 vector, +u32 max_isr_time_msec) +{ +struct hw_eq *eq; +int rc =0 ; + +/* +* The caller should disable interrupts if they wish to prevent us +* from processing during a shutdown. The following states are defined: +* EFCT_HW_STATE_UNINITIALIZED - No queues allocated +* EFCT_HW_STATE_QUEUES_ALLOCATED - The state after a chip reset, +* queues are cleared. +* EFCT_HW_STATE_ACTIVE - Chip and queues are operational +* EFCT_HW_STATE_RESET_IN_PROGRESS - reset, we still want completions +* EFCT_HW_STATE_TEARDOWN_IN_PROGRESS - We still want mailbox +* completions. +*/ +if (hw->state ==EFCT_HW_STATE_UNINITIALIZED ) +return EFC_SUCCESS ; + +/* Get pointer to struct hw_eq */ + eq = hw->hw_eq[vector]; +if (!eq) +return EFC_SUCCESS ; + + eq->use_count++; + + rc =efct_hw_eq_process (hw, eq, max_isr_time_msec); + +return rc; +} + +int +efct_hw_eq_process (struct efct_hw *hw,struct hw_eq *eq, +u32 max_isr_time_msec) +{ +u8 eqe[sizeof (struct sli4_eqe )] = {0 }; +u32 tcheck_count; +u64 tstart; +u64 telapsed; +bool done = false; + + tcheck_count =EFCT_HW_TIMECHECK_ITERATIONS ; + tstart =jiffies_to_msecs (jiffies); + +while (!done && !sli_eq_read (&hw->sli, eq->queue, eqe)) { +u16 cq_id =0 ; +int rc; + + rc =sli_eq_parse (&hw->sli, eqe, &cq_id); +if (unlikely (rc)) { +if (rc ==SLI4_EQE_STATUS_EQ_FULL ) { +u32 i; + +/* +* Received a sentinel EQE indicating the +* EQ is full. Process all CQs +*/ +for (i =0 ; i < hw->cq_count; i++) +efct_hw_cq_process (hw, hw->hw_cq[i]); +continue ; + }else { +return rc; + } + }else { +int index; + + index =efct_hw_queue_hash_find (hw->cq_hash, cq_id); + +if (likely (index >=0 )) +efct_hw_cq_process (hw, hw->hw_cq[index]); +else +efc_log_err (hw->os,"bad CQ_ID %#06x\n" , + cq_id); + } + +if (eq->queue->n_posted > eq->queue->posted_limit) +sli_queue_arm (&hw->sli, eq->queue, false); + +if (tcheck_count && (--tcheck_count ==0 )) { + tcheck_count =EFCT_HW_TIMECHECK_ITERATIONS ; + telapsed =jiffies_to_msecs (jiffies) - tstart; +if (telapsed >= max_isr_time_msec) + done = true; + } + } +sli_queue_eq_arm (&hw->sli, eq->queue, true); + +return EFC_SUCCESS ; +} + +static int +_efct_hw_wq_write (struct hw_wq *wq,struct efct_hw_wqe *wqe) +{ +int queue_rc; + +/* Every so often, set the wqec bit to generate comsummed completions */ +if (wq->wqec_count) + wq->wqec_count--; + +if (wq->wqec_count ==0 ) { +struct sli4_generic_wqe *genwqe = (void *)wqe->wqebuf; + + genwqe->cmdtype_wqec_byte |=SLI4_GEN_WQE_WQEC ; + wq->wqec_count = wq->wqec_set_count; + } + +/* Decrement WQ free count */ + wq->free_count--; + + queue_rc =sli_wq_write (&wq->hw->sli, wq->queue, wqe->wqebuf); + +return (queue_rc <0 ) ?EFC_FAIL :EFC_SUCCESS ; +} + +static void +hw_wq_submit_pending (struct hw_wq *wq,u32 update_free_count) +{ +struct efct_hw_wqe *wqe; +unsigned long flags =0 ; + +spin_lock_irqsave (&wq->queue->lock, flags); + +/* Update free count with value passed in */ + wq->free_count += update_free_count; + +while ((wq->free_count >0 ) && (!list_empty (&wq->pending_list))) { + wqe =list_first_entry (&wq->pending_list, + struct efct_hw_wqe, list_entry); +list_del (&wqe->list_entry); +_efct_hw_wq_write (wq, wqe); + +if (wqe->abort_wqe_submit_needed) { + wqe->abort_wqe_submit_needed = false; +efct_hw_fill_abort_wqe (wq->hw, wqe); +INIT_LIST_HEAD (&wqe->list_entry); +list_add_tail (&wqe->list_entry, &wq->pending_list); + wq->wq_pending_count++; + } + } + +spin_unlock_irqrestore (&wq->queue->lock, flags); +} + +void +efct_hw_cq_process (struct efct_hw *hw,struct hw_cq *cq) +{ +u8 cqe[sizeof (struct sli4_mcqe )]; +u16 rid =U16_MAX ; +/* completion type */ +enum sli4_qentry ctype; +u32 n_processed =0 ; +u32 tstart, telapsed; + + tstart =jiffies_to_msecs (jiffies); + +while (!sli_cq_read (&hw->sli, cq->queue, cqe)) { +int status; + + status =sli_cq_parse (&hw->sli, cq->queue, cqe, &ctype, &rid); +/* +* The sign of status is significant. If status is: +* == 0 : call completed correctly and +* the CQE indicated success +* > 0 : call completed correctly and +* the CQE indicated an error +* < 0 : call failed and no information is available about the +* CQE +*/ +if (status <0 ) { +if (status ==SLI4_MCQE_STATUS_NOT_COMPLETED ) +/* +* Notification that an entry was consumed, +* but not completed +*/ +continue ; + +break ; + } + +switch (ctype) { +case SLI4_QENTRY_ASYNC : +sli_cqe_async (&hw->sli, cqe); +break ; +case SLI4_QENTRY_MQ : +/* +* Process MQ entry. Note there is no way to determine +* the MQ_ID from the completion entry. +*/ +efct_hw_mq_process (hw, status, hw->mq); +break ; +case SLI4_QENTRY_WQ : +efct_hw_wq_process (hw, cq, cqe, status, rid); +break ; +case SLI4_QENTRY_WQ_RELEASE : { +u32 wq_id = rid; +int index; +struct hw_wq *wq =NULL ; + + index =efct_hw_queue_hash_find (hw->wq_hash, wq_id); + +if (likely (index >=0 )) { + wq = hw->hw_wq[index]; + }else { +efc_log_err (hw->os,"bad WQ_ID %#06x\n" , wq_id); +break ; + } +/* Submit any HW IOs that are on the WQ pending list */ +hw_wq_submit_pending (wq, wq->wqec_set_count); + +break ; + } + +case SLI4_QENTRY_RQ : +efct_hw_rqpair_process_rq (hw, cq, cqe); +break ; +case SLI4_QENTRY_XABT : { +efct_hw_xabt_process (hw, cq, cqe, rid); +break ; + } +default : +efc_log_test (hw->os, +"unhandled ctype=%#x rid=%#x\n" , + ctype, rid); +break ; + } + + n_processed++; +if (n_processed == cq->queue->proc_limit) +break ; + +if (cq->queue->n_posted >= cq->queue->posted_limit) +sli_queue_arm (&hw->sli, cq->queue, false); + } + +sli_queue_arm (&hw->sli, cq->queue, true); + +if (n_processed > cq->queue->max_num_processed) + cq->queue->max_num_processed = n_processed; + telapsed =jiffies_to_msecs (jiffies) - tstart; +if (telapsed > cq->queue->max_process_time) + cq->queue->max_process_time = telapsed; +} + +void +efct_hw_wq_process (struct efct_hw *hw,struct hw_cq *cq, +u8 *cqe,int status,u16 rid) +{ +struct hw_wq_callback *wqcb; + +if (rid ==EFCT_HW_REQUE_XRI_REGTAG ) { +if (status) +efc_log_err (hw->os,"reque xri failed, status = %d\n" , + status); +return ; + } + + wqcb =efct_hw_reqtag_get_instance (hw, rid); +if (!wqcb) { +efc_log_err (hw->os,"invalid request tag: x%x\n" , rid); +return ; + } + +if (!wqcb->callback) { +efc_log_err (hw->os,"wqcb callback is NULL\n" ); +return ; + } + + (*wqcb->callback)(wqcb->arg, cqe, status); +} + +void +efct_hw_xabt_process (struct efct_hw *hw,struct hw_cq *cq, +u8 *cqe,u16 rid) +{ +/* search IOs wait free list */ +struct efct_hw_io *io =NULL ; +unsigned long flags =0 ; + + io =efct_hw_io_lookup (hw, rid); +if (!io) { +/* IO lookup failure should never happen */ +efc_log_err (hw->os, +"Error: xabt io lookup failed rid=%#x\n" , rid); +return ; + } + +if (!io->xbusy) +efc_log_debug (hw->os,"xabt io not busy rid=%#x\n" , rid); +else +/* mark IO as no longer busy */ + io->xbusy = false; + +/* +* For IOs that were aborted internally, we need to issue any pending +* callback here. +*/ +if (io->done) { +efct_hw_done_t done = io->done; +void *arg = io->arg; + +/* +* Use latched status as this is always saved for an internal +* abort +*/ +int status = io->saved_status; +u32 len = io->saved_len; +u32 ext = io->saved_ext; + + io->done =NULL ; + io->status_saved = false; + +done (io, len, status, ext, arg); + } + +spin_lock_irqsave (&hw->io_lock, flags); +if (io->state ==EFCT_HW_IO_STATE_INUSE || + io->state ==EFCT_HW_IO_STATE_WAIT_FREE ) { +/* if on wait_free list, caller has already freed IO; +* remove from wait_free list and add to free list. +* if on in-use list, already marked as no longer busy; +* just leave there and wait for caller to free. +*/ +if (io->state ==EFCT_HW_IO_STATE_WAIT_FREE ) { + io->state =EFCT_HW_IO_STATE_FREE ; +list_del (&io->list_entry); +efct_hw_io_free_move_correct_list (hw, io); + } + } +spin_unlock_irqrestore (&hw->io_lock, flags); +} + +static int +efct_hw_flush (struct efct_hw *hw) +{ +u32 i =0 ; + +/* Process any remaining completions */ +for (i =0 ; i < hw->eq_count; i++) +efct_hw_process (hw, i, ~0 ); + +return EFC_SUCCESS ; +}
drivers/scsi/elx/efct/efct_hw.h +38 -0
@@ -669,4 +669,42 @@ efct_hw_reqtag_free(struct efct_hw *hw, struct hw_wq_callback *wqcb);struct hw_wq_callback *efct_hw_reqtag_get_instance (struct efct_hw *hw,u32 instance_index); +/* RQ completion handlers for RQ pair mode */ +int +efct_hw_rqpair_process_rq (struct efct_hw *hw, +struct hw_cq *cq,u8 *cqe); +enum efct_hw_rtn +efct_hw_rqpair_sequence_free (struct efct_hw *hw,struct efc_hw_sequence *seq); +static inline void +efct_hw_sequence_copy (struct efc_hw_sequence *dst, +struct efc_hw_sequence *src) +{ +/* Copy src to dst, then zero out the linked list link */ + *dst = *src; +} + +int +efct_efc_hw_sequence_free (struct efc *efc,struct efc_hw_sequence *seq); + +static inline enum efct_hw_rtn +efct_hw_sequence_free (struct efct_hw *hw,struct efc_hw_sequence *seq) +{ +/* Only RQ pair mode is supported */ +return efct_hw_rqpair_sequence_free (hw, seq); +} +int +efct_hw_eq_process (struct efct_hw *hw,struct hw_eq *eq, +u32 max_isr_time_msec); +void efct_hw_cq_process (struct efct_hw *hw,struct hw_cq *cq); +void +efct_hw_wq_process (struct efct_hw *hw,struct hw_cq *cq, +u8 *cqe,int status,u16 rid); +void +efct_hw_xabt_process (struct efct_hw *hw,struct hw_cq *cq, +u8 *cqe,u16 rid); +int +efct_hw_process (struct efct_hw *hw,u32 vector,u32 max_isr_time_msec); +int +efct_hw_queue_hash_find (struct efct_queue_hash *hash,u16 id); +#endif /* __EFCT_H__ */
drivers/scsi/elx/efct/efct_io.c new file +191 -0
191 lines not on this page · raw message
drivers/scsi/elx/efct/efct_io.h new file +166 -0
166 lines not on this page · raw message
Signature · 1 line
2.26.2
Re: [PATCH v4 22/31] elx: efct: Hardware queues processing
Quoted 15 lines · James Smart
This patch continues the efct driver population.
This patch adds driver definitions for:
Routines for EQ, CQ, WQ and RQ processing. Routines for IO object pool allocation and deallocation.Co-developed-by Ram Vegesna <[email protected]>Signed-off-by Ram Vegesna <[email protected]>Signed-off-by James Smart <[email protected]>---
v4:
Remove els entries from scsi io object, as discovery IO object handles
all els.
scsi io takesefct_nodeobject refernce and releases when IO is done.
Quoted 9 lines
--- drivers/scsi/elx/efct/efct_hw.c | 366 ++++++++++++++++++++++++++++++++ drivers/scsi/elx/efct/efct_hw.h | 38 ++++ drivers/scsi/elx/efct/efct_io.c | 191 +++++++++++++++++ drivers/scsi/elx/efct/efct_io.h | 166 +++++++++++++++ 4 files changed, 761 insertions(+)create mode 100644
drivers/scsi/elx/efct/efct_io.ccreate mode 100644drivers/scsi/elx/efct/efct_io.h
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
PATCH v4 23/31 elx: efct: Unsolicited FC frame processing routines
In reply to James SmartThis patch continues the efct driver population.
This patch adds driver definitions for:
Routines to handle unsolicited FC frames.
---
v4:
Changed unsol frame handling.
Lookup for efct target node based on d_id and s_id. Take ref count and
release when cmd handling is done.
Now IO path doesn't lookup for discovery objects. So no impact on IO
path because of EFC lock.
--- drivers/scsi/elx/efct/efct_unsol.c | 495 +++++++++++++++++++++++++++++ drivers/scsi/elx/efct/efct_unsol.h | 17 + 2 files changed, 512 insertions(+) create mode 100644 drivers/scsi/elx/efct/efct_unsol.c create mode 100644 drivers/scsi/elx/efct/efct_unsol.h
drivers/scsi/elx/efct/efct_unsol.c new file +495 -0
@@ -0,0 +1,495 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +#include "efct_driver.h" +#include "efct_unsol.h" + +#define frame_printf (efct, hdr, fmt, ...) \ + do { \ + char s_id_text[16]; \ + efc_node_fcid_display(ntoh24((hdr)->fh_s_id), \ + s_id_text, sizeof(s_id_text)); \ + efc_log_debug(efct, "[%06x.%s] %02x/%04x/%04x: " fmt, \ + ntoh24((hdr)->fh_d_id), s_id_text, \ + (hdr)->fh_r_ctl, be16_to_cpu((hdr)->fh_ox_id), \ + be16_to_cpu((hdr)->fh_rx_id), ##__VA_ARGS__); \ + } while (0) + +static struct efct_node * +efct_node_find (struct efct *efct,u32 port_id,u32 node_id) +{ +struct efct_node *node; +u64 id = (u64 ) port_id <<32 | node_id; + +/* +* During node shutdown, Lookup will be removed first, +* before announcing to backend. So, no new IOs will be allowed +*/ +/* Find a target node, given s_id and d_id */ + node =xa_load (&efct->lookup, id); +if (node) +kref_get (&node->ref); + +return node; +} + +static int +efct_dispatch_frame (struct efct *efct,struct efc_hw_sequence *seq) +{ +struct efct_node *node; +struct fc_frame_header *hdr; +u32 s_id, d_id; + + 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); + +if (!(hdr->fh_type ==FC_TYPE_FCP || hdr->fh_type ==FC_TYPE_BLS )) +return EFC_FAIL ; + +if (hdr->fh_type ==FC_TYPE_FCP ) { + node =efct_node_find (efct, d_id, s_id); +if (!node) { +efc_log_err (efct, +"Node not found, drop cmd d_id:%x s_id:%x\n" , + d_id, s_id); +efct_hw_sequence_free (&efct->hw, seq); +return EFC_SUCCESS ; + } + +efct_dispatch_fcp_cmd (node, seq); + }else { + node =efct_node_find (efct, d_id, s_id); +if (!node) { +efc_log_err (efct,"Node not found, d_id:%x s_id:%x\n" , + d_id, s_id); +return EFC_FAIL ; + } + +efc_log_err (efct,"Received ABTS for Node:%p\n" , node); +efct_node_recv_abts_frame (node, seq); + } + +kref_put (&node->ref, node->release); +efct_hw_sequence_free (&efct->hw, seq); +return EFC_SUCCESS ; +} + +int +efct_unsolicited_cb (void *arg,struct efc_hw_sequence *seq) +{ +struct efct *efct = arg; + +/* Process FCP command */ +if (!efct_dispatch_frame (efct, seq)) +return EFC_SUCCESS ; + +/* Forward frame to discovery lib */ +efc_dispatch_frame (efct->efcport, seq); +return EFC_SUCCESS ; +} + +static int +efct_fc_tmf_rejected_cb (struct efct_io *io, +enum efct_scsi_io_status scsi_status, +u32 flags,void *arg) +{ +efct_scsi_io_free (io); +return EFC_SUCCESS ; +} + +static void +efct_dispatch_unsol_tmf (struct efct_io *io,u8 tm_flags,u32 lun) +{ +u32 i; +struct { +u32 mask; +enum efct_scsi_tmf_cmd cmd; + } tmflist[] = { + {FCP_TMF_ABT_TASK_SET ,EFCT_SCSI_TMF_ABORT_TASK_SET }, + {FCP_TMF_CLR_TASK_SET ,EFCT_SCSI_TMF_CLEAR_TASK_SET }, + {FCP_TMF_LUN_RESET ,EFCT_SCSI_TMF_LOGICAL_UNIT_RESET }, + {FCP_TMF_TGT_RESET ,EFCT_SCSI_TMF_TARGET_RESET }, + {FCP_TMF_CLR_ACA ,EFCT_SCSI_TMF_CLEAR_ACA } }; + + io->exp_xfer_len =0 ; + +for (i =0 ; i <ARRAY_SIZE (tmflist); i++) { +if (tmflist[i].mask & tm_flags) { + io->tmf_cmd = tmflist[i].cmd; +efct_scsi_recv_tmf (io, lun, tmflist[i].cmd,NULL ,0 ); +break ; + } + } +if (i ==ARRAY_SIZE (tmflist)) { +/* Not handled */ +node_printf (io->node,"TMF x%x rejected\n" , tm_flags); +efct_scsi_send_tmf_resp (io,EFCT_SCSI_TMF_FUNCTION_REJECTED , +NULL , efct_fc_tmf_rejected_cb,NULL ); + } +} + +static int +efct_validate_fcp_cmd (struct efct *efct,struct efc_hw_sequence *seq) +{ +/* +* If we received less than FCP_CMND_IU bytes, assume that the frame is +* corrupted in some way and drop it. +* This was seen when jamming the FCTL +* fill bytes field. +*/ +if (seq->payload->dma.len <sizeof (struct fcp_cmnd )) { +struct fc_frame_header *fchdr = seq->header->dma.virt; + +efc_log_debug (efct, +"drop ox_id %04x with payload (%zd) less than (%zd)\n" , +be16_to_cpu (fchdr->fh_ox_id), + seq->payload->dma.len, +sizeof (struct fcp_cmnd )); +return EFC_FAIL ; + } +return EFC_SUCCESS ; +} + +static void +efct_populate_io_fcp_cmd (struct efct_io *io,struct fcp_cmnd *cmnd, +struct fc_frame_header *fchdr,bool sit) +{ + io->init_task_tag =be16_to_cpu (fchdr->fh_ox_id); +/* note, tgt_task_tag, hw_tag set when HW io is allocated */ + io->exp_xfer_len =be32_to_cpu (cmnd->fc_dl); + io->transferred =0 ; + +/* The upper 7 bits of CS_CTL is the frame priority thru the SAN. +* Our assertion here is, the priority given to a frame containing +* the FCP cmd should be the priority given to ALL frames contained +* in that IO. Thus we need to save the incoming CS_CTL here. +*/ +if (ntoh24 (fchdr->fh_f_ctl) &FC_FC_RES_B17 ) + io->cs_ctl = fchdr->fh_cs_ctl; +else + io->cs_ctl =0 ; + + io->seq_init = sit; +} + +static u32 +efct_get_flags_fcp_cmd (struct fcp_cmnd *cmnd) +{ +u32 flags =0 ; + +switch (cmnd->fc_pri_ta &FCP_PTA_MASK ) { +case FCP_PTA_SIMPLE : + flags |=EFCT_SCSI_CMD_SIMPLE ; +break ; +case FCP_PTA_HEADQ : + flags |=EFCT_SCSI_CMD_HEAD_OF_QUEUE ; +break ; +case FCP_PTA_ORDERED : + flags |=EFCT_SCSI_CMD_ORDERED ; +break ; +case FCP_PTA_ACA : + flags |=EFCT_SCSI_CMD_ACA ; +break ; + } +if (cmnd->fc_flags &FCP_CFL_WRDATA ) + flags |=EFCT_SCSI_CMD_DIR_IN ; +if (cmnd->fc_flags &FCP_CFL_RDDATA ) + flags |=EFCT_SCSI_CMD_DIR_OUT ; + +return flags; +} + +static void +efct_sframe_common_send_cb (void *arg,u8 *cqe,int status) +{ +struct efct_hw_send_frame_context *ctx = arg; +struct efct_hw *hw = ctx->hw; + +/* Free WQ completion callback */ +efct_hw_reqtag_free (hw, ctx->wqcb); + +/* Free sequence */ +efct_hw_sequence_free (hw, ctx->seq); +} + +static int +efct_sframe_common_send (struct efct_node *node, +struct efc_hw_sequence *seq, +enum fc_rctl r_ctl,u32 f_ctl, +u8 type,void *payload,u32 payload_len) +{ +struct efct *efct = node->efct; +struct efct_hw *hw = &efct->hw; +enum efct_hw_rtn rc =0 ; +struct fc_frame_header *req_hdr = seq->header->dma.virt; +struct fc_frame_header hdr; +struct efct_hw_send_frame_context *ctx; + +u32 heap_size = seq->payload->dma.size; +uintptr_t heap_phys_base = seq->payload->dma.phys; +u8 *heap_virt_base = seq->payload->dma.virt; +u32 heap_offset =0 ; + +/* Build the FC header reusing the RQ header DMA buffer */ +memset (&hdr,0 ,sizeof (hdr)); + hdr.fh_r_ctl = r_ctl; +/* send it back to whomever sent it to us */ +memcpy (hdr.fh_d_id, req_hdr->fh_s_id,sizeof (hdr.fh_d_id)); +memcpy (hdr.fh_s_id, req_hdr->fh_d_id,sizeof (hdr.fh_s_id)); + hdr.fh_type = type; +hton24 (hdr.fh_f_ctl, f_ctl); + hdr.fh_ox_id = req_hdr->fh_ox_id; + hdr.fh_rx_id = req_hdr->fh_rx_id; + hdr.fh_cs_ctl =0 ; + hdr.fh_df_ctl =0 ; + hdr.fh_seq_cnt =0 ; + hdr.fh_parm_offset =0 ; + +/* +* send_frame_seq_id is an atomic, we just let it increment, +* while storing only the low 8 bits to hdr->seq_id +*/ + hdr.fh_seq_id = (u8 )atomic_add_return (1 , &hw->send_frame_seq_id); + hdr.fh_seq_id--; + +/* Allocate and fill in the send frame request context */ + ctx = (void *)(heap_virt_base + heap_offset); + heap_offset +=sizeof (*ctx); +if (heap_offset > heap_size) { +efc_log_err (efct,"Fill send frame failed offset %d size %d\n" , + heap_offset, heap_size); +return EFC_FAIL ; + } + +memset (ctx,0 ,sizeof (*ctx)); + +/* Save sequence */ + ctx->seq = seq; + +/* Allocate a response payload DMA buffer from the heap */ + ctx->payload.phys = heap_phys_base + heap_offset; + ctx->payload.virt = heap_virt_base + heap_offset; + ctx->payload.size = payload_len; + ctx->payload.len = payload_len; + heap_offset += payload_len; +if (heap_offset > heap_size) { +efc_log_err (efct,"Fill send frame failed offset %d size %d\n" , + heap_offset, heap_size); +return EFC_FAIL ; + } + +/* Copy the payload in */ +memcpy (ctx->payload.virt, payload, payload_len); + +/* Send */ + rc =efct_hw_send_frame (&efct->hw, (void *)&hdr,FC_SOF_N3 , +FC_EOF_T , &ctx->payload, ctx, + efct_sframe_common_send_cb, ctx); +if (rc) +efc_log_test (efct,"efct_hw_send_frame failed: %d\n" , rc); + +return rc; +} + +static int +efct_sframe_send_fcp_rsp (struct efct_node *node,struct efc_hw_sequence *seq, +void *rsp,u32 rsp_len) +{ +return efct_sframe_common_send (node, seq,FC_RCTL_DD_CMD_STATUS , +FC_FC_EX_CTX | +FC_FC_LAST_SEQ | +FC_FC_END_SEQ | +FC_FC_SEQ_INIT , +FC_TYPE_FCP , + rsp, rsp_len); +} + +static int +efct_sframe_send_task_set_full_or_busy (struct efct_node *node, +struct efc_hw_sequence *seq) +{ +struct fcp_resp_with_ext fcprsp; +struct fcp_cmnd *fcpcmd = seq->payload->dma.virt; +int rc =0 ; +unsigned long flags =0 ; +struct efct *efct = node->efct; + +/* construct task set full or busy response */ +memset (&fcprsp,0 ,sizeof (fcprsp)); +spin_lock_irqsave (&node->active_ios_lock, flags); + fcprsp.resp.fr_status =list_empty (&node->active_ios) ? +SAM_STAT_BUSY :SAM_STAT_TASK_SET_FULL ; +spin_unlock_irqrestore (&node->active_ios_lock, flags); + *((u32 *)&fcprsp.ext.fr_resid) =be32_to_cpu (fcpcmd->fc_dl); + +/* send it using send_frame */ + rc =efct_sframe_send_fcp_rsp (node, seq, &fcprsp,sizeof (fcprsp)); +if (rc) +efc_log_test (efct,"efct_sframe_send_fcp_rsp failed: %d\n" , rc); + +return rc; +} + +int +efct_dispatch_fcp_cmd (struct efct_node *node,struct efc_hw_sequence *seq) +{ +struct efct *efct = node->efct; +struct fc_frame_header *fchdr = seq->header->dma.virt; +struct fcp_cmnd *cmnd =NULL ; +struct efct_io *io =NULL ; +u32 lun =U32_MAX ; + +if (!seq->payload) { +efc_log_err (efct,"Sequence payload is NULL.\n" ); +return EFC_FAIL ; + } + + cmnd = seq->payload->dma.virt; + +/* perform FCP_CMND validation check(s) */ +if (efct_validate_fcp_cmd (efct, seq)) +return EFC_FAIL ; + + lun =scsilun_to_int (&cmnd->fc_lun); +if (lun ==U32_MAX ) +return EFC_FAIL ; + + io =efct_scsi_io_alloc (node); +if (!io) { +int rc; + +/* Use SEND_FRAME to send task set full or busy */ + rc =efct_sframe_send_task_set_full_or_busy (node, seq); +if (rc) +efc_log_err (efct,"Failed to send busy task: %d\n" , rc); + +return rc; + } + + io->hw_priv = seq->hw_priv; + + io->app_id =0 ; + +/* RQ pair, if we got here, SIT=1 */ +efct_populate_io_fcp_cmd (io, cmnd, fchdr, true); + +if (cmnd->fc_tm_flags) { +efct_dispatch_unsol_tmf (io, cmnd->fc_tm_flags, lun); + }else { +u32 flags =efct_get_flags_fcp_cmd (cmnd); + +if (cmnd->fc_flags &FCP_CFL_LEN_MASK ) { +efc_log_err (efct,"Additional CDB not supported\n" ); +return EFC_FAIL ; + } +/* +* Can return failure for things like task set full and UAs, +* no need to treat as a dropped frame if rc != 0 +*/ +efct_scsi_recv_cmd (io, lun, cmnd->fc_cdb, +sizeof (cmnd->fc_cdb), flags); + } + +return EFC_SUCCESS ; +} + +static int +efct_process_abts (struct efct_io *io,struct fc_frame_header *hdr) +{ +struct efct_node *node = io->node; +struct efct *efct = io->efct; +u16 ox_id =be16_to_cpu (hdr->fh_ox_id); +u16 rx_id =be16_to_cpu (hdr->fh_rx_id); +struct efct_io *abortio; + +/* Find IO and attempt to take a reference on it */ + abortio =efct_io_find_tgt_io (efct, node, ox_id, rx_id); + +if (abortio) { +/* Got a reference on the IO. Hold it until backend +* is notified below +*/ +node_printf (node,"Abort request: ox_id [%04x] rx_id [%04x]\n" , + ox_id, rx_id); + +/* +* Save the ox_id for the ABTS as the init_task_tag in our +* manufactured +* TMF IO object +*/ + io->display_name ="abts" ; + io->init_task_tag = ox_id; +/* don't set tgt_task_tag, don't want to confuse with XRI */ + +/* +* Save the rx_id from the ABTS as it is +* needed for the BLS response, +* regardless of the IO context's rx_id +*/ + io->abort_rx_id = rx_id; + +/* Call target server command abort */ + io->tmf_cmd =EFCT_SCSI_TMF_ABORT_TASK ; +efct_scsi_recv_tmf (io, abortio->tgt_io.lun, +EFCT_SCSI_TMF_ABORT_TASK , abortio,0 ); + +/* +* Backend will have taken an additional +* reference on the IO if needed; +* done with current reference. +*/ +kref_put (&abortio->ref, abortio->release); + }else { +/* +* Either IO was not found or it has been +* freed between finding it +* and attempting to get the reference, +*/ +node_printf (node,"Abort request: ox_id [%04x], IO not found\n" , + ox_id); + +/* Send a BA_RJT */ +efct_bls_send_rjt (io, hdr); + } +return EFC_SUCCESS ; +} + +int +efct_node_recv_abts_frame (struct efct_node *node,struct efc_hw_sequence *seq) +{ +struct efct *efct = node->efct; +struct fc_frame_header *hdr = seq->header->dma.virt; +struct efct_io *io =NULL ; + + node->abort_cnt++; + io =efct_scsi_io_alloc (node); +if (io) { + io->hw_priv = seq->hw_priv; +/* If we got this far, SIT=1 */ + io->seq_init =1 ; + +/* fill out generic fields */ + io->efct = efct; + io->node = node; + io->cmd_tgt = true; + +efct_process_abts (io, seq->header->dma.virt); + }else { +node_printf (node, +"SCSI IO allocation failed for ABTS received " ); +node_printf (node, +"s_id %06x d_id %06x ox_id %04x rx_id %04x\n" , +ntoh24 (hdr->fh_s_id), +ntoh24 (hdr->fh_d_id), +be16_to_cpu (hdr->fh_ox_id), +be16_to_cpu (hdr->fh_rx_id)); + } + +return EFC_SUCCESS ; +}
drivers/scsi/elx/efct/efct_unsol.h new file +17 -0
@@ -0,0 +1,17 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2020 Broadcom. All Rights Reserved. The term +* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +*/ + +#if !defined(__OSC_UNSOL_H__) +#define __OSC_UNSOL_H__ + +int +efct_unsolicited_cb (void *arg,struct efc_hw_sequence *seq); +int +efct_dispatch_fcp_cmd (struct efct_node *node,struct efc_hw_sequence *seq); +int +efct_node_recv_abts_frame (struct efct_node *node,struct efc_hw_sequence *seq); + +#endif /* __OSC_UNSOL_H__ */
Signature · 1 line
2.26.2