drivers/scsi/csiostor/csio_lnode.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 two
   7  * licenses.  You may choose to be licensed under the terms of the GNU
   8  * General Public License (GPL) Version 2, available from the file
   9  * COPYING in the main directory of this source tree, or the
  10  * OpenIB.org BSD license below:
  11  *
  12  *     Redistribution and use in source and binary forms, with or
  13  *     without modification, are permitted provided that the following
  14  *     conditions are met:
  15  *
  16  *      - Redistributions of source code must retain the above
  17  *        copyright notice, this list of conditions and the following
  18  *        disclaimer.
  19  *
  20  *      - Redistributions in binary form must reproduce the above
  21  *        copyright notice, this list of conditions and the following
  22  *        disclaimer in the documentation and/or other materials
  23  *        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 OF
  27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  32  * 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 <asm/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
  52 int csio_fcoe_rnodes = 1024;
  53 int csio_fdmi_enable = 1;
  54
  55 #define PORT_ID_PTR(_x)         ((uint8_t *)(&_x) + 1)
  56
  57 /* Lnode SM declarations */
  58 static void csio_lns_uninit(struct csio_lnode *, enum csio_ln_ev);
  59 static void csio_lns_online(struct csio_lnode *, enum csio_ln_ev);
  60 static void csio_lns_ready(struct csio_lnode *, enum csio_ln_ev);
  61 static void csio_lns_offline(struct csio_lnode *, enum csio_ln_ev);
  62
  63 static 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 */
  68 static 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 module
 110  * @portid: port-id.
 111  *
 112  * If found, returns lnode matching given portid otherwise returns NULL.
 113  */
 114 static struct csio_lnode *
 115 csio_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 module
 133  * @vnpi - vnp index.
 134  * Returns - If found, returns lnode matching given vnp id
 135  * otherwise returns NULL.
 136  */
 137 static struct csio_lnode *
 138 csio_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  */
 177 struct csio_lnode *
 178 csio_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 */
 210 static void
 211 csio_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
 220 static int
 221 csio_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
 228 static int
 229 csio_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
 240 static inline void
 241 csio_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 completion
 263  * @hw: HW context
 264  * @fdmi_req: fdmi request
 265  */
 266 static void
 267 csio_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 completion
 287  * @hw: HW context
 288  * @fdmi_req: fdmi request
 289  */
 290 static void
 291 csio_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         else
 365                 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 completion
 400  * @hw: HW context
 401  * @fdmi_req: fdmi request
 402  */
 403 static void
 404 csio_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(&reg_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 completion
 507  * @hw: HW context
 508  * @fdmi_req: fdmi request
 509  */
 510 static void
 511 csio_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 registered
 536          * before
 537          */
 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:         lnode
 560  * @context:    session context
 561  *
 562  * Issued with lock held.
 563  */
 564 int
 565 csio_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 registered
 580          * before
 581          */
 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 lnode
 610  * @cbfn: Completion handler.
 611  *
 612  * Reads vnp response and updates ln parameters.
 613  */
 614 static void
 615 csio_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 between
 642          * 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: lnode
 675  * @cbfn: Completion handler.
 676  *
 677  * Issued with lock held.
 678  */
 679 static int
 680 csio_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: lnode
 713  * @enable: enable/disable
 714  * Issued with lock held.
 715  * Issues mbox cmd to bring up FCOE link on port associated with given ln.
 716  */
 717 static int
 718 csio_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
 771 out:
 772         mempool_free(mbp, hw->mb_mempool);
 773         return 0;
 774 }
 775
 776 /*
 777  * csio_ln_read_fcf_cbfn - Read fcf parameters
 778  * @ln: lnode
 779  *
 780  * read fcf response and Update ln fcf information.
 781  */
 782 static void
 783 csio_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: lnode
 826  * @cbfn: Completion handler.
 827  *
 828  * Issued with lock held.
 829  */
 830 static int
 831 csio_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 number
 860  * @fcfi - FCF index.
 861  * @vnpi - VNP index.
 862  * Returns - none.
 863  *
 864  * This event is received from FW, when virtual link is established between
 865  * Physical port[ENode] and FCF. If its new vnpi, then local node object is
 866  * created on this FCF and set to [ONLINE] state.
 867  * Lnode waits for FW_RDEV_CMD event to be received indicating that
 868  * Fabric login is completed and lnode moves to [READY] state.
 869  *
 870  * This called with hw lock held
 871  */
 872 static void
 873 csio_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_rns
 924  * @ln - FCOE lnode
 925  * @evt - Given rnode event
 926  * Returns - none
 927  *
 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/CLOSE
 930  * event.
 931  *
 932  * This called with hw lock held
 933  */
 934 static void
 935 csio_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_rns
 949  * @ln - FCOE lnode
 950  * Returns - none
 951  *
 952  * Frees all FCOE rnodes connected with given Lnode.
 953  *
 954  * This called with hw lock held
 955  */
 956 static void
 957 csio_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_lns
 972  * @ln - FCOE lnode
 973  * @evt - Given lnode event
 974  * Returns - none
 975  *
 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/CLOSE
 978  * event.
 979  *
 980  * This called with hw lock held
 981  */
 982 static void
 983 csio_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 down
1007  * @ln - FCOE Lnode
1008  * Returns - none
1009  *
1010  * Sends LINK_DOWN events to Lnode and its associated NPIVs lnodes.
1011  *
1012  * This called with hw lock held
1013  */
1014 static void
1015 csio_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 number
1024  * @fcfi - FCF index.
1025  * @vnpi - VNP index.
1026  * Returns - none
1027  *
1028  * This event is received from FW, when virtual link goes down between
1029  * Physical port[ENode] and FCF. Lnode and its associated NPIVs lnode hosted on
1030  * this vnpi[VN-Port] will be de-instantiated.
1031  *
1032  * This called with hw lock held
1033  */
1034 static void
1035 csio_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 module
1092  *
1093  * Returns True if FCOE lnode is in ready state.
1094  */
1095 int
1096 csio_is_lnode_ready(struct csio_lnode *ln)
1097 {
1098         return (csio_get_state(ln) == ((csio_sm_state_t)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  */
1113 static void
1114 csio_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  */
1166 static void
1167 csio_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                 /* Fall through */
1191         case CSIO_LNE_DOWN_LINK:
1192                 csio_set_state(&ln->sm, csio_lns_uninit);
1193                 if (csio_is_phys_ln(ln)) {
1194                         /* Remove FCF entry */
1195                         list_del_init(&ln->fcfinfo->list);
1196                 }
1197                 break;
1198
1199         default:
1200                 csio_ln_dbg(ln,
1201                             "unexp ln event %d recv from did:x%x in "
1202                             "ln state[uninit].\n", evt, ln->nport_id);
1203                 CSIO_INC_STATS(ln, n_evt_unexp);
1204
1205                 break;
1206         } /* switch event */
1207 }
1208
1209 /*
1210  * csio_lns_ready - The request in ready state.
1211  * @ln - FCOE lnode.
1212  * @evt - Event to be processed.
1213  *
1214  * Process the given lnode event which is currently in "ready" state.
1215  * Invoked with HW lock held.
1216  * Return - none.
1217  */
1218 static void
1219 csio_lns_ready(struct csio_lnode *ln, enum csio_ln_ev evt)
1220 {
1221         struct csio_hw *hw = csio_lnode_to_hw(ln);
1222
1223         CSIO_INC_STATS(ln, n_evt_sm[evt]);
1224         switch (evt) {
1225         case CSIO_LNE_FAB_INIT_DONE:
1226                 csio_ln_dbg(ln,
1227                             "ignoring event %d recv from did x%x"
1228                             "in ln state[ready].\n", evt, ln->nport_id);
1229                 CSIO_INC_STATS(ln, n_evt_drop);
1230                 break;
1231
1232         case CSIO_LNE_LINK_DOWN:
1233                 csio_set_state(&ln->sm, csio_lns_offline);
1234                 csio_post_event_rns(ln, CSIO_RNFE_DOWN);
1235
1236                 spin_unlock_irq(&hw->lock);
1237                 csio_lnode_async_event(ln, CSIO_LN_FC_LINKDOWN);
1238                 spin_lock_irq(&hw->lock);
1239
1240                 if (csio_is_phys_ln(ln)) {
1241                         /* Remove FCF entry */
1242                         list_del_init(&ln->fcfinfo->list);
1243                 }
1244                 break;
1245
1246         case CSIO_LNE_DOWN_LINK:
1247                 csio_set_state(&ln->sm, csio_lns_offline);
1248                 csio_post_event_rns(ln, CSIO_RNFE_DOWN);
1249
1250                 /* Host need to issue aborts in case if FW has not returned
1251                  * WRs with status "ABORTED"
1252                  */
1253                 spin_unlock_irq(&hw->lock);
1254                 csio_lnode_async_event(ln, CSIO_LN_FC_LINKDOWN);
1255                 spin_lock_irq(&hw->lock);
1256
1257                 if (csio_is_phys_ln(ln)) {
1258                         /* Remove FCF entry */
1259                         list_del_init(&ln->fcfinfo->list);
1260                 }
1261                 break;
1262
1263         case CSIO_LNE_CLOSE:
1264                 csio_set_state(&ln->sm, csio_lns_uninit);
1265                 csio_post_event_rns(ln, CSIO_RNFE_CLOSE);
1266                 break;
1267
1268         case CSIO_LNE_LOGO:
1269                 csio_set_state(&ln->sm, csio_lns_offline);
1270                 csio_post_event_rns(ln, CSIO_RNFE_DOWN);
1271                 break;
1272
1273         default:
1274                 csio_ln_dbg(ln,
1275                             "unexp ln event %d recv from did:x%x in "
1276                             "ln state[uninit].\n", evt, ln->nport_id);
1277                 CSIO_INC_STATS(ln, n_evt_unexp);
1278                 CSIO_DB_ASSERT(0);
1279                 break;
1280         } /* switch event */
1281 }
1282
1283 /*
1284  * csio_lns_offline - The request in offline state.
1285  * @ln - FCOE lnode.
1286  * @evt - Event to be processed.
1287  *
1288  * Process the given lnode event which is currently in "offline" state.
1289  * Invoked with HW lock held.
1290  * Return - none.
1291  */
1292 static void
1293 csio_lns_offline(struct csio_lnode *ln, enum csio_ln_ev evt)
1294 {
1295         struct csio_hw *hw = csio_lnode_to_hw(ln);
1296         struct csio_lnode *rln = hw->rln;
1297         int rv;
1298
1299         CSIO_INC_STATS(ln, n_evt_sm[evt]);
1300         switch (evt) {
1301         case CSIO_LNE_LINKUP:
1302                 csio_set_state(&ln->sm, csio_lns_online);
1303                 /* Read FCF only for physical lnode */
1304                 if (csio_is_phys_ln(ln)) {
1305                         rv = csio_ln_read_fcf_entry(ln,
1306                                         csio_ln_read_fcf_cbfn);
1307                         if (rv != 0) {
1308                                 /* TODO: Send HW RESET event */
1309                                 CSIO_INC_STATS(ln, n_err);
1310                                 break;
1311                         }
1312
1313                         /* Add FCF record */
1314                         list_add_tail(&ln->fcfinfo->list, &rln->fcf_lsthead);
1315                 }
1316
1317                 rv = csio_ln_vnp_read(ln, csio_ln_vnp_read_cbfn);
1318                 if (rv != 0) {
1319                         /* TODO: Send HW RESET event */
1320                         CSIO_INC_STATS(ln, n_err);
1321                 }
1322                 break;
1323
1324         case CSIO_LNE_LINK_DOWN:
1325         case CSIO_LNE_DOWN_LINK:
1326         case CSIO_LNE_LOGO:
1327                 csio_ln_dbg(ln,
1328                             "ignoring event %d recv from did x%x"
1329                             "in ln state[offline].\n", evt, ln->nport_id);
1330                 CSIO_INC_STATS(ln, n_evt_drop);
1331                 break;
1332
1333         case CSIO_LNE_CLOSE:
1334                 csio_set_state(&ln->sm, csio_lns_uninit);
1335                 csio_post_event_rns(ln, CSIO_RNFE_CLOSE);
1336                 break;
1337
1338         default:
1339                 csio_ln_dbg(ln,
1340                             "unexp ln event %d recv from did:x%x in "
1341                             "ln state[offline]\n", evt, ln->nport_id);
1342                 CSIO_INC_STATS(ln, n_evt_unexp);
1343                 CSIO_DB_ASSERT(0);
1344                 break;
1345         } /* switch event */
1346 }
1347
1348 /*****************************************************************************/
1349 /* END: Lnode SM                                                             */
1350 /*****************************************************************************/
1351
1352 static void
1353 csio_free_fcfinfo(struct kref *kref)
1354 {
1355         struct csio_fcf_info *fcfinfo = container_of(kref,
1356                                                 struct csio_fcf_info, kref);
1357         kfree(fcfinfo);
1358 }
1359
1360 /* Helper routines for attributes  */
1361 /*
1362  * csio_lnode_state_to_str - Get current state of FCOE lnode.
1363  * @ln - lnode
1364  * @str - state of lnode.
1365  *
1366  */
1367 void
1368 csio_lnode_state_to_str(struct csio_lnode *ln, int8_t *str)
1369 {
1370         if (csio_get_state(ln) == ((csio_sm_state_t)csio_lns_uninit)) {
1371                 strcpy(str, "UNINIT");
1372                 return;
1373         }
1374         if (csio_get_state(ln) == ((csio_sm_state_t)csio_lns_ready)) {
1375                 strcpy(str, "READY");
1376                 return;
1377         }
1378         if (csio_get_state(ln) == ((csio_sm_state_t)csio_lns_offline)) {
1379                 strcpy(str, "OFFLINE");
1380                 return;
1381         }
1382         strcpy(str, "UNKNOWN");
1383 } /* csio_lnode_state_to_str */
1384
1385
1386 int
1387 csio_get_phy_port_stats(struct csio_hw *hw, uint8_t portid,
1388                         struct fw_fcoe_port_stats *port_stats)
1389 {
1390         struct csio_mb  *mbp;
1391         struct fw_fcoe_port_cmd_params portparams;
1392         enum fw_retval retval;
1393         int idx;
1394
1395         mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
1396         if (!mbp) {
1397                 csio_err(hw, "FCoE FCF PARAMS command out of memory!\n");
1398                 return -EINVAL;
1399         }
1400         portparams.portid = portid;
1401
1402         for (idx = 1; idx <= 3; idx++) {
1403                 portparams.idx = (idx-1)*6 + 1;
1404                 portparams.nstats = 6;
1405                 if (idx == 3)
1406                         portparams.nstats = 4;
1407                 csio_fcoe_read_portparams_init_mb(hw, mbp, CSIO_MB_DEFAULT_TMO,
1408                                                         &portparams, NULL);
1409                 if (csio_mb_issue(hw, mbp)) {
1410                         csio_err(hw, "Issue of FCoE port params failed!\n");
1411                         mempool_free(mbp, hw->mb_mempool);
1412                         return -EINVAL;
1413                 }
1414                 csio_mb_process_portparams_rsp(hw, mbp, &retval,
1415                                                 &portparams, port_stats);
1416         }
1417
1418         mempool_free(mbp, hw->mb_mempool);
1419         return 0;
1420 }
1421
1422 /*
1423  * csio_ln_mgmt_wr_handler -Mgmt Work Request handler.
1424  * @wr - WR.
1425  * @len - WR len.
1426  * This handler is invoked when an outstanding mgmt WR is completed.
1427  * Its invoked in the context of FW event worker thread for every
1428  * mgmt event received.
1429  * Return - none.
1430  */
1431
1432 static void
1433 csio_ln_mgmt_wr_handler(struct csio_hw *hw, void *wr, uint32_t len)
1434 {
1435         struct csio_mgmtm *mgmtm = csio_hw_to_mgmtm(hw);
1436         struct csio_ioreq *io_req = NULL;
1437         struct fw_fcoe_els_ct_wr *wr_cmd;
1438
1439
1440         wr_cmd = (struct fw_fcoe_els_ct_wr *) wr;
1441
1442         if (len < sizeof(struct fw_fcoe_els_ct_wr)) {
1443                 csio_err(mgmtm->hw,
1444                          "Invalid ELS CT WR length recvd, len:%x\n", len);
1445                 mgmtm->stats.n_err++;
1446                 return;
1447         }
1448
1449         io_req = (struct csio_ioreq *) ((uintptr_t) wr_cmd->cookie);
1450         io_req->wr_status = csio_wr_status(wr_cmd);
1451
1452         /* lookup ioreq exists in our active Q */
1453         spin_lock_irq(&hw->lock);
1454         if (csio_mgmt_req_lookup(mgmtm, io_req) != 0) {
1455                 csio_err(mgmtm->hw,
1456                         "Error- Invalid IO handle recv in WR. handle: %p\n",
1457                         io_req);
1458                 mgmtm->stats.n_err++;
1459                 spin_unlock_irq(&hw->lock);
1460                 return;
1461         }
1462
1463         mgmtm = csio_hw_to_mgmtm(hw);
1464
1465         /* Dequeue from active queue */
1466         list_del_init(&io_req->sm.sm_list);
1467         mgmtm->stats.n_active--;
1468         spin_unlock_irq(&hw->lock);
1469
1470         /* io_req will be freed by completion handler */
1471         if (io_req->io_cbfn)
1472                 io_req->io_cbfn(hw, io_req);
1473 }
1474
1475 /**
1476  * csio_fcoe_fwevt_handler - Event handler for Firmware FCoE events.
1477  * @hw:         HW module
1478  * @cpl_op:     CPL opcode
1479  * @cmd:        FW cmd/WR.
1480  *
1481  * Process received FCoE cmd/WR event from FW.
1482  */
1483 void
1484 csio_fcoe_fwevt_handler(struct csio_hw *hw, __u8 cpl_op, __be64 *cmd)
1485 {
1486         struct csio_lnode *ln;
1487         struct csio_rnode *rn;
1488         uint8_t portid, opcode = *(uint8_t *)cmd;
1489         struct fw_fcoe_link_cmd *lcmd;
1490         struct fw_wr_hdr *wr;
1491         struct fw_rdev_wr *rdev_wr;
1492         enum fw_fcoe_link_status lstatus;
1493         uint32_t fcfi, rdev_flowid, vnpi;
1494         enum csio_ln_ev evt;
1495
1496         if (cpl_op == CPL_FW6_MSG && opcode == FW_FCOE_LINK_CMD) {
1497
1498                 lcmd = (struct fw_fcoe_link_cmd *)cmd;
1499                 lstatus = lcmd->lstatus;
1500                 portid = FW_FCOE_LINK_CMD_PORTID_GET(
1501                                         ntohl(lcmd->op_to_portid));
1502                 fcfi = FW_FCOE_LINK_CMD_FCFI_GET(ntohl(lcmd->sub_opcode_fcfi));
1503                 vnpi = FW_FCOE_LINK_CMD_VNPI_GET(ntohl(lcmd->vnpi_pkd));
1504
1505                 if (lstatus == FCOE_LINKUP) {
1506
1507                         /* HW lock here */
1508                         spin_lock_irq(&hw->lock);
1509                         csio_handle_link_up(hw, portid, fcfi, vnpi);
1510                         spin_unlock_irq(&hw->lock);
1511                         /* HW un lock here */
1512
1513                 } else if (lstatus == FCOE_LINKDOWN) {
1514
1515                         /* HW lock here */
1516                         spin_lock_irq(&hw->lock);
1517                         csio_handle_link_down(hw, portid, fcfi, vnpi);
1518                         spin_unlock_irq(&hw->lock);
1519                         /* HW un lock here */
1520                 } else {
1521                         csio_warn(hw, "Unexpected FCOE LINK status:0x%x\n",
1522                                   lcmd->lstatus);
1523                         CSIO_INC_STATS(hw, n_cpl_unexp);
1524                 }
1525         } else if (cpl_op == CPL_FW6_PLD) {
1526                 wr = (struct fw_wr_hdr *) (cmd + 4);
1527                 if (FW_WR_OP_G(be32_to_cpu(wr->hi))
1528                         == FW_RDEV_WR) {
1529
1530                         rdev_wr = (struct fw_rdev_wr *) (cmd + 4);
1531
1532                         rdev_flowid = FW_RDEV_WR_FLOWID_GET(
1533                                         ntohl(rdev_wr->alloc_to_len16));
1534                         vnpi = FW_RDEV_WR_ASSOC_FLOWID_GET(
1535                                     ntohl(rdev_wr->flags_to_assoc_flowid));
1536
1537                         csio_dbg(hw,
1538                                 "FW_RDEV_WR: flowid:x%x ev_cause:x%x "
1539                                 "vnpi:0x%x\n", rdev_flowid,
1540                                 rdev_wr->event_cause, vnpi);
1541
1542                         if (rdev_wr->protocol != PROT_FCOE) {
1543                                 csio_err(hw,
1544                                         "FW_RDEV_WR: invalid proto:x%x "
1545                                         "received with flowid:x%x\n",
1546                                         rdev_wr->protocol,
1547                                         rdev_flowid);
1548                                 CSIO_INC_STATS(hw, n_evt_drop);
1549                                 return;
1550                         }
1551
1552                         /* HW lock here */
1553                         spin_lock_irq(&hw->lock);
1554                         ln = csio_ln_lookup_by_vnpi(hw, vnpi);
1555                         if (!ln) {
1556                                 csio_err(hw,
1557                                         "FW_DEV_WR: invalid vnpi:x%x received "
1558                                         "with flowid:x%x\n", vnpi, rdev_flowid);
1559                                 CSIO_INC_STATS(hw, n_evt_drop);
1560                                 goto out_pld;
1561                         }
1562
1563                         rn = csio_confirm_rnode(ln, rdev_flowid,
1564                                         &rdev_wr->u.fcoe_rdev);
1565                         if (!rn) {
1566                                 csio_ln_dbg(ln,
1567                                         "Failed to confirm rnode "
1568                                         "for flowid:x%x\n", rdev_flowid);
1569                                 CSIO_INC_STATS(hw, n_evt_drop);
1570                                 goto out_pld;
1571                         }
1572
1573                         /* save previous event for debugging */
1574                         ln->prev_evt = ln->cur_evt;
1575                         ln->cur_evt = rdev_wr->event_cause;
1576                         CSIO_INC_STATS(ln, n_evt_fw[rdev_wr->event_cause]);
1577
1578                         /* Translate all the fabric events to lnode SM events */
1579                         evt = CSIO_FWE_TO_LNE(rdev_wr->event_cause);
1580                         if (evt) {
1581                                 csio_ln_dbg(ln,
1582                                         "Posting event to lnode event:%d "
1583                                         "cause:%d flowid:x%x\n", evt,
1584                                         rdev_wr->event_cause, rdev_flowid);
1585                                 csio_post_event(&ln->sm, evt);
1586                         }
1587
1588                         /* Handover event to rn SM here. */
1589                         csio_rnode_fwevt_handler(rn, rdev_wr->event_cause);
1590 out_pld:
1591                         spin_unlock_irq(&hw->lock);
1592                         return;
1593                 } else {
1594                         csio_warn(hw, "unexpected WR op(0x%x) recv\n",
1595                                   FW_WR_OP_G(be32_to_cpu((wr->hi))));
1596                         CSIO_INC_STATS(hw, n_cpl_unexp);
1597                 }
1598         } else if (cpl_op == CPL_FW6_MSG) {
1599                 wr = (struct fw_wr_hdr *) (cmd);
1600                 if (FW_WR_OP_G(be32_to_cpu(wr->hi)) == FW_FCOE_ELS_CT_WR) {
1601                         csio_ln_mgmt_wr_handler(hw, wr,
1602                                         sizeof(struct fw_fcoe_els_ct_wr));
1603                 } else {
1604                         csio_warn(hw, "unexpected WR op(0x%x) recv\n",
1605                                   FW_WR_OP_G(be32_to_cpu((wr->hi))));
1606                         CSIO_INC_STATS(hw, n_cpl_unexp);
1607                 }
1608         } else {
1609                 csio_warn(hw, "unexpected CPL op(0x%x) recv\n", opcode);
1610                 CSIO_INC_STATS(hw, n_cpl_unexp);
1611         }
1612 }
1613
1614 /**
1615  * csio_lnode_start - Kickstart lnode discovery.
1616  * @ln:         lnode
1617  *
1618  * This routine kickstarts the discovery by issuing an FCOE_LINK (up) command.
1619  */
1620 int
1621 csio_lnode_start(struct csio_lnode *ln)
1622 {
1623         int rv = 0;
1624         if (csio_is_phys_ln(ln) && !(ln->flags & CSIO_LNF_LINK_ENABLE)) {
1625                 rv = csio_fcoe_enable_link(ln, 1);
1626                 ln->flags |= CSIO_LNF_LINK_ENABLE;
1627         }
1628
1629         return rv;
1630 }
1631
1632 /**
1633  * csio_lnode_stop - Stop the lnode.
1634  * @ln:         lnode
1635  *
1636  * This routine is invoked by HW module to stop lnode and its associated NPIV
1637  * lnodes.
1638  */
1639 void
1640 csio_lnode_stop(struct csio_lnode *ln)
1641 {
1642         csio_post_event_lns(ln, CSIO_LNE_DOWN_LINK);
1643         if (csio_is_phys_ln(ln) && (ln->flags & CSIO_LNF_LINK_ENABLE)) {
1644                 csio_fcoe_enable_link(ln, 0);
1645                 ln->flags &= ~CSIO_LNF_LINK_ENABLE;
1646         }
1647         csio_ln_dbg(ln, "stopping ln :%p\n", ln);
1648 }
1649
1650 /**
1651  * csio_lnode_close - Close an lnode.
1652  * @ln:         lnode
1653  *
1654  * This routine is invoked by HW module to close an lnode and its
1655  * associated NPIV lnodes. Lnode and its associated NPIV lnodes are
1656  * set to uninitialized state.
1657  */
1658 void
1659 csio_lnode_close(struct csio_lnode *ln)
1660 {
1661         csio_post_event_lns(ln, CSIO_LNE_CLOSE);
1662         if (csio_is_phys_ln(ln))
1663                 ln->vnp_flowid = CSIO_INVALID_IDX;
1664
1665         csio_ln_dbg(ln, "closed ln :%p\n", ln);
1666 }
1667
1668 /*
1669  * csio_ln_prep_ecwr - Prepare ELS/CT WR.
1670  * @io_req - IO request.
1671  * @wr_len - WR len
1672  * @immd_len - WR immediate data
1673  * @sub_op - Sub opcode
1674  * @sid - source portid.
1675  * @did - destination portid
1676  * @flow_id - flowid
1677  * @fw_wr - ELS/CT WR to be prepared.
1678  * Returns: 0 - on success
1679  */
1680 static int
1681 csio_ln_prep_ecwr(struct csio_ioreq *io_req, uint32_t wr_len,
1682                       uint32_t immd_len, uint8_t sub_op, uint32_t sid,
1683                       uint32_t did, uint32_t flow_id, uint8_t *fw_wr)
1684 {
1685         struct fw_fcoe_els_ct_wr *wr;
1686         __be32 port_id;
1687
1688         wr  = (struct fw_fcoe_els_ct_wr *)fw_wr;
1689         wr->op_immdlen = cpu_to_be32(FW_WR_OP_V(FW_FCOE_ELS_CT_WR) |
1690                                      FW_FCOE_ELS_CT_WR_IMMDLEN(immd_len));
1691
1692         wr_len =  DIV_ROUND_UP(wr_len, 16);
1693         wr->flowid_len16 = cpu_to_be32(FW_WR_FLOWID_V(flow_id) |
1694                                        FW_WR_LEN16_V(wr_len));
1695         wr->els_ct_type = sub_op;
1696         wr->ctl_pri = 0;
1697         wr->cp_en_class = 0;
1698         wr->cookie = io_req->fw_handle;
1699         wr->iqid = cpu_to_be16(csio_q_physiqid(
1700                                         io_req->lnode->hwp, io_req->iq_idx));
1701         wr->fl_to_sp =  FW_FCOE_ELS_CT_WR_SP(1);
1702         wr->tmo_val = (uint8_t) io_req->tmo;
1703         port_id = htonl(sid);
1704         memcpy(wr->l_id, PORT_ID_PTR(port_id), 3);
1705         port_id = htonl(did);
1706         memcpy(wr->r_id, PORT_ID_PTR(port_id), 3);
1707
1708         /* Prepare RSP SGL */
1709         wr->rsp_dmalen = cpu_to_be32(io_req->dma_buf.len);
1710         wr->rsp_dmaaddr = cpu_to_be64(io_req->dma_buf.paddr);
1711         return 0;
1712 }
1713
1714 /*
1715  * csio_ln_mgmt_submit_wr - Post elsct work request.
1716  * @mgmtm - mgmtm
1717  * @io_req - io request.
1718  * @sub_op - ELS or CT request type
1719  * @pld - Dma Payload buffer
1720  * @pld_len - Payload len
1721  * Prepares ELSCT Work request and sents it to FW.
1722  * Returns: 0 - on success
1723  */
1724 static int
1725 csio_ln_mgmt_submit_wr(struct csio_mgmtm *mgmtm, struct csio_ioreq *io_req,
1726                 uint8_t sub_op, struct csio_dma_buf *pld,
1727                 uint32_t pld_len)
1728 {
1729         struct csio_wr_pair wrp;
1730         struct csio_lnode *ln = io_req->lnode;
1731         struct csio_rnode *rn = io_req->rnode;
1732         struct  csio_hw *hw = mgmtm->hw;
1733         uint8_t fw_wr[64];
1734         struct ulptx_sgl dsgl;
1735         uint32_t wr_size = 0;
1736         uint8_t im_len = 0;
1737         uint32_t wr_off = 0;
1738
1739         int ret = 0;
1740
1741         /* Calculate WR Size for this ELS REQ */
1742         wr_size = sizeof(struct fw_fcoe_els_ct_wr);
1743
1744         /* Send as immediate data if pld < 256 */
1745         if (pld_len < 256) {
1746                 wr_size += ALIGN(pld_len, 8);
1747                 im_len = (uint8_t)pld_len;
1748         } else
1749                 wr_size += sizeof(struct ulptx_sgl);
1750
1751         /* Roundup WR size in units of 16 bytes */
1752         wr_size = ALIGN(wr_size, 16);
1753
1754         /* Get WR to send ELS REQ */
1755         ret = csio_wr_get(hw, mgmtm->eq_idx, wr_size, &wrp);
1756         if (ret != 0) {
1757                 csio_err(hw, "Failed to get WR for ec_req %p ret:%d\n",
1758                         io_req, ret);
1759                 return ret;
1760         }
1761
1762         /* Prepare Generic WR used by all ELS/CT cmd */
1763         csio_ln_prep_ecwr(io_req, wr_size, im_len, sub_op,
1764                                 ln->nport_id, rn->nport_id,
1765                                 csio_rn_flowid(rn),
1766                                 &fw_wr[0]);
1767
1768         /* Copy ELS/CT WR CMD */
1769         csio_wr_copy_to_wrp(&fw_wr[0], &wrp, wr_off,
1770                         sizeof(struct fw_fcoe_els_ct_wr));
1771         wr_off += sizeof(struct fw_fcoe_els_ct_wr);
1772
1773         /* Copy payload to Immediate section of WR */
1774         if (im_len)
1775                 csio_wr_copy_to_wrp(pld->vaddr, &wrp, wr_off, im_len);
1776         else {
1777                 /* Program DSGL to dma payload */
1778                 dsgl.cmd_nsge = htonl(ULPTX_CMD_V(ULP_TX_SC_DSGL) |
1779                                         ULPTX_MORE_F | ULPTX_NSGE_V(1));
1780                 dsgl.len0 = cpu_to_be32(pld_len);
1781                 dsgl.addr0 = cpu_to_be64(pld->paddr);
1782                 csio_wr_copy_to_wrp(&dsgl, &wrp, ALIGN(wr_off, 8),
1783                                    sizeof(struct ulptx_sgl));
1784         }
1785
1786         /* Issue work request to xmit ELS/CT req to FW */
1787         csio_wr_issue(mgmtm->hw, mgmtm->eq_idx, false);
1788         return ret;
1789 }
1790
1791 /*
1792  * csio_ln_mgmt_submit_req - Submit FCOE Mgmt request.
1793  * @io_req - IO Request
1794  * @io_cbfn - Completion handler.
1795  * @req_type - ELS or CT request type
1796  * @pld - Dma Payload buffer
1797  * @pld_len - Payload len
1798  *
1799  *
1800  * This API used submit managment ELS/CT request.
1801  * This called with hw lock held
1802  * Returns: 0 - on success
1803  *          -ENOMEM     - on error.
1804  */
1805 static int
1806 csio_ln_mgmt_submit_req(struct csio_ioreq *io_req,
1807                 void (*io_cbfn) (struct csio_hw *, struct csio_ioreq *),
1808                 enum fcoe_cmn_type req_type, struct csio_dma_buf *pld,
1809                 uint32_t pld_len)
1810 {
1811         struct csio_hw *hw = csio_lnode_to_hw(io_req->lnode);
1812         struct csio_mgmtm *mgmtm = csio_hw_to_mgmtm(hw);
1813         int rv;
1814
1815         BUG_ON(pld_len > pld->len);
1816
1817         io_req->io_cbfn = io_cbfn;      /* Upper layer callback handler */
1818         io_req->fw_handle = (uintptr_t) (io_req);
1819         io_req->eq_idx = mgmtm->eq_idx;
1820         io_req->iq_idx = mgmtm->iq_idx;
1821
1822         rv = csio_ln_mgmt_submit_wr(mgmtm, io_req, req_type, pld, pld_len);
1823         if (rv == 0) {
1824                 list_add_tail(&io_req->sm.sm_list, &mgmtm->active_q);
1825                 mgmtm->stats.n_active++;
1826         }
1827         return rv;
1828 }
1829
1830 /*
1831  * csio_ln_fdmi_init - FDMI Init entry point.
1832  * @ln: lnode
1833  */
1834 static int
1835 csio_ln_fdmi_init(struct csio_lnode *ln)
1836 {
1837         struct csio_hw *hw = csio_lnode_to_hw(ln);
1838         struct csio_dma_buf     *dma_buf;
1839
1840         /* Allocate MGMT request required for FDMI */
1841         ln->mgmt_req = kzalloc(sizeof(struct csio_ioreq), GFP_KERNEL);
1842         if (!ln->mgmt_req) {
1843                 csio_ln_err(ln, "Failed to alloc ioreq for FDMI\n");
1844                 CSIO_INC_STATS(hw, n_err_nomem);
1845                 return -ENOMEM;
1846         }
1847
1848         /* Allocate Dma buffers for FDMI response Payload */
1849         dma_buf = &ln->mgmt_req->dma_buf;
1850         dma_buf->len = 2048;
1851         dma_buf->vaddr = pci_alloc_consistent(hw->pdev, dma_buf->len,
1852                                                 &dma_buf->paddr);
1853         if (!dma_buf->vaddr) {
1854                 csio_err(hw, "Failed to alloc DMA buffer for FDMI!\n");
1855                 kfree(ln->mgmt_req);
1856                 ln->mgmt_req = NULL;
1857                 return -ENOMEM;
1858         }
1859
1860         ln->flags |= CSIO_LNF_FDMI_ENABLE;
1861         return 0;
1862 }
1863
1864 /*
1865  * csio_ln_fdmi_exit - FDMI exit entry point.
1866  * @ln: lnode
1867  */
1868 static int
1869 csio_ln_fdmi_exit(struct csio_lnode *ln)
1870 {
1871         struct csio_dma_buf *dma_buf;
1872         struct csio_hw *hw = csio_lnode_to_hw(ln);
1873
1874         if (!ln->mgmt_req)
1875                 return 0;
1876
1877         dma_buf = &ln->mgmt_req->dma_buf;
1878         if (dma_buf->vaddr)
1879                 pci_free_consistent(hw->pdev, dma_buf->len, dma_buf->vaddr,
1880                                     dma_buf->paddr);
1881
1882         kfree(ln->mgmt_req);
1883         return 0;
1884 }
1885
1886 int
1887 csio_scan_done(struct csio_lnode *ln, unsigned long ticks,
1888                 unsigned long time, unsigned long max_scan_ticks,
1889                 unsigned long delta_scan_ticks)
1890 {
1891         int rv = 0;
1892
1893         if (time >= max_scan_ticks)
1894                 return 1;
1895
1896         if (!ln->tgt_scan_tick)
1897                 ln->tgt_scan_tick = ticks;
1898
1899         if (((ticks - ln->tgt_scan_tick) >= delta_scan_ticks)) {
1900                 if (!ln->last_scan_ntgts)
1901                         ln->last_scan_ntgts = ln->n_scsi_tgts;
1902                 else {
1903                         if (ln->last_scan_ntgts == ln->n_scsi_tgts)
1904                                 return 1;
1905
1906                         ln->last_scan_ntgts = ln->n_scsi_tgts;
1907                 }
1908                 ln->tgt_scan_tick = ticks;
1909         }
1910         return rv;
1911 }
1912
1913 /*
1914  * csio_notify_lnodes:
1915  * @hw: HW module
1916  * @note: Notification
1917  *
1918  * Called from the HW SM to fan out notifications to the
1919  * Lnode SM. Since the HW SM is entered with lock held,
1920  * there is no need to hold locks here.
1921  *
1922  */
1923 void
1924 csio_notify_lnodes(struct csio_hw *hw, enum csio_ln_notify note)
1925 {
1926         struct list_head *tmp;
1927         struct csio_lnode *ln;
1928
1929         csio_dbg(hw, "Notifying all nodes of event %d\n", note);
1930
1931         /* Traverse children lnodes list and send evt */
1932         list_for_each(tmp, &hw->sln_head) {
1933                 ln = (struct csio_lnode *) tmp;
1934
1935                 switch (note) {
1936                 case CSIO_LN_NOTIFY_HWREADY:
1937                         csio_lnode_start(ln);
1938                         break;
1939
1940                 case CSIO_LN_NOTIFY_HWRESET:
1941                 case CSIO_LN_NOTIFY_HWREMOVE:
1942                         csio_lnode_close(ln);
1943                         break;
1944
1945                 case CSIO_LN_NOTIFY_HWSTOP:
1946                         csio_lnode_stop(ln);
1947                         break;
1948
1949                 default:
1950                         break;
1951
1952                 }
1953         }
1954 }
1955
1956 /*
1957  * csio_disable_lnodes:
1958  * @hw: HW module
1959  * @portid:port id
1960  * @disable: disable/enable flag.
1961  * If disable=1, disables all lnode hosted on given physical port.
1962  * otherwise enables all the lnodes on given phsysical port.
1963  * This routine need to called with hw lock held.
1964  */
1965 void
1966 csio_disable_lnodes(struct csio_hw *hw, uint8_t portid, bool disable)
1967 {
1968         struct list_head *tmp;
1969         struct csio_lnode *ln;
1970
1971         csio_dbg(hw, "Notifying event to all nodes of port:%d\n", portid);
1972
1973         /* Traverse sibling lnodes list and send evt */
1974         list_for_each(tmp, &hw->sln_head) {
1975                 ln = (struct csio_lnode *) tmp;
1976                 if (ln->portid != portid)
1977                         continue;
1978
1979                 if (disable)
1980                         csio_lnode_stop(ln);
1981                 else
1982                         csio_lnode_start(ln);
1983         }
1984 }
1985
1986 /*
1987  * csio_ln_init - Initialize an lnode.
1988  * @ln:         lnode
1989  *
1990  */
1991 static int
1992 csio_ln_init(struct csio_lnode *ln)
1993 {
1994         int rv = -EINVAL;
1995         struct csio_lnode *rln, *pln;
1996         struct csio_hw *hw = csio_lnode_to_hw(ln);
1997
1998         csio_init_state(&ln->sm, csio_lns_uninit);
1999         ln->vnp_flowid = CSIO_INVALID_IDX;
2000         ln->fcf_flowid = CSIO_INVALID_IDX;
2001
2002         if (csio_is_root_ln(ln)) {
2003
2004                 /* This is the lnode used during initialization */
2005
2006                 ln->fcfinfo = kzalloc(sizeof(struct csio_fcf_info), GFP_KERNEL);
2007                 if (!ln->fcfinfo) {
2008                         csio_ln_err(ln, "Failed to alloc FCF record\n");
2009                         CSIO_INC_STATS(hw, n_err_nomem);
2010                         goto err;
2011                 }
2012
2013                 INIT_LIST_HEAD(&ln->fcf_lsthead);
2014                 kref_init(&ln->fcfinfo->kref);
2015
2016                 if (csio_fdmi_enable && csio_ln_fdmi_init(ln))
2017                         goto err;
2018
2019         } else { /* Either a non-root physical or a virtual lnode */
2020
2021                 /*
2022                  * THe rest is common for non-root physical and NPIV lnodes.
2023                  * Just get references to all other modules
2024                  */
2025                 rln = csio_root_lnode(ln);
2026
2027                 if (csio_is_npiv_ln(ln)) {
2028                         /* NPIV */
2029                         pln = csio_parent_lnode(ln);
2030                         kref_get(&pln->fcfinfo->kref);
2031                         ln->fcfinfo = pln->fcfinfo;
2032                 } else {
2033                         /* Another non-root physical lnode (FCF) */
2034                         ln->fcfinfo = kzalloc(sizeof(struct csio_fcf_info),
2035                                                                 GFP_KERNEL);
2036                         if (!ln->fcfinfo) {
2037                                 csio_ln_err(ln, "Failed to alloc FCF info\n");
2038                                 CSIO_INC_STATS(hw, n_err_nomem);
2039                                 goto err;
2040                         }
2041
2042                         kref_init(&ln->fcfinfo->kref);
2043
2044                         if (csio_fdmi_enable && csio_ln_fdmi_init(ln))
2045                                 goto err;
2046                 }
2047
2048         } /* if (!csio_is_root_ln(ln)) */
2049
2050         return 0;
2051 err:
2052         return rv;
2053 }
2054
2055 static void
2056 csio_ln_exit(struct csio_lnode *ln)
2057 {
2058         struct csio_lnode *pln;
2059
2060         csio_cleanup_rns(ln);
2061         if (csio_is_npiv_ln(ln)) {
2062                 pln = csio_parent_lnode(ln);
2063                 kref_put(&pln->fcfinfo->kref, csio_free_fcfinfo);
2064         } else {
2065                 kref_put(&ln->fcfinfo->kref, csio_free_fcfinfo);
2066                 if (csio_fdmi_enable)
2067                         csio_ln_fdmi_exit(ln);
2068         }
2069         ln->fcfinfo = NULL;
2070 }
2071
2072 /**
2073  * csio_lnode_init - Initialize the members of an lnode.
2074  * @ln:         lnode
2075  *
2076  */
2077 int
2078 csio_lnode_init(struct csio_lnode *ln, struct csio_hw *hw,
2079                 struct csio_lnode *pln)
2080 {
2081         int rv = -EINVAL;
2082
2083         /* Link this lnode to hw */
2084         csio_lnode_to_hw(ln)    = hw;
2085
2086         /* Link child to parent if child lnode */
2087         if (pln)
2088                 ln->pln = pln;
2089         else
2090                 ln->pln = NULL;
2091
2092         /* Initialize scsi_tgt and timers to zero */
2093         ln->n_scsi_tgts = 0;
2094         ln->last_scan_ntgts = 0;
2095         ln->tgt_scan_tick = 0;
2096
2097         /* Initialize rnode list */
2098         INIT_LIST_HEAD(&ln->rnhead);
2099         INIT_LIST_HEAD(&ln->cln_head);
2100
2101         /* Initialize log level for debug */
2102         ln->params.log_level    = hw->params.log_level;
2103
2104         if (csio_ln_init(ln))
2105                 goto err;
2106
2107         /* Add lnode to list of sibling or children lnodes */
2108         spin_lock_irq(&hw->lock);
2109         list_add_tail(&ln->sm.sm_list, pln ? &pln->cln_head : &hw->sln_head);
2110         if (pln)
2111                 pln->num_vports++;
2112         spin_unlock_irq(&hw->lock);
2113
2114         hw->num_lns++;
2115
2116         return 0;
2117 err:
2118         csio_lnode_to_hw(ln) = NULL;
2119         return rv;
2120 }
2121
2122 /**
2123  * csio_lnode_exit - De-instantiate an lnode.
2124  * @ln:         lnode
2125  *
2126  */
2127 void
2128 csio_lnode_exit(struct csio_lnode *ln)
2129 {
2130         struct csio_hw *hw = csio_lnode_to_hw(ln);
2131
2132         csio_ln_exit(ln);
2133
2134         /* Remove this lnode from hw->sln_head */
2135         spin_lock_irq(&hw->lock);
2136
2137         list_del_init(&ln->sm.sm_list);
2138
2139         /* If it is children lnode, decrement the
2140          * counter in its parent lnode
2141          */
2142         if (ln->pln)
2143                 ln->pln->num_vports--;
2144
2145         /* Update root lnode pointer */
2146         if (list_empty(&hw->sln_head))
2147                 hw->rln = NULL;
2148         else
2149                 hw->rln = (struct csio_lnode *)csio_list_next(&hw->sln_head);
2150
2151         spin_unlock_irq(&hw->lock);
2152
2153         csio_lnode_to_hw(ln)    = NULL;
2154         hw->num_lns--;
2155 }