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_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         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  */
1217 static void
1218 csio_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 returned
1250                  * 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  */
1291 static void
1292 csio_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
1351 static void
1352 csio_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 - lnode
1363  * @str - state of lnode.
1364  *
1365  */
1366 void
1367 csio_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
1385 int
1386 csio_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 every
1427  * mgmt event received.
1428  * Return - none.
1429  */
1430
1431 static void
1432 csio_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 module
1477  * @cpl_op:     CPL opcode
1478  * @cmd:        FW cmd/WR.
1479  *
1480  * Process received FCoE cmd/WR event from FW.
1481  */
1482 void
1483 csio_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);
1589 out_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:         lnode
1616  *
1617  * This routine kickstarts the discovery by issuing an FCOE_LINK (up) command.
1618  */
1619 int
1620 csio_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:         lnode
1634  *
1635  * This routine is invoked by HW module to stop lnode and its associated NPIV
1636  * lnodes.
1637  */
1638 void
1639 csio_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:         lnode
1652  *
1653  * This routine is invoked by HW module to close an lnode and its
1654  * associated NPIV lnodes. Lnode and its associated NPIV lnodes are
1655  * set to uninitialized state.
1656  */
1657 void
1658 csio_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 len
1671  * @immd_len - WR immediate data
1672  * @sub_op - Sub opcode
1673  * @sid - source portid.
1674  * @did - destination portid
1675  * @flow_id - flowid
1676  * @fw_wr - ELS/CT WR to be prepared.
1677  * Returns: 0 - on success
1678  */
1679 static int
1680 csio_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 - mgmtm
1716  * @io_req - io request.
1717  * @sub_op - ELS or CT request type
1718  * @pld - Dma Payload buffer
1719  * @pld_len - Payload len
1720  * Prepares ELSCT Work request and sents it to FW.
1721  * Returns: 0 - on success
1722  */
1723 static int
1724 csio_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         } else
1748                 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 Request
1793  * @io_cbfn - Completion handler.
1794  * @req_type - ELS or CT request type
1795  * @pld - Dma Payload buffer
1796  * @pld_len - Payload len
1797  *
1798  *
1799  * This API used submit managment ELS/CT request.
1800  * This called with hw lock held
1801  * Returns: 0 - on success
1802  *          -ENOMEM     - on error.
1803  */
1804 static int
1805 csio_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: lnode
1832  */
1833 static int
1834 csio_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: lnode
1866  */
1867 static int
1868 csio_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
1885 int
1886 csio_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 module
1915  * @note: Notification
1916  *
1917  * Called from the HW SM to fan out notifications to the
1918  * Lnode SM. Since the HW SM is entered with lock held,
1919  * there is no need to hold locks here.
1920  *
1921  */
1922 void
1923 csio_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 module
1958  * @portid:port id
1959  * @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  */
1964 void
1965 csio_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                 else
1981                         csio_lnode_start(ln);
1982         }
1983 }
1984
1985 /*
1986  * csio_ln_init - Initialize an lnode.
1987  * @ln:         lnode
1988  *
1989  */
1990 static int
1991 csio_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 modules
2023                  */
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;
2049 err:
2050         return rv;
2051 }
2052
2053 static void
2054 csio_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:         lnode
2073  */
2074 int
2075 csio_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         else
2087                 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;
2114 err:
2115         csio_lnode_to_hw(ln) = NULL;
2116         return rv;
2117 }
2118
2119 /**
2120  * csio_lnode_exit - De-instantiate an lnode.
2121  * @ln:         lnode
2122  *
2123  */
2124 void
2125 csio_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 the
2137          * counter in its parent lnode
2138          */
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         else
2146                 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 }