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