2153 lines · c
1/*2 * This file is part of the Chelsio FCoE driver for Linux.3 *4 * Copyright (c) 2008-2012 Chelsio Communications, Inc. All rights reserved.5 *6 * This software is available to you under a choice of one of two7 * licenses. You may choose to be licensed under the terms of the GNU8 * General Public License (GPL) Version 2, available from the file9 * COPYING in the main directory of this source tree, or the10 * OpenIB.org BSD license below:11 *12 * Redistribution and use in source and binary forms, with or13 * without modification, are permitted provided that the following14 * conditions are met:15 *16 * - Redistributions of source code must retain the above17 * copyright notice, this list of conditions and the following18 * disclaimer.19 *20 * - Redistributions in binary form must reproduce the above21 * copyright notice, this list of conditions and the following22 * disclaimer in the documentation and/or other materials23 * provided with the distribution.24 *25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE32 * SOFTWARE.33 */34 35#include <linux/kernel.h>36#include <linux/delay.h>37#include <linux/slab.h>38#include <linux/utsname.h>39#include <scsi/scsi_device.h>40#include <scsi/scsi_transport_fc.h>41#include <linux/unaligned.h>42#include <scsi/fc/fc_els.h>43#include <scsi/fc/fc_fs.h>44#include <scsi/fc/fc_gs.h>45#include <scsi/fc/fc_ms.h>46 47#include "csio_hw.h"48#include "csio_mb.h"49#include "csio_lnode.h"50#include "csio_rnode.h"51 52int csio_fcoe_rnodes = 1024;53int csio_fdmi_enable = 1;54 55#define PORT_ID_PTR(_x) ((uint8_t *)(&_x) + 1)56 57/* Lnode SM declarations */58static void csio_lns_uninit(struct csio_lnode *, enum csio_ln_ev);59static void csio_lns_online(struct csio_lnode *, enum csio_ln_ev);60static void csio_lns_ready(struct csio_lnode *, enum csio_ln_ev);61static void csio_lns_offline(struct csio_lnode *, enum csio_ln_ev);62 63static int csio_ln_mgmt_submit_req(struct csio_ioreq *,64 void (*io_cbfn) (struct csio_hw *, struct csio_ioreq *),65 enum fcoe_cmn_type, struct csio_dma_buf *, uint32_t);66 67/* LN event mapping */68static enum csio_ln_ev fwevt_to_lnevt[] = {69 CSIO_LNE_NONE, /* None */70 CSIO_LNE_NONE, /* PLOGI_ACC_RCVD */71 CSIO_LNE_NONE, /* PLOGI_RJT_RCVD */72 CSIO_LNE_NONE, /* PLOGI_RCVD */73 CSIO_LNE_NONE, /* PLOGO_RCVD */74 CSIO_LNE_NONE, /* PRLI_ACC_RCVD */75 CSIO_LNE_NONE, /* PRLI_RJT_RCVD */76 CSIO_LNE_NONE, /* PRLI_RCVD */77 CSIO_LNE_NONE, /* PRLO_RCVD */78 CSIO_LNE_NONE, /* NPORT_ID_CHGD */79 CSIO_LNE_LOGO, /* FLOGO_RCVD */80 CSIO_LNE_LOGO, /* CLR_VIRT_LNK_RCVD */81 CSIO_LNE_FAB_INIT_DONE,/* FLOGI_ACC_RCVD */82 CSIO_LNE_NONE, /* FLOGI_RJT_RCVD */83 CSIO_LNE_FAB_INIT_DONE,/* FDISC_ACC_RCVD */84 CSIO_LNE_NONE, /* FDISC_RJT_RCVD */85 CSIO_LNE_NONE, /* FLOGI_TMO_MAX_RETRY */86 CSIO_LNE_NONE, /* IMPL_LOGO_ADISC_ACC */87 CSIO_LNE_NONE, /* IMPL_LOGO_ADISC_RJT */88 CSIO_LNE_NONE, /* IMPL_LOGO_ADISC_CNFLT */89 CSIO_LNE_NONE, /* PRLI_TMO */90 CSIO_LNE_NONE, /* ADISC_TMO */91 CSIO_LNE_NONE, /* RSCN_DEV_LOST */92 CSIO_LNE_NONE, /* SCR_ACC_RCVD */93 CSIO_LNE_NONE, /* ADISC_RJT_RCVD */94 CSIO_LNE_NONE, /* LOGO_SNT */95 CSIO_LNE_NONE, /* PROTO_ERR_IMPL_LOGO */96};97 98#define CSIO_FWE_TO_LNE(_evt) ((_evt > PROTO_ERR_IMPL_LOGO) ? \99 CSIO_LNE_NONE : \100 fwevt_to_lnevt[_evt])101 102#define csio_ct_rsp(cp) (((struct fc_ct_hdr *)cp)->ct_cmd)103#define csio_ct_reason(cp) (((struct fc_ct_hdr *)cp)->ct_reason)104#define csio_ct_expl(cp) (((struct fc_ct_hdr *)cp)->ct_explan)105#define csio_ct_get_pld(cp) ((void *)(((uint8_t *)cp) + FC_CT_HDR_LEN))106 107/*108 * csio_ln_match_by_portid - lookup lnode using given portid.109 * @hw: HW module110 * @portid: port-id.111 *112 * If found, returns lnode matching given portid otherwise returns NULL.113 */114static struct csio_lnode *115csio_ln_lookup_by_portid(struct csio_hw *hw, uint8_t portid)116{117 struct csio_lnode *ln;118 struct list_head *tmp;119 120 /* Match siblings lnode with portid */121 list_for_each(tmp, &hw->sln_head) {122 ln = (struct csio_lnode *) tmp;123 if (ln->portid == portid)124 return ln;125 }126 127 return NULL;128}129 130/*131 * csio_ln_lookup_by_vnpi - Lookup lnode using given vnp id.132 * @hw - HW module133 * @vnpi - vnp index.134 * Returns - If found, returns lnode matching given vnp id135 * otherwise returns NULL.136 */137static struct csio_lnode *138csio_ln_lookup_by_vnpi(struct csio_hw *hw, uint32_t vnp_id)139{140 struct list_head *tmp1, *tmp2;141 struct csio_lnode *sln = NULL, *cln = NULL;142 143 if (list_empty(&hw->sln_head)) {144 CSIO_INC_STATS(hw, n_lnlkup_miss);145 return NULL;146 }147 /* Traverse sibling lnodes */148 list_for_each(tmp1, &hw->sln_head) {149 sln = (struct csio_lnode *) tmp1;150 151 /* Match sibling lnode */152 if (sln->vnp_flowid == vnp_id)153 return sln;154 155 if (list_empty(&sln->cln_head))156 continue;157 158 /* Traverse children lnodes */159 list_for_each(tmp2, &sln->cln_head) {160 cln = (struct csio_lnode *) tmp2;161 162 if (cln->vnp_flowid == vnp_id)163 return cln;164 }165 }166 CSIO_INC_STATS(hw, n_lnlkup_miss);167 return NULL;168}169 170/**171 * csio_lnode_lookup_by_wwpn - Lookup lnode using given wwpn.172 * @hw: HW module.173 * @wwpn: WWPN.174 *175 * If found, returns lnode matching given wwpn, returns NULL otherwise.176 */177struct csio_lnode *178csio_lnode_lookup_by_wwpn(struct csio_hw *hw, uint8_t *wwpn)179{180 struct list_head *tmp1, *tmp2;181 struct csio_lnode *sln = NULL, *cln = NULL;182 183 if (list_empty(&hw->sln_head)) {184 CSIO_INC_STATS(hw, n_lnlkup_miss);185 return NULL;186 }187 /* Traverse sibling lnodes */188 list_for_each(tmp1, &hw->sln_head) {189 sln = (struct csio_lnode *) tmp1;190 191 /* Match sibling lnode */192 if (!memcmp(csio_ln_wwpn(sln), wwpn, 8))193 return sln;194 195 if (list_empty(&sln->cln_head))196 continue;197 198 /* Traverse children lnodes */199 list_for_each(tmp2, &sln->cln_head) {200 cln = (struct csio_lnode *) tmp2;201 202 if (!memcmp(csio_ln_wwpn(cln), wwpn, 8))203 return cln;204 }205 }206 return NULL;207}208 209/* FDMI */210static void211csio_fill_ct_iu(void *buf, uint8_t type, uint8_t sub_type, uint16_t op)212{213 struct fc_ct_hdr *cmd = (struct fc_ct_hdr *)buf;214 cmd->ct_rev = FC_CT_REV;215 cmd->ct_fs_type = type;216 cmd->ct_fs_subtype = sub_type;217 cmd->ct_cmd = htons(op);218}219 220static int221csio_hostname(uint8_t *buf, size_t buf_len)222{223 if (snprintf(buf, buf_len, "%s", init_utsname()->nodename) > 0)224 return 0;225 return -1;226}227 228static int229csio_osname(uint8_t *buf, size_t buf_len)230{231 if (snprintf(buf, buf_len, "%s %s %s",232 init_utsname()->sysname,233 init_utsname()->release,234 init_utsname()->version) > 0)235 return 0;236 237 return -1;238}239 240static inline void241csio_append_attrib(uint8_t **ptr, uint16_t type, void *val, size_t val_len)242{243 uint16_t len;244 struct fc_fdmi_attr_entry *ae = (struct fc_fdmi_attr_entry *)*ptr;245 246 if (WARN_ON(val_len > U16_MAX))247 return;248 249 len = val_len;250 251 ae->type = htons(type);252 len += 4; /* includes attribute type and length */253 len = (len + 3) & ~3; /* should be multiple of 4 bytes */254 ae->len = htons(len);255 memcpy(ae->value, val, val_len);256 if (len > val_len)257 memset(ae->value + val_len, 0, len - val_len);258 *ptr += len;259}260 261/*262 * csio_ln_fdmi_done - FDMI registeration completion263 * @hw: HW context264 * @fdmi_req: fdmi request265 */266static void267csio_ln_fdmi_done(struct csio_hw *hw, struct csio_ioreq *fdmi_req)268{269 void *cmd;270 struct csio_lnode *ln = fdmi_req->lnode;271 272 if (fdmi_req->wr_status != FW_SUCCESS) {273 csio_ln_dbg(ln, "WR error:%x in processing fdmi rpa cmd\n",274 fdmi_req->wr_status);275 CSIO_INC_STATS(ln, n_fdmi_err);276 }277 278 cmd = fdmi_req->dma_buf.vaddr;279 if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) {280 csio_ln_dbg(ln, "fdmi rpa cmd rejected reason %x expl %x\n",281 csio_ct_reason(cmd), csio_ct_expl(cmd));282 }283}284 285/*286 * csio_ln_fdmi_rhba_cbfn - RHBA completion287 * @hw: HW context288 * @fdmi_req: fdmi request289 */290static void291csio_ln_fdmi_rhba_cbfn(struct csio_hw *hw, struct csio_ioreq *fdmi_req)292{293 void *cmd;294 uint8_t *pld;295 uint32_t len = 0;296 __be32 val;297 __be16 mfs;298 uint32_t numattrs = 0;299 struct csio_lnode *ln = fdmi_req->lnode;300 struct fs_fdmi_attrs *attrib_blk;301 struct fc_fdmi_port_name *port_name;302 uint8_t buf[64];303 uint8_t *fc4_type;304 unsigned long flags;305 306 if (fdmi_req->wr_status != FW_SUCCESS) {307 csio_ln_dbg(ln, "WR error:%x in processing fdmi rhba cmd\n",308 fdmi_req->wr_status);309 CSIO_INC_STATS(ln, n_fdmi_err);310 }311 312 cmd = fdmi_req->dma_buf.vaddr;313 if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) {314 csio_ln_dbg(ln, "fdmi rhba cmd rejected reason %x expl %x\n",315 csio_ct_reason(cmd), csio_ct_expl(cmd));316 }317 318 if (!csio_is_rnode_ready(fdmi_req->rnode)) {319 CSIO_INC_STATS(ln, n_fdmi_err);320 return;321 }322 323 /* Prepare CT hdr for RPA cmd */324 memset(cmd, 0, FC_CT_HDR_LEN);325 csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_RPA);326 327 /* Prepare RPA payload */328 pld = (uint8_t *)csio_ct_get_pld(cmd);329 port_name = (struct fc_fdmi_port_name *)pld;330 memcpy(&port_name->portname, csio_ln_wwpn(ln), 8);331 pld += sizeof(*port_name);332 333 /* Start appending Port attributes */334 attrib_blk = (struct fs_fdmi_attrs *)pld;335 attrib_blk->numattrs = 0;336 len += sizeof(attrib_blk->numattrs);337 pld += sizeof(attrib_blk->numattrs);338 339 fc4_type = &buf[0];340 memset(fc4_type, 0, FC_FDMI_PORT_ATTR_FC4TYPES_LEN);341 fc4_type[2] = 1;342 fc4_type[7] = 1;343 csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_FC4TYPES,344 fc4_type, FC_FDMI_PORT_ATTR_FC4TYPES_LEN);345 numattrs++;346 val = htonl(FC_PORTSPEED_1GBIT | FC_PORTSPEED_10GBIT);347 csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_SUPPORTEDSPEED,348 &val,349 FC_FDMI_PORT_ATTR_SUPPORTEDSPEED_LEN);350 numattrs++;351 352 if (hw->pport[ln->portid].link_speed == FW_PORT_CAP_SPEED_1G)353 val = htonl(FC_PORTSPEED_1GBIT);354 else if (hw->pport[ln->portid].link_speed == FW_PORT_CAP_SPEED_10G)355 val = htonl(FC_PORTSPEED_10GBIT);356 else if (hw->pport[ln->portid].link_speed == FW_PORT_CAP32_SPEED_25G)357 val = htonl(FC_PORTSPEED_25GBIT);358 else if (hw->pport[ln->portid].link_speed == FW_PORT_CAP32_SPEED_40G)359 val = htonl(FC_PORTSPEED_40GBIT);360 else if (hw->pport[ln->portid].link_speed == FW_PORT_CAP32_SPEED_50G)361 val = htonl(FC_PORTSPEED_50GBIT);362 else if (hw->pport[ln->portid].link_speed == FW_PORT_CAP32_SPEED_100G)363 val = htonl(FC_PORTSPEED_100GBIT);364 else365 val = htonl(CSIO_HBA_PORTSPEED_UNKNOWN);366 csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_CURRENTPORTSPEED,367 &val, FC_FDMI_PORT_ATTR_CURRENTPORTSPEED_LEN);368 numattrs++;369 370 mfs = ln->ln_sparm.csp.sp_bb_data;371 csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_MAXFRAMESIZE,372 &mfs, sizeof(mfs));373 numattrs++;374 375 strcpy(buf, "csiostor");376 csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_OSDEVICENAME, buf,377 strlen(buf));378 numattrs++;379 380 if (!csio_hostname(buf, sizeof(buf))) {381 csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_HOSTNAME,382 buf, strlen(buf));383 numattrs++;384 }385 attrib_blk->numattrs = htonl(numattrs);386 len = (uint32_t)(pld - (uint8_t *)cmd);387 388 /* Submit FDMI RPA request */389 spin_lock_irqsave(&hw->lock, flags);390 if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_done,391 FCOE_CT, &fdmi_req->dma_buf, len)) {392 CSIO_INC_STATS(ln, n_fdmi_err);393 csio_ln_dbg(ln, "Failed to issue fdmi rpa req\n");394 }395 spin_unlock_irqrestore(&hw->lock, flags);396}397 398/*399 * csio_ln_fdmi_dprt_cbfn - DPRT completion400 * @hw: HW context401 * @fdmi_req: fdmi request402 */403static void404csio_ln_fdmi_dprt_cbfn(struct csio_hw *hw, struct csio_ioreq *fdmi_req)405{406 void *cmd;407 uint8_t *pld;408 uint32_t len = 0;409 uint32_t numattrs = 0;410 __be32 maxpayload = htonl(65536);411 struct fc_fdmi_hba_identifier *hbaid;412 struct csio_lnode *ln = fdmi_req->lnode;413 struct fc_fdmi_rpl *reg_pl;414 struct fs_fdmi_attrs *attrib_blk;415 uint8_t buf[64];416 unsigned long flags;417 418 if (fdmi_req->wr_status != FW_SUCCESS) {419 csio_ln_dbg(ln, "WR error:%x in processing fdmi dprt cmd\n",420 fdmi_req->wr_status);421 CSIO_INC_STATS(ln, n_fdmi_err);422 }423 424 if (!csio_is_rnode_ready(fdmi_req->rnode)) {425 CSIO_INC_STATS(ln, n_fdmi_err);426 return;427 }428 cmd = fdmi_req->dma_buf.vaddr;429 if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) {430 csio_ln_dbg(ln, "fdmi dprt cmd rejected reason %x expl %x\n",431 csio_ct_reason(cmd), csio_ct_expl(cmd));432 }433 434 /* Prepare CT hdr for RHBA cmd */435 memset(cmd, 0, FC_CT_HDR_LEN);436 csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_RHBA);437 len = FC_CT_HDR_LEN;438 439 /* Prepare RHBA payload */440 pld = (uint8_t *)csio_ct_get_pld(cmd);441 hbaid = (struct fc_fdmi_hba_identifier *)pld;442 memcpy(&hbaid->id, csio_ln_wwpn(ln), 8); /* HBA identifer */443 pld += sizeof(*hbaid);444 445 /* Register one port per hba */446 reg_pl = (struct fc_fdmi_rpl *)pld;447 reg_pl->numport = htonl(1);448 memcpy(®_pl->port[0].portname, csio_ln_wwpn(ln), 8);449 pld += sizeof(*reg_pl);450 451 /* Start appending HBA attributes hba */452 attrib_blk = (struct fs_fdmi_attrs *)pld;453 attrib_blk->numattrs = 0;454 len += sizeof(attrib_blk->numattrs);455 pld += sizeof(attrib_blk->numattrs);456 457 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_NODENAME, csio_ln_wwnn(ln),458 FC_FDMI_HBA_ATTR_NODENAME_LEN);459 numattrs++;460 461 memset(buf, 0, sizeof(buf));462 463 strcpy(buf, "Chelsio Communications");464 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MANUFACTURER, buf,465 strlen(buf));466 numattrs++;467 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_SERIALNUMBER,468 hw->vpd.sn, sizeof(hw->vpd.sn));469 numattrs++;470 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MODEL, hw->vpd.id,471 sizeof(hw->vpd.id));472 numattrs++;473 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MODELDESCRIPTION,474 hw->model_desc, strlen(hw->model_desc));475 numattrs++;476 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_HARDWAREVERSION,477 hw->hw_ver, sizeof(hw->hw_ver));478 numattrs++;479 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_FIRMWAREVERSION,480 hw->fwrev_str, strlen(hw->fwrev_str));481 numattrs++;482 483 if (!csio_osname(buf, sizeof(buf))) {484 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_OSNAMEVERSION,485 buf, strlen(buf));486 numattrs++;487 }488 489 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MAXCTPAYLOAD,490 &maxpayload, FC_FDMI_HBA_ATTR_MAXCTPAYLOAD_LEN);491 len = (uint32_t)(pld - (uint8_t *)cmd);492 numattrs++;493 attrib_blk->numattrs = htonl(numattrs);494 495 /* Submit FDMI RHBA request */496 spin_lock_irqsave(&hw->lock, flags);497 if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_rhba_cbfn,498 FCOE_CT, &fdmi_req->dma_buf, len)) {499 CSIO_INC_STATS(ln, n_fdmi_err);500 csio_ln_dbg(ln, "Failed to issue fdmi rhba req\n");501 }502 spin_unlock_irqrestore(&hw->lock, flags);503}504 505/*506 * csio_ln_fdmi_dhba_cbfn - DHBA completion507 * @hw: HW context508 * @fdmi_req: fdmi request509 */510static void511csio_ln_fdmi_dhba_cbfn(struct csio_hw *hw, struct csio_ioreq *fdmi_req)512{513 struct csio_lnode *ln = fdmi_req->lnode;514 void *cmd;515 struct fc_fdmi_port_name *port_name;516 uint32_t len;517 unsigned long flags;518 519 if (fdmi_req->wr_status != FW_SUCCESS) {520 csio_ln_dbg(ln, "WR error:%x in processing fdmi dhba cmd\n",521 fdmi_req->wr_status);522 CSIO_INC_STATS(ln, n_fdmi_err);523 }524 525 if (!csio_is_rnode_ready(fdmi_req->rnode)) {526 CSIO_INC_STATS(ln, n_fdmi_err);527 return;528 }529 cmd = fdmi_req->dma_buf.vaddr;530 if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) {531 csio_ln_dbg(ln, "fdmi dhba cmd rejected reason %x expl %x\n",532 csio_ct_reason(cmd), csio_ct_expl(cmd));533 }534 535 /* Send FDMI cmd to de-register any Port attributes if registered536 * before537 */538 539 /* Prepare FDMI DPRT cmd */540 memset(cmd, 0, FC_CT_HDR_LEN);541 csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_DPRT);542 len = FC_CT_HDR_LEN;543 port_name = (struct fc_fdmi_port_name *)csio_ct_get_pld(cmd);544 memcpy(&port_name->portname, csio_ln_wwpn(ln), 8);545 len += sizeof(*port_name);546 547 /* Submit FDMI request */548 spin_lock_irqsave(&hw->lock, flags);549 if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_dprt_cbfn,550 FCOE_CT, &fdmi_req->dma_buf, len)) {551 CSIO_INC_STATS(ln, n_fdmi_err);552 csio_ln_dbg(ln, "Failed to issue fdmi dprt req\n");553 }554 spin_unlock_irqrestore(&hw->lock, flags);555}556 557/**558 * csio_ln_fdmi_start - Start an FDMI request.559 * @ln: lnode560 * @context: session context561 *562 * Issued with lock held.563 */564int565csio_ln_fdmi_start(struct csio_lnode *ln, void *context)566{567 struct csio_ioreq *fdmi_req;568 struct csio_rnode *fdmi_rn = (struct csio_rnode *)context;569 void *cmd;570 struct fc_fdmi_hba_identifier *hbaid;571 uint32_t len;572 573 if (!(ln->flags & CSIO_LNF_FDMI_ENABLE))574 return -EPROTONOSUPPORT;575 576 if (!csio_is_rnode_ready(fdmi_rn))577 CSIO_INC_STATS(ln, n_fdmi_err);578 579 /* Send FDMI cmd to de-register any HBA attributes if registered580 * before581 */582 583 fdmi_req = ln->mgmt_req;584 fdmi_req->lnode = ln;585 fdmi_req->rnode = fdmi_rn;586 587 /* Prepare FDMI DHBA cmd */588 cmd = fdmi_req->dma_buf.vaddr;589 memset(cmd, 0, FC_CT_HDR_LEN);590 csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_DHBA);591 len = FC_CT_HDR_LEN;592 593 hbaid = (struct fc_fdmi_hba_identifier *)csio_ct_get_pld(cmd);594 memcpy(&hbaid->id, csio_ln_wwpn(ln), 8);595 len += sizeof(*hbaid);596 597 /* Submit FDMI request */598 if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_dhba_cbfn,599 FCOE_CT, &fdmi_req->dma_buf, len)) {600 CSIO_INC_STATS(ln, n_fdmi_err);601 csio_ln_dbg(ln, "Failed to issue fdmi dhba req\n");602 }603 604 return 0;605}606 607/*608 * csio_ln_vnp_read_cbfn - vnp read completion handler.609 * @hw: HW lnode610 * @cbfn: Completion handler.611 *612 * Reads vnp response and updates ln parameters.613 */614static void615csio_ln_vnp_read_cbfn(struct csio_hw *hw, struct csio_mb *mbp)616{617 struct csio_lnode *ln = ((struct csio_lnode *)mbp->priv);618 struct fw_fcoe_vnp_cmd *rsp = (struct fw_fcoe_vnp_cmd *)(mbp->mb);619 struct fc_els_csp *csp;620 struct fc_els_cssp *clsp;621 enum fw_retval retval;622 __be32 nport_id = 0;623 624 retval = FW_CMD_RETVAL_G(ntohl(rsp->alloc_to_len16));625 if (retval != FW_SUCCESS) {626 csio_err(hw, "FCOE VNP read cmd returned error:0x%x\n", retval);627 mempool_free(mbp, hw->mb_mempool);628 return;629 }630 631 spin_lock_irq(&hw->lock);632 633 memcpy(ln->mac, rsp->vnport_mac, sizeof(ln->mac));634 memcpy(&nport_id, &rsp->vnport_mac[3], sizeof(uint8_t)*3);635 ln->nport_id = ntohl(nport_id);636 ln->nport_id = ln->nport_id >> 8;637 638 /* Update WWNs */639 /*640 * This may look like a duplication of what csio_fcoe_enable_link()641 * does, but is absolutely necessary if the vnpi changes between642 * a FCOE LINK UP and FCOE LINK DOWN.643 */644 memcpy(csio_ln_wwnn(ln), rsp->vnport_wwnn, 8);645 memcpy(csio_ln_wwpn(ln), rsp->vnport_wwpn, 8);646 647 /* Copy common sparam */648 csp = (struct fc_els_csp *)rsp->cmn_srv_parms;649 ln->ln_sparm.csp.sp_hi_ver = csp->sp_hi_ver;650 ln->ln_sparm.csp.sp_lo_ver = csp->sp_lo_ver;651 ln->ln_sparm.csp.sp_bb_cred = csp->sp_bb_cred;652 ln->ln_sparm.csp.sp_features = csp->sp_features;653 ln->ln_sparm.csp.sp_bb_data = csp->sp_bb_data;654 ln->ln_sparm.csp.sp_r_a_tov = csp->sp_r_a_tov;655 ln->ln_sparm.csp.sp_e_d_tov = csp->sp_e_d_tov;656 657 /* Copy word 0 & word 1 of class sparam */658 clsp = (struct fc_els_cssp *)rsp->clsp_word_0_1;659 ln->ln_sparm.clsp[2].cp_class = clsp->cp_class;660 ln->ln_sparm.clsp[2].cp_init = clsp->cp_init;661 ln->ln_sparm.clsp[2].cp_recip = clsp->cp_recip;662 ln->ln_sparm.clsp[2].cp_rdfs = clsp->cp_rdfs;663 664 spin_unlock_irq(&hw->lock);665 666 mempool_free(mbp, hw->mb_mempool);667 668 /* Send an event to update local attribs */669 csio_lnode_async_event(ln, CSIO_LN_FC_ATTRIB_UPDATE);670}671 672/*673 * csio_ln_vnp_read - Read vnp params.674 * @ln: lnode675 * @cbfn: Completion handler.676 *677 * Issued with lock held.678 */679static int680csio_ln_vnp_read(struct csio_lnode *ln,681 void (*cbfn) (struct csio_hw *, struct csio_mb *))682{683 struct csio_hw *hw = ln->hwp;684 struct csio_mb *mbp;685 686 /* Allocate Mbox request */687 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);688 if (!mbp) {689 CSIO_INC_STATS(hw, n_err_nomem);690 return -ENOMEM;691 }692 693 /* Prepare VNP Command */694 csio_fcoe_vnp_read_init_mb(ln, mbp,695 CSIO_MB_DEFAULT_TMO,696 ln->fcf_flowid,697 ln->vnp_flowid,698 cbfn);699 700 /* Issue MBOX cmd */701 if (csio_mb_issue(hw, mbp)) {702 csio_err(hw, "Failed to issue mbox FCoE VNP command\n");703 mempool_free(mbp, hw->mb_mempool);704 return -EINVAL;705 }706 707 return 0;708}709 710/*711 * csio_fcoe_enable_link - Enable fcoe link.712 * @ln: lnode713 * @enable: enable/disable714 * Issued with lock held.715 * Issues mbox cmd to bring up FCOE link on port associated with given ln.716 */717static int718csio_fcoe_enable_link(struct csio_lnode *ln, bool enable)719{720 struct csio_hw *hw = ln->hwp;721 struct csio_mb *mbp;722 enum fw_retval retval;723 uint8_t portid;724 uint8_t sub_op;725 struct fw_fcoe_link_cmd *lcmd;726 int i;727 728 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);729 if (!mbp) {730 CSIO_INC_STATS(hw, n_err_nomem);731 return -ENOMEM;732 }733 734 portid = ln->portid;735 sub_op = enable ? FCOE_LINK_UP : FCOE_LINK_DOWN;736 737 csio_dbg(hw, "bringing FCOE LINK %s on Port:%d\n",738 sub_op ? "UP" : "DOWN", portid);739 740 csio_write_fcoe_link_cond_init_mb(ln, mbp, CSIO_MB_DEFAULT_TMO,741 portid, sub_op, 0, 0, 0, NULL);742 743 if (csio_mb_issue(hw, mbp)) {744 csio_err(hw, "failed to issue FCOE LINK cmd on port[%d]\n",745 portid);746 mempool_free(mbp, hw->mb_mempool);747 return -EINVAL;748 }749 750 retval = csio_mb_fw_retval(mbp);751 if (retval != FW_SUCCESS) {752 csio_err(hw,753 "FCOE LINK %s cmd on port[%d] failed with "754 "ret:x%x\n", sub_op ? "UP" : "DOWN", portid, retval);755 mempool_free(mbp, hw->mb_mempool);756 return -EINVAL;757 }758 759 if (!enable)760 goto out;761 762 lcmd = (struct fw_fcoe_link_cmd *)mbp->mb;763 764 memcpy(csio_ln_wwnn(ln), lcmd->vnport_wwnn, 8);765 memcpy(csio_ln_wwpn(ln), lcmd->vnport_wwpn, 8);766 767 for (i = 0; i < CSIO_MAX_PPORTS; i++)768 if (hw->pport[i].portid == portid)769 memcpy(hw->pport[i].mac, lcmd->phy_mac, 6);770 771out:772 mempool_free(mbp, hw->mb_mempool);773 return 0;774}775 776/*777 * csio_ln_read_fcf_cbfn - Read fcf parameters778 * @ln: lnode779 *780 * read fcf response and Update ln fcf information.781 */782static void783csio_ln_read_fcf_cbfn(struct csio_hw *hw, struct csio_mb *mbp)784{785 struct csio_lnode *ln = (struct csio_lnode *)mbp->priv;786 struct csio_fcf_info *fcf_info;787 struct fw_fcoe_fcf_cmd *rsp =788 (struct fw_fcoe_fcf_cmd *)(mbp->mb);789 enum fw_retval retval;790 791 retval = FW_CMD_RETVAL_G(ntohl(rsp->retval_len16));792 if (retval != FW_SUCCESS) {793 csio_ln_err(ln, "FCOE FCF cmd failed with ret x%x\n",794 retval);795 mempool_free(mbp, hw->mb_mempool);796 return;797 }798 799 spin_lock_irq(&hw->lock);800 fcf_info = ln->fcfinfo;801 fcf_info->priority = FW_FCOE_FCF_CMD_PRIORITY_GET(802 ntohs(rsp->priority_pkd));803 fcf_info->vf_id = ntohs(rsp->vf_id);804 fcf_info->vlan_id = rsp->vlan_id;805 fcf_info->max_fcoe_size = ntohs(rsp->max_fcoe_size);806 fcf_info->fka_adv = be32_to_cpu(rsp->fka_adv);807 fcf_info->fcfi = FW_FCOE_FCF_CMD_FCFI_GET(ntohl(rsp->op_to_fcfi));808 fcf_info->fpma = FW_FCOE_FCF_CMD_FPMA_GET(rsp->fpma_to_portid);809 fcf_info->spma = FW_FCOE_FCF_CMD_SPMA_GET(rsp->fpma_to_portid);810 fcf_info->login = FW_FCOE_FCF_CMD_LOGIN_GET(rsp->fpma_to_portid);811 fcf_info->portid = FW_FCOE_FCF_CMD_PORTID_GET(rsp->fpma_to_portid);812 memcpy(fcf_info->fc_map, rsp->fc_map, sizeof(fcf_info->fc_map));813 memcpy(fcf_info->mac, rsp->mac, sizeof(fcf_info->mac));814 memcpy(fcf_info->name_id, rsp->name_id, sizeof(fcf_info->name_id));815 memcpy(fcf_info->fabric, rsp->fabric, sizeof(fcf_info->fabric));816 memcpy(fcf_info->spma_mac, rsp->spma_mac, sizeof(fcf_info->spma_mac));817 818 spin_unlock_irq(&hw->lock);819 820 mempool_free(mbp, hw->mb_mempool);821}822 823/*824 * csio_ln_read_fcf_entry - Read fcf entry.825 * @ln: lnode826 * @cbfn: Completion handler.827 *828 * Issued with lock held.829 */830static int831csio_ln_read_fcf_entry(struct csio_lnode *ln,832 void (*cbfn) (struct csio_hw *, struct csio_mb *))833{834 struct csio_hw *hw = ln->hwp;835 struct csio_mb *mbp;836 837 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);838 if (!mbp) {839 CSIO_INC_STATS(hw, n_err_nomem);840 return -ENOMEM;841 }842 843 /* Get FCoE FCF information */844 csio_fcoe_read_fcf_init_mb(ln, mbp, CSIO_MB_DEFAULT_TMO,845 ln->portid, ln->fcf_flowid, cbfn);846 847 if (csio_mb_issue(hw, mbp)) {848 csio_err(hw, "failed to issue FCOE FCF cmd\n");849 mempool_free(mbp, hw->mb_mempool);850 return -EINVAL;851 }852 853 return 0;854}855 856/*857 * csio_handle_link_up - Logical Linkup event.858 * @hw - HW module.859 * @portid - Physical port number860 * @fcfi - FCF index.861 * @vnpi - VNP index.862 * Returns - none.863 *864 * This event is received from FW, when virtual link is established between865 * Physical port[ENode] and FCF. If its new vnpi, then local node object is866 * created on this FCF and set to [ONLINE] state.867 * Lnode waits for FW_RDEV_CMD event to be received indicating that868 * Fabric login is completed and lnode moves to [READY] state.869 *870 * This called with hw lock held871 */872static void873csio_handle_link_up(struct csio_hw *hw, uint8_t portid, uint32_t fcfi,874 uint32_t vnpi)875{876 struct csio_lnode *ln = NULL;877 878 /* Lookup lnode based on vnpi */879 ln = csio_ln_lookup_by_vnpi(hw, vnpi);880 if (!ln) {881 /* Pick lnode based on portid */882 ln = csio_ln_lookup_by_portid(hw, portid);883 if (!ln) {884 csio_err(hw, "failed to lookup fcoe lnode on port:%d\n",885 portid);886 CSIO_DB_ASSERT(0);887 return;888 }889 890 /* Check if lnode has valid vnp flowid */891 if (ln->vnp_flowid != CSIO_INVALID_IDX) {892 /* New VN-Port */893 spin_unlock_irq(&hw->lock);894 csio_lnode_alloc(hw);895 spin_lock_irq(&hw->lock);896 if (!ln) {897 csio_err(hw,898 "failed to allocate fcoe lnode"899 "for port:%d vnpi:x%x\n",900 portid, vnpi);901 CSIO_DB_ASSERT(0);902 return;903 }904 ln->portid = portid;905 }906 ln->vnp_flowid = vnpi;907 ln->dev_num &= ~0xFFFF;908 ln->dev_num |= vnpi;909 }910 911 /*Initialize fcfi */912 ln->fcf_flowid = fcfi;913 914 csio_info(hw, "Port:%d - FCOE LINK UP\n", portid);915 916 CSIO_INC_STATS(ln, n_link_up);917 918 /* Send LINKUP event to SM */919 csio_post_event(&ln->sm, CSIO_LNE_LINKUP);920}921 922/*923 * csio_post_event_rns924 * @ln - FCOE lnode925 * @evt - Given rnode event926 * Returns - none927 *928 * Posts given rnode event to all FCOE rnodes connected with given Lnode.929 * This routine is invoked when lnode receives LINK_DOWN/DOWN_LINK/CLOSE930 * event.931 *932 * This called with hw lock held933 */934static void935csio_post_event_rns(struct csio_lnode *ln, enum csio_rn_ev evt)936{937 struct csio_rnode *rnhead = (struct csio_rnode *) &ln->rnhead;938 struct list_head *tmp, *next;939 struct csio_rnode *rn;940 941 list_for_each_safe(tmp, next, &rnhead->sm.sm_list) {942 rn = (struct csio_rnode *) tmp;943 csio_post_event(&rn->sm, evt);944 }945}946 947/*948 * csio_cleanup_rns949 * @ln - FCOE lnode950 * Returns - none951 *952 * Frees all FCOE rnodes connected with given Lnode.953 *954 * This called with hw lock held955 */956static void957csio_cleanup_rns(struct csio_lnode *ln)958{959 struct csio_rnode *rnhead = (struct csio_rnode *) &ln->rnhead;960 struct list_head *tmp, *next_rn;961 struct csio_rnode *rn;962 963 list_for_each_safe(tmp, next_rn, &rnhead->sm.sm_list) {964 rn = (struct csio_rnode *) tmp;965 csio_put_rnode(ln, rn);966 }967 968}969 970/*971 * csio_post_event_lns972 * @ln - FCOE lnode973 * @evt - Given lnode event974 * Returns - none975 *976 * Posts given lnode event to all FCOE lnodes connected with given Lnode.977 * This routine is invoked when lnode receives LINK_DOWN/DOWN_LINK/CLOSE978 * event.979 *980 * This called with hw lock held981 */982static void983csio_post_event_lns(struct csio_lnode *ln, enum csio_ln_ev evt)984{985 struct list_head *tmp;986 struct csio_lnode *cln, *sln;987 988 /* If NPIV lnode, send evt only to that and return */989 if (csio_is_npiv_ln(ln)) {990 csio_post_event(&ln->sm, evt);991 return;992 }993 994 sln = ln;995 /* Traverse children lnodes list and send evt */996 list_for_each(tmp, &sln->cln_head) {997 cln = (struct csio_lnode *) tmp;998 csio_post_event(&cln->sm, evt);999 }1000 1001 /* Send evt to parent lnode */1002 csio_post_event(&ln->sm, evt);1003}1004 1005/*1006 * csio_ln_down - Lcoal nport is down1007 * @ln - FCOE Lnode1008 * Returns - none1009 *1010 * Sends LINK_DOWN events to Lnode and its associated NPIVs lnodes.1011 *1012 * This called with hw lock held1013 */1014static void1015csio_ln_down(struct csio_lnode *ln)1016{1017 csio_post_event_lns(ln, CSIO_LNE_LINK_DOWN);1018}1019 1020/*1021 * csio_handle_link_down - Logical Linkdown event.1022 * @hw - HW module.1023 * @portid - Physical port number1024 * @fcfi - FCF index.1025 * @vnpi - VNP index.1026 * Returns - none1027 *1028 * This event is received from FW, when virtual link goes down between1029 * Physical port[ENode] and FCF. Lnode and its associated NPIVs lnode hosted on1030 * this vnpi[VN-Port] will be de-instantiated.1031 *1032 * This called with hw lock held1033 */1034static void1035csio_handle_link_down(struct csio_hw *hw, uint8_t portid, uint32_t fcfi,1036 uint32_t vnpi)1037{1038 struct csio_fcf_info *fp;1039 struct csio_lnode *ln;1040 1041 /* Lookup lnode based on vnpi */1042 ln = csio_ln_lookup_by_vnpi(hw, vnpi);1043 if (ln) {1044 fp = ln->fcfinfo;1045 CSIO_INC_STATS(ln, n_link_down);1046 1047 /*Warn if linkdown received if lnode is not in ready state */1048 if (!csio_is_lnode_ready(ln)) {1049 csio_ln_warn(ln,1050 "warn: FCOE link is already in offline "1051 "Ignoring Fcoe linkdown event on portid %d\n",1052 portid);1053 CSIO_INC_STATS(ln, n_evt_drop);1054 return;1055 }1056 1057 /* Verify portid */1058 if (fp->portid != portid) {1059 csio_ln_warn(ln,1060 "warn: FCOE linkdown recv with "1061 "invalid port %d\n", portid);1062 CSIO_INC_STATS(ln, n_evt_drop);1063 return;1064 }1065 1066 /* verify fcfi */1067 if (ln->fcf_flowid != fcfi) {1068 csio_ln_warn(ln,1069 "warn: FCOE linkdown recv with "1070 "invalid fcfi x%x\n", fcfi);1071 CSIO_INC_STATS(ln, n_evt_drop);1072 return;1073 }1074 1075 csio_info(hw, "Port:%d - FCOE LINK DOWN\n", portid);1076 1077 /* Send LINK_DOWN event to lnode s/m */1078 csio_ln_down(ln);1079 1080 return;1081 } else {1082 csio_warn(hw,1083 "warn: FCOE linkdown recv with invalid vnpi x%x\n",1084 vnpi);1085 CSIO_INC_STATS(hw, n_evt_drop);1086 }1087}1088 1089/*1090 * csio_is_lnode_ready - Checks FCOE lnode is in ready state.1091 * @ln: Lnode module1092 *1093 * Returns True if FCOE lnode is in ready state.1094 */1095int1096csio_is_lnode_ready(struct csio_lnode *ln)1097{1098 return (csio_get_state(ln) == csio_lns_ready);1099}1100 1101/*****************************************************************************/1102/* START: Lnode SM */1103/*****************************************************************************/1104/*1105 * csio_lns_uninit - The request in uninit state.1106 * @ln - FCOE lnode.1107 * @evt - Event to be processed.1108 *1109 * Process the given lnode event which is currently in "uninit" state.1110 * Invoked with HW lock held.1111 * Return - none.1112 */1113static void1114csio_lns_uninit(struct csio_lnode *ln, enum csio_ln_ev evt)1115{1116 struct csio_hw *hw = csio_lnode_to_hw(ln);1117 struct csio_lnode *rln = hw->rln;1118 int rv;1119 1120 CSIO_INC_STATS(ln, n_evt_sm[evt]);1121 switch (evt) {1122 case CSIO_LNE_LINKUP:1123 csio_set_state(&ln->sm, csio_lns_online);1124 /* Read FCF only for physical lnode */1125 if (csio_is_phys_ln(ln)) {1126 rv = csio_ln_read_fcf_entry(ln,1127 csio_ln_read_fcf_cbfn);1128 if (rv != 0) {1129 /* TODO: Send HW RESET event */1130 CSIO_INC_STATS(ln, n_err);1131 break;1132 }1133 1134 /* Add FCF record */1135 list_add_tail(&ln->fcfinfo->list, &rln->fcf_lsthead);1136 }1137 1138 rv = csio_ln_vnp_read(ln, csio_ln_vnp_read_cbfn);1139 if (rv != 0) {1140 /* TODO: Send HW RESET event */1141 CSIO_INC_STATS(ln, n_err);1142 }1143 break;1144 1145 case CSIO_LNE_DOWN_LINK:1146 break;1147 1148 default:1149 csio_ln_dbg(ln,1150 "unexp ln event %d recv from did:x%x in "1151 "ln state[uninit].\n", evt, ln->nport_id);1152 CSIO_INC_STATS(ln, n_evt_unexp);1153 break;1154 } /* switch event */1155}1156 1157/*1158 * csio_lns_online - The request in online state.1159 * @ln - FCOE lnode.1160 * @evt - Event to be processed.1161 *1162 * Process the given lnode event which is currently in "online" state.1163 * Invoked with HW lock held.1164 * Return - none.1165 */1166static void1167csio_lns_online(struct csio_lnode *ln, enum csio_ln_ev evt)1168{1169 struct csio_hw *hw = csio_lnode_to_hw(ln);1170 1171 CSIO_INC_STATS(ln, n_evt_sm[evt]);1172 switch (evt) {1173 case CSIO_LNE_LINKUP:1174 csio_ln_warn(ln,1175 "warn: FCOE link is up already "1176 "Ignoring linkup on port:%d\n", ln->portid);1177 CSIO_INC_STATS(ln, n_evt_drop);1178 break;1179 1180 case CSIO_LNE_FAB_INIT_DONE:1181 csio_set_state(&ln->sm, csio_lns_ready);1182 1183 spin_unlock_irq(&hw->lock);1184 csio_lnode_async_event(ln, CSIO_LN_FC_LINKUP);1185 spin_lock_irq(&hw->lock);1186 1187 break;1188 1189 case CSIO_LNE_LINK_DOWN:1190 case CSIO_LNE_DOWN_LINK:1191 csio_set_state(&ln->sm, csio_lns_uninit);1192 if (csio_is_phys_ln(ln)) {1193 /* Remove FCF entry */1194 list_del_init(&ln->fcfinfo->list);1195 }1196 break;1197 1198 default:1199 csio_ln_dbg(ln,1200 "unexp ln event %d recv from did:x%x in "1201 "ln state[uninit].\n", evt, ln->nport_id);1202 CSIO_INC_STATS(ln, n_evt_unexp);1203 1204 break;1205 } /* switch event */1206}1207 1208/*1209 * csio_lns_ready - The request in ready state.1210 * @ln - FCOE lnode.1211 * @evt - Event to be processed.1212 *1213 * Process the given lnode event which is currently in "ready" state.1214 * Invoked with HW lock held.1215 * Return - none.1216 */1217static void1218csio_lns_ready(struct csio_lnode *ln, enum csio_ln_ev evt)1219{1220 struct csio_hw *hw = csio_lnode_to_hw(ln);1221 1222 CSIO_INC_STATS(ln, n_evt_sm[evt]);1223 switch (evt) {1224 case CSIO_LNE_FAB_INIT_DONE:1225 csio_ln_dbg(ln,1226 "ignoring event %d recv from did x%x"1227 "in ln state[ready].\n", evt, ln->nport_id);1228 CSIO_INC_STATS(ln, n_evt_drop);1229 break;1230 1231 case CSIO_LNE_LINK_DOWN:1232 csio_set_state(&ln->sm, csio_lns_offline);1233 csio_post_event_rns(ln, CSIO_RNFE_DOWN);1234 1235 spin_unlock_irq(&hw->lock);1236 csio_lnode_async_event(ln, CSIO_LN_FC_LINKDOWN);1237 spin_lock_irq(&hw->lock);1238 1239 if (csio_is_phys_ln(ln)) {1240 /* Remove FCF entry */1241 list_del_init(&ln->fcfinfo->list);1242 }1243 break;1244 1245 case CSIO_LNE_DOWN_LINK:1246 csio_set_state(&ln->sm, csio_lns_offline);1247 csio_post_event_rns(ln, CSIO_RNFE_DOWN);1248 1249 /* Host need to issue aborts in case if FW has not returned1250 * WRs with status "ABORTED"1251 */1252 spin_unlock_irq(&hw->lock);1253 csio_lnode_async_event(ln, CSIO_LN_FC_LINKDOWN);1254 spin_lock_irq(&hw->lock);1255 1256 if (csio_is_phys_ln(ln)) {1257 /* Remove FCF entry */1258 list_del_init(&ln->fcfinfo->list);1259 }1260 break;1261 1262 case CSIO_LNE_CLOSE:1263 csio_set_state(&ln->sm, csio_lns_uninit);1264 csio_post_event_rns(ln, CSIO_RNFE_CLOSE);1265 break;1266 1267 case CSIO_LNE_LOGO:1268 csio_set_state(&ln->sm, csio_lns_offline);1269 csio_post_event_rns(ln, CSIO_RNFE_DOWN);1270 break;1271 1272 default:1273 csio_ln_dbg(ln,1274 "unexp ln event %d recv from did:x%x in "1275 "ln state[uninit].\n", evt, ln->nport_id);1276 CSIO_INC_STATS(ln, n_evt_unexp);1277 CSIO_DB_ASSERT(0);1278 break;1279 } /* switch event */1280}1281 1282/*1283 * csio_lns_offline - The request in offline state.1284 * @ln - FCOE lnode.1285 * @evt - Event to be processed.1286 *1287 * Process the given lnode event which is currently in "offline" state.1288 * Invoked with HW lock held.1289 * Return - none.1290 */1291static void1292csio_lns_offline(struct csio_lnode *ln, enum csio_ln_ev evt)1293{1294 struct csio_hw *hw = csio_lnode_to_hw(ln);1295 struct csio_lnode *rln = hw->rln;1296 int rv;1297 1298 CSIO_INC_STATS(ln, n_evt_sm[evt]);1299 switch (evt) {1300 case CSIO_LNE_LINKUP:1301 csio_set_state(&ln->sm, csio_lns_online);1302 /* Read FCF only for physical lnode */1303 if (csio_is_phys_ln(ln)) {1304 rv = csio_ln_read_fcf_entry(ln,1305 csio_ln_read_fcf_cbfn);1306 if (rv != 0) {1307 /* TODO: Send HW RESET event */1308 CSIO_INC_STATS(ln, n_err);1309 break;1310 }1311 1312 /* Add FCF record */1313 list_add_tail(&ln->fcfinfo->list, &rln->fcf_lsthead);1314 }1315 1316 rv = csio_ln_vnp_read(ln, csio_ln_vnp_read_cbfn);1317 if (rv != 0) {1318 /* TODO: Send HW RESET event */1319 CSIO_INC_STATS(ln, n_err);1320 }1321 break;1322 1323 case CSIO_LNE_LINK_DOWN:1324 case CSIO_LNE_DOWN_LINK:1325 case CSIO_LNE_LOGO:1326 csio_ln_dbg(ln,1327 "ignoring event %d recv from did x%x"1328 "in ln state[offline].\n", evt, ln->nport_id);1329 CSIO_INC_STATS(ln, n_evt_drop);1330 break;1331 1332 case CSIO_LNE_CLOSE:1333 csio_set_state(&ln->sm, csio_lns_uninit);1334 csio_post_event_rns(ln, CSIO_RNFE_CLOSE);1335 break;1336 1337 default:1338 csio_ln_dbg(ln,1339 "unexp ln event %d recv from did:x%x in "1340 "ln state[offline]\n", evt, ln->nport_id);1341 CSIO_INC_STATS(ln, n_evt_unexp);1342 CSIO_DB_ASSERT(0);1343 break;1344 } /* switch event */1345}1346 1347/*****************************************************************************/1348/* END: Lnode SM */1349/*****************************************************************************/1350 1351static void1352csio_free_fcfinfo(struct kref *kref)1353{1354 struct csio_fcf_info *fcfinfo = container_of(kref,1355 struct csio_fcf_info, kref);1356 kfree(fcfinfo);1357}1358 1359/* Helper routines for attributes */1360/*1361 * csio_lnode_state_to_str - Get current state of FCOE lnode.1362 * @ln - lnode1363 * @str - state of lnode.1364 *1365 */1366void1367csio_lnode_state_to_str(struct csio_lnode *ln, int8_t *str)1368{1369 if (csio_get_state(ln) == csio_lns_uninit) {1370 strcpy(str, "UNINIT");1371 return;1372 }1373 if (csio_get_state(ln) == csio_lns_ready) {1374 strcpy(str, "READY");1375 return;1376 }1377 if (csio_get_state(ln) == csio_lns_offline) {1378 strcpy(str, "OFFLINE");1379 return;1380 }1381 strcpy(str, "UNKNOWN");1382} /* csio_lnode_state_to_str */1383 1384 1385int1386csio_get_phy_port_stats(struct csio_hw *hw, uint8_t portid,1387 struct fw_fcoe_port_stats *port_stats)1388{1389 struct csio_mb *mbp;1390 struct fw_fcoe_port_cmd_params portparams;1391 enum fw_retval retval;1392 int idx;1393 1394 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);1395 if (!mbp) {1396 csio_err(hw, "FCoE FCF PARAMS command out of memory!\n");1397 return -EINVAL;1398 }1399 portparams.portid = portid;1400 1401 for (idx = 1; idx <= 3; idx++) {1402 portparams.idx = (idx-1)*6 + 1;1403 portparams.nstats = 6;1404 if (idx == 3)1405 portparams.nstats = 4;1406 csio_fcoe_read_portparams_init_mb(hw, mbp, CSIO_MB_DEFAULT_TMO,1407 &portparams, NULL);1408 if (csio_mb_issue(hw, mbp)) {1409 csio_err(hw, "Issue of FCoE port params failed!\n");1410 mempool_free(mbp, hw->mb_mempool);1411 return -EINVAL;1412 }1413 csio_mb_process_portparams_rsp(hw, mbp, &retval,1414 &portparams, port_stats);1415 }1416 1417 mempool_free(mbp, hw->mb_mempool);1418 return 0;1419}1420 1421/*1422 * csio_ln_mgmt_wr_handler -Mgmt Work Request handler.1423 * @wr - WR.1424 * @len - WR len.1425 * This handler is invoked when an outstanding mgmt WR is completed.1426 * Its invoked in the context of FW event worker thread for every1427 * mgmt event received.1428 * Return - none.1429 */1430 1431static void1432csio_ln_mgmt_wr_handler(struct csio_hw *hw, void *wr, uint32_t len)1433{1434 struct csio_mgmtm *mgmtm = csio_hw_to_mgmtm(hw);1435 struct csio_ioreq *io_req = NULL;1436 struct fw_fcoe_els_ct_wr *wr_cmd;1437 1438 1439 wr_cmd = (struct fw_fcoe_els_ct_wr *) wr;1440 1441 if (len < sizeof(struct fw_fcoe_els_ct_wr)) {1442 csio_err(mgmtm->hw,1443 "Invalid ELS CT WR length recvd, len:%x\n", len);1444 mgmtm->stats.n_err++;1445 return;1446 }1447 1448 io_req = (struct csio_ioreq *) ((uintptr_t) wr_cmd->cookie);1449 io_req->wr_status = csio_wr_status(wr_cmd);1450 1451 /* lookup ioreq exists in our active Q */1452 spin_lock_irq(&hw->lock);1453 if (csio_mgmt_req_lookup(mgmtm, io_req) != 0) {1454 csio_err(mgmtm->hw,1455 "Error- Invalid IO handle recv in WR. handle: %p\n",1456 io_req);1457 mgmtm->stats.n_err++;1458 spin_unlock_irq(&hw->lock);1459 return;1460 }1461 1462 mgmtm = csio_hw_to_mgmtm(hw);1463 1464 /* Dequeue from active queue */1465 list_del_init(&io_req->sm.sm_list);1466 mgmtm->stats.n_active--;1467 spin_unlock_irq(&hw->lock);1468 1469 /* io_req will be freed by completion handler */1470 if (io_req->io_cbfn)1471 io_req->io_cbfn(hw, io_req);1472}1473 1474/**1475 * csio_fcoe_fwevt_handler - Event handler for Firmware FCoE events.1476 * @hw: HW module1477 * @cpl_op: CPL opcode1478 * @cmd: FW cmd/WR.1479 *1480 * Process received FCoE cmd/WR event from FW.1481 */1482void1483csio_fcoe_fwevt_handler(struct csio_hw *hw, __u8 cpl_op, __be64 *cmd)1484{1485 struct csio_lnode *ln;1486 struct csio_rnode *rn;1487 uint8_t portid, opcode = *(uint8_t *)cmd;1488 struct fw_fcoe_link_cmd *lcmd;1489 struct fw_wr_hdr *wr;1490 struct fw_rdev_wr *rdev_wr;1491 enum fw_fcoe_link_status lstatus;1492 uint32_t fcfi, rdev_flowid, vnpi;1493 enum csio_ln_ev evt;1494 1495 if (cpl_op == CPL_FW6_MSG && opcode == FW_FCOE_LINK_CMD) {1496 1497 lcmd = (struct fw_fcoe_link_cmd *)cmd;1498 lstatus = lcmd->lstatus;1499 portid = FW_FCOE_LINK_CMD_PORTID_GET(1500 ntohl(lcmd->op_to_portid));1501 fcfi = FW_FCOE_LINK_CMD_FCFI_GET(ntohl(lcmd->sub_opcode_fcfi));1502 vnpi = FW_FCOE_LINK_CMD_VNPI_GET(ntohl(lcmd->vnpi_pkd));1503 1504 if (lstatus == FCOE_LINKUP) {1505 1506 /* HW lock here */1507 spin_lock_irq(&hw->lock);1508 csio_handle_link_up(hw, portid, fcfi, vnpi);1509 spin_unlock_irq(&hw->lock);1510 /* HW un lock here */1511 1512 } else if (lstatus == FCOE_LINKDOWN) {1513 1514 /* HW lock here */1515 spin_lock_irq(&hw->lock);1516 csio_handle_link_down(hw, portid, fcfi, vnpi);1517 spin_unlock_irq(&hw->lock);1518 /* HW un lock here */1519 } else {1520 csio_warn(hw, "Unexpected FCOE LINK status:0x%x\n",1521 lcmd->lstatus);1522 CSIO_INC_STATS(hw, n_cpl_unexp);1523 }1524 } else if (cpl_op == CPL_FW6_PLD) {1525 wr = (struct fw_wr_hdr *) (cmd + 4);1526 if (FW_WR_OP_G(be32_to_cpu(wr->hi))1527 == FW_RDEV_WR) {1528 1529 rdev_wr = (struct fw_rdev_wr *) (cmd + 4);1530 1531 rdev_flowid = FW_RDEV_WR_FLOWID_GET(1532 ntohl(rdev_wr->alloc_to_len16));1533 vnpi = FW_RDEV_WR_ASSOC_FLOWID_GET(1534 ntohl(rdev_wr->flags_to_assoc_flowid));1535 1536 csio_dbg(hw,1537 "FW_RDEV_WR: flowid:x%x ev_cause:x%x "1538 "vnpi:0x%x\n", rdev_flowid,1539 rdev_wr->event_cause, vnpi);1540 1541 if (rdev_wr->protocol != PROT_FCOE) {1542 csio_err(hw,1543 "FW_RDEV_WR: invalid proto:x%x "1544 "received with flowid:x%x\n",1545 rdev_wr->protocol,1546 rdev_flowid);1547 CSIO_INC_STATS(hw, n_evt_drop);1548 return;1549 }1550 1551 /* HW lock here */1552 spin_lock_irq(&hw->lock);1553 ln = csio_ln_lookup_by_vnpi(hw, vnpi);1554 if (!ln) {1555 csio_err(hw,1556 "FW_DEV_WR: invalid vnpi:x%x received "1557 "with flowid:x%x\n", vnpi, rdev_flowid);1558 CSIO_INC_STATS(hw, n_evt_drop);1559 goto out_pld;1560 }1561 1562 rn = csio_confirm_rnode(ln, rdev_flowid,1563 &rdev_wr->u.fcoe_rdev);1564 if (!rn) {1565 csio_ln_dbg(ln,1566 "Failed to confirm rnode "1567 "for flowid:x%x\n", rdev_flowid);1568 CSIO_INC_STATS(hw, n_evt_drop);1569 goto out_pld;1570 }1571 1572 /* save previous event for debugging */1573 ln->prev_evt = ln->cur_evt;1574 ln->cur_evt = rdev_wr->event_cause;1575 CSIO_INC_STATS(ln, n_evt_fw[rdev_wr->event_cause]);1576 1577 /* Translate all the fabric events to lnode SM events */1578 evt = CSIO_FWE_TO_LNE(rdev_wr->event_cause);1579 if (evt) {1580 csio_ln_dbg(ln,1581 "Posting event to lnode event:%d "1582 "cause:%d flowid:x%x\n", evt,1583 rdev_wr->event_cause, rdev_flowid);1584 csio_post_event(&ln->sm, evt);1585 }1586 1587 /* Handover event to rn SM here. */1588 csio_rnode_fwevt_handler(rn, rdev_wr->event_cause);1589out_pld:1590 spin_unlock_irq(&hw->lock);1591 return;1592 } else {1593 csio_warn(hw, "unexpected WR op(0x%x) recv\n",1594 FW_WR_OP_G(be32_to_cpu((wr->hi))));1595 CSIO_INC_STATS(hw, n_cpl_unexp);1596 }1597 } else if (cpl_op == CPL_FW6_MSG) {1598 wr = (struct fw_wr_hdr *) (cmd);1599 if (FW_WR_OP_G(be32_to_cpu(wr->hi)) == FW_FCOE_ELS_CT_WR) {1600 csio_ln_mgmt_wr_handler(hw, wr,1601 sizeof(struct fw_fcoe_els_ct_wr));1602 } else {1603 csio_warn(hw, "unexpected WR op(0x%x) recv\n",1604 FW_WR_OP_G(be32_to_cpu((wr->hi))));1605 CSIO_INC_STATS(hw, n_cpl_unexp);1606 }1607 } else {1608 csio_warn(hw, "unexpected CPL op(0x%x) recv\n", opcode);1609 CSIO_INC_STATS(hw, n_cpl_unexp);1610 }1611}1612 1613/**1614 * csio_lnode_start - Kickstart lnode discovery.1615 * @ln: lnode1616 *1617 * This routine kickstarts the discovery by issuing an FCOE_LINK (up) command.1618 */1619int1620csio_lnode_start(struct csio_lnode *ln)1621{1622 int rv = 0;1623 if (csio_is_phys_ln(ln) && !(ln->flags & CSIO_LNF_LINK_ENABLE)) {1624 rv = csio_fcoe_enable_link(ln, 1);1625 ln->flags |= CSIO_LNF_LINK_ENABLE;1626 }1627 1628 return rv;1629}1630 1631/**1632 * csio_lnode_stop - Stop the lnode.1633 * @ln: lnode1634 *1635 * This routine is invoked by HW module to stop lnode and its associated NPIV1636 * lnodes.1637 */1638void1639csio_lnode_stop(struct csio_lnode *ln)1640{1641 csio_post_event_lns(ln, CSIO_LNE_DOWN_LINK);1642 if (csio_is_phys_ln(ln) && (ln->flags & CSIO_LNF_LINK_ENABLE)) {1643 csio_fcoe_enable_link(ln, 0);1644 ln->flags &= ~CSIO_LNF_LINK_ENABLE;1645 }1646 csio_ln_dbg(ln, "stopping ln :%p\n", ln);1647}1648 1649/**1650 * csio_lnode_close - Close an lnode.1651 * @ln: lnode1652 *1653 * This routine is invoked by HW module to close an lnode and its1654 * associated NPIV lnodes. Lnode and its associated NPIV lnodes are1655 * set to uninitialized state.1656 */1657void1658csio_lnode_close(struct csio_lnode *ln)1659{1660 csio_post_event_lns(ln, CSIO_LNE_CLOSE);1661 if (csio_is_phys_ln(ln))1662 ln->vnp_flowid = CSIO_INVALID_IDX;1663 1664 csio_ln_dbg(ln, "closed ln :%p\n", ln);1665}1666 1667/*1668 * csio_ln_prep_ecwr - Prepare ELS/CT WR.1669 * @io_req - IO request.1670 * @wr_len - WR len1671 * @immd_len - WR immediate data1672 * @sub_op - Sub opcode1673 * @sid - source portid.1674 * @did - destination portid1675 * @flow_id - flowid1676 * @fw_wr - ELS/CT WR to be prepared.1677 * Returns: 0 - on success1678 */1679static int1680csio_ln_prep_ecwr(struct csio_ioreq *io_req, uint32_t wr_len,1681 uint32_t immd_len, uint8_t sub_op, uint32_t sid,1682 uint32_t did, uint32_t flow_id, uint8_t *fw_wr)1683{1684 struct fw_fcoe_els_ct_wr *wr;1685 __be32 port_id;1686 1687 wr = (struct fw_fcoe_els_ct_wr *)fw_wr;1688 wr->op_immdlen = cpu_to_be32(FW_WR_OP_V(FW_FCOE_ELS_CT_WR) |1689 FW_FCOE_ELS_CT_WR_IMMDLEN(immd_len));1690 1691 wr_len = DIV_ROUND_UP(wr_len, 16);1692 wr->flowid_len16 = cpu_to_be32(FW_WR_FLOWID_V(flow_id) |1693 FW_WR_LEN16_V(wr_len));1694 wr->els_ct_type = sub_op;1695 wr->ctl_pri = 0;1696 wr->cp_en_class = 0;1697 wr->cookie = io_req->fw_handle;1698 wr->iqid = cpu_to_be16(csio_q_physiqid(1699 io_req->lnode->hwp, io_req->iq_idx));1700 wr->fl_to_sp = FW_FCOE_ELS_CT_WR_SP(1);1701 wr->tmo_val = (uint8_t) io_req->tmo;1702 port_id = htonl(sid);1703 memcpy(wr->l_id, PORT_ID_PTR(port_id), 3);1704 port_id = htonl(did);1705 memcpy(wr->r_id, PORT_ID_PTR(port_id), 3);1706 1707 /* Prepare RSP SGL */1708 wr->rsp_dmalen = cpu_to_be32(io_req->dma_buf.len);1709 wr->rsp_dmaaddr = cpu_to_be64(io_req->dma_buf.paddr);1710 return 0;1711}1712 1713/*1714 * csio_ln_mgmt_submit_wr - Post elsct work request.1715 * @mgmtm - mgmtm1716 * @io_req - io request.1717 * @sub_op - ELS or CT request type1718 * @pld - Dma Payload buffer1719 * @pld_len - Payload len1720 * Prepares ELSCT Work request and sents it to FW.1721 * Returns: 0 - on success1722 */1723static int1724csio_ln_mgmt_submit_wr(struct csio_mgmtm *mgmtm, struct csio_ioreq *io_req,1725 uint8_t sub_op, struct csio_dma_buf *pld,1726 uint32_t pld_len)1727{1728 struct csio_wr_pair wrp;1729 struct csio_lnode *ln = io_req->lnode;1730 struct csio_rnode *rn = io_req->rnode;1731 struct csio_hw *hw = mgmtm->hw;1732 uint8_t fw_wr[64];1733 struct ulptx_sgl dsgl;1734 uint32_t wr_size = 0;1735 uint8_t im_len = 0;1736 uint32_t wr_off = 0;1737 1738 int ret = 0;1739 1740 /* Calculate WR Size for this ELS REQ */1741 wr_size = sizeof(struct fw_fcoe_els_ct_wr);1742 1743 /* Send as immediate data if pld < 256 */1744 if (pld_len < 256) {1745 wr_size += ALIGN(pld_len, 8);1746 im_len = (uint8_t)pld_len;1747 } else1748 wr_size += sizeof(struct ulptx_sgl);1749 1750 /* Roundup WR size in units of 16 bytes */1751 wr_size = ALIGN(wr_size, 16);1752 1753 /* Get WR to send ELS REQ */1754 ret = csio_wr_get(hw, mgmtm->eq_idx, wr_size, &wrp);1755 if (ret != 0) {1756 csio_err(hw, "Failed to get WR for ec_req %p ret:%d\n",1757 io_req, ret);1758 return ret;1759 }1760 1761 /* Prepare Generic WR used by all ELS/CT cmd */1762 csio_ln_prep_ecwr(io_req, wr_size, im_len, sub_op,1763 ln->nport_id, rn->nport_id,1764 csio_rn_flowid(rn),1765 &fw_wr[0]);1766 1767 /* Copy ELS/CT WR CMD */1768 csio_wr_copy_to_wrp(&fw_wr[0], &wrp, wr_off,1769 sizeof(struct fw_fcoe_els_ct_wr));1770 wr_off += sizeof(struct fw_fcoe_els_ct_wr);1771 1772 /* Copy payload to Immediate section of WR */1773 if (im_len)1774 csio_wr_copy_to_wrp(pld->vaddr, &wrp, wr_off, im_len);1775 else {1776 /* Program DSGL to dma payload */1777 dsgl.cmd_nsge = htonl(ULPTX_CMD_V(ULP_TX_SC_DSGL) |1778 ULPTX_MORE_F | ULPTX_NSGE_V(1));1779 dsgl.len0 = cpu_to_be32(pld_len);1780 dsgl.addr0 = cpu_to_be64(pld->paddr);1781 csio_wr_copy_to_wrp(&dsgl, &wrp, ALIGN(wr_off, 8),1782 sizeof(struct ulptx_sgl));1783 }1784 1785 /* Issue work request to xmit ELS/CT req to FW */1786 csio_wr_issue(mgmtm->hw, mgmtm->eq_idx, false);1787 return ret;1788}1789 1790/*1791 * csio_ln_mgmt_submit_req - Submit FCOE Mgmt request.1792 * @io_req - IO Request1793 * @io_cbfn - Completion handler.1794 * @req_type - ELS or CT request type1795 * @pld - Dma Payload buffer1796 * @pld_len - Payload len1797 *1798 *1799 * This API used submit managment ELS/CT request.1800 * This called with hw lock held1801 * Returns: 0 - on success1802 * -ENOMEM - on error.1803 */1804static int1805csio_ln_mgmt_submit_req(struct csio_ioreq *io_req,1806 void (*io_cbfn) (struct csio_hw *, struct csio_ioreq *),1807 enum fcoe_cmn_type req_type, struct csio_dma_buf *pld,1808 uint32_t pld_len)1809{1810 struct csio_hw *hw = csio_lnode_to_hw(io_req->lnode);1811 struct csio_mgmtm *mgmtm = csio_hw_to_mgmtm(hw);1812 int rv;1813 1814 BUG_ON(pld_len > pld->len);1815 1816 io_req->io_cbfn = io_cbfn; /* Upper layer callback handler */1817 io_req->fw_handle = (uintptr_t) (io_req);1818 io_req->eq_idx = mgmtm->eq_idx;1819 io_req->iq_idx = mgmtm->iq_idx;1820 1821 rv = csio_ln_mgmt_submit_wr(mgmtm, io_req, req_type, pld, pld_len);1822 if (rv == 0) {1823 list_add_tail(&io_req->sm.sm_list, &mgmtm->active_q);1824 mgmtm->stats.n_active++;1825 }1826 return rv;1827}1828 1829/*1830 * csio_ln_fdmi_init - FDMI Init entry point.1831 * @ln: lnode1832 */1833static int1834csio_ln_fdmi_init(struct csio_lnode *ln)1835{1836 struct csio_hw *hw = csio_lnode_to_hw(ln);1837 struct csio_dma_buf *dma_buf;1838 1839 /* Allocate MGMT request required for FDMI */1840 ln->mgmt_req = kzalloc(sizeof(struct csio_ioreq), GFP_KERNEL);1841 if (!ln->mgmt_req) {1842 csio_ln_err(ln, "Failed to alloc ioreq for FDMI\n");1843 CSIO_INC_STATS(hw, n_err_nomem);1844 return -ENOMEM;1845 }1846 1847 /* Allocate Dma buffers for FDMI response Payload */1848 dma_buf = &ln->mgmt_req->dma_buf;1849 dma_buf->len = 2048;1850 dma_buf->vaddr = dma_alloc_coherent(&hw->pdev->dev, dma_buf->len,1851 &dma_buf->paddr, GFP_KERNEL);1852 if (!dma_buf->vaddr) {1853 csio_err(hw, "Failed to alloc DMA buffer for FDMI!\n");1854 kfree(ln->mgmt_req);1855 ln->mgmt_req = NULL;1856 return -ENOMEM;1857 }1858 1859 ln->flags |= CSIO_LNF_FDMI_ENABLE;1860 return 0;1861}1862 1863/*1864 * csio_ln_fdmi_exit - FDMI exit entry point.1865 * @ln: lnode1866 */1867static int1868csio_ln_fdmi_exit(struct csio_lnode *ln)1869{1870 struct csio_dma_buf *dma_buf;1871 struct csio_hw *hw = csio_lnode_to_hw(ln);1872 1873 if (!ln->mgmt_req)1874 return 0;1875 1876 dma_buf = &ln->mgmt_req->dma_buf;1877 if (dma_buf->vaddr)1878 dma_free_coherent(&hw->pdev->dev, dma_buf->len, dma_buf->vaddr,1879 dma_buf->paddr);1880 1881 kfree(ln->mgmt_req);1882 return 0;1883}1884 1885int1886csio_scan_done(struct csio_lnode *ln, unsigned long ticks,1887 unsigned long time, unsigned long max_scan_ticks,1888 unsigned long delta_scan_ticks)1889{1890 int rv = 0;1891 1892 if (time >= max_scan_ticks)1893 return 1;1894 1895 if (!ln->tgt_scan_tick)1896 ln->tgt_scan_tick = ticks;1897 1898 if (((ticks - ln->tgt_scan_tick) >= delta_scan_ticks)) {1899 if (!ln->last_scan_ntgts)1900 ln->last_scan_ntgts = ln->n_scsi_tgts;1901 else {1902 if (ln->last_scan_ntgts == ln->n_scsi_tgts)1903 return 1;1904 1905 ln->last_scan_ntgts = ln->n_scsi_tgts;1906 }1907 ln->tgt_scan_tick = ticks;1908 }1909 return rv;1910}1911 1912/*1913 * csio_notify_lnodes:1914 * @hw: HW module1915 * @note: Notification1916 *1917 * Called from the HW SM to fan out notifications to the1918 * Lnode SM. Since the HW SM is entered with lock held,1919 * there is no need to hold locks here.1920 *1921 */1922void1923csio_notify_lnodes(struct csio_hw *hw, enum csio_ln_notify note)1924{1925 struct list_head *tmp;1926 struct csio_lnode *ln;1927 1928 csio_dbg(hw, "Notifying all nodes of event %d\n", note);1929 1930 /* Traverse children lnodes list and send evt */1931 list_for_each(tmp, &hw->sln_head) {1932 ln = (struct csio_lnode *) tmp;1933 1934 switch (note) {1935 case CSIO_LN_NOTIFY_HWREADY:1936 csio_lnode_start(ln);1937 break;1938 1939 case CSIO_LN_NOTIFY_HWRESET:1940 case CSIO_LN_NOTIFY_HWREMOVE:1941 csio_lnode_close(ln);1942 break;1943 1944 case CSIO_LN_NOTIFY_HWSTOP:1945 csio_lnode_stop(ln);1946 break;1947 1948 default:1949 break;1950 1951 }1952 }1953}1954 1955/*1956 * csio_disable_lnodes:1957 * @hw: HW module1958 * @portid:port id1959 * @disable: disable/enable flag.1960 * If disable=1, disables all lnode hosted on given physical port.1961 * otherwise enables all the lnodes on given phsysical port.1962 * This routine need to called with hw lock held.1963 */1964void1965csio_disable_lnodes(struct csio_hw *hw, uint8_t portid, bool disable)1966{1967 struct list_head *tmp;1968 struct csio_lnode *ln;1969 1970 csio_dbg(hw, "Notifying event to all nodes of port:%d\n", portid);1971 1972 /* Traverse sibling lnodes list and send evt */1973 list_for_each(tmp, &hw->sln_head) {1974 ln = (struct csio_lnode *) tmp;1975 if (ln->portid != portid)1976 continue;1977 1978 if (disable)1979 csio_lnode_stop(ln);1980 else1981 csio_lnode_start(ln);1982 }1983}1984 1985/*1986 * csio_ln_init - Initialize an lnode.1987 * @ln: lnode1988 *1989 */1990static int1991csio_ln_init(struct csio_lnode *ln)1992{1993 int rv = -EINVAL;1994 struct csio_lnode *pln;1995 struct csio_hw *hw = csio_lnode_to_hw(ln);1996 1997 csio_init_state(&ln->sm, csio_lns_uninit);1998 ln->vnp_flowid = CSIO_INVALID_IDX;1999 ln->fcf_flowid = CSIO_INVALID_IDX;2000 2001 if (csio_is_root_ln(ln)) {2002 2003 /* This is the lnode used during initialization */2004 2005 ln->fcfinfo = kzalloc(sizeof(struct csio_fcf_info), GFP_KERNEL);2006 if (!ln->fcfinfo) {2007 csio_ln_err(ln, "Failed to alloc FCF record\n");2008 CSIO_INC_STATS(hw, n_err_nomem);2009 goto err;2010 }2011 2012 INIT_LIST_HEAD(&ln->fcf_lsthead);2013 kref_init(&ln->fcfinfo->kref);2014 2015 if (csio_fdmi_enable && csio_ln_fdmi_init(ln))2016 goto err;2017 2018 } else { /* Either a non-root physical or a virtual lnode */2019 2020 /*2021 * THe rest is common for non-root physical and NPIV lnodes.2022 * Just get references to all other modules2023 */2024 2025 if (csio_is_npiv_ln(ln)) {2026 /* NPIV */2027 pln = csio_parent_lnode(ln);2028 kref_get(&pln->fcfinfo->kref);2029 ln->fcfinfo = pln->fcfinfo;2030 } else {2031 /* Another non-root physical lnode (FCF) */2032 ln->fcfinfo = kzalloc(sizeof(struct csio_fcf_info),2033 GFP_KERNEL);2034 if (!ln->fcfinfo) {2035 csio_ln_err(ln, "Failed to alloc FCF info\n");2036 CSIO_INC_STATS(hw, n_err_nomem);2037 goto err;2038 }2039 2040 kref_init(&ln->fcfinfo->kref);2041 2042 if (csio_fdmi_enable && csio_ln_fdmi_init(ln))2043 goto err;2044 }2045 2046 } /* if (!csio_is_root_ln(ln)) */2047 2048 return 0;2049err:2050 return rv;2051}2052 2053static void2054csio_ln_exit(struct csio_lnode *ln)2055{2056 struct csio_lnode *pln;2057 2058 csio_cleanup_rns(ln);2059 if (csio_is_npiv_ln(ln)) {2060 pln = csio_parent_lnode(ln);2061 kref_put(&pln->fcfinfo->kref, csio_free_fcfinfo);2062 } else {2063 kref_put(&ln->fcfinfo->kref, csio_free_fcfinfo);2064 if (csio_fdmi_enable)2065 csio_ln_fdmi_exit(ln);2066 }2067 ln->fcfinfo = NULL;2068}2069 2070/*2071 * csio_lnode_init - Initialize the members of an lnode.2072 * @ln: lnode2073 */2074int2075csio_lnode_init(struct csio_lnode *ln, struct csio_hw *hw,2076 struct csio_lnode *pln)2077{2078 int rv = -EINVAL;2079 2080 /* Link this lnode to hw */2081 csio_lnode_to_hw(ln) = hw;2082 2083 /* Link child to parent if child lnode */2084 if (pln)2085 ln->pln = pln;2086 else2087 ln->pln = NULL;2088 2089 /* Initialize scsi_tgt and timers to zero */2090 ln->n_scsi_tgts = 0;2091 ln->last_scan_ntgts = 0;2092 ln->tgt_scan_tick = 0;2093 2094 /* Initialize rnode list */2095 INIT_LIST_HEAD(&ln->rnhead);2096 INIT_LIST_HEAD(&ln->cln_head);2097 2098 /* Initialize log level for debug */2099 ln->params.log_level = hw->params.log_level;2100 2101 if (csio_ln_init(ln))2102 goto err;2103 2104 /* Add lnode to list of sibling or children lnodes */2105 spin_lock_irq(&hw->lock);2106 list_add_tail(&ln->sm.sm_list, pln ? &pln->cln_head : &hw->sln_head);2107 if (pln)2108 pln->num_vports++;2109 spin_unlock_irq(&hw->lock);2110 2111 hw->num_lns++;2112 2113 return 0;2114err:2115 csio_lnode_to_hw(ln) = NULL;2116 return rv;2117}2118 2119/**2120 * csio_lnode_exit - De-instantiate an lnode.2121 * @ln: lnode2122 *2123 */2124void2125csio_lnode_exit(struct csio_lnode *ln)2126{2127 struct csio_hw *hw = csio_lnode_to_hw(ln);2128 2129 csio_ln_exit(ln);2130 2131 /* Remove this lnode from hw->sln_head */2132 spin_lock_irq(&hw->lock);2133 2134 list_del_init(&ln->sm.sm_list);2135 2136 /* If it is children lnode, decrement the2137 * counter in its parent lnode2138 */2139 if (ln->pln)2140 ln->pln->num_vports--;2141 2142 /* Update root lnode pointer */2143 if (list_empty(&hw->sln_head))2144 hw->rln = NULL;2145 else2146 hw->rln = (struct csio_lnode *)csio_list_next(&hw->sln_head);2147 2148 spin_unlock_irq(&hw->lock);2149 2150 csio_lnode_to_hw(ln) = NULL;2151 hw->num_lns--;2152}2153