/* * This file is part of the Chelsio FCoE driver for Linux. * * Copyright (c) 2008-2012 Chelsio Communications, Inc. All rights reserved. * * This software is available to you under a choice of one of two * licenses. You may choose to be licensed under the terms of the GNU * General Public License (GPL) Version 2, available from the file * COPYING in the main directory of this source tree, or the * OpenIB.org BSD license below: * * Redistribution and use in source and binary forms, with or * without modification, are permitted provided that the following * conditions are met: * * - Redistributions of source code must retain the above * copyright notice, this list of conditions and the following * disclaimer. * * - Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials * provided with the distribution. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include #include #include #include #include #include #include #include #include #include #include #include "csio_hw.h" #include "csio_mb.h" #include "csio_lnode.h" #include "csio_rnode.h" int csio_fcoe_rnodes = 1024; int csio_fdmi_enable = 1; #define PORT_ID_PTR(_x) ((uint8_t *)(&_x) + 1) /* Lnode SM declarations */ static void csio_lns_uninit(struct csio_lnode *, enum csio_ln_ev); static void csio_lns_online(struct csio_lnode *, enum csio_ln_ev); static void csio_lns_ready(struct csio_lnode *, enum csio_ln_ev); static void csio_lns_offline(struct csio_lnode *, enum csio_ln_ev); static int csio_ln_mgmt_submit_req(struct csio_ioreq *, void (*io_cbfn) (struct csio_hw *, struct csio_ioreq *), enum fcoe_cmn_type, struct csio_dma_buf *, uint32_t); /* LN event mapping */ static enum csio_ln_ev fwevt_to_lnevt[] = { CSIO_LNE_NONE, /* None */ CSIO_LNE_NONE, /* PLOGI_ACC_RCVD */ CSIO_LNE_NONE, /* PLOGI_RJT_RCVD */ CSIO_LNE_NONE, /* PLOGI_RCVD */ CSIO_LNE_NONE, /* PLOGO_RCVD */ CSIO_LNE_NONE, /* PRLI_ACC_RCVD */ CSIO_LNE_NONE, /* PRLI_RJT_RCVD */ CSIO_LNE_NONE, /* PRLI_RCVD */ CSIO_LNE_NONE, /* PRLO_RCVD */ CSIO_LNE_NONE, /* NPORT_ID_CHGD */ CSIO_LNE_LOGO, /* FLOGO_RCVD */ CSIO_LNE_LOGO, /* CLR_VIRT_LNK_RCVD */ CSIO_LNE_FAB_INIT_DONE,/* FLOGI_ACC_RCVD */ CSIO_LNE_NONE, /* FLOGI_RJT_RCVD */ CSIO_LNE_FAB_INIT_DONE,/* FDISC_ACC_RCVD */ CSIO_LNE_NONE, /* FDISC_RJT_RCVD */ CSIO_LNE_NONE, /* FLOGI_TMO_MAX_RETRY */ CSIO_LNE_NONE, /* IMPL_LOGO_ADISC_ACC */ CSIO_LNE_NONE, /* IMPL_LOGO_ADISC_RJT */ CSIO_LNE_NONE, /* IMPL_LOGO_ADISC_CNFLT */ CSIO_LNE_NONE, /* PRLI_TMO */ CSIO_LNE_NONE, /* ADISC_TMO */ CSIO_LNE_NONE, /* RSCN_DEV_LOST */ CSIO_LNE_NONE, /* SCR_ACC_RCVD */ CSIO_LNE_NONE, /* ADISC_RJT_RCVD */ CSIO_LNE_NONE, /* LOGO_SNT */ CSIO_LNE_NONE, /* PROTO_ERR_IMPL_LOGO */ }; #define CSIO_FWE_TO_LNE(_evt) ((_evt > PROTO_ERR_IMPL_LOGO) ? \ CSIO_LNE_NONE : \ fwevt_to_lnevt[_evt]) #define csio_ct_rsp(cp) (((struct fc_ct_hdr *)cp)->ct_cmd) #define csio_ct_reason(cp) (((struct fc_ct_hdr *)cp)->ct_reason) #define csio_ct_expl(cp) (((struct fc_ct_hdr *)cp)->ct_explan) #define csio_ct_get_pld(cp) ((void *)(((uint8_t *)cp) + FC_CT_HDR_LEN)) /* * csio_ln_match_by_portid - lookup lnode using given portid. * @hw: HW module * @portid: port-id. * * If found, returns lnode matching given portid otherwise returns NULL. */ static struct csio_lnode * csio_ln_lookup_by_portid(struct csio_hw *hw, uint8_t portid) { struct csio_lnode *ln = hw->rln; struct list_head *tmp; /* Match siblings lnode with portid */ list_for_each(tmp, &hw->sln_head) { ln = (struct csio_lnode *) tmp; if (ln->portid == portid) return ln; } return NULL; } /* * csio_ln_lookup_by_vnpi - Lookup lnode using given vnp id. * @hw - HW module * @vnpi - vnp index. * Returns - If found, returns lnode matching given vnp id * otherwise returns NULL. */ static struct csio_lnode * csio_ln_lookup_by_vnpi(struct csio_hw *hw, uint32_t vnp_id) { struct list_head *tmp1, *tmp2; struct csio_lnode *sln = NULL, *cln = NULL; if (list_empty(&hw->sln_head)) { CSIO_INC_STATS(hw, n_lnlkup_miss); return NULL; } /* Traverse sibling lnodes */ list_for_each(tmp1, &hw->sln_head) { sln = (struct csio_lnode *) tmp1; /* Match sibling lnode */ if (sln->vnp_flowid == vnp_id) return sln; if (list_empty(&sln->cln_head)) continue; /* Traverse children lnodes */ list_for_each(tmp2, &sln->cln_head) { cln = (struct csio_lnode *) tmp2; if (cln->vnp_flowid == vnp_id) return cln; } } CSIO_INC_STATS(hw, n_lnlkup_miss); return NULL; } /** * csio_lnode_lookup_by_wwpn - Lookup lnode using given wwpn. * @hw: HW module. * @wwpn: WWPN. * * If found, returns lnode matching given wwpn, returns NULL otherwise. */ struct csio_lnode * csio_lnode_lookup_by_wwpn(struct csio_hw *hw, uint8_t *wwpn) { struct list_head *tmp1, *tmp2; struct csio_lnode *sln = NULL, *cln = NULL; if (list_empty(&hw->sln_head)) { CSIO_INC_STATS(hw, n_lnlkup_miss); return NULL; } /* Traverse sibling lnodes */ list_for_each(tmp1, &hw->sln_head) { sln = (struct csio_lnode *) tmp1; /* Match sibling lnode */ if (!memcmp(csio_ln_wwpn(sln), wwpn, 8)) return sln; if (list_empty(&sln->cln_head)) continue; /* Traverse children lnodes */ list_for_each(tmp2, &sln->cln_head) { cln = (struct csio_lnode *) tmp2; if (!memcmp(csio_ln_wwpn(cln), wwpn, 8)) return cln; } } return NULL; } /* FDMI */ static void csio_fill_ct_iu(void *buf, uint8_t type, uint8_t sub_type, uint16_t op) { struct fc_ct_hdr *cmd = (struct fc_ct_hdr *)buf; cmd->ct_rev = FC_CT_REV; cmd->ct_fs_type = type; cmd->ct_fs_subtype = sub_type; cmd->ct_cmd = htons(op); } static int csio_hostname(uint8_t *buf, size_t buf_len) { if (snprintf(buf, buf_len, "%s", init_utsname()->nodename) > 0) return 0; return -1; } static int csio_osname(uint8_t *buf, size_t buf_len) { if (snprintf(buf, buf_len, "%s %s %s", init_utsname()->sysname, init_utsname()->release, init_utsname()->version) > 0) return 0; return -1; } static inline void csio_append_attrib(uint8_t **ptr, uint16_t type, void *val, size_t val_len) { uint16_t len; struct fc_fdmi_attr_entry *ae = (struct fc_fdmi_attr_entry *)*ptr; if (WARN_ON(val_len > U16_MAX)) return; len = val_len; ae->type = htons(type); len += 4; /* includes attribute type and length */ len = (len + 3) & ~3; /* should be multiple of 4 bytes */ ae->len = htons(len); memcpy(ae->value, val, val_len); if (len > val_len) memset(ae->value + val_len, 0, len - val_len); *ptr += len; } /* * csio_ln_fdmi_done - FDMI registeration completion * @hw: HW context * @fdmi_req: fdmi request */ static void csio_ln_fdmi_done(struct csio_hw *hw, struct csio_ioreq *fdmi_req) { void *cmd; struct csio_lnode *ln = fdmi_req->lnode; if (fdmi_req->wr_status != FW_SUCCESS) { csio_ln_dbg(ln, "WR error:%x in processing fdmi rpa cmd\n", fdmi_req->wr_status); CSIO_INC_STATS(ln, n_fdmi_err); } cmd = fdmi_req->dma_buf.vaddr; if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) { csio_ln_dbg(ln, "fdmi rpa cmd rejected reason %x expl %x\n", csio_ct_reason(cmd), csio_ct_expl(cmd)); } } /* * csio_ln_fdmi_rhba_cbfn - RHBA completion * @hw: HW context * @fdmi_req: fdmi request */ static void csio_ln_fdmi_rhba_cbfn(struct csio_hw *hw, struct csio_ioreq *fdmi_req) { void *cmd; uint8_t *pld; uint32_t len = 0; __be32 val; __be16 mfs; uint32_t numattrs = 0; struct csio_lnode *ln = fdmi_req->lnode; struct fs_fdmi_attrs *attrib_blk; struct fc_fdmi_port_name *port_name; uint8_t buf[64]; uint8_t *fc4_type; unsigned long flags; if (fdmi_req->wr_status != FW_SUCCESS) { csio_ln_dbg(ln, "WR error:%x in processing fdmi rhba cmd\n", fdmi_req->wr_status); CSIO_INC_STATS(ln, n_fdmi_err); } cmd = fdmi_req->dma_buf.vaddr; if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) { csio_ln_dbg(ln, "fdmi rhba cmd rejected reason %x expl %x\n", csio_ct_reason(cmd), csio_ct_expl(cmd)); } if (!csio_is_rnode_ready(fdmi_req->rnode)) { CSIO_INC_STATS(ln, n_fdmi_err); return; } /* Prepare CT hdr for RPA cmd */ memset(cmd, 0, FC_CT_HDR_LEN); csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_RPA); /* Prepare RPA payload */ pld = (uint8_t *)csio_ct_get_pld(cmd); port_name = (struct fc_fdmi_port_name *)pld; memcpy(&port_name->portname, csio_ln_wwpn(ln), 8); pld += sizeof(*port_name); /* Start appending Port attributes */ attrib_blk = (struct fs_fdmi_attrs *)pld; attrib_blk->numattrs = 0; len += sizeof(attrib_blk->numattrs); pld += sizeof(attrib_blk->numattrs); fc4_type = &buf[0]; memset(fc4_type, 0, FC_FDMI_PORT_ATTR_FC4TYPES_LEN); fc4_type[2] = 1; fc4_type[7] = 1; csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_FC4TYPES, fc4_type, FC_FDMI_PORT_ATTR_FC4TYPES_LEN); numattrs++; val = htonl(FC_PORTSPEED_1GBIT | FC_PORTSPEED_10GBIT); csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_SUPPORTEDSPEED, &val, FC_FDMI_PORT_ATTR_SUPPORTEDSPEED_LEN); numattrs++; if (hw->pport[ln->portid].link_speed == FW_PORT_CAP_SPEED_1G) val = htonl(FC_PORTSPEED_1GBIT); else if (hw->pport[ln->portid].link_speed == FW_PORT_CAP_SPEED_10G) val = htonl(FC_PORTSPEED_10GBIT); else val = htonl(CSIO_HBA_PORTSPEED_UNKNOWN); csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_CURRENTPORTSPEED, &val, FC_FDMI_PORT_ATTR_CURRENTPORTSPEED_LEN); numattrs++; mfs = ln->ln_sparm.csp.sp_bb_data; csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_MAXFRAMESIZE, &mfs, sizeof(mfs)); numattrs++; strcpy(buf, "csiostor"); csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_OSDEVICENAME, buf, strlen(buf)); numattrs++; if (!csio_hostname(buf, sizeof(buf))) { csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_HOSTNAME, buf, strlen(buf)); numattrs++; } attrib_blk->numattrs = htonl(numattrs); len = (uint32_t)(pld - (uint8_t *)cmd); /* Submit FDMI RPA request */ spin_lock_irqsave(&hw->lock, flags); if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_done, FCOE_CT, &fdmi_req->dma_buf, len)) { CSIO_INC_STATS(ln, n_fdmi_err); csio_ln_dbg(ln, "Failed to issue fdmi rpa req\n"); } spin_unlock_irqrestore(&hw->lock, flags); } /* * csio_ln_fdmi_dprt_cbfn - DPRT completion * @hw: HW context * @fdmi_req: fdmi request */ static void csio_ln_fdmi_dprt_cbfn(struct csio_hw *hw, struct csio_ioreq *fdmi_req) { void *cmd; uint8_t *pld; uint32_t len = 0; uint32_t numattrs = 0; __be32 maxpayload = htonl(65536); struct fc_fdmi_hba_identifier *hbaid; struct csio_lnode *ln = fdmi_req->lnode; struct fc_fdmi_rpl *reg_pl; struct fs_fdmi_attrs *attrib_blk; uint8_t buf[64]; unsigned long flags; if (fdmi_req->wr_status != FW_SUCCESS) { csio_ln_dbg(ln, "WR error:%x in processing fdmi dprt cmd\n", fdmi_req->wr_status); CSIO_INC_STATS(ln, n_fdmi_err); } if (!csio_is_rnode_ready(fdmi_req->rnode)) { CSIO_INC_STATS(ln, n_fdmi_err); return; } cmd = fdmi_req->dma_buf.vaddr; if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) { csio_ln_dbg(ln, "fdmi dprt cmd rejected reason %x expl %x\n", csio_ct_reason(cmd), csio_ct_expl(cmd)); } /* Prepare CT hdr for RHBA cmd */ memset(cmd, 0, FC_CT_HDR_LEN); csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_RHBA); len = FC_CT_HDR_LEN; /* Prepare RHBA payload */ pld = (uint8_t *)csio_ct_get_pld(cmd); hbaid = (struct fc_fdmi_hba_identifier *)pld; memcpy(&hbaid->id, csio_ln_wwpn(ln), 8); /* HBA identifer */ pld += sizeof(*hbaid); /* Register one port per hba */ reg_pl = (struct fc_fdmi_rpl *)pld; reg_pl->numport = htonl(1); memcpy(®_pl->port[0].portname, csio_ln_wwpn(ln), 8); pld += sizeof(*reg_pl); /* Start appending HBA attributes hba */ attrib_blk = (struct fs_fdmi_attrs *)pld; attrib_blk->numattrs = 0; len += sizeof(attrib_blk->numattrs); pld += sizeof(attrib_blk->numattrs); csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_NODENAME, csio_ln_wwnn(ln), FC_FDMI_HBA_ATTR_NODENAME_LEN); numattrs++; memset(buf, 0, sizeof(buf)); strcpy(buf, "Chelsio Communications"); csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MANUFACTURER, buf, strlen(buf)); numattrs++; csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_SERIALNUMBER, hw->vpd.sn, sizeof(hw->vpd.sn)); numattrs++; csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MODEL, hw->vpd.id, sizeof(hw->vpd.id)); numattrs++; csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MODELDESCRIPTION, hw->model_desc, strlen(hw->model_desc)); numattrs++; csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_HARDWAREVERSION, hw->hw_ver, sizeof(hw->hw_ver)); numattrs++; csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_FIRMWAREVERSION, hw->fwrev_str, strlen(hw->fwrev_str)); numattrs++; if (!csio_osname(buf, sizeof(buf))) { csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_OSNAMEVERSION, buf, strlen(buf)); numattrs++; } csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MAXCTPAYLOAD, &maxpayload, FC_FDMI_HBA_ATTR_MAXCTPAYLOAD_LEN); len = (uint32_t)(pld - (uint8_t *)cmd); numattrs++; attrib_blk->numattrs = htonl(numattrs); /* Submit FDMI RHBA request */ spin_lock_irqsave(&hw->lock, flags); if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_rhba_cbfn, FCOE_CT, &fdmi_req->dma_buf, len)) { CSIO_INC_STATS(ln, n_fdmi_err); csio_ln_dbg(ln, "Failed to issue fdmi rhba req\n"); } spin_unlock_irqrestore(&hw->lock, flags); } /* * csio_ln_fdmi_dhba_cbfn - DHBA completion * @hw: HW context * @fdmi_req: fdmi request */ static void csio_ln_fdmi_dhba_cbfn(struct csio_hw *hw, struct csio_ioreq *fdmi_req) { struct csio_lnode *ln = fdmi_req->lnode; void *cmd; struct fc_fdmi_port_name *port_name; uint32_t len; unsigned long flags; if (fdmi_req->wr_status != FW_SUCCESS) { csio_ln_dbg(ln, "WR error:%x in processing fdmi dhba cmd\n", fdmi_req->wr_status); CSIO_INC_STATS(ln, n_fdmi_err); } if (!csio_is_rnode_ready(fdmi_req->rnode)) { CSIO_INC_STATS(ln, n_fdmi_err); return; } cmd = fdmi_req->dma_buf.vaddr; if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) { csio_ln_dbg(ln, "fdmi dhba cmd rejected reason %x expl %x\n", csio_ct_reason(cmd), csio_ct_expl(cmd)); } /* Send FDMI cmd to de-register any Port attributes if registered * before */ /* Prepare FDMI DPRT cmd */ memset(cmd, 0, FC_CT_HDR_LEN); csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_DPRT); len = FC_CT_HDR_LEN; port_name = (struct fc_fdmi_port_name *)csio_ct_get_pld(cmd); memcpy(&port_name->portname, csio_ln_wwpn(ln), 8); len += sizeof(*port_name); /* Submit FDMI request */ spin_lock_irqsave(&hw->lock, flags); if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_dprt_cbfn, FCOE_CT, &fdmi_req->dma_buf, len)) { CSIO_INC_STATS(ln, n_fdmi_err); csio_ln_dbg(ln, "Failed to issue fdmi dprt req\n"); } spin_unlock_irqrestore(&hw->lock, flags); } /** * csio_ln_fdmi_start - Start an FDMI request. * @ln: lnode * @context: session context * * Issued with lock held. */ int csio_ln_fdmi_start(struct csio_lnode *ln, void *context) { struct csio_ioreq *fdmi_req; struct csio_rnode *fdmi_rn = (struct csio_rnode *)context; void *cmd; struct fc_fdmi_hba_identifier *hbaid; uint32_t len; if (!(ln->flags & CSIO_LNF_FDMI_ENABLE)) return -EPROTONOSUPPORT; if (!csio_is_rnode_ready(fdmi_rn)) CSIO_INC_STATS(ln, n_fdmi_err); /* Send FDMI cmd to de-register any HBA attributes if registered * before */ fdmi_req = ln->mgmt_req; fdmi_req->lnode = ln; fdmi_req->rnode = fdmi_rn; /* Prepare FDMI DHBA cmd */ cmd = fdmi_req->dma_buf.vaddr; memset(cmd, 0, FC_CT_HDR_LEN); csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_DHBA); len = FC_CT_HDR_LEN; hbaid = (struct fc_fdmi_hba_identifier *)csio_ct_get_pld(cmd); memcpy(&hbaid->id, csio_ln_wwpn(ln), 8); len += sizeof(*hbaid); /* Submit FDMI request */ if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_dhba_cbfn, FCOE_CT, &fdmi_req->dma_buf, len)) { CSIO_INC_STATS(ln, n_fdmi_err); csio_ln_dbg(ln, "Failed to issue fdmi dhba req\n"); } return 0; } /* * csio_ln_vnp_read_cbfn - vnp read completion handler. * @hw: HW lnode * @cbfn: Completion handler. * * Reads vnp response and updates ln parameters. */ static void csio_ln_vnp_read_cbfn(struct csio_hw *hw, struct csio_mb *mbp) { struct csio_lnode *ln = ((struct csio_lnode *)mbp->priv); struct fw_fcoe_vnp_cmd *rsp = (struct fw_fcoe_vnp_cmd *)(mbp->mb); struct fc_els_csp *csp; struct fc_els_cssp *clsp; enum fw_retval retval; __be32 nport_id = 0; retval = FW_CMD_RETVAL_G(ntohl(rsp->alloc_to_len16)); if (retval != FW_SUCCESS) { csio_err(hw, "FCOE VNP read cmd returned error:0x%x\n", retval); mempool_free(mbp, hw->mb_mempool); return; } spin_lock_irq(&hw->lock); memcpy(ln->mac, rsp->vnport_mac, sizeof(ln->mac)); memcpy(&nport_id, &rsp->vnport_mac[3], sizeof(uint8_t)*3); ln->nport_id = ntohl(nport_id); ln->nport_id = ln->nport_id >> 8; /* Update WWNs */ /* * This may look like a duplication of what csio_fcoe_enable_link() * does, but is absolutely necessary if the vnpi changes between * a FCOE LINK UP and FCOE LINK DOWN. */ memcpy(csio_ln_wwnn(ln), rsp->vnport_wwnn, 8); memcpy(csio_ln_wwpn(ln), rsp->vnport_wwpn, 8); /* Copy common sparam */ csp = (struct fc_els_csp *)rsp->cmn_srv_parms; ln->ln_sparm.csp.sp_hi_ver = csp->sp_hi_ver; ln->ln_sparm.csp.sp_lo_ver = csp->sp_lo_ver; ln->ln_sparm.csp.sp_bb_cred = csp->sp_bb_cred; ln->ln_sparm.csp.sp_features = csp->sp_features; ln->ln_sparm.csp.sp_bb_data = csp->sp_bb_data; ln->ln_sparm.csp.sp_r_a_tov = csp->sp_r_a_tov; ln->ln_sparm.csp.sp_e_d_tov = csp->sp_e_d_tov; /* Copy word 0 & word 1 of class sparam */ clsp = (struct fc_els_cssp *)rsp->clsp_word_0_1; ln->ln_sparm.clsp[2].cp_class = clsp->cp_class; ln->ln_sparm.clsp[2].cp_init = clsp->cp_init; ln->ln_sparm.clsp[2].cp_recip = clsp->cp_recip; ln->ln_sparm.clsp[2].cp_rdfs = clsp->cp_rdfs; spin_unlock_irq(&hw->lock); mempool_free(mbp, hw->mb_mempool); /* Send an event to update local attribs */ csio_lnode_async_event(ln, CSIO_LN_FC_ATTRIB_UPDATE); } /* * csio_ln_vnp_read - Read vnp params. * @ln: lnode * @cbfn: Completion handler. * * Issued with lock held. */ static int csio_ln_vnp_read(struct csio_lnode *ln, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { struct csio_hw *hw = ln->hwp; struct csio_mb *mbp; /* Allocate Mbox request */ mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC); if (!mbp) { CSIO_INC_STATS(hw, n_err_nomem); return -ENOMEM; } /* Prepare VNP Command */ csio_fcoe_vnp_read_init_mb(ln, mbp, CSIO_MB_DEFAULT_TMO, ln->fcf_flowid, ln->vnp_flowid, cbfn); /* Issue MBOX cmd */ if (csio_mb_issue(hw, mbp)) { csio_err(hw, "Failed to issue mbox FCoE VNP command\n"); mempool_free(mbp, hw->mb_mempool); return -EINVAL; } return 0; } /* * csio_fcoe_enable_link - Enable fcoe link. * @ln: lnode * @enable: enable/disable * Issued with lock held. * Issues mbox cmd to bring up FCOE link on port associated with given ln. */ static int csio_fcoe_enable_link(struct csio_lnode *ln, bool enable) { struct csio_hw *hw = ln->hwp; struct csio_mb *mbp; enum fw_retval retval; uint8_t portid; uint8_t sub_op; struct fw_fcoe_link_cmd *lcmd; int i; mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC); if (!mbp) { CSIO_INC_STATS(hw, n_err_nomem); return -ENOMEM; } portid = ln->portid; sub_op = enable ? FCOE_LINK_UP : FCOE_LINK_DOWN; csio_dbg(hw, "bringing FCOE LINK %s on Port:%d\n", sub_op ? "UP" : "DOWN", portid); csio_write_fcoe_link_cond_init_mb(ln, mbp, CSIO_MB_DEFAULT_TMO, portid, sub_op, 0, 0, 0, NULL); if (csio_mb_issue(hw, mbp)) { csio_err(hw, "failed to issue FCOE LINK cmd on port[%d]\n", portid); mempool_free(mbp, hw->mb_mempool); return -EINVAL; } retval = csio_mb_fw_retval(mbp); if (retval != FW_SUCCESS) { csio_err(hw, "FCOE LINK %s cmd on port[%d] failed with " "ret:x%x\n", sub_op ? "UP" : "DOWN", portid, retval); mempool_free(mbp, hw->mb_mempool); return -EINVAL; } if (!enable) goto out; lcmd = (struct fw_fcoe_link_cmd *)mbp->mb; memcpy(csio_ln_wwnn(ln), lcmd->vnport_wwnn, 8); memcpy(csio_ln_wwpn(ln), lcmd->vnport_wwpn, 8); for (i = 0; i < CSIO_MAX_PPORTS; i++) if (hw->pport[i].portid == portid) memcpy(hw->pport[i].mac, lcmd->phy_mac, 6); out: mempool_free(mbp, hw->mb_mempool); return 0; } /* * csio_ln_read_fcf_cbfn - Read fcf parameters * @ln: lnode * * read fcf response and Update ln fcf information. */ static void csio_ln_read_fcf_cbfn(struct csio_hw *hw, struct csio_mb *mbp) { struct csio_lnode *ln = (struct csio_lnode *)mbp->priv; struct csio_fcf_info *fcf_info; struct fw_fcoe_fcf_cmd *rsp = (struct fw_fcoe_fcf_cmd *)(mbp->mb); enum fw_retval retval; retval = FW_CMD_RETVAL_G(ntohl(rsp->retval_len16)); if (retval != FW_SUCCESS) { csio_ln_err(ln, "FCOE FCF cmd failed with ret x%x\n", retval); mempool_free(mbp, hw->mb_mempool); return; } spin_lock_irq(&hw->lock); fcf_info = ln->fcfinfo; fcf_info->priority = FW_FCOE_FCF_CMD_PRIORITY_GET( ntohs(rsp->priority_pkd)); fcf_info->vf_id = ntohs(rsp->vf_id); fcf_info->vlan_id = rsp->vlan_id; fcf_info->max_fcoe_size = ntohs(rsp->max_fcoe_size); fcf_info->fka_adv = be32_to_cpu(rsp->fka_adv); fcf_info->fcfi = FW_FCOE_FCF_CMD_FCFI_GET(ntohl(rsp->op_to_fcfi)); fcf_info->fpma = FW_FCOE_FCF_CMD_FPMA_GET(rsp->fpma_to_portid); fcf_info->spma = FW_FCOE_FCF_CMD_SPMA_GET(rsp->fpma_to_portid); fcf_info->login = FW_FCOE_FCF_CMD_LOGIN_GET(rsp->fpma_to_portid); fcf_info->portid = FW_FCOE_FCF_CMD_PORTID_GET(rsp->fpma_to_portid); memcpy(fcf_info->fc_map, rsp->fc_map, sizeof(fcf_info->fc_map)); memcpy(fcf_info->mac, rsp->mac, sizeof(fcf_info->mac)); memcpy(fcf_info->name_id, rsp->name_id, sizeof(fcf_info->name_id)); memcpy(fcf_info->fabric, rsp->fabric, sizeof(fcf_info->fabric)); memcpy(fcf_info->spma_mac, rsp->spma_mac, sizeof(fcf_info->spma_mac)); spin_unlock_irq(&hw->lock); mempool_free(mbp, hw->mb_mempool); } /* * csio_ln_read_fcf_entry - Read fcf entry. * @ln: lnode * @cbfn: Completion handler. * * Issued with lock held. */ static int csio_ln_read_fcf_entry(struct csio_lnode *ln, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { struct csio_hw *hw = ln->hwp; struct csio_mb *mbp; mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC); if (!mbp) { CSIO_INC_STATS(hw, n_err_nomem); return -ENOMEM; } /* Get FCoE FCF information */ csio_fcoe_read_fcf_init_mb(ln, mbp, CSIO_MB_DEFAULT_TMO, ln->portid, ln->fcf_flowid, cbfn); if (csio_mb_issue(hw, mbp)) { csio_err(hw, "failed to issue FCOE FCF cmd\n"); mempool_free(mbp, hw->mb_mempool); return -EINVAL; } return 0; } /* * csio_handle_link_up - Logical Linkup event. * @hw - HW module. * @portid - Physical port number * @fcfi - FCF index. * @vnpi - VNP index. * Returns - none. * * This event is received from FW, when virtual link is established between * Physical port[ENode] and FCF. If its new vnpi, then local node object is * created on this FCF and set to [ONLINE] state. * Lnode waits for FW_RDEV_CMD event to be received indicating that * Fabric login is completed and lnode moves to [READY] state. * * This called with hw lock held */ static void csio_handle_link_up(struct csio_hw *hw, uint8_t portid, uint32_t fcfi, uint32_t vnpi) { struct csio_lnode *ln = NULL; /* Lookup lnode based on vnpi */ ln = csio_ln_lookup_by_vnpi(hw, vnpi); if (!ln) { /* Pick lnode based on portid */ ln = csio_ln_lookup_by_portid(hw, portid); if (!ln) { csio_err(hw, "failed to lookup fcoe lnode on port:%d\n", portid); CSIO_DB_ASSERT(0); return; } /* Check if lnode has valid vnp flowid */ if (ln->vnp_flowid != CSIO_INVALID_IDX) { /* New VN-Port */ spin_unlock_irq(&hw->lock); csio_lnode_alloc(hw); spin_lock_irq(&hw->lock); if (!ln) { csio_err(hw, "failed to allocate fcoe lnode" "for port:%d vnpi:x%x\n", portid, vnpi); CSIO_DB_ASSERT(0); return; } ln->portid = portid; } ln->vnp_flowid = vnpi; ln->dev_num &= ~0xFFFF; ln->dev_num |= vnpi; } /*Initialize fcfi */ ln->fcf_flowid = fcfi; csio_info(hw, "Port:%d - FCOE LINK UP\n", portid); CSIO_INC_STATS(ln, n_link_up); /* Send LINKUP event to SM */ csio_post_event(&ln->sm, CSIO_LNE_LINKUP); } /* * csio_post_event_rns * @ln - FCOE lnode * @evt - Given rnode event * Returns - none * * Posts given rnode event to all FCOE rnodes connected with given Lnode. * This routine is invoked when lnode receives LINK_DOWN/DOWN_LINK/CLOSE * event. * * This called with hw lock held */ static void csio_post_event_rns(struct csio_lnode *ln, enum csio_rn_ev evt) { struct csio_rnode *rnhead = (struct csio_rnode *) &ln->rnhead; struct list_head *tmp, *next; struct csio_rnode *rn; list_for_each_safe(tmp, next, &rnhead->sm.sm_list) { rn = (struct csio_rnode *) tmp; csio_post_event(&rn->sm, evt); } } /* * csio_cleanup_rns * @ln - FCOE lnode * Returns - none * * Frees all FCOE rnodes connected with given Lnode. * * This called with hw lock held */ static void csio_cleanup_rns(struct csio_lnode *ln) { struct csio_rnode *rnhead = (struct csio_rnode *) &ln->rnhead; struct list_head *tmp, *next_rn; struct csio_rnode *rn; list_for_each_safe(tmp, next_rn, &rnhead->sm.sm_list) { rn = (struct csio_rnode *) tmp; csio_put_rnode(ln, rn); } } /* * csio_post_event_lns * @ln - FCOE lnode * @evt - Given lnode event * Returns - none * * Posts given lnode event to all FCOE lnodes connected with given Lnode. * This routine is invoked when lnode receives LINK_DOWN/DOWN_LINK/CLOSE * event. * * This called with hw lock held */ static void csio_post_event_lns(struct csio_lnode *ln, enum csio_ln_ev evt) { struct list_head *tmp; struct csio_lnode *cln, *sln; /* If NPIV lnode, send evt only to that and return */ if (csio_is_npiv_ln(ln)) { csio_post_event(&ln->sm, evt); return; } sln = ln; /* Traverse children lnodes list and send evt */ list_for_each(tmp, &sln->cln_head) { cln = (struct csio_lnode *) tmp; csio_post_event(&cln->sm, evt); } /* Send evt to parent lnode */ csio_post_event(&ln->sm, evt); } /* * csio_ln_down - Lcoal nport is down * @ln - FCOE Lnode * Returns - none * * Sends LINK_DOWN events to Lnode and its associated NPIVs lnodes. * * This called with hw lock held */ static void csio_ln_down(struct csio_lnode *ln) { csio_post_event_lns(ln, CSIO_LNE_LINK_DOWN); } /* * csio_handle_link_down - Logical Linkdown event. * @hw - HW module. * @portid - Physical port number * @fcfi - FCF index. * @vnpi - VNP index. * Returns - none * * This event is received from FW, when virtual link goes down between * Physical port[ENode] and FCF. Lnode and its associated NPIVs lnode hosted on * this vnpi[VN-Port] will be de-instantiated. * * This called with hw lock held */ static void csio_handle_link_down(struct csio_hw *hw, uint8_t portid, uint32_t fcfi, uint32_t vnpi) { struct csio_fcf_info *fp; struct csio_lnode *ln; /* Lookup lnode based on vnpi */ ln = csio_ln_lookup_by_vnpi(hw, vnpi); if (ln) { fp = ln->fcfinfo; CSIO_INC_STATS(ln, n_link_down); /*Warn if linkdown received if lnode is not in ready state */ if (!csio_is_lnode_ready(ln)) { csio_ln_warn(ln, "warn: FCOE link is already in offline " "Ignoring Fcoe linkdown event on portid %d\n", portid); CSIO_INC_STATS(ln, n_evt_drop); return; } /* Verify portid */ if (fp->portid != portid) { csio_ln_warn(ln, "warn: FCOE linkdown recv with " "invalid port %d\n", portid); CSIO_INC_STATS(ln, n_evt_drop); return; } /* verify fcfi */ if (ln->fcf_flowid != fcfi) { csio_ln_warn(ln, "warn: FCOE linkdown recv with " "invalid fcfi x%x\n", fcfi); CSIO_INC_STATS(ln, n_evt_drop); return; } csio_info(hw, "Port:%d - FCOE LINK DOWN\n", portid); /* Send LINK_DOWN event to lnode s/m */ csio_ln_down(ln); return; } else { csio_warn(hw, "warn: FCOE linkdown recv with invalid vnpi x%x\n", vnpi); CSIO_INC_STATS(hw, n_evt_drop); } } /* * csio_is_lnode_ready - Checks FCOE lnode is in ready state. * @ln: Lnode module * * Returns True if FCOE lnode is in ready state. */ int csio_is_lnode_ready(struct csio_lnode *ln) { return (csio_get_state(ln) == ((csio_sm_state_t)csio_lns_ready)); } /*****************************************************************************/ /* START: Lnode SM */ /*****************************************************************************/ /* * csio_lns_uninit - The request in uninit state. * @ln - FCOE lnode. * @evt - Event to be processed. * * Process the given lnode event which is currently in "uninit" state. * Invoked with HW lock held. * Return - none. */ static void csio_lns_uninit(struct csio_lnode *ln, enum csio_ln_ev evt) { struct csio_hw *hw = csio_lnode_to_hw(ln); struct csio_lnode *rln = hw->rln; int rv; CSIO_INC_STATS(ln, n_evt_sm[evt]); switch (evt) { case CSIO_LNE_LINKUP: csio_set_state(&ln->sm, csio_lns_online); /* Read FCF only for physical lnode */ if (csio_is_phys_ln(ln)) { rv = csio_ln_read_fcf_entry(ln, csio_ln_read_fcf_cbfn); if (rv != 0) { /* TODO: Send HW RESET event */ CSIO_INC_STATS(ln, n_err); break; } /* Add FCF record */ list_add_tail(&ln->fcfinfo->list, &rln->fcf_lsthead); } rv = csio_ln_vnp_read(ln, csio_ln_vnp_read_cbfn); if (rv != 0) { /* TODO: Send HW RESET event */ CSIO_INC_STATS(ln, n_err); } break; case CSIO_LNE_DOWN_LINK: break; default: csio_ln_dbg(ln, "unexp ln event %d recv from did:x%x in " "ln state[uninit].\n", evt, ln->nport_id); CSIO_INC_STATS(ln, n_evt_unexp); break; } /* switch event */ } /* * csio_lns_online - The request in online state. * @ln - FCOE lnode. * @evt - Event to be processed. * * Process the given lnode event which is currently in "online" state. * Invoked with HW lock held. * Return - none. */ static void csio_lns_online(struct csio_lnode *ln, enum csio_ln_ev evt) { struct csio_hw *hw = csio_lnode_to_hw(ln); CSIO_INC_STATS(ln, n_evt_sm[evt]); switch (evt) { case CSIO_LNE_LINKUP: csio_ln_warn(ln, "warn: FCOE link is up already " "Ignoring linkup on port:%d\n", ln->portid); CSIO_INC_STATS(ln, n_evt_drop); break; case CSIO_LNE_FAB_INIT_DONE: csio_set_state(&ln->sm, csio_lns_ready); spin_unlock_irq(&hw->lock); csio_lnode_async_event(ln, CSIO_LN_FC_LINKUP); spin_lock_irq(&hw->lock); break; case CSIO_LNE_LINK_DOWN: /* Fall through */ case CSIO_LNE_DOWN_LINK: csio_set_state(&ln->sm, csio_lns_uninit); if (csio_is_phys_ln(ln)) { /* Remove FCF entry */ list_del_init(&ln->fcfinfo->list); } break; default: csio_ln_dbg(ln, "unexp ln event %d recv from did:x%x in " "ln state[uninit].\n", evt, ln->nport_id); CSIO_INC_STATS(ln, n_evt_unexp); break; } /* switch event */ } /* * csio_lns_ready - The request in ready state. * @ln - FCOE lnode. * @evt - Event to be processed. * * Process the given lnode event which is currently in "ready" state. * Invoked with HW lock held. * Return - none. */ static void csio_lns_ready(struct csio_lnode *ln, enum csio_ln_ev evt) { struct csio_hw *hw = csio_lnode_to_hw(ln); CSIO_INC_STATS(ln, n_evt_sm[evt]); switch (evt) { case CSIO_LNE_FAB_INIT_DONE: csio_ln_dbg(ln, "ignoring event %d recv from did x%x" "in ln state[ready].\n", evt, ln->nport_id); CSIO_INC_STATS(ln, n_evt_drop); break; case CSIO_LNE_LINK_DOWN: csio_set_state(&ln->sm, csio_lns_offline); csio_post_event_rns(ln, CSIO_RNFE_DOWN); spin_unlock_irq(&hw->lock); csio_lnode_async_event(ln, CSIO_LN_FC_LINKDOWN); spin_lock_irq(&hw->lock); if (csio_is_phys_ln(ln)) { /* Remove FCF entry */ list_del_init(&ln->fcfinfo->list); } break; case CSIO_LNE_DOWN_LINK: csio_set_state(&ln->sm, csio_lns_offline); csio_post_event_rns(ln, CSIO_RNFE_DOWN); /* Host need to issue aborts in case if FW has not returned * WRs with status "ABORTED" */ spin_unlock_irq(&hw->lock); csio_lnode_async_event(ln, CSIO_LN_FC_LINKDOWN); spin_lock_irq(&hw->lock); if (csio_is_phys_ln(ln)) { /* Remove FCF entry */ list_del_init(&ln->fcfinfo->list); } break; case CSIO_LNE_CLOSE: csio_set_state(&ln->sm, csio_lns_uninit); csio_post_event_rns(ln, CSIO_RNFE_CLOSE); break; case CSIO_LNE_LOGO: csio_set_state(&ln->sm, csio_lns_offline); csio_post_event_rns(ln, CSIO_RNFE_DOWN); break; default: csio_ln_dbg(ln, "unexp ln event %d recv from did:x%x in " "ln state[uninit].\n", evt, ln->nport_id); CSIO_INC_STATS(ln, n_evt_unexp); CSIO_DB_ASSERT(0); break; } /* switch event */ } /* * csio_lns_offline - The request in offline state. * @ln - FCOE lnode. * @evt - Event to be processed. * * Process the given lnode event which is currently in "offline" state. * Invoked with HW lock held. * Return - none. */ static void csio_lns_offline(struct csio_lnode *ln, enum csio_ln_ev evt) { struct csio_hw *hw = csio_lnode_to_hw(ln); struct csio_lnode *rln = hw->rln; int rv; CSIO_INC_STATS(ln, n_evt_sm[evt]); switch (evt) { case CSIO_LNE_LINKUP: csio_set_state(&ln->sm, csio_lns_online); /* Read FCF only for physical lnode */ if (csio_is_phys_ln(ln)) { rv = csio_ln_read_fcf_entry(ln, csio_ln_read_fcf_cbfn); if (rv != 0) { /* TODO: Send HW RESET event */ CSIO_INC_STATS(ln, n_err); break; } /* Add FCF record */ list_add_tail(&ln->fcfinfo->list, &rln->fcf_lsthead); } rv = csio_ln_vnp_read(ln, csio_ln_vnp_read_cbfn); if (rv != 0) { /* TODO: Send HW RESET event */ CSIO_INC_STATS(ln, n_err); } break; case CSIO_LNE_LINK_DOWN: case CSIO_LNE_DOWN_LINK: case CSIO_LNE_LOGO: csio_ln_dbg(ln, "ignoring event %d recv from did x%x" "in ln state[offline].\n", evt, ln->nport_id); CSIO_INC_STATS(ln, n_evt_drop); break; case CSIO_LNE_CLOSE: csio_set_state(&ln->sm, csio_lns_uninit); csio_post_event_rns(ln, CSIO_RNFE_CLOSE); break; default: csio_ln_dbg(ln, "unexp ln event %d recv from did:x%x in " "ln state[offline]\n", evt, ln->nport_id); CSIO_INC_STATS(ln, n_evt_unexp); CSIO_DB_ASSERT(0); break; } /* switch event */ } /*****************************************************************************/ /* END: Lnode SM */ /*****************************************************************************/ static void csio_free_fcfinfo(struct kref *kref) { struct csio_fcf_info *fcfinfo = container_of(kref, struct csio_fcf_info, kref); kfree(fcfinfo); } /* Helper routines for attributes */ /* * csio_lnode_state_to_str - Get current state of FCOE lnode. * @ln - lnode * @str - state of lnode. * */ void csio_lnode_state_to_str(struct csio_lnode *ln, int8_t *str) { if (csio_get_state(ln) == ((csio_sm_state_t)csio_lns_uninit)) { strcpy(str, "UNINIT"); return; } if (csio_get_state(ln) == ((csio_sm_state_t)csio_lns_ready)) { strcpy(str, "READY"); return; } if (csio_get_state(ln) == ((csio_sm_state_t)csio_lns_offline)) { strcpy(str, "OFFLINE"); return; } strcpy(str, "UNKNOWN"); } /* csio_lnode_state_to_str */ int csio_get_phy_port_stats(struct csio_hw *hw, uint8_t portid, struct fw_fcoe_port_stats *port_stats) { struct csio_mb *mbp; struct fw_fcoe_port_cmd_params portparams; enum fw_retval retval; int idx; mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC); if (!mbp) { csio_err(hw, "FCoE FCF PARAMS command out of memory!\n"); return -EINVAL; } portparams.portid = portid; for (idx = 1; idx <= 3; idx++) { portparams.idx = (idx-1)*6 + 1; portparams.nstats = 6; if (idx == 3) portparams.nstats = 4; csio_fcoe_read_portparams_init_mb(hw, mbp, CSIO_MB_DEFAULT_TMO, &portparams, NULL); if (csio_mb_issue(hw, mbp)) { csio_err(hw, "Issue of FCoE port params failed!\n"); mempool_free(mbp, hw->mb_mempool); return -EINVAL; } csio_mb_process_portparams_rsp(hw, mbp, &retval, &portparams, port_stats); } mempool_free(mbp, hw->mb_mempool); return 0; } /* * csio_ln_mgmt_wr_handler -Mgmt Work Request handler. * @wr - WR. * @len - WR len. * This handler is invoked when an outstanding mgmt WR is completed. * Its invoked in the context of FW event worker thread for every * mgmt event received. * Return - none. */ static void csio_ln_mgmt_wr_handler(struct csio_hw *hw, void *wr, uint32_t len) { struct csio_mgmtm *mgmtm = csio_hw_to_mgmtm(hw); struct csio_ioreq *io_req = NULL; struct fw_fcoe_els_ct_wr *wr_cmd; wr_cmd = (struct fw_fcoe_els_ct_wr *) wr; if (len < sizeof(struct fw_fcoe_els_ct_wr)) { csio_err(mgmtm->hw, "Invalid ELS CT WR length recvd, len:%x\n", len); mgmtm->stats.n_err++; return; } io_req = (struct csio_ioreq *) ((uintptr_t) wr_cmd->cookie); io_req->wr_status = csio_wr_status(wr_cmd); /* lookup ioreq exists in our active Q */ spin_lock_irq(&hw->lock); if (csio_mgmt_req_lookup(mgmtm, io_req) != 0) { csio_err(mgmtm->hw, "Error- Invalid IO handle recv in WR. handle: %p\n", io_req); mgmtm->stats.n_err++; spin_unlock_irq(&hw->lock); return; } mgmtm = csio_hw_to_mgmtm(hw); /* Dequeue from active queue */ list_del_init(&io_req->sm.sm_list); mgmtm->stats.n_active--; spin_unlock_irq(&hw->lock); /* io_req will be freed by completion handler */ if (io_req->io_cbfn) io_req->io_cbfn(hw, io_req); } /** * csio_fcoe_fwevt_handler - Event handler for Firmware FCoE events. * @hw: HW module * @cpl_op: CPL opcode * @cmd: FW cmd/WR. * * Process received FCoE cmd/WR event from FW. */ void csio_fcoe_fwevt_handler(struct csio_hw *hw, __u8 cpl_op, __be64 *cmd) { struct csio_lnode *ln; struct csio_rnode *rn; uint8_t portid, opcode = *(uint8_t *)cmd; struct fw_fcoe_link_cmd *lcmd; struct fw_wr_hdr *wr; struct fw_rdev_wr *rdev_wr; enum fw_fcoe_link_status lstatus; uint32_t fcfi, rdev_flowid, vnpi; enum csio_ln_ev evt; if (cpl_op == CPL_FW6_MSG && opcode == FW_FCOE_LINK_CMD) { lcmd = (struct fw_fcoe_link_cmd *)cmd; lstatus = lcmd->lstatus; portid = FW_FCOE_LINK_CMD_PORTID_GET( ntohl(lcmd->op_to_portid)); fcfi = FW_FCOE_LINK_CMD_FCFI_GET(ntohl(lcmd->sub_opcode_fcfi)); vnpi = FW_FCOE_LINK_CMD_VNPI_GET(ntohl(lcmd->vnpi_pkd)); if (lstatus == FCOE_LINKUP) { /* HW lock here */ spin_lock_irq(&hw->lock); csio_handle_link_up(hw, portid, fcfi, vnpi); spin_unlock_irq(&hw->lock); /* HW un lock here */ } else if (lstatus == FCOE_LINKDOWN) { /* HW lock here */ spin_lock_irq(&hw->lock); csio_handle_link_down(hw, portid, fcfi, vnpi); spin_unlock_irq(&hw->lock); /* HW un lock here */ } else { csio_warn(hw, "Unexpected FCOE LINK status:0x%x\n", lcmd->lstatus); CSIO_INC_STATS(hw, n_cpl_unexp); } } else if (cpl_op == CPL_FW6_PLD) { wr = (struct fw_wr_hdr *) (cmd + 4); if (FW_WR_OP_G(be32_to_cpu(wr->hi)) == FW_RDEV_WR) { rdev_wr = (struct fw_rdev_wr *) (cmd + 4); rdev_flowid = FW_RDEV_WR_FLOWID_GET( ntohl(rdev_wr->alloc_to_len16)); vnpi = FW_RDEV_WR_ASSOC_FLOWID_GET( ntohl(rdev_wr->flags_to_assoc_flowid)); csio_dbg(hw, "FW_RDEV_WR: flowid:x%x ev_cause:x%x " "vnpi:0x%x\n", rdev_flowid, rdev_wr->event_cause, vnpi); if (rdev_wr->protocol != PROT_FCOE) { csio_err(hw, "FW_RDEV_WR: invalid proto:x%x " "received with flowid:x%x\n", rdev_wr->protocol, rdev_flowid); CSIO_INC_STATS(hw, n_evt_drop); return; } /* HW lock here */ spin_lock_irq(&hw->lock); ln = csio_ln_lookup_by_vnpi(hw, vnpi); if (!ln) { csio_err(hw, "FW_DEV_WR: invalid vnpi:x%x received " "with flowid:x%x\n", vnpi, rdev_flowid); CSIO_INC_STATS(hw, n_evt_drop); goto out_pld; } rn = csio_confirm_rnode(ln, rdev_flowid, &rdev_wr->u.fcoe_rdev); if (!rn) { csio_ln_dbg(ln, "Failed to confirm rnode " "for flowid:x%x\n", rdev_flowid); CSIO_INC_STATS(hw, n_evt_drop); goto out_pld; } /* save previous event for debugging */ ln->prev_evt = ln->cur_evt; ln->cur_evt = rdev_wr->event_cause; CSIO_INC_STATS(ln, n_evt_fw[rdev_wr->event_cause]); /* Translate all the fabric events to lnode SM events */ evt = CSIO_FWE_TO_LNE(rdev_wr->event_cause); if (evt) { csio_ln_dbg(ln, "Posting event to lnode event:%d " "cause:%d flowid:x%x\n", evt, rdev_wr->event_cause, rdev_flowid); csio_post_event(&ln->sm, evt); } /* Handover event to rn SM here. */ csio_rnode_fwevt_handler(rn, rdev_wr->event_cause); out_pld: spin_unlock_irq(&hw->lock); return; } else { csio_warn(hw, "unexpected WR op(0x%x) recv\n", FW_WR_OP_G(be32_to_cpu((wr->hi)))); CSIO_INC_STATS(hw, n_cpl_unexp); } } else if (cpl_op == CPL_FW6_MSG) { wr = (struct fw_wr_hdr *) (cmd); if (FW_WR_OP_G(be32_to_cpu(wr->hi)) == FW_FCOE_ELS_CT_WR) { csio_ln_mgmt_wr_handler(hw, wr, sizeof(struct fw_fcoe_els_ct_wr)); } else { csio_warn(hw, "unexpected WR op(0x%x) recv\n", FW_WR_OP_G(be32_to_cpu((wr->hi)))); CSIO_INC_STATS(hw, n_cpl_unexp); } } else { csio_warn(hw, "unexpected CPL op(0x%x) recv\n", opcode); CSIO_INC_STATS(hw, n_cpl_unexp); } } /** * csio_lnode_start - Kickstart lnode discovery. * @ln: lnode * * This routine kickstarts the discovery by issuing an FCOE_LINK (up) command. */ int csio_lnode_start(struct csio_lnode *ln) { int rv = 0; if (csio_is_phys_ln(ln) && !(ln->flags & CSIO_LNF_LINK_ENABLE)) { rv = csio_fcoe_enable_link(ln, 1); ln->flags |= CSIO_LNF_LINK_ENABLE; } return rv; } /** * csio_lnode_stop - Stop the lnode. * @ln: lnode * * This routine is invoked by HW module to stop lnode and its associated NPIV * lnodes. */ void csio_lnode_stop(struct csio_lnode *ln) { csio_post_event_lns(ln, CSIO_LNE_DOWN_LINK); if (csio_is_phys_ln(ln) && (ln->flags & CSIO_LNF_LINK_ENABLE)) { csio_fcoe_enable_link(ln, 0); ln->flags &= ~CSIO_LNF_LINK_ENABLE; } csio_ln_dbg(ln, "stopping ln :%p\n", ln); } /** * csio_lnode_close - Close an lnode. * @ln: lnode * * This routine is invoked by HW module to close an lnode and its * associated NPIV lnodes. Lnode and its associated NPIV lnodes are * set to uninitialized state. */ void csio_lnode_close(struct csio_lnode *ln) { csio_post_event_lns(ln, CSIO_LNE_CLOSE); if (csio_is_phys_ln(ln)) ln->vnp_flowid = CSIO_INVALID_IDX; csio_ln_dbg(ln, "closed ln :%p\n", ln); } /* * csio_ln_prep_ecwr - Prepare ELS/CT WR. * @io_req - IO request. * @wr_len - WR len * @immd_len - WR immediate data * @sub_op - Sub opcode * @sid - source portid. * @did - destination portid * @flow_id - flowid * @fw_wr - ELS/CT WR to be prepared. * Returns: 0 - on success */ static int csio_ln_prep_ecwr(struct csio_ioreq *io_req, uint32_t wr_len, uint32_t immd_len, uint8_t sub_op, uint32_t sid, uint32_t did, uint32_t flow_id, uint8_t *fw_wr) { struct fw_fcoe_els_ct_wr *wr; __be32 port_id; wr = (struct fw_fcoe_els_ct_wr *)fw_wr; wr->op_immdlen = cpu_to_be32(FW_WR_OP_V(FW_FCOE_ELS_CT_WR) | FW_FCOE_ELS_CT_WR_IMMDLEN(immd_len)); wr_len = DIV_ROUND_UP(wr_len, 16); wr->flowid_len16 = cpu_to_be32(FW_WR_FLOWID_V(flow_id) | FW_WR_LEN16_V(wr_len)); wr->els_ct_type = sub_op; wr->ctl_pri = 0; wr->cp_en_class = 0; wr->cookie = io_req->fw_handle; wr->iqid = cpu_to_be16(csio_q_physiqid( io_req->lnode->hwp, io_req->iq_idx)); wr->fl_to_sp = FW_FCOE_ELS_CT_WR_SP(1); wr->tmo_val = (uint8_t) io_req->tmo; port_id = htonl(sid); memcpy(wr->l_id, PORT_ID_PTR(port_id), 3); port_id = htonl(did); memcpy(wr->r_id, PORT_ID_PTR(port_id), 3); /* Prepare RSP SGL */ wr->rsp_dmalen = cpu_to_be32(io_req->dma_buf.len); wr->rsp_dmaaddr = cpu_to_be64(io_req->dma_buf.paddr); return 0; } /* * csio_ln_mgmt_submit_wr - Post elsct work request. * @mgmtm - mgmtm * @io_req - io request. * @sub_op - ELS or CT request type * @pld - Dma Payload buffer * @pld_len - Payload len * Prepares ELSCT Work request and sents it to FW. * Returns: 0 - on success */ static int csio_ln_mgmt_submit_wr(struct csio_mgmtm *mgmtm, struct csio_ioreq *io_req, uint8_t sub_op, struct csio_dma_buf *pld, uint32_t pld_len) { struct csio_wr_pair wrp; struct csio_lnode *ln = io_req->lnode; struct csio_rnode *rn = io_req->rnode; struct csio_hw *hw = mgmtm->hw; uint8_t fw_wr[64]; struct ulptx_sgl dsgl; uint32_t wr_size = 0; uint8_t im_len = 0; uint32_t wr_off = 0; int ret = 0; /* Calculate WR Size for this ELS REQ */ wr_size = sizeof(struct fw_fcoe_els_ct_wr); /* Send as immediate data if pld < 256 */ if (pld_len < 256) { wr_size += ALIGN(pld_len, 8); im_len = (uint8_t)pld_len; } else wr_size += sizeof(struct ulptx_sgl); /* Roundup WR size in units of 16 bytes */ wr_size = ALIGN(wr_size, 16); /* Get WR to send ELS REQ */ ret = csio_wr_get(hw, mgmtm->eq_idx, wr_size, &wrp); if (ret != 0) { csio_err(hw, "Failed to get WR for ec_req %p ret:%d\n", io_req, ret); return ret; } /* Prepare Generic WR used by all ELS/CT cmd */ csio_ln_prep_ecwr(io_req, wr_size, im_len, sub_op, ln->nport_id, rn->nport_id, csio_rn_flowid(rn), &fw_wr[0]); /* Copy ELS/CT WR CMD */ csio_wr_copy_to_wrp(&fw_wr[0], &wrp, wr_off, sizeof(struct fw_fcoe_els_ct_wr)); wr_off += sizeof(struct fw_fcoe_els_ct_wr); /* Copy payload to Immediate section of WR */ if (im_len) csio_wr_copy_to_wrp(pld->vaddr, &wrp, wr_off, im_len); else { /* Program DSGL to dma payload */ dsgl.cmd_nsge = htonl(ULPTX_CMD_V(ULP_TX_SC_DSGL) | ULPTX_MORE_F | ULPTX_NSGE_V(1)); dsgl.len0 = cpu_to_be32(pld_len); dsgl.addr0 = cpu_to_be64(pld->paddr); csio_wr_copy_to_wrp(&dsgl, &wrp, ALIGN(wr_off, 8), sizeof(struct ulptx_sgl)); } /* Issue work request to xmit ELS/CT req to FW */ csio_wr_issue(mgmtm->hw, mgmtm->eq_idx, false); return ret; } /* * csio_ln_mgmt_submit_req - Submit FCOE Mgmt request. * @io_req - IO Request * @io_cbfn - Completion handler. * @req_type - ELS or CT request type * @pld - Dma Payload buffer * @pld_len - Payload len * * * This API used submit managment ELS/CT request. * This called with hw lock held * Returns: 0 - on success * -ENOMEM - on error. */ static int csio_ln_mgmt_submit_req(struct csio_ioreq *io_req, void (*io_cbfn) (struct csio_hw *, struct csio_ioreq *), enum fcoe_cmn_type req_type, struct csio_dma_buf *pld, uint32_t pld_len) { struct csio_hw *hw = csio_lnode_to_hw(io_req->lnode); struct csio_mgmtm *mgmtm = csio_hw_to_mgmtm(hw); int rv; BUG_ON(pld_len > pld->len); io_req->io_cbfn = io_cbfn; /* Upper layer callback handler */ io_req->fw_handle = (uintptr_t) (io_req); io_req->eq_idx = mgmtm->eq_idx; io_req->iq_idx = mgmtm->iq_idx; rv = csio_ln_mgmt_submit_wr(mgmtm, io_req, req_type, pld, pld_len); if (rv == 0) { list_add_tail(&io_req->sm.sm_list, &mgmtm->active_q); mgmtm->stats.n_active++; } return rv; } /* * csio_ln_fdmi_init - FDMI Init entry point. * @ln: lnode */ static int csio_ln_fdmi_init(struct csio_lnode *ln) { struct csio_hw *hw = csio_lnode_to_hw(ln); struct csio_dma_buf *dma_buf; /* Allocate MGMT request required for FDMI */ ln->mgmt_req = kzalloc(sizeof(struct csio_ioreq), GFP_KERNEL); if (!ln->mgmt_req) { csio_ln_err(ln, "Failed to alloc ioreq for FDMI\n"); CSIO_INC_STATS(hw, n_err_nomem); return -ENOMEM; } /* Allocate Dma buffers for FDMI response Payload */ dma_buf = &ln->mgmt_req->dma_buf; dma_buf->len = 2048; dma_buf->vaddr = pci_alloc_consistent(hw->pdev, dma_buf->len, &dma_buf->paddr); if (!dma_buf->vaddr) { csio_err(hw, "Failed to alloc DMA buffer for FDMI!\n"); kfree(ln->mgmt_req); ln->mgmt_req = NULL; return -ENOMEM; } ln->flags |= CSIO_LNF_FDMI_ENABLE; return 0; } /* * csio_ln_fdmi_exit - FDMI exit entry point. * @ln: lnode */ static int csio_ln_fdmi_exit(struct csio_lnode *ln) { struct csio_dma_buf *dma_buf; struct csio_hw *hw = csio_lnode_to_hw(ln); if (!ln->mgmt_req) return 0; dma_buf = &ln->mgmt_req->dma_buf; if (dma_buf->vaddr) pci_free_consistent(hw->pdev, dma_buf->len, dma_buf->vaddr, dma_buf->paddr); kfree(ln->mgmt_req); return 0; } int csio_scan_done(struct csio_lnode *ln, unsigned long ticks, unsigned long time, unsigned long max_scan_ticks, unsigned long delta_scan_ticks) { int rv = 0; if (time >= max_scan_ticks) return 1; if (!ln->tgt_scan_tick) ln->tgt_scan_tick = ticks; if (((ticks - ln->tgt_scan_tick) >= delta_scan_ticks)) { if (!ln->last_scan_ntgts) ln->last_scan_ntgts = ln->n_scsi_tgts; else { if (ln->last_scan_ntgts == ln->n_scsi_tgts) return 1; ln->last_scan_ntgts = ln->n_scsi_tgts; } ln->tgt_scan_tick = ticks; } return rv; } /* * csio_notify_lnodes: * @hw: HW module * @note: Notification * * Called from the HW SM to fan out notifications to the * Lnode SM. Since the HW SM is entered with lock held, * there is no need to hold locks here. * */ void csio_notify_lnodes(struct csio_hw *hw, enum csio_ln_notify note) { struct list_head *tmp; struct csio_lnode *ln; csio_dbg(hw, "Notifying all nodes of event %d\n", note); /* Traverse children lnodes list and send evt */ list_for_each(tmp, &hw->sln_head) { ln = (struct csio_lnode *) tmp; switch (note) { case CSIO_LN_NOTIFY_HWREADY: csio_lnode_start(ln); break; case CSIO_LN_NOTIFY_HWRESET: case CSIO_LN_NOTIFY_HWREMOVE: csio_lnode_close(ln); break; case CSIO_LN_NOTIFY_HWSTOP: csio_lnode_stop(ln); break; default: break; } } } /* * csio_disable_lnodes: * @hw: HW module * @portid:port id * @disable: disable/enable flag. * If disable=1, disables all lnode hosted on given physical port. * otherwise enables all the lnodes on given phsysical port. * This routine need to called with hw lock held. */ void csio_disable_lnodes(struct csio_hw *hw, uint8_t portid, bool disable) { struct list_head *tmp; struct csio_lnode *ln; csio_dbg(hw, "Notifying event to all nodes of port:%d\n", portid); /* Traverse sibling lnodes list and send evt */ list_for_each(tmp, &hw->sln_head) { ln = (struct csio_lnode *) tmp; if (ln->portid != portid) continue; if (disable) csio_lnode_stop(ln); else csio_lnode_start(ln); } } /* * csio_ln_init - Initialize an lnode. * @ln: lnode * */ static int csio_ln_init(struct csio_lnode *ln) { int rv = -EINVAL; struct csio_lnode *rln, *pln; struct csio_hw *hw = csio_lnode_to_hw(ln); csio_init_state(&ln->sm, csio_lns_uninit); ln->vnp_flowid = CSIO_INVALID_IDX; ln->fcf_flowid = CSIO_INVALID_IDX; if (csio_is_root_ln(ln)) { /* This is the lnode used during initialization */ ln->fcfinfo = kzalloc(sizeof(struct csio_fcf_info), GFP_KERNEL); if (!ln->fcfinfo) { csio_ln_err(ln, "Failed to alloc FCF record\n"); CSIO_INC_STATS(hw, n_err_nomem); goto err; } INIT_LIST_HEAD(&ln->fcf_lsthead); kref_init(&ln->fcfinfo->kref); if (csio_fdmi_enable && csio_ln_fdmi_init(ln)) goto err; } else { /* Either a non-root physical or a virtual lnode */ /* * THe rest is common for non-root physical and NPIV lnodes. * Just get references to all other modules */ rln = csio_root_lnode(ln); if (csio_is_npiv_ln(ln)) { /* NPIV */ pln = csio_parent_lnode(ln); kref_get(&pln->fcfinfo->kref); ln->fcfinfo = pln->fcfinfo; } else { /* Another non-root physical lnode (FCF) */ ln->fcfinfo = kzalloc(sizeof(struct csio_fcf_info), GFP_KERNEL); if (!ln->fcfinfo) { csio_ln_err(ln, "Failed to alloc FCF info\n"); CSIO_INC_STATS(hw, n_err_nomem); goto err; } kref_init(&ln->fcfinfo->kref); if (csio_fdmi_enable && csio_ln_fdmi_init(ln)) goto err; } } /* if (!csio_is_root_ln(ln)) */ return 0; err: return rv; } static void csio_ln_exit(struct csio_lnode *ln) { struct csio_lnode *pln; csio_cleanup_rns(ln); if (csio_is_npiv_ln(ln)) { pln = csio_parent_lnode(ln); kref_put(&pln->fcfinfo->kref, csio_free_fcfinfo); } else { kref_put(&ln->fcfinfo->kref, csio_free_fcfinfo); if (csio_fdmi_enable) csio_ln_fdmi_exit(ln); } ln->fcfinfo = NULL; } /** * csio_lnode_init - Initialize the members of an lnode. * @ln: lnode * */ int csio_lnode_init(struct csio_lnode *ln, struct csio_hw *hw, struct csio_lnode *pln) { int rv = -EINVAL; /* Link this lnode to hw */ csio_lnode_to_hw(ln) = hw; /* Link child to parent if child lnode */ if (pln) ln->pln = pln; else ln->pln = NULL; /* Initialize scsi_tgt and timers to zero */ ln->n_scsi_tgts = 0; ln->last_scan_ntgts = 0; ln->tgt_scan_tick = 0; /* Initialize rnode list */ INIT_LIST_HEAD(&ln->rnhead); INIT_LIST_HEAD(&ln->cln_head); /* Initialize log level for debug */ ln->params.log_level = hw->params.log_level; if (csio_ln_init(ln)) goto err; /* Add lnode to list of sibling or children lnodes */ spin_lock_irq(&hw->lock); list_add_tail(&ln->sm.sm_list, pln ? &pln->cln_head : &hw->sln_head); if (pln) pln->num_vports++; spin_unlock_irq(&hw->lock); hw->num_lns++; return 0; err: csio_lnode_to_hw(ln) = NULL; return rv; } /** * csio_lnode_exit - De-instantiate an lnode. * @ln: lnode * */ void csio_lnode_exit(struct csio_lnode *ln) { struct csio_hw *hw = csio_lnode_to_hw(ln); csio_ln_exit(ln); /* Remove this lnode from hw->sln_head */ spin_lock_irq(&hw->lock); list_del_init(&ln->sm.sm_list); /* If it is children lnode, decrement the * counter in its parent lnode */ if (ln->pln) ln->pln->num_vports--; /* Update root lnode pointer */ if (list_empty(&hw->sln_head)) hw->rln = NULL; else hw->rln = (struct csio_lnode *)csio_list_next(&hw->sln_head); spin_unlock_irq(&hw->lock); csio_lnode_to_hw(ln) = NULL; hw->num_lns--; }