linux/drivers/scsi/bfa/bfa_svc.c
<<
>>
Prefs
   1/*
   2 * Copyright (c) 2005-2014 Brocade Communications Systems, Inc.
   3 * Copyright (c) 2014- QLogic Corporation.
   4 * All rights reserved
   5 * www.qlogic.com
   6 *
   7 * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter.
   8 *
   9 * This program is free software; you can redistribute it and/or modify it
  10 * under the terms of the GNU General Public License (GPL) Version 2 as
  11 * published by the Free Software Foundation
  12 *
  13 * This program is distributed in the hope that it will be useful, but
  14 * WITHOUT ANY WARRANTY; without even the implied warranty of
  15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 * General Public License for more details.
  17 */
  18
  19#include "bfad_drv.h"
  20#include "bfad_im.h"
  21#include "bfa_plog.h"
  22#include "bfa_cs.h"
  23#include "bfa_modules.h"
  24
  25BFA_TRC_FILE(HAL, FCXP);
  26
  27/*
  28 * LPS related definitions
  29 */
  30#define BFA_LPS_MIN_LPORTS      (1)
  31#define BFA_LPS_MAX_LPORTS      (256)
  32
  33/*
  34 * Maximum Vports supported per physical port or vf.
  35 */
  36#define BFA_LPS_MAX_VPORTS_SUPP_CB  255
  37#define BFA_LPS_MAX_VPORTS_SUPP_CT  190
  38
  39
  40/*
  41 * FC PORT related definitions
  42 */
  43/*
  44 * The port is considered disabled if corresponding physical port or IOC are
  45 * disabled explicitly
  46 */
  47#define BFA_PORT_IS_DISABLED(bfa) \
  48        ((bfa_fcport_is_disabled(bfa) == BFA_TRUE) || \
  49        (bfa_ioc_is_disabled(&bfa->ioc) == BFA_TRUE))
  50
  51/*
  52 * BFA port state machine events
  53 */
  54enum bfa_fcport_sm_event {
  55        BFA_FCPORT_SM_START     = 1,    /*  start port state machine    */
  56        BFA_FCPORT_SM_STOP      = 2,    /*  stop port state machine     */
  57        BFA_FCPORT_SM_ENABLE    = 3,    /*  enable port         */
  58        BFA_FCPORT_SM_DISABLE   = 4,    /*  disable port state machine */
  59        BFA_FCPORT_SM_FWRSP     = 5,    /*  firmware enable/disable rsp */
  60        BFA_FCPORT_SM_LINKUP    = 6,    /*  firmware linkup event       */
  61        BFA_FCPORT_SM_LINKDOWN  = 7,    /*  firmware linkup down        */
  62        BFA_FCPORT_SM_QRESUME   = 8,    /*  CQ space available  */
  63        BFA_FCPORT_SM_HWFAIL    = 9,    /*  IOC h/w failure             */
  64        BFA_FCPORT_SM_DPORTENABLE = 10, /*  enable dport      */
  65        BFA_FCPORT_SM_DPORTDISABLE = 11,/*  disable dport     */
  66        BFA_FCPORT_SM_FAA_MISCONFIG = 12,       /* FAA misconfiguratin */
  67        BFA_FCPORT_SM_DDPORTENABLE  = 13,       /* enable ddport        */
  68        BFA_FCPORT_SM_DDPORTDISABLE = 14,       /* disable ddport       */
  69};
  70
  71/*
  72 * BFA port link notification state machine events
  73 */
  74
  75enum bfa_fcport_ln_sm_event {
  76        BFA_FCPORT_LN_SM_LINKUP         = 1,    /*  linkup event        */
  77        BFA_FCPORT_LN_SM_LINKDOWN       = 2,    /*  linkdown event      */
  78        BFA_FCPORT_LN_SM_NOTIFICATION   = 3     /*  done notification   */
  79};
  80
  81/*
  82 * RPORT related definitions
  83 */
  84#define bfa_rport_offline_cb(__rp) do {                                 \
  85        if ((__rp)->bfa->fcs)                                           \
  86                bfa_cb_rport_offline((__rp)->rport_drv);      \
  87        else {                                                          \
  88                bfa_cb_queue((__rp)->bfa, &(__rp)->hcb_qe,              \
  89                                __bfa_cb_rport_offline, (__rp));      \
  90        }                                                               \
  91} while (0)
  92
  93#define bfa_rport_online_cb(__rp) do {                                  \
  94        if ((__rp)->bfa->fcs)                                           \
  95                bfa_cb_rport_online((__rp)->rport_drv);      \
  96        else {                                                          \
  97                bfa_cb_queue((__rp)->bfa, &(__rp)->hcb_qe,              \
  98                                  __bfa_cb_rport_online, (__rp));      \
  99                }                                                       \
 100} while (0)
 101
 102/*
 103 * forward declarations FCXP related functions
 104 */
 105static void     __bfa_fcxp_send_cbfn(void *cbarg, bfa_boolean_t complete);
 106static void     hal_fcxp_rx_plog(struct bfa_s *bfa, struct bfa_fcxp_s *fcxp,
 107                                struct bfi_fcxp_send_rsp_s *fcxp_rsp);
 108static void     hal_fcxp_tx_plog(struct bfa_s *bfa, u32 reqlen,
 109                                struct bfa_fcxp_s *fcxp, struct fchs_s *fchs);
 110static void     bfa_fcxp_qresume(void *cbarg);
 111static void     bfa_fcxp_queue(struct bfa_fcxp_s *fcxp,
 112                                struct bfi_fcxp_send_req_s *send_req);
 113
 114/*
 115 * forward declarations for LPS functions
 116 */
 117static void bfa_lps_login_rsp(struct bfa_s *bfa,
 118                                struct bfi_lps_login_rsp_s *rsp);
 119static void bfa_lps_no_res(struct bfa_lps_s *first_lps, u8 count);
 120static void bfa_lps_logout_rsp(struct bfa_s *bfa,
 121                                struct bfi_lps_logout_rsp_s *rsp);
 122static void bfa_lps_reqq_resume(void *lps_arg);
 123static void bfa_lps_free(struct bfa_lps_s *lps);
 124static void bfa_lps_send_login(struct bfa_lps_s *lps);
 125static void bfa_lps_send_logout(struct bfa_lps_s *lps);
 126static void bfa_lps_send_set_n2n_pid(struct bfa_lps_s *lps);
 127static void bfa_lps_login_comp(struct bfa_lps_s *lps);
 128static void bfa_lps_logout_comp(struct bfa_lps_s *lps);
 129static void bfa_lps_cvl_event(struct bfa_lps_s *lps);
 130
 131/*
 132 * forward declaration for LPS state machine
 133 */
 134static void bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event);
 135static void bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event);
 136static void bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event
 137                                        event);
 138static void bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event);
 139static void bfa_lps_sm_online_n2n_pid_wait(struct bfa_lps_s *lps,
 140                                        enum bfa_lps_event event);
 141static void bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event);
 142static void bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event
 143                                        event);
 144
 145/*
 146 * forward declaration for FC Port functions
 147 */
 148static bfa_boolean_t bfa_fcport_send_enable(struct bfa_fcport_s *fcport);
 149static bfa_boolean_t bfa_fcport_send_disable(struct bfa_fcport_s *fcport);
 150static void bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport);
 151static void bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport);
 152static void bfa_fcport_set_wwns(struct bfa_fcport_s *fcport);
 153static void __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete);
 154static void bfa_fcport_scn(struct bfa_fcport_s *fcport,
 155                        enum bfa_port_linkstate event, bfa_boolean_t trunk);
 156static void bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln,
 157                                enum bfa_port_linkstate event);
 158static void __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete);
 159static void bfa_fcport_stats_get_timeout(void *cbarg);
 160static void bfa_fcport_stats_clr_timeout(void *cbarg);
 161static void bfa_trunk_iocdisable(struct bfa_s *bfa);
 162
 163/*
 164 * forward declaration for FC PORT state machine
 165 */
 166static void     bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
 167                                        enum bfa_fcport_sm_event event);
 168static void     bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
 169                                        enum bfa_fcport_sm_event event);
 170static void     bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
 171                                        enum bfa_fcport_sm_event event);
 172static void     bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
 173                                        enum bfa_fcport_sm_event event);
 174static void     bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
 175                                        enum bfa_fcport_sm_event event);
 176static void     bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
 177                                        enum bfa_fcport_sm_event event);
 178static void     bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
 179                                        enum bfa_fcport_sm_event event);
 180static void     bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s *fcport,
 181                                        enum bfa_fcport_sm_event event);
 182static void     bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
 183                                        enum bfa_fcport_sm_event event);
 184static void     bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
 185                                        enum bfa_fcport_sm_event event);
 186static void     bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
 187                                        enum bfa_fcport_sm_event event);
 188static void     bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
 189                                        enum bfa_fcport_sm_event event);
 190static void     bfa_fcport_sm_dport(struct bfa_fcport_s *fcport,
 191                                        enum bfa_fcport_sm_event event);
 192static void     bfa_fcport_sm_ddport(struct bfa_fcport_s *fcport,
 193                                        enum bfa_fcport_sm_event event);
 194static void     bfa_fcport_sm_faa_misconfig(struct bfa_fcport_s *fcport,
 195                                        enum bfa_fcport_sm_event event);
 196
 197static void     bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
 198                                        enum bfa_fcport_ln_sm_event event);
 199static void     bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
 200                                        enum bfa_fcport_ln_sm_event event);
 201static void     bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
 202                                        enum bfa_fcport_ln_sm_event event);
 203static void     bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
 204                                        enum bfa_fcport_ln_sm_event event);
 205static void     bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
 206                                        enum bfa_fcport_ln_sm_event event);
 207static void     bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
 208                                        enum bfa_fcport_ln_sm_event event);
 209static void     bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
 210                                        enum bfa_fcport_ln_sm_event event);
 211
 212static struct bfa_sm_table_s hal_port_sm_table[] = {
 213        {BFA_SM(bfa_fcport_sm_uninit), BFA_PORT_ST_UNINIT},
 214        {BFA_SM(bfa_fcport_sm_enabling_qwait), BFA_PORT_ST_ENABLING_QWAIT},
 215        {BFA_SM(bfa_fcport_sm_enabling), BFA_PORT_ST_ENABLING},
 216        {BFA_SM(bfa_fcport_sm_linkdown), BFA_PORT_ST_LINKDOWN},
 217        {BFA_SM(bfa_fcport_sm_linkup), BFA_PORT_ST_LINKUP},
 218        {BFA_SM(bfa_fcport_sm_disabling_qwait), BFA_PORT_ST_DISABLING_QWAIT},
 219        {BFA_SM(bfa_fcport_sm_toggling_qwait), BFA_PORT_ST_TOGGLING_QWAIT},
 220        {BFA_SM(bfa_fcport_sm_disabling), BFA_PORT_ST_DISABLING},
 221        {BFA_SM(bfa_fcport_sm_disabled), BFA_PORT_ST_DISABLED},
 222        {BFA_SM(bfa_fcport_sm_stopped), BFA_PORT_ST_STOPPED},
 223        {BFA_SM(bfa_fcport_sm_iocdown), BFA_PORT_ST_IOCDOWN},
 224        {BFA_SM(bfa_fcport_sm_iocfail), BFA_PORT_ST_IOCDOWN},
 225        {BFA_SM(bfa_fcport_sm_dport), BFA_PORT_ST_DPORT},
 226        {BFA_SM(bfa_fcport_sm_ddport), BFA_PORT_ST_DDPORT},
 227        {BFA_SM(bfa_fcport_sm_faa_misconfig), BFA_PORT_ST_FAA_MISCONFIG},
 228};
 229
 230
 231/*
 232 * forward declaration for RPORT related functions
 233 */
 234static struct bfa_rport_s *bfa_rport_alloc(struct bfa_rport_mod_s *rp_mod);
 235static void             bfa_rport_free(struct bfa_rport_s *rport);
 236static bfa_boolean_t    bfa_rport_send_fwcreate(struct bfa_rport_s *rp);
 237static bfa_boolean_t    bfa_rport_send_fwdelete(struct bfa_rport_s *rp);
 238static bfa_boolean_t    bfa_rport_send_fwspeed(struct bfa_rport_s *rp);
 239static void             __bfa_cb_rport_online(void *cbarg,
 240                                                bfa_boolean_t complete);
 241static void             __bfa_cb_rport_offline(void *cbarg,
 242                                                bfa_boolean_t complete);
 243
 244/*
 245 * forward declaration for RPORT state machine
 246 */
 247static void     bfa_rport_sm_uninit(struct bfa_rport_s *rp,
 248                                        enum bfa_rport_event event);
 249static void     bfa_rport_sm_created(struct bfa_rport_s *rp,
 250                                        enum bfa_rport_event event);
 251static void     bfa_rport_sm_fwcreate(struct bfa_rport_s *rp,
 252                                        enum bfa_rport_event event);
 253static void     bfa_rport_sm_online(struct bfa_rport_s *rp,
 254                                        enum bfa_rport_event event);
 255static void     bfa_rport_sm_fwdelete(struct bfa_rport_s *rp,
 256                                        enum bfa_rport_event event);
 257static void     bfa_rport_sm_offline(struct bfa_rport_s *rp,
 258                                        enum bfa_rport_event event);
 259static void     bfa_rport_sm_deleting(struct bfa_rport_s *rp,
 260                                        enum bfa_rport_event event);
 261static void     bfa_rport_sm_offline_pending(struct bfa_rport_s *rp,
 262                                        enum bfa_rport_event event);
 263static void     bfa_rport_sm_delete_pending(struct bfa_rport_s *rp,
 264                                        enum bfa_rport_event event);
 265static void     bfa_rport_sm_iocdisable(struct bfa_rport_s *rp,
 266                                        enum bfa_rport_event event);
 267static void     bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s *rp,
 268                                        enum bfa_rport_event event);
 269static void     bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s *rp,
 270                                        enum bfa_rport_event event);
 271static void     bfa_rport_sm_deleting_qfull(struct bfa_rport_s *rp,
 272                                        enum bfa_rport_event event);
 273
 274/*
 275 * PLOG related definitions
 276 */
 277static int
 278plkd_validate_logrec(struct bfa_plog_rec_s *pl_rec)
 279{
 280        if ((pl_rec->log_type != BFA_PL_LOG_TYPE_INT) &&
 281                (pl_rec->log_type != BFA_PL_LOG_TYPE_STRING))
 282                return 1;
 283
 284        if ((pl_rec->log_type != BFA_PL_LOG_TYPE_INT) &&
 285                (pl_rec->log_num_ints > BFA_PL_INT_LOG_SZ))
 286                return 1;
 287
 288        return 0;
 289}
 290
 291static void
 292bfa_plog_add(struct bfa_plog_s *plog, struct bfa_plog_rec_s *pl_rec)
 293{
 294        u16 tail;
 295        struct bfa_plog_rec_s *pl_recp;
 296
 297        if (plog->plog_enabled == 0)
 298                return;
 299
 300        if (plkd_validate_logrec(pl_rec)) {
 301                WARN_ON(1);
 302                return;
 303        }
 304
 305        tail = plog->tail;
 306
 307        pl_recp = &(plog->plog_recs[tail]);
 308
 309        memcpy(pl_recp, pl_rec, sizeof(struct bfa_plog_rec_s));
 310
 311        pl_recp->tv = ktime_get_real_seconds();
 312        BFA_PL_LOG_REC_INCR(plog->tail);
 313
 314        if (plog->head == plog->tail)
 315                BFA_PL_LOG_REC_INCR(plog->head);
 316}
 317
 318void
 319bfa_plog_init(struct bfa_plog_s *plog)
 320{
 321        memset((char *)plog, 0, sizeof(struct bfa_plog_s));
 322
 323        memcpy(plog->plog_sig, BFA_PL_SIG_STR, BFA_PL_SIG_LEN);
 324        plog->head = plog->tail = 0;
 325        plog->plog_enabled = 1;
 326}
 327
 328void
 329bfa_plog_str(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
 330                enum bfa_plog_eid event,
 331                u16 misc, char *log_str)
 332{
 333        struct bfa_plog_rec_s  lp;
 334
 335        if (plog->plog_enabled) {
 336                memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
 337                lp.mid = mid;
 338                lp.eid = event;
 339                lp.log_type = BFA_PL_LOG_TYPE_STRING;
 340                lp.misc = misc;
 341                strlcpy(lp.log_entry.string_log, log_str,
 342                        BFA_PL_STRING_LOG_SZ);
 343                lp.log_entry.string_log[BFA_PL_STRING_LOG_SZ - 1] = '\0';
 344                bfa_plog_add(plog, &lp);
 345        }
 346}
 347
 348void
 349bfa_plog_intarr(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
 350                enum bfa_plog_eid event,
 351                u16 misc, u32 *intarr, u32 num_ints)
 352{
 353        struct bfa_plog_rec_s  lp;
 354        u32 i;
 355
 356        if (num_ints > BFA_PL_INT_LOG_SZ)
 357                num_ints = BFA_PL_INT_LOG_SZ;
 358
 359        if (plog->plog_enabled) {
 360                memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
 361                lp.mid = mid;
 362                lp.eid = event;
 363                lp.log_type = BFA_PL_LOG_TYPE_INT;
 364                lp.misc = misc;
 365
 366                for (i = 0; i < num_ints; i++)
 367                        lp.log_entry.int_log[i] = intarr[i];
 368
 369                lp.log_num_ints = (u8) num_ints;
 370
 371                bfa_plog_add(plog, &lp);
 372        }
 373}
 374
 375void
 376bfa_plog_fchdr(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
 377                        enum bfa_plog_eid event,
 378                        u16 misc, struct fchs_s *fchdr)
 379{
 380        struct bfa_plog_rec_s  lp;
 381        u32     *tmp_int = (u32 *) fchdr;
 382        u32     ints[BFA_PL_INT_LOG_SZ];
 383
 384        if (plog->plog_enabled) {
 385                memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
 386
 387                ints[0] = tmp_int[0];
 388                ints[1] = tmp_int[1];
 389                ints[2] = tmp_int[4];
 390
 391                bfa_plog_intarr(plog, mid, event, misc, ints, 3);
 392        }
 393}
 394
 395void
 396bfa_plog_fchdr_and_pl(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
 397                      enum bfa_plog_eid event, u16 misc, struct fchs_s *fchdr,
 398                      u32 pld_w0)
 399{
 400        struct bfa_plog_rec_s  lp;
 401        u32     *tmp_int = (u32 *) fchdr;
 402        u32     ints[BFA_PL_INT_LOG_SZ];
 403
 404        if (plog->plog_enabled) {
 405                memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
 406
 407                ints[0] = tmp_int[0];
 408                ints[1] = tmp_int[1];
 409                ints[2] = tmp_int[4];
 410                ints[3] = pld_w0;
 411
 412                bfa_plog_intarr(plog, mid, event, misc, ints, 4);
 413        }
 414}
 415
 416
 417/*
 418 *  fcxp_pvt BFA FCXP private functions
 419 */
 420
 421static void
 422claim_fcxps_mem(struct bfa_fcxp_mod_s *mod)
 423{
 424        u16     i;
 425        struct bfa_fcxp_s *fcxp;
 426
 427        fcxp = (struct bfa_fcxp_s *) bfa_mem_kva_curp(mod);
 428        memset(fcxp, 0, sizeof(struct bfa_fcxp_s) * mod->num_fcxps);
 429
 430        INIT_LIST_HEAD(&mod->fcxp_req_free_q);
 431        INIT_LIST_HEAD(&mod->fcxp_rsp_free_q);
 432        INIT_LIST_HEAD(&mod->fcxp_active_q);
 433        INIT_LIST_HEAD(&mod->fcxp_req_unused_q);
 434        INIT_LIST_HEAD(&mod->fcxp_rsp_unused_q);
 435
 436        mod->fcxp_list = fcxp;
 437
 438        for (i = 0; i < mod->num_fcxps; i++) {
 439                fcxp->fcxp_mod = mod;
 440                fcxp->fcxp_tag = i;
 441
 442                if (i < (mod->num_fcxps / 2)) {
 443                        list_add_tail(&fcxp->qe, &mod->fcxp_req_free_q);
 444                        fcxp->req_rsp = BFA_TRUE;
 445                } else {
 446                        list_add_tail(&fcxp->qe, &mod->fcxp_rsp_free_q);
 447                        fcxp->req_rsp = BFA_FALSE;
 448                }
 449
 450                bfa_reqq_winit(&fcxp->reqq_wqe, bfa_fcxp_qresume, fcxp);
 451                fcxp->reqq_waiting = BFA_FALSE;
 452
 453                fcxp = fcxp + 1;
 454        }
 455
 456        bfa_mem_kva_curp(mod) = (void *)fcxp;
 457}
 458
 459void
 460bfa_fcxp_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
 461                struct bfa_s *bfa)
 462{
 463        struct bfa_fcxp_mod_s *fcxp_mod = BFA_FCXP_MOD(bfa);
 464        struct bfa_mem_kva_s *fcxp_kva = BFA_MEM_FCXP_KVA(bfa);
 465        struct bfa_mem_dma_s *seg_ptr;
 466        u16     nsegs, idx, per_seg_fcxp;
 467        u16     num_fcxps = cfg->fwcfg.num_fcxp_reqs;
 468        u32     per_fcxp_sz;
 469
 470        if (num_fcxps == 0)
 471                return;
 472
 473        if (cfg->drvcfg.min_cfg)
 474                per_fcxp_sz = 2 * BFA_FCXP_MAX_IBUF_SZ;
 475        else
 476                per_fcxp_sz = BFA_FCXP_MAX_IBUF_SZ + BFA_FCXP_MAX_LBUF_SZ;
 477
 478        /* dma memory */
 479        nsegs = BFI_MEM_DMA_NSEGS(num_fcxps, per_fcxp_sz);
 480        per_seg_fcxp = BFI_MEM_NREQS_SEG(per_fcxp_sz);
 481
 482        bfa_mem_dma_seg_iter(fcxp_mod, seg_ptr, nsegs, idx) {
 483                if (num_fcxps >= per_seg_fcxp) {
 484                        num_fcxps -= per_seg_fcxp;
 485                        bfa_mem_dma_setup(minfo, seg_ptr,
 486                                per_seg_fcxp * per_fcxp_sz);
 487                } else
 488                        bfa_mem_dma_setup(minfo, seg_ptr,
 489                                num_fcxps * per_fcxp_sz);
 490        }
 491
 492        /* kva memory */
 493        bfa_mem_kva_setup(minfo, fcxp_kva,
 494                cfg->fwcfg.num_fcxp_reqs * sizeof(struct bfa_fcxp_s));
 495}
 496
 497void
 498bfa_fcxp_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
 499                struct bfa_pcidev_s *pcidev)
 500{
 501        struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
 502
 503        mod->bfa = bfa;
 504        mod->num_fcxps = cfg->fwcfg.num_fcxp_reqs;
 505
 506        /*
 507         * Initialize FCXP request and response payload sizes.
 508         */
 509        mod->req_pld_sz = mod->rsp_pld_sz = BFA_FCXP_MAX_IBUF_SZ;
 510        if (!cfg->drvcfg.min_cfg)
 511                mod->rsp_pld_sz = BFA_FCXP_MAX_LBUF_SZ;
 512
 513        INIT_LIST_HEAD(&mod->req_wait_q);
 514        INIT_LIST_HEAD(&mod->rsp_wait_q);
 515
 516        claim_fcxps_mem(mod);
 517}
 518
 519void
 520bfa_fcxp_iocdisable(struct bfa_s *bfa)
 521{
 522        struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
 523        struct bfa_fcxp_s *fcxp;
 524        struct list_head              *qe, *qen;
 525
 526        /* Enqueue unused fcxp resources to free_q */
 527        list_splice_tail_init(&mod->fcxp_req_unused_q, &mod->fcxp_req_free_q);
 528        list_splice_tail_init(&mod->fcxp_rsp_unused_q, &mod->fcxp_rsp_free_q);
 529
 530        list_for_each_safe(qe, qen, &mod->fcxp_active_q) {
 531                fcxp = (struct bfa_fcxp_s *) qe;
 532                if (fcxp->caller == NULL) {
 533                        fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
 534                                        BFA_STATUS_IOC_FAILURE, 0, 0, NULL);
 535                        bfa_fcxp_free(fcxp);
 536                } else {
 537                        fcxp->rsp_status = BFA_STATUS_IOC_FAILURE;
 538                        bfa_cb_queue(bfa, &fcxp->hcb_qe,
 539                                     __bfa_fcxp_send_cbfn, fcxp);
 540                }
 541        }
 542}
 543
 544static struct bfa_fcxp_s *
 545bfa_fcxp_get(struct bfa_fcxp_mod_s *fm, bfa_boolean_t req)
 546{
 547        struct bfa_fcxp_s *fcxp;
 548
 549        if (req)
 550                bfa_q_deq(&fm->fcxp_req_free_q, &fcxp);
 551        else
 552                bfa_q_deq(&fm->fcxp_rsp_free_q, &fcxp);
 553
 554        if (fcxp)
 555                list_add_tail(&fcxp->qe, &fm->fcxp_active_q);
 556
 557        return fcxp;
 558}
 559
 560static void
 561bfa_fcxp_init_reqrsp(struct bfa_fcxp_s *fcxp,
 562               struct bfa_s *bfa,
 563               u8 *use_ibuf,
 564               u32 *nr_sgles,
 565               bfa_fcxp_get_sgaddr_t *r_sga_cbfn,
 566               bfa_fcxp_get_sglen_t *r_sglen_cbfn,
 567               struct list_head *r_sgpg_q,
 568               int n_sgles,
 569               bfa_fcxp_get_sgaddr_t sga_cbfn,
 570               bfa_fcxp_get_sglen_t sglen_cbfn)
 571{
 572
 573        WARN_ON(bfa == NULL);
 574
 575        bfa_trc(bfa, fcxp->fcxp_tag);
 576
 577        if (n_sgles == 0) {
 578                *use_ibuf = 1;
 579        } else {
 580                WARN_ON(*sga_cbfn == NULL);
 581                WARN_ON(*sglen_cbfn == NULL);
 582
 583                *use_ibuf = 0;
 584                *r_sga_cbfn = sga_cbfn;
 585                *r_sglen_cbfn = sglen_cbfn;
 586
 587                *nr_sgles = n_sgles;
 588
 589                /*
 590                 * alloc required sgpgs
 591                 */
 592                if (n_sgles > BFI_SGE_INLINE)
 593                        WARN_ON(1);
 594        }
 595
 596}
 597
 598static void
 599bfa_fcxp_init(struct bfa_fcxp_s *fcxp,
 600               void *caller, struct bfa_s *bfa, int nreq_sgles,
 601               int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
 602               bfa_fcxp_get_sglen_t req_sglen_cbfn,
 603               bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
 604               bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
 605{
 606
 607        WARN_ON(bfa == NULL);
 608
 609        bfa_trc(bfa, fcxp->fcxp_tag);
 610
 611        fcxp->caller = caller;
 612
 613        bfa_fcxp_init_reqrsp(fcxp, bfa,
 614                &fcxp->use_ireqbuf, &fcxp->nreq_sgles, &fcxp->req_sga_cbfn,
 615                &fcxp->req_sglen_cbfn, &fcxp->req_sgpg_q,
 616                nreq_sgles, req_sga_cbfn, req_sglen_cbfn);
 617
 618        bfa_fcxp_init_reqrsp(fcxp, bfa,
 619                &fcxp->use_irspbuf, &fcxp->nrsp_sgles, &fcxp->rsp_sga_cbfn,
 620                &fcxp->rsp_sglen_cbfn, &fcxp->rsp_sgpg_q,
 621                nrsp_sgles, rsp_sga_cbfn, rsp_sglen_cbfn);
 622
 623}
 624
 625static void
 626bfa_fcxp_put(struct bfa_fcxp_s *fcxp)
 627{
 628        struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
 629        struct bfa_fcxp_wqe_s *wqe;
 630
 631        if (fcxp->req_rsp)
 632                bfa_q_deq(&mod->req_wait_q, &wqe);
 633        else
 634                bfa_q_deq(&mod->rsp_wait_q, &wqe);
 635
 636        if (wqe) {
 637                bfa_trc(mod->bfa, fcxp->fcxp_tag);
 638
 639                bfa_fcxp_init(fcxp, wqe->caller, wqe->bfa, wqe->nreq_sgles,
 640                        wqe->nrsp_sgles, wqe->req_sga_cbfn,
 641                        wqe->req_sglen_cbfn, wqe->rsp_sga_cbfn,
 642                        wqe->rsp_sglen_cbfn);
 643
 644                wqe->alloc_cbfn(wqe->alloc_cbarg, fcxp);
 645                return;
 646        }
 647
 648        WARN_ON(!bfa_q_is_on_q(&mod->fcxp_active_q, fcxp));
 649        list_del(&fcxp->qe);
 650
 651        if (fcxp->req_rsp)
 652                list_add_tail(&fcxp->qe, &mod->fcxp_req_free_q);
 653        else
 654                list_add_tail(&fcxp->qe, &mod->fcxp_rsp_free_q);
 655}
 656
 657static void
 658bfa_fcxp_null_comp(void *bfad_fcxp, struct bfa_fcxp_s *fcxp, void *cbarg,
 659                   bfa_status_t req_status, u32 rsp_len,
 660                   u32 resid_len, struct fchs_s *rsp_fchs)
 661{
 662        /* discarded fcxp completion */
 663}
 664
 665static void
 666__bfa_fcxp_send_cbfn(void *cbarg, bfa_boolean_t complete)
 667{
 668        struct bfa_fcxp_s *fcxp = cbarg;
 669
 670        if (complete) {
 671                fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
 672                                fcxp->rsp_status, fcxp->rsp_len,
 673                                fcxp->residue_len, &fcxp->rsp_fchs);
 674        } else {
 675                bfa_fcxp_free(fcxp);
 676        }
 677}
 678
 679static void
 680hal_fcxp_send_comp(struct bfa_s *bfa, struct bfi_fcxp_send_rsp_s *fcxp_rsp)
 681{
 682        struct bfa_fcxp_mod_s   *mod = BFA_FCXP_MOD(bfa);
 683        struct bfa_fcxp_s       *fcxp;
 684        u16             fcxp_tag = be16_to_cpu(fcxp_rsp->fcxp_tag);
 685
 686        bfa_trc(bfa, fcxp_tag);
 687
 688        fcxp_rsp->rsp_len = be32_to_cpu(fcxp_rsp->rsp_len);
 689
 690        /*
 691         * @todo f/w should not set residue to non-0 when everything
 692         *       is received.
 693         */
 694        if (fcxp_rsp->req_status == BFA_STATUS_OK)
 695                fcxp_rsp->residue_len = 0;
 696        else
 697                fcxp_rsp->residue_len = be32_to_cpu(fcxp_rsp->residue_len);
 698
 699        fcxp = BFA_FCXP_FROM_TAG(mod, fcxp_tag);
 700
 701        WARN_ON(fcxp->send_cbfn == NULL);
 702
 703        hal_fcxp_rx_plog(mod->bfa, fcxp, fcxp_rsp);
 704
 705        if (fcxp->send_cbfn != NULL) {
 706                bfa_trc(mod->bfa, (NULL == fcxp->caller));
 707                if (fcxp->caller == NULL) {
 708                        fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
 709                                        fcxp_rsp->req_status, fcxp_rsp->rsp_len,
 710                                        fcxp_rsp->residue_len, &fcxp_rsp->fchs);
 711                        /*
 712                         * fcxp automatically freed on return from the callback
 713                         */
 714                        bfa_fcxp_free(fcxp);
 715                } else {
 716                        fcxp->rsp_status = fcxp_rsp->req_status;
 717                        fcxp->rsp_len = fcxp_rsp->rsp_len;
 718                        fcxp->residue_len = fcxp_rsp->residue_len;
 719                        fcxp->rsp_fchs = fcxp_rsp->fchs;
 720
 721                        bfa_cb_queue(bfa, &fcxp->hcb_qe,
 722                                        __bfa_fcxp_send_cbfn, fcxp);
 723                }
 724        } else {
 725                bfa_trc(bfa, (NULL == fcxp->send_cbfn));
 726        }
 727}
 728
 729static void
 730hal_fcxp_tx_plog(struct bfa_s *bfa, u32 reqlen, struct bfa_fcxp_s *fcxp,
 731                 struct fchs_s *fchs)
 732{
 733        /*
 734         * TODO: TX ox_id
 735         */
 736        if (reqlen > 0) {
 737                if (fcxp->use_ireqbuf) {
 738                        u32     pld_w0 =
 739                                *((u32 *) BFA_FCXP_REQ_PLD(fcxp));
 740
 741                        bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_FCXP,
 742                                        BFA_PL_EID_TX,
 743                                        reqlen + sizeof(struct fchs_s), fchs,
 744                                        pld_w0);
 745                } else {
 746                        bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP,
 747                                        BFA_PL_EID_TX,
 748                                        reqlen + sizeof(struct fchs_s),
 749                                        fchs);
 750                }
 751        } else {
 752                bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_TX,
 753                               reqlen + sizeof(struct fchs_s), fchs);
 754        }
 755}
 756
 757static void
 758hal_fcxp_rx_plog(struct bfa_s *bfa, struct bfa_fcxp_s *fcxp,
 759                 struct bfi_fcxp_send_rsp_s *fcxp_rsp)
 760{
 761        if (fcxp_rsp->rsp_len > 0) {
 762                if (fcxp->use_irspbuf) {
 763                        u32     pld_w0 =
 764                                *((u32 *) BFA_FCXP_RSP_PLD(fcxp));
 765
 766                        bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_FCXP,
 767                                              BFA_PL_EID_RX,
 768                                              (u16) fcxp_rsp->rsp_len,
 769                                              &fcxp_rsp->fchs, pld_w0);
 770                } else {
 771                        bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP,
 772                                       BFA_PL_EID_RX,
 773                                       (u16) fcxp_rsp->rsp_len,
 774                                       &fcxp_rsp->fchs);
 775                }
 776        } else {
 777                bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_RX,
 778                               (u16) fcxp_rsp->rsp_len, &fcxp_rsp->fchs);
 779        }
 780}
 781
 782/*
 783 * Handler to resume sending fcxp when space in available in cpe queue.
 784 */
 785static void
 786bfa_fcxp_qresume(void *cbarg)
 787{
 788        struct bfa_fcxp_s               *fcxp = cbarg;
 789        struct bfa_s                    *bfa = fcxp->fcxp_mod->bfa;
 790        struct bfi_fcxp_send_req_s      *send_req;
 791
 792        fcxp->reqq_waiting = BFA_FALSE;
 793        send_req = bfa_reqq_next(bfa, BFA_REQQ_FCXP);
 794        bfa_fcxp_queue(fcxp, send_req);
 795}
 796
 797/*
 798 * Queue fcxp send request to foimrware.
 799 */
 800static void
 801bfa_fcxp_queue(struct bfa_fcxp_s *fcxp, struct bfi_fcxp_send_req_s *send_req)
 802{
 803        struct bfa_s                    *bfa = fcxp->fcxp_mod->bfa;
 804        struct bfa_fcxp_req_info_s      *reqi = &fcxp->req_info;
 805        struct bfa_fcxp_rsp_info_s      *rspi = &fcxp->rsp_info;
 806        struct bfa_rport_s              *rport = reqi->bfa_rport;
 807
 808        bfi_h2i_set(send_req->mh, BFI_MC_FCXP, BFI_FCXP_H2I_SEND_REQ,
 809                    bfa_fn_lpu(bfa));
 810
 811        send_req->fcxp_tag = cpu_to_be16(fcxp->fcxp_tag);
 812        if (rport) {
 813                send_req->rport_fw_hndl = rport->fw_handle;
 814                send_req->max_frmsz = cpu_to_be16(rport->rport_info.max_frmsz);
 815                if (send_req->max_frmsz == 0)
 816                        send_req->max_frmsz = cpu_to_be16(FC_MAX_PDUSZ);
 817        } else {
 818                send_req->rport_fw_hndl = 0;
 819                send_req->max_frmsz = cpu_to_be16(FC_MAX_PDUSZ);
 820        }
 821
 822        send_req->vf_id = cpu_to_be16(reqi->vf_id);
 823        send_req->lp_fwtag = bfa_lps_get_fwtag(bfa, reqi->lp_tag);
 824        send_req->class = reqi->class;
 825        send_req->rsp_timeout = rspi->rsp_timeout;
 826        send_req->cts = reqi->cts;
 827        send_req->fchs = reqi->fchs;
 828
 829        send_req->req_len = cpu_to_be32(reqi->req_tot_len);
 830        send_req->rsp_maxlen = cpu_to_be32(rspi->rsp_maxlen);
 831
 832        /*
 833         * setup req sgles
 834         */
 835        if (fcxp->use_ireqbuf == 1) {
 836                bfa_alen_set(&send_req->req_alen, reqi->req_tot_len,
 837                                        BFA_FCXP_REQ_PLD_PA(fcxp));
 838        } else {
 839                if (fcxp->nreq_sgles > 0) {
 840                        WARN_ON(fcxp->nreq_sgles != 1);
 841                        bfa_alen_set(&send_req->req_alen, reqi->req_tot_len,
 842                                fcxp->req_sga_cbfn(fcxp->caller, 0));
 843                } else {
 844                        WARN_ON(reqi->req_tot_len != 0);
 845                        bfa_alen_set(&send_req->rsp_alen, 0, 0);
 846                }
 847        }
 848
 849        /*
 850         * setup rsp sgles
 851         */
 852        if (fcxp->use_irspbuf == 1) {
 853                WARN_ON(rspi->rsp_maxlen > BFA_FCXP_MAX_LBUF_SZ);
 854
 855                bfa_alen_set(&send_req->rsp_alen, rspi->rsp_maxlen,
 856                                        BFA_FCXP_RSP_PLD_PA(fcxp));
 857        } else {
 858                if (fcxp->nrsp_sgles > 0) {
 859                        WARN_ON(fcxp->nrsp_sgles != 1);
 860                        bfa_alen_set(&send_req->rsp_alen, rspi->rsp_maxlen,
 861                                fcxp->rsp_sga_cbfn(fcxp->caller, 0));
 862
 863                } else {
 864                        WARN_ON(rspi->rsp_maxlen != 0);
 865                        bfa_alen_set(&send_req->rsp_alen, 0, 0);
 866                }
 867        }
 868
 869        hal_fcxp_tx_plog(bfa, reqi->req_tot_len, fcxp, &reqi->fchs);
 870
 871        bfa_reqq_produce(bfa, BFA_REQQ_FCXP, send_req->mh);
 872
 873        bfa_trc(bfa, bfa_reqq_pi(bfa, BFA_REQQ_FCXP));
 874        bfa_trc(bfa, bfa_reqq_ci(bfa, BFA_REQQ_FCXP));
 875}
 876
 877/*
 878 * Allocate an FCXP instance to send a response or to send a request
 879 * that has a response. Request/response buffers are allocated by caller.
 880 *
 881 * @param[in]   bfa             BFA bfa instance
 882 * @param[in]   nreq_sgles      Number of SG elements required for request
 883 *                              buffer. 0, if fcxp internal buffers are used.
 884 *                              Use bfa_fcxp_get_reqbuf() to get the
 885 *                              internal req buffer.
 886 * @param[in]   req_sgles       SG elements describing request buffer. Will be
 887 *                              copied in by BFA and hence can be freed on
 888 *                              return from this function.
 889 * @param[in]   get_req_sga     function ptr to be called to get a request SG
 890 *                              Address (given the sge index).
 891 * @param[in]   get_req_sglen   function ptr to be called to get a request SG
 892 *                              len (given the sge index).
 893 * @param[in]   get_rsp_sga     function ptr to be called to get a response SG
 894 *                              Address (given the sge index).
 895 * @param[in]   get_rsp_sglen   function ptr to be called to get a response SG
 896 *                              len (given the sge index).
 897 * @param[in]   req             Allocated FCXP is used to send req or rsp?
 898 *                              request - BFA_TRUE, response - BFA_FALSE
 899 *
 900 * @return FCXP instance. NULL on failure.
 901 */
 902struct bfa_fcxp_s *
 903bfa_fcxp_req_rsp_alloc(void *caller, struct bfa_s *bfa, int nreq_sgles,
 904                int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
 905                bfa_fcxp_get_sglen_t req_sglen_cbfn,
 906                bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
 907                bfa_fcxp_get_sglen_t rsp_sglen_cbfn, bfa_boolean_t req)
 908{
 909        struct bfa_fcxp_s *fcxp = NULL;
 910
 911        WARN_ON(bfa == NULL);
 912
 913        fcxp = bfa_fcxp_get(BFA_FCXP_MOD(bfa), req);
 914        if (fcxp == NULL)
 915                return NULL;
 916
 917        bfa_trc(bfa, fcxp->fcxp_tag);
 918
 919        bfa_fcxp_init(fcxp, caller, bfa, nreq_sgles, nrsp_sgles, req_sga_cbfn,
 920                        req_sglen_cbfn, rsp_sga_cbfn, rsp_sglen_cbfn);
 921
 922        return fcxp;
 923}
 924
 925/*
 926 * Get the internal request buffer pointer
 927 *
 928 * @param[in]   fcxp    BFA fcxp pointer
 929 *
 930 * @return              pointer to the internal request buffer
 931 */
 932void *
 933bfa_fcxp_get_reqbuf(struct bfa_fcxp_s *fcxp)
 934{
 935        struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
 936        void    *reqbuf;
 937
 938        WARN_ON(fcxp->use_ireqbuf != 1);
 939        reqbuf = bfa_mem_get_dmabuf_kva(mod, fcxp->fcxp_tag,
 940                                mod->req_pld_sz + mod->rsp_pld_sz);
 941        return reqbuf;
 942}
 943
 944u32
 945bfa_fcxp_get_reqbufsz(struct bfa_fcxp_s *fcxp)
 946{
 947        struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
 948
 949        return mod->req_pld_sz;
 950}
 951
 952/*
 953 * Get the internal response buffer pointer
 954 *
 955 * @param[in]   fcxp    BFA fcxp pointer
 956 *
 957 * @return              pointer to the internal request buffer
 958 */
 959void *
 960bfa_fcxp_get_rspbuf(struct bfa_fcxp_s *fcxp)
 961{
 962        struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
 963        void    *fcxp_buf;
 964
 965        WARN_ON(fcxp->use_irspbuf != 1);
 966
 967        fcxp_buf = bfa_mem_get_dmabuf_kva(mod, fcxp->fcxp_tag,
 968                                mod->req_pld_sz + mod->rsp_pld_sz);
 969
 970        /* fcxp_buf = req_buf + rsp_buf :- add req_buf_sz to get to rsp_buf */
 971        return ((u8 *) fcxp_buf) + mod->req_pld_sz;
 972}
 973
 974/*
 975 * Free the BFA FCXP
 976 *
 977 * @param[in]   fcxp                    BFA fcxp pointer
 978 *
 979 * @return              void
 980 */
 981void
 982bfa_fcxp_free(struct bfa_fcxp_s *fcxp)
 983{
 984        struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
 985
 986        WARN_ON(fcxp == NULL);
 987        bfa_trc(mod->bfa, fcxp->fcxp_tag);
 988        bfa_fcxp_put(fcxp);
 989}
 990
 991/*
 992 * Send a FCXP request
 993 *
 994 * @param[in]   fcxp    BFA fcxp pointer
 995 * @param[in]   rport   BFA rport pointer. Could be left NULL for WKA rports
 996 * @param[in]   vf_id   virtual Fabric ID
 997 * @param[in]   lp_tag  lport tag
 998 * @param[in]   cts     use Continuous sequence
 999 * @param[in]   cos     fc Class of Service
1000 * @param[in]   reqlen  request length, does not include FCHS length
1001 * @param[in]   fchs    fc Header Pointer. The header content will be copied
1002 *                      in by BFA.
1003 *
1004 * @param[in]   cbfn    call back function to be called on receiving
1005 *                                                              the response
1006 * @param[in]   cbarg   arg for cbfn
1007 * @param[in]   rsp_timeout
1008 *                      response timeout
1009 *
1010 * @return              bfa_status_t
1011 */
1012void
1013bfa_fcxp_send(struct bfa_fcxp_s *fcxp, struct bfa_rport_s *rport,
1014              u16 vf_id, u8 lp_tag, bfa_boolean_t cts, enum fc_cos cos,
1015              u32 reqlen, struct fchs_s *fchs, bfa_cb_fcxp_send_t cbfn,
1016              void *cbarg, u32 rsp_maxlen, u8 rsp_timeout)
1017{
1018        struct bfa_s                    *bfa  = fcxp->fcxp_mod->bfa;
1019        struct bfa_fcxp_req_info_s      *reqi = &fcxp->req_info;
1020        struct bfa_fcxp_rsp_info_s      *rspi = &fcxp->rsp_info;
1021        struct bfi_fcxp_send_req_s      *send_req;
1022
1023        bfa_trc(bfa, fcxp->fcxp_tag);
1024
1025        /*
1026         * setup request/response info
1027         */
1028        reqi->bfa_rport = rport;
1029        reqi->vf_id = vf_id;
1030        reqi->lp_tag = lp_tag;
1031        reqi->class = cos;
1032        rspi->rsp_timeout = rsp_timeout;
1033        reqi->cts = cts;
1034        reqi->fchs = *fchs;
1035        reqi->req_tot_len = reqlen;
1036        rspi->rsp_maxlen = rsp_maxlen;
1037        fcxp->send_cbfn = cbfn ? cbfn : bfa_fcxp_null_comp;
1038        fcxp->send_cbarg = cbarg;
1039
1040        /*
1041         * If no room in CPE queue, wait for space in request queue
1042         */
1043        send_req = bfa_reqq_next(bfa, BFA_REQQ_FCXP);
1044        if (!send_req) {
1045                bfa_trc(bfa, fcxp->fcxp_tag);
1046                fcxp->reqq_waiting = BFA_TRUE;
1047                bfa_reqq_wait(bfa, BFA_REQQ_FCXP, &fcxp->reqq_wqe);
1048                return;
1049        }
1050
1051        bfa_fcxp_queue(fcxp, send_req);
1052}
1053
1054/*
1055 * Abort a BFA FCXP
1056 *
1057 * @param[in]   fcxp    BFA fcxp pointer
1058 *
1059 * @return              void
1060 */
1061bfa_status_t
1062bfa_fcxp_abort(struct bfa_fcxp_s *fcxp)
1063{
1064        bfa_trc(fcxp->fcxp_mod->bfa, fcxp->fcxp_tag);
1065        WARN_ON(1);
1066        return BFA_STATUS_OK;
1067}
1068
1069void
1070bfa_fcxp_req_rsp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
1071               bfa_fcxp_alloc_cbfn_t alloc_cbfn, void *alloc_cbarg,
1072               void *caller, int nreq_sgles,
1073               int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
1074               bfa_fcxp_get_sglen_t req_sglen_cbfn,
1075               bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
1076               bfa_fcxp_get_sglen_t rsp_sglen_cbfn, bfa_boolean_t req)
1077{
1078        struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1079
1080        if (req)
1081                WARN_ON(!list_empty(&mod->fcxp_req_free_q));
1082        else
1083                WARN_ON(!list_empty(&mod->fcxp_rsp_free_q));
1084
1085        wqe->alloc_cbfn = alloc_cbfn;
1086        wqe->alloc_cbarg = alloc_cbarg;
1087        wqe->caller = caller;
1088        wqe->bfa = bfa;
1089        wqe->nreq_sgles = nreq_sgles;
1090        wqe->nrsp_sgles = nrsp_sgles;
1091        wqe->req_sga_cbfn = req_sga_cbfn;
1092        wqe->req_sglen_cbfn = req_sglen_cbfn;
1093        wqe->rsp_sga_cbfn = rsp_sga_cbfn;
1094        wqe->rsp_sglen_cbfn = rsp_sglen_cbfn;
1095
1096        if (req)
1097                list_add_tail(&wqe->qe, &mod->req_wait_q);
1098        else
1099                list_add_tail(&wqe->qe, &mod->rsp_wait_q);
1100}
1101
1102void
1103bfa_fcxp_walloc_cancel(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe)
1104{
1105        struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1106
1107        WARN_ON(!bfa_q_is_on_q(&mod->req_wait_q, wqe) ||
1108                !bfa_q_is_on_q(&mod->rsp_wait_q, wqe));
1109        list_del(&wqe->qe);
1110}
1111
1112void
1113bfa_fcxp_discard(struct bfa_fcxp_s *fcxp)
1114{
1115        /*
1116         * If waiting for room in request queue, cancel reqq wait
1117         * and free fcxp.
1118         */
1119        if (fcxp->reqq_waiting) {
1120                fcxp->reqq_waiting = BFA_FALSE;
1121                bfa_reqq_wcancel(&fcxp->reqq_wqe);
1122                bfa_fcxp_free(fcxp);
1123                return;
1124        }
1125
1126        fcxp->send_cbfn = bfa_fcxp_null_comp;
1127}
1128
1129void
1130bfa_fcxp_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
1131{
1132        switch (msg->mhdr.msg_id) {
1133        case BFI_FCXP_I2H_SEND_RSP:
1134                hal_fcxp_send_comp(bfa, (struct bfi_fcxp_send_rsp_s *) msg);
1135                break;
1136
1137        default:
1138                bfa_trc(bfa, msg->mhdr.msg_id);
1139                WARN_ON(1);
1140        }
1141}
1142
1143u32
1144bfa_fcxp_get_maxrsp(struct bfa_s *bfa)
1145{
1146        struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1147
1148        return mod->rsp_pld_sz;
1149}
1150
1151void
1152bfa_fcxp_res_recfg(struct bfa_s *bfa, u16 num_fcxp_fw)
1153{
1154        struct bfa_fcxp_mod_s   *mod = BFA_FCXP_MOD(bfa);
1155        struct list_head        *qe;
1156        int     i;
1157
1158        for (i = 0; i < (mod->num_fcxps - num_fcxp_fw); i++) {
1159                if (i < ((mod->num_fcxps - num_fcxp_fw) / 2)) {
1160                        bfa_q_deq_tail(&mod->fcxp_req_free_q, &qe);
1161                        list_add_tail(qe, &mod->fcxp_req_unused_q);
1162                } else {
1163                        bfa_q_deq_tail(&mod->fcxp_rsp_free_q, &qe);
1164                        list_add_tail(qe, &mod->fcxp_rsp_unused_q);
1165                }
1166        }
1167}
1168
1169/*
1170 *  BFA LPS state machine functions
1171 */
1172
1173/*
1174 * Init state -- no login
1175 */
1176static void
1177bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event)
1178{
1179        bfa_trc(lps->bfa, lps->bfa_tag);
1180        bfa_trc(lps->bfa, event);
1181
1182        switch (event) {
1183        case BFA_LPS_SM_LOGIN:
1184                if (bfa_reqq_full(lps->bfa, lps->reqq)) {
1185                        bfa_sm_set_state(lps, bfa_lps_sm_loginwait);
1186                        bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe);
1187                } else {
1188                        bfa_sm_set_state(lps, bfa_lps_sm_login);
1189                        bfa_lps_send_login(lps);
1190                }
1191
1192                if (lps->fdisc)
1193                        bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1194                                BFA_PL_EID_LOGIN, 0, "FDISC Request");
1195                else
1196                        bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1197                                BFA_PL_EID_LOGIN, 0, "FLOGI Request");
1198                break;
1199
1200        case BFA_LPS_SM_LOGOUT:
1201                bfa_lps_logout_comp(lps);
1202                break;
1203
1204        case BFA_LPS_SM_DELETE:
1205                bfa_lps_free(lps);
1206                break;
1207
1208        case BFA_LPS_SM_RX_CVL:
1209        case BFA_LPS_SM_OFFLINE:
1210                break;
1211
1212        case BFA_LPS_SM_FWRSP:
1213                /*
1214                 * Could happen when fabric detects loopback and discards
1215                 * the lps request. Fw will eventually sent out the timeout
1216                 * Just ignore
1217                 */
1218                break;
1219        case BFA_LPS_SM_SET_N2N_PID:
1220                /*
1221                 * When topology is set to loop, bfa_lps_set_n2n_pid() sends
1222                 * this event. Ignore this event.
1223                 */
1224                break;
1225
1226        default:
1227                bfa_sm_fault(lps->bfa, event);
1228        }
1229}
1230
1231/*
1232 * login is in progress -- awaiting response from firmware
1233 */
1234static void
1235bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event)
1236{
1237        bfa_trc(lps->bfa, lps->bfa_tag);
1238        bfa_trc(lps->bfa, event);
1239
1240        switch (event) {
1241        case BFA_LPS_SM_FWRSP:
1242                if (lps->status == BFA_STATUS_OK) {
1243                        bfa_sm_set_state(lps, bfa_lps_sm_online);
1244                        if (lps->fdisc)
1245                                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1246                                        BFA_PL_EID_LOGIN, 0, "FDISC Accept");
1247                        else
1248                                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1249                                        BFA_PL_EID_LOGIN, 0, "FLOGI Accept");
1250                        /* If N2N, send the assigned PID to FW */
1251                        bfa_trc(lps->bfa, lps->fport);
1252                        bfa_trc(lps->bfa, lps->lp_pid);
1253
1254                        if (!lps->fport && lps->lp_pid)
1255                                bfa_sm_send_event(lps, BFA_LPS_SM_SET_N2N_PID);
1256                } else {
1257                        bfa_sm_set_state(lps, bfa_lps_sm_init);
1258                        if (lps->fdisc)
1259                                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1260                                        BFA_PL_EID_LOGIN, 0,
1261                                        "FDISC Fail (RJT or timeout)");
1262                        else
1263                                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1264                                        BFA_PL_EID_LOGIN, 0,
1265                                        "FLOGI Fail (RJT or timeout)");
1266                }
1267                bfa_lps_login_comp(lps);
1268                break;
1269
1270        case BFA_LPS_SM_OFFLINE:
1271        case BFA_LPS_SM_DELETE:
1272                bfa_sm_set_state(lps, bfa_lps_sm_init);
1273                break;
1274
1275        case BFA_LPS_SM_SET_N2N_PID:
1276                bfa_trc(lps->bfa, lps->fport);
1277                bfa_trc(lps->bfa, lps->lp_pid);
1278                break;
1279
1280        default:
1281                bfa_sm_fault(lps->bfa, event);
1282        }
1283}
1284
1285/*
1286 * login pending - awaiting space in request queue
1287 */
1288static void
1289bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1290{
1291        bfa_trc(lps->bfa, lps->bfa_tag);
1292        bfa_trc(lps->bfa, event);
1293
1294        switch (event) {
1295        case BFA_LPS_SM_RESUME:
1296                bfa_sm_set_state(lps, bfa_lps_sm_login);
1297                bfa_lps_send_login(lps);
1298                break;
1299
1300        case BFA_LPS_SM_OFFLINE:
1301        case BFA_LPS_SM_DELETE:
1302                bfa_sm_set_state(lps, bfa_lps_sm_init);
1303                bfa_reqq_wcancel(&lps->wqe);
1304                break;
1305
1306        case BFA_LPS_SM_RX_CVL:
1307                /*
1308                 * Login was not even sent out; so when getting out
1309                 * of this state, it will appear like a login retry
1310                 * after Clear virtual link
1311                 */
1312                break;
1313
1314        default:
1315                bfa_sm_fault(lps->bfa, event);
1316        }
1317}
1318
1319/*
1320 * login complete
1321 */
1322static void
1323bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event)
1324{
1325        bfa_trc(lps->bfa, lps->bfa_tag);
1326        bfa_trc(lps->bfa, event);
1327
1328        switch (event) {
1329        case BFA_LPS_SM_LOGOUT:
1330                if (bfa_reqq_full(lps->bfa, lps->reqq)) {
1331                        bfa_sm_set_state(lps, bfa_lps_sm_logowait);
1332                        bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe);
1333                } else {
1334                        bfa_sm_set_state(lps, bfa_lps_sm_logout);
1335                        bfa_lps_send_logout(lps);
1336                }
1337                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1338                        BFA_PL_EID_LOGO, 0, "Logout");
1339                break;
1340
1341        case BFA_LPS_SM_RX_CVL:
1342                bfa_sm_set_state(lps, bfa_lps_sm_init);
1343
1344                /* Let the vport module know about this event */
1345                bfa_lps_cvl_event(lps);
1346                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1347                        BFA_PL_EID_FIP_FCF_CVL, 0, "FCF Clear Virt. Link Rx");
1348                break;
1349
1350        case BFA_LPS_SM_SET_N2N_PID:
1351                if (bfa_reqq_full(lps->bfa, lps->reqq)) {
1352                        bfa_sm_set_state(lps, bfa_lps_sm_online_n2n_pid_wait);
1353                        bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe);
1354                } else
1355                        bfa_lps_send_set_n2n_pid(lps);
1356                break;
1357
1358        case BFA_LPS_SM_OFFLINE:
1359        case BFA_LPS_SM_DELETE:
1360                bfa_sm_set_state(lps, bfa_lps_sm_init);
1361                break;
1362
1363        default:
1364                bfa_sm_fault(lps->bfa, event);
1365        }
1366}
1367
1368/*
1369 * login complete
1370 */
1371static void
1372bfa_lps_sm_online_n2n_pid_wait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1373{
1374        bfa_trc(lps->bfa, lps->bfa_tag);
1375        bfa_trc(lps->bfa, event);
1376
1377        switch (event) {
1378        case BFA_LPS_SM_RESUME:
1379                bfa_sm_set_state(lps, bfa_lps_sm_online);
1380                bfa_lps_send_set_n2n_pid(lps);
1381                break;
1382
1383        case BFA_LPS_SM_LOGOUT:
1384                bfa_sm_set_state(lps, bfa_lps_sm_logowait);
1385                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1386                        BFA_PL_EID_LOGO, 0, "Logout");
1387                break;
1388
1389        case BFA_LPS_SM_RX_CVL:
1390                bfa_sm_set_state(lps, bfa_lps_sm_init);
1391                bfa_reqq_wcancel(&lps->wqe);
1392
1393                /* Let the vport module know about this event */
1394                bfa_lps_cvl_event(lps);
1395                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1396                        BFA_PL_EID_FIP_FCF_CVL, 0, "FCF Clear Virt. Link Rx");
1397                break;
1398
1399        case BFA_LPS_SM_OFFLINE:
1400        case BFA_LPS_SM_DELETE:
1401                bfa_sm_set_state(lps, bfa_lps_sm_init);
1402                bfa_reqq_wcancel(&lps->wqe);
1403                break;
1404
1405        default:
1406                bfa_sm_fault(lps->bfa, event);
1407        }
1408}
1409
1410/*
1411 * logout in progress - awaiting firmware response
1412 */
1413static void
1414bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event)
1415{
1416        bfa_trc(lps->bfa, lps->bfa_tag);
1417        bfa_trc(lps->bfa, event);
1418
1419        switch (event) {
1420        case BFA_LPS_SM_FWRSP:
1421        case BFA_LPS_SM_OFFLINE:
1422                bfa_sm_set_state(lps, bfa_lps_sm_init);
1423                bfa_lps_logout_comp(lps);
1424                break;
1425
1426        case BFA_LPS_SM_DELETE:
1427                bfa_sm_set_state(lps, bfa_lps_sm_init);
1428                break;
1429
1430        default:
1431                bfa_sm_fault(lps->bfa, event);
1432        }
1433}
1434
1435/*
1436 * logout pending -- awaiting space in request queue
1437 */
1438static void
1439bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1440{
1441        bfa_trc(lps->bfa, lps->bfa_tag);
1442        bfa_trc(lps->bfa, event);
1443
1444        switch (event) {
1445        case BFA_LPS_SM_RESUME:
1446                bfa_sm_set_state(lps, bfa_lps_sm_logout);
1447                bfa_lps_send_logout(lps);
1448                break;
1449
1450        case BFA_LPS_SM_OFFLINE:
1451        case BFA_LPS_SM_DELETE:
1452                bfa_sm_set_state(lps, bfa_lps_sm_init);
1453                bfa_reqq_wcancel(&lps->wqe);
1454                break;
1455
1456        default:
1457                bfa_sm_fault(lps->bfa, event);
1458        }
1459}
1460
1461
1462
1463/*
1464 *  lps_pvt BFA LPS private functions
1465 */
1466
1467/*
1468 * return memory requirement
1469 */
1470void
1471bfa_lps_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
1472                struct bfa_s *bfa)
1473{
1474        struct bfa_mem_kva_s *lps_kva = BFA_MEM_LPS_KVA(bfa);
1475
1476        if (cfg->drvcfg.min_cfg)
1477                bfa_mem_kva_setup(minfo, lps_kva,
1478                        sizeof(struct bfa_lps_s) * BFA_LPS_MIN_LPORTS);
1479        else
1480                bfa_mem_kva_setup(minfo, lps_kva,
1481                        sizeof(struct bfa_lps_s) * BFA_LPS_MAX_LPORTS);
1482}
1483
1484/*
1485 * bfa module attach at initialization time
1486 */
1487void
1488bfa_lps_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1489        struct bfa_pcidev_s *pcidev)
1490{
1491        struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1492        struct bfa_lps_s        *lps;
1493        int                     i;
1494
1495        mod->num_lps = BFA_LPS_MAX_LPORTS;
1496        if (cfg->drvcfg.min_cfg)
1497                mod->num_lps = BFA_LPS_MIN_LPORTS;
1498        else
1499                mod->num_lps = BFA_LPS_MAX_LPORTS;
1500        mod->lps_arr = lps = (struct bfa_lps_s *) bfa_mem_kva_curp(mod);
1501
1502        bfa_mem_kva_curp(mod) += mod->num_lps * sizeof(struct bfa_lps_s);
1503
1504        INIT_LIST_HEAD(&mod->lps_free_q);
1505        INIT_LIST_HEAD(&mod->lps_active_q);
1506        INIT_LIST_HEAD(&mod->lps_login_q);
1507
1508        for (i = 0; i < mod->num_lps; i++, lps++) {
1509                lps->bfa        = bfa;
1510                lps->bfa_tag    = (u8) i;
1511                lps->reqq       = BFA_REQQ_LPS;
1512                bfa_reqq_winit(&lps->wqe, bfa_lps_reqq_resume, lps);
1513                list_add_tail(&lps->qe, &mod->lps_free_q);
1514        }
1515}
1516
1517/*
1518 * IOC in disabled state -- consider all lps offline
1519 */
1520void
1521bfa_lps_iocdisable(struct bfa_s *bfa)
1522{
1523        struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1524        struct bfa_lps_s        *lps;
1525        struct list_head                *qe, *qen;
1526
1527        list_for_each_safe(qe, qen, &mod->lps_active_q) {
1528                lps = (struct bfa_lps_s *) qe;
1529                bfa_sm_send_event(lps, BFA_LPS_SM_OFFLINE);
1530        }
1531        list_for_each_safe(qe, qen, &mod->lps_login_q) {
1532                lps = (struct bfa_lps_s *) qe;
1533                bfa_sm_send_event(lps, BFA_LPS_SM_OFFLINE);
1534        }
1535        list_splice_tail_init(&mod->lps_login_q, &mod->lps_active_q);
1536}
1537
1538/*
1539 * Firmware login response
1540 */
1541static void
1542bfa_lps_login_rsp(struct bfa_s *bfa, struct bfi_lps_login_rsp_s *rsp)
1543{
1544        struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1545        struct bfa_lps_s        *lps;
1546
1547        WARN_ON(rsp->bfa_tag >= mod->num_lps);
1548        lps = BFA_LPS_FROM_TAG(mod, rsp->bfa_tag);
1549
1550        lps->status = rsp->status;
1551        switch (rsp->status) {
1552        case BFA_STATUS_OK:
1553                lps->fw_tag     = rsp->fw_tag;
1554                lps->fport      = rsp->f_port;
1555                if (lps->fport)
1556                        lps->lp_pid = rsp->lp_pid;
1557                lps->npiv_en    = rsp->npiv_en;
1558                lps->pr_bbcred  = be16_to_cpu(rsp->bb_credit);
1559                lps->pr_pwwn    = rsp->port_name;
1560                lps->pr_nwwn    = rsp->node_name;
1561                lps->auth_req   = rsp->auth_req;
1562                lps->lp_mac     = rsp->lp_mac;
1563                lps->brcd_switch = rsp->brcd_switch;
1564                lps->fcf_mac    = rsp->fcf_mac;
1565
1566                break;
1567
1568        case BFA_STATUS_FABRIC_RJT:
1569                lps->lsrjt_rsn = rsp->lsrjt_rsn;
1570                lps->lsrjt_expl = rsp->lsrjt_expl;
1571
1572                break;
1573
1574        case BFA_STATUS_EPROTOCOL:
1575                lps->ext_status = rsp->ext_status;
1576
1577                break;
1578
1579        case BFA_STATUS_VPORT_MAX:
1580                if (rsp->ext_status)
1581                        bfa_lps_no_res(lps, rsp->ext_status);
1582                break;
1583
1584        default:
1585                /* Nothing to do with other status */
1586                break;
1587        }
1588
1589        list_del(&lps->qe);
1590        list_add_tail(&lps->qe, &mod->lps_active_q);
1591        bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
1592}
1593
1594static void
1595bfa_lps_no_res(struct bfa_lps_s *first_lps, u8 count)
1596{
1597        struct bfa_s            *bfa = first_lps->bfa;
1598        struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1599        struct list_head        *qe, *qe_next;
1600        struct bfa_lps_s        *lps;
1601
1602        bfa_trc(bfa, count);
1603
1604        qe = bfa_q_next(first_lps);
1605
1606        while (count && qe) {
1607                qe_next = bfa_q_next(qe);
1608                lps = (struct bfa_lps_s *)qe;
1609                bfa_trc(bfa, lps->bfa_tag);
1610                lps->status = first_lps->status;
1611                list_del(&lps->qe);
1612                list_add_tail(&lps->qe, &mod->lps_active_q);
1613                bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
1614                qe = qe_next;
1615                count--;
1616        }
1617}
1618
1619/*
1620 * Firmware logout response
1621 */
1622static void
1623bfa_lps_logout_rsp(struct bfa_s *bfa, struct bfi_lps_logout_rsp_s *rsp)
1624{
1625        struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1626        struct bfa_lps_s        *lps;
1627
1628        WARN_ON(rsp->bfa_tag >= mod->num_lps);
1629        lps = BFA_LPS_FROM_TAG(mod, rsp->bfa_tag);
1630
1631        bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
1632}
1633
1634/*
1635 * Firmware received a Clear virtual link request (for FCoE)
1636 */
1637static void
1638bfa_lps_rx_cvl_event(struct bfa_s *bfa, struct bfi_lps_cvl_event_s *cvl)
1639{
1640        struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1641        struct bfa_lps_s        *lps;
1642
1643        lps = BFA_LPS_FROM_TAG(mod, cvl->bfa_tag);
1644
1645        bfa_sm_send_event(lps, BFA_LPS_SM_RX_CVL);
1646}
1647
1648/*
1649 * Space is available in request queue, resume queueing request to firmware.
1650 */
1651static void
1652bfa_lps_reqq_resume(void *lps_arg)
1653{
1654        struct bfa_lps_s        *lps = lps_arg;
1655
1656        bfa_sm_send_event(lps, BFA_LPS_SM_RESUME);
1657}
1658
1659/*
1660 * lps is freed -- triggered by vport delete
1661 */
1662static void
1663bfa_lps_free(struct bfa_lps_s *lps)
1664{
1665        struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(lps->bfa);
1666
1667        lps->lp_pid = 0;
1668        list_del(&lps->qe);
1669        list_add_tail(&lps->qe, &mod->lps_free_q);
1670}
1671
1672/*
1673 * send login request to firmware
1674 */
1675static void
1676bfa_lps_send_login(struct bfa_lps_s *lps)
1677{
1678        struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(lps->bfa);
1679        struct bfi_lps_login_req_s      *m;
1680
1681        m = bfa_reqq_next(lps->bfa, lps->reqq);
1682        WARN_ON(!m);
1683
1684        bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGIN_REQ,
1685                bfa_fn_lpu(lps->bfa));
1686
1687        m->bfa_tag      = lps->bfa_tag;
1688        m->alpa         = lps->alpa;
1689        m->pdu_size     = cpu_to_be16(lps->pdusz);
1690        m->pwwn         = lps->pwwn;
1691        m->nwwn         = lps->nwwn;
1692        m->fdisc        = lps->fdisc;
1693        m->auth_en      = lps->auth_en;
1694
1695        bfa_reqq_produce(lps->bfa, lps->reqq, m->mh);
1696        list_del(&lps->qe);
1697        list_add_tail(&lps->qe, &mod->lps_login_q);
1698}
1699
1700/*
1701 * send logout request to firmware
1702 */
1703static void
1704bfa_lps_send_logout(struct bfa_lps_s *lps)
1705{
1706        struct bfi_lps_logout_req_s *m;
1707
1708        m = bfa_reqq_next(lps->bfa, lps->reqq);
1709        WARN_ON(!m);
1710
1711        bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGOUT_REQ,
1712                bfa_fn_lpu(lps->bfa));
1713
1714        m->fw_tag = lps->fw_tag;
1715        m->port_name = lps->pwwn;
1716        bfa_reqq_produce(lps->bfa, lps->reqq, m->mh);
1717}
1718
1719/*
1720 * send n2n pid set request to firmware
1721 */
1722static void
1723bfa_lps_send_set_n2n_pid(struct bfa_lps_s *lps)
1724{
1725        struct bfi_lps_n2n_pid_req_s *m;
1726
1727        m = bfa_reqq_next(lps->bfa, lps->reqq);
1728        WARN_ON(!m);
1729
1730        bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_N2N_PID_REQ,
1731                bfa_fn_lpu(lps->bfa));
1732
1733        m->fw_tag = lps->fw_tag;
1734        m->lp_pid = lps->lp_pid;
1735        bfa_reqq_produce(lps->bfa, lps->reqq, m->mh);
1736}
1737
1738/*
1739 * Indirect login completion handler for non-fcs
1740 */
1741static void
1742bfa_lps_login_comp_cb(void *arg, bfa_boolean_t complete)
1743{
1744        struct bfa_lps_s *lps   = arg;
1745
1746        if (!complete)
1747                return;
1748
1749        if (lps->fdisc)
1750                bfa_cb_lps_fdisc_comp(lps->bfa->bfad, lps->uarg, lps->status);
1751        else
1752                bfa_cb_lps_flogi_comp(lps->bfa->bfad, lps->uarg, lps->status);
1753}
1754
1755/*
1756 * Login completion handler -- direct call for fcs, queue for others
1757 */
1758static void
1759bfa_lps_login_comp(struct bfa_lps_s *lps)
1760{
1761        if (!lps->bfa->fcs) {
1762                bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_login_comp_cb,
1763                        lps);
1764                return;
1765        }
1766
1767        if (lps->fdisc)
1768                bfa_cb_lps_fdisc_comp(lps->bfa->bfad, lps->uarg, lps->status);
1769        else
1770                bfa_cb_lps_flogi_comp(lps->bfa->bfad, lps->uarg, lps->status);
1771}
1772
1773/*
1774 * Indirect logout completion handler for non-fcs
1775 */
1776static void
1777bfa_lps_logout_comp_cb(void *arg, bfa_boolean_t complete)
1778{
1779        struct bfa_lps_s *lps   = arg;
1780
1781        if (!complete)
1782                return;
1783
1784        if (lps->fdisc)
1785                bfa_cb_lps_fdisclogo_comp(lps->bfa->bfad, lps->uarg);
1786        else
1787                bfa_cb_lps_flogo_comp(lps->bfa->bfad, lps->uarg);
1788}
1789
1790/*
1791 * Logout completion handler -- direct call for fcs, queue for others
1792 */
1793static void
1794bfa_lps_logout_comp(struct bfa_lps_s *lps)
1795{
1796        if (!lps->bfa->fcs) {
1797                bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_logout_comp_cb,
1798                        lps);
1799                return;
1800        }
1801        if (lps->fdisc)
1802                bfa_cb_lps_fdisclogo_comp(lps->bfa->bfad, lps->uarg);
1803}
1804
1805/*
1806 * Clear virtual link completion handler for non-fcs
1807 */
1808static void
1809bfa_lps_cvl_event_cb(void *arg, bfa_boolean_t complete)
1810{
1811        struct bfa_lps_s *lps   = arg;
1812
1813        if (!complete)
1814                return;
1815
1816        /* Clear virtual link to base port will result in link down */
1817        if (lps->fdisc)
1818                bfa_cb_lps_cvl_event(lps->bfa->bfad, lps->uarg);
1819}
1820
1821/*
1822 * Received Clear virtual link event --direct call for fcs,
1823 * queue for others
1824 */
1825static void
1826bfa_lps_cvl_event(struct bfa_lps_s *lps)
1827{
1828        if (!lps->bfa->fcs) {
1829                bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_cvl_event_cb,
1830                        lps);
1831                return;
1832        }
1833
1834        /* Clear virtual link to base port will result in link down */
1835        if (lps->fdisc)
1836                bfa_cb_lps_cvl_event(lps->bfa->bfad, lps->uarg);
1837}
1838
1839
1840
1841/*
1842 *  lps_public BFA LPS public functions
1843 */
1844
1845u32
1846bfa_lps_get_max_vport(struct bfa_s *bfa)
1847{
1848        if (bfa_ioc_devid(&bfa->ioc) == BFA_PCI_DEVICE_ID_CT)
1849                return BFA_LPS_MAX_VPORTS_SUPP_CT;
1850        else
1851                return BFA_LPS_MAX_VPORTS_SUPP_CB;
1852}
1853
1854/*
1855 * Allocate a lport srvice tag.
1856 */
1857struct bfa_lps_s  *
1858bfa_lps_alloc(struct bfa_s *bfa)
1859{
1860        struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1861        struct bfa_lps_s        *lps = NULL;
1862
1863        bfa_q_deq(&mod->lps_free_q, &lps);
1864
1865        if (lps == NULL)
1866                return NULL;
1867
1868        list_add_tail(&lps->qe, &mod->lps_active_q);
1869
1870        bfa_sm_set_state(lps, bfa_lps_sm_init);
1871        return lps;
1872}
1873
1874/*
1875 * Free lport service tag. This can be called anytime after an alloc.
1876 * No need to wait for any pending login/logout completions.
1877 */
1878void
1879bfa_lps_delete(struct bfa_lps_s *lps)
1880{
1881        bfa_sm_send_event(lps, BFA_LPS_SM_DELETE);
1882}
1883
1884/*
1885 * Initiate a lport login.
1886 */
1887void
1888bfa_lps_flogi(struct bfa_lps_s *lps, void *uarg, u8 alpa, u16 pdusz,
1889        wwn_t pwwn, wwn_t nwwn, bfa_boolean_t auth_en)
1890{
1891        lps->uarg       = uarg;
1892        lps->alpa       = alpa;
1893        lps->pdusz      = pdusz;
1894        lps->pwwn       = pwwn;
1895        lps->nwwn       = nwwn;
1896        lps->fdisc      = BFA_FALSE;
1897        lps->auth_en    = auth_en;
1898        bfa_sm_send_event(lps, BFA_LPS_SM_LOGIN);
1899}
1900
1901/*
1902 * Initiate a lport fdisc login.
1903 */
1904void
1905bfa_lps_fdisc(struct bfa_lps_s *lps, void *uarg, u16 pdusz, wwn_t pwwn,
1906        wwn_t nwwn)
1907{
1908        lps->uarg       = uarg;
1909        lps->alpa       = 0;
1910        lps->pdusz      = pdusz;
1911        lps->pwwn       = pwwn;
1912        lps->nwwn       = nwwn;
1913        lps->fdisc      = BFA_TRUE;
1914        lps->auth_en    = BFA_FALSE;
1915        bfa_sm_send_event(lps, BFA_LPS_SM_LOGIN);
1916}
1917
1918
1919/*
1920 * Initiate a lport FDSIC logout.
1921 */
1922void
1923bfa_lps_fdisclogo(struct bfa_lps_s *lps)
1924{
1925        bfa_sm_send_event(lps, BFA_LPS_SM_LOGOUT);
1926}
1927
1928u8
1929bfa_lps_get_fwtag(struct bfa_s *bfa, u8 lp_tag)
1930{
1931        struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1932
1933        return BFA_LPS_FROM_TAG(mod, lp_tag)->fw_tag;
1934}
1935
1936/*
1937 * Return lport services tag given the pid
1938 */
1939u8
1940bfa_lps_get_tag_from_pid(struct bfa_s *bfa, u32 pid)
1941{
1942        struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1943        struct bfa_lps_s        *lps;
1944        int                     i;
1945
1946        for (i = 0, lps = mod->lps_arr; i < mod->num_lps; i++, lps++) {
1947                if (lps->lp_pid == pid)
1948                        return lps->bfa_tag;
1949        }
1950
1951        /* Return base port tag anyway */
1952        return 0;
1953}
1954
1955
1956/*
1957 * return port id assigned to the base lport
1958 */
1959u32
1960bfa_lps_get_base_pid(struct bfa_s *bfa)
1961{
1962        struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1963
1964        return BFA_LPS_FROM_TAG(mod, 0)->lp_pid;
1965}
1966
1967/*
1968 * Set PID in case of n2n (which is assigned during PLOGI)
1969 */
1970void
1971bfa_lps_set_n2n_pid(struct bfa_lps_s *lps, uint32_t n2n_pid)
1972{
1973        bfa_trc(lps->bfa, lps->bfa_tag);
1974        bfa_trc(lps->bfa, n2n_pid);
1975
1976        lps->lp_pid = n2n_pid;
1977        bfa_sm_send_event(lps, BFA_LPS_SM_SET_N2N_PID);
1978}
1979
1980/*
1981 * LPS firmware message class handler.
1982 */
1983void
1984bfa_lps_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
1985{
1986        union bfi_lps_i2h_msg_u msg;
1987
1988        bfa_trc(bfa, m->mhdr.msg_id);
1989        msg.msg = m;
1990
1991        switch (m->mhdr.msg_id) {
1992        case BFI_LPS_I2H_LOGIN_RSP:
1993                bfa_lps_login_rsp(bfa, msg.login_rsp);
1994                break;
1995
1996        case BFI_LPS_I2H_LOGOUT_RSP:
1997                bfa_lps_logout_rsp(bfa, msg.logout_rsp);
1998                break;
1999
2000        case BFI_LPS_I2H_CVL_EVENT:
2001                bfa_lps_rx_cvl_event(bfa, msg.cvl_event);
2002                break;
2003
2004        default:
2005                bfa_trc(bfa, m->mhdr.msg_id);
2006                WARN_ON(1);
2007        }
2008}
2009
2010static void
2011bfa_fcport_aen_post(struct bfa_fcport_s *fcport, enum bfa_port_aen_event event)
2012{
2013        struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2014        struct bfa_aen_entry_s  *aen_entry;
2015
2016        bfad_get_aen_entry(bfad, aen_entry);
2017        if (!aen_entry)
2018                return;
2019
2020        aen_entry->aen_data.port.ioc_type = bfa_get_type(fcport->bfa);
2021        aen_entry->aen_data.port.pwwn = fcport->pwwn;
2022
2023        /* Send the AEN notification */
2024        bfad_im_post_vendor_event(aen_entry, bfad, ++fcport->bfa->bfa_aen_seq,
2025                                  BFA_AEN_CAT_PORT, event);
2026}
2027
2028/*
2029 * FC PORT state machine functions
2030 */
2031static void
2032bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
2033                        enum bfa_fcport_sm_event event)
2034{
2035        bfa_trc(fcport->bfa, event);
2036
2037        switch (event) {
2038        case BFA_FCPORT_SM_START:
2039                /*
2040                 * Start event after IOC is configured and BFA is started.
2041                 */
2042                fcport->use_flash_cfg = BFA_TRUE;
2043
2044                if (bfa_fcport_send_enable(fcport)) {
2045                        bfa_trc(fcport->bfa, BFA_TRUE);
2046                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2047                } else {
2048                        bfa_trc(fcport->bfa, BFA_FALSE);
2049                        bfa_sm_set_state(fcport,
2050                                        bfa_fcport_sm_enabling_qwait);
2051                }
2052                break;
2053
2054        case BFA_FCPORT_SM_ENABLE:
2055                /*
2056                 * Port is persistently configured to be in enabled state. Do
2057                 * not change state. Port enabling is done when START event is
2058                 * received.
2059                 */
2060                break;
2061
2062        case BFA_FCPORT_SM_DISABLE:
2063                /*
2064                 * If a port is persistently configured to be disabled, the
2065                 * first event will a port disable request.
2066                 */
2067                bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2068                break;
2069
2070        case BFA_FCPORT_SM_HWFAIL:
2071                bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2072                break;
2073
2074        default:
2075                bfa_sm_fault(fcport->bfa, event);
2076        }
2077}
2078
2079static void
2080bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
2081                                enum bfa_fcport_sm_event event)
2082{
2083        char pwwn_buf[BFA_STRING_32];
2084        struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2085        bfa_trc(fcport->bfa, event);
2086
2087        switch (event) {
2088        case BFA_FCPORT_SM_QRESUME:
2089                bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2090                bfa_fcport_send_enable(fcport);
2091                break;
2092
2093        case BFA_FCPORT_SM_STOP:
2094                bfa_reqq_wcancel(&fcport->reqq_wait);
2095                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2096                break;
2097
2098        case BFA_FCPORT_SM_ENABLE:
2099                /*
2100                 * Already enable is in progress.
2101                 */
2102                break;
2103
2104        case BFA_FCPORT_SM_DISABLE:
2105                /*
2106                 * Just send disable request to firmware when room becomes
2107                 * available in request queue.
2108                 */
2109                bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2110                bfa_reqq_wcancel(&fcport->reqq_wait);
2111                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2112                                BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2113                wwn2str(pwwn_buf, fcport->pwwn);
2114                BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2115                        "Base port disabled: WWN = %s\n", pwwn_buf);
2116                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
2117                break;
2118
2119        case BFA_FCPORT_SM_LINKUP:
2120        case BFA_FCPORT_SM_LINKDOWN:
2121                /*
2122                 * Possible to get link events when doing back-to-back
2123                 * enable/disables.
2124                 */
2125                break;
2126
2127        case BFA_FCPORT_SM_HWFAIL:
2128                bfa_reqq_wcancel(&fcport->reqq_wait);
2129                bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2130                break;
2131
2132        case BFA_FCPORT_SM_FAA_MISCONFIG:
2133                bfa_fcport_reset_linkinfo(fcport);
2134                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2135                bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig);
2136                break;
2137
2138        default:
2139                bfa_sm_fault(fcport->bfa, event);
2140        }
2141}
2142
2143static void
2144bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
2145                                                enum bfa_fcport_sm_event event)
2146{
2147        char pwwn_buf[BFA_STRING_32];
2148        struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2149        bfa_trc(fcport->bfa, event);
2150
2151        switch (event) {
2152        case BFA_FCPORT_SM_FWRSP:
2153        case BFA_FCPORT_SM_LINKDOWN:
2154                bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
2155                break;
2156
2157        case BFA_FCPORT_SM_LINKUP:
2158                bfa_fcport_update_linkinfo(fcport);
2159                bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
2160
2161                WARN_ON(!fcport->event_cbfn);
2162                bfa_fcport_scn(fcport, BFA_PORT_LINKUP, BFA_FALSE);
2163                break;
2164
2165        case BFA_FCPORT_SM_ENABLE:
2166                /*
2167                 * Already being enabled.
2168                 */
2169                break;
2170
2171        case BFA_FCPORT_SM_DISABLE:
2172                if (bfa_fcport_send_disable(fcport))
2173                        bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2174                else
2175                        bfa_sm_set_state(fcport,
2176                                         bfa_fcport_sm_disabling_qwait);
2177
2178                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2179                                BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2180                wwn2str(pwwn_buf, fcport->pwwn);
2181                BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2182                        "Base port disabled: WWN = %s\n", pwwn_buf);
2183                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
2184                break;
2185
2186        case BFA_FCPORT_SM_STOP:
2187                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2188                break;
2189
2190        case BFA_FCPORT_SM_HWFAIL:
2191                bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2192                break;
2193
2194        case BFA_FCPORT_SM_FAA_MISCONFIG:
2195                bfa_fcport_reset_linkinfo(fcport);
2196                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2197                bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig);
2198                break;
2199
2200        default:
2201                bfa_sm_fault(fcport->bfa, event);
2202        }
2203}
2204
2205static void
2206bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
2207                                                enum bfa_fcport_sm_event event)
2208{
2209        struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
2210        char pwwn_buf[BFA_STRING_32];
2211        struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2212
2213        bfa_trc(fcport->bfa, event);
2214
2215        switch (event) {
2216        case BFA_FCPORT_SM_LINKUP:
2217                bfa_fcport_update_linkinfo(fcport);
2218                bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
2219                WARN_ON(!fcport->event_cbfn);
2220                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2221                                BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkup");
2222                if (!bfa_ioc_get_fcmode(&fcport->bfa->ioc)) {
2223
2224                        bfa_trc(fcport->bfa,
2225                                pevent->link_state.attr.vc_fcf.fcf.fipenabled);
2226                        bfa_trc(fcport->bfa,
2227                                pevent->link_state.attr.vc_fcf.fcf.fipfailed);
2228
2229                        if (pevent->link_state.attr.vc_fcf.fcf.fipfailed)
2230                                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2231                                        BFA_PL_EID_FIP_FCF_DISC, 0,
2232                                        "FIP FCF Discovery Failed");
2233                        else
2234                                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2235                                        BFA_PL_EID_FIP_FCF_DISC, 0,
2236                                        "FIP FCF Discovered");
2237                }
2238
2239                bfa_fcport_scn(fcport, BFA_PORT_LINKUP, BFA_FALSE);
2240                wwn2str(pwwn_buf, fcport->pwwn);
2241                BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2242                        "Base port online: WWN = %s\n", pwwn_buf);
2243                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ONLINE);
2244
2245                /* If QoS is enabled and it is not online, send AEN */
2246                if (fcport->cfg.qos_enabled &&
2247                    fcport->qos_attr.state != BFA_QOS_ONLINE)
2248                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_QOS_NEG);
2249                break;
2250
2251        case BFA_FCPORT_SM_LINKDOWN:
2252                /*
2253                 * Possible to get link down event.
2254                 */
2255                break;
2256
2257        case BFA_FCPORT_SM_ENABLE:
2258                /*
2259                 * Already enabled.
2260                 */
2261                break;
2262
2263        case BFA_FCPORT_SM_DISABLE:
2264                if (bfa_fcport_send_disable(fcport))
2265                        bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2266                else
2267                        bfa_sm_set_state(fcport,
2268                                         bfa_fcport_sm_disabling_qwait);
2269
2270                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2271                                BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2272                wwn2str(pwwn_buf, fcport->pwwn);
2273                BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2274                        "Base port disabled: WWN = %s\n", pwwn_buf);
2275                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
2276                break;
2277
2278        case BFA_FCPORT_SM_STOP:
2279                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2280                break;
2281
2282        case BFA_FCPORT_SM_HWFAIL:
2283                bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2284                break;
2285
2286        case BFA_FCPORT_SM_FAA_MISCONFIG:
2287                bfa_fcport_reset_linkinfo(fcport);
2288                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2289                bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig);
2290                break;
2291
2292        default:
2293                bfa_sm_fault(fcport->bfa, event);
2294        }
2295}
2296
2297static void
2298bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
2299        enum bfa_fcport_sm_event event)
2300{
2301        char pwwn_buf[BFA_STRING_32];
2302        struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2303
2304        bfa_trc(fcport->bfa, event);
2305
2306        switch (event) {
2307        case BFA_FCPORT_SM_ENABLE:
2308                /*
2309                 * Already enabled.
2310                 */
2311                break;
2312
2313        case BFA_FCPORT_SM_DISABLE:
2314                if (bfa_fcport_send_disable(fcport))
2315                        bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2316                else
2317                        bfa_sm_set_state(fcport,
2318                                         bfa_fcport_sm_disabling_qwait);
2319
2320                bfa_fcport_reset_linkinfo(fcport);
2321                bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2322                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2323                                BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2324                wwn2str(pwwn_buf, fcport->pwwn);
2325                BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2326                        "Base port offline: WWN = %s\n", pwwn_buf);
2327                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
2328                BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2329                        "Base port disabled: WWN = %s\n", pwwn_buf);
2330                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
2331                break;
2332
2333        case BFA_FCPORT_SM_LINKDOWN:
2334                bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
2335                bfa_fcport_reset_linkinfo(fcport);
2336                bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2337                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2338                                BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkdown");
2339                wwn2str(pwwn_buf, fcport->pwwn);
2340                if (BFA_PORT_IS_DISABLED(fcport->bfa)) {
2341                        BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2342                                "Base port offline: WWN = %s\n", pwwn_buf);
2343                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
2344                } else {
2345                        BFA_LOG(KERN_ERR, bfad, bfa_log_level,
2346                                "Base port (WWN = %s) "
2347                                "lost fabric connectivity\n", pwwn_buf);
2348                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2349                }
2350                break;
2351
2352        case BFA_FCPORT_SM_STOP:
2353                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2354                bfa_fcport_reset_linkinfo(fcport);
2355                wwn2str(pwwn_buf, fcport->pwwn);
2356                if (BFA_PORT_IS_DISABLED(fcport->bfa)) {
2357                        BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2358                                "Base port offline: WWN = %s\n", pwwn_buf);
2359                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
2360                } else {
2361                        BFA_LOG(KERN_ERR, bfad, bfa_log_level,
2362                                "Base port (WWN = %s) "
2363                                "lost fabric connectivity\n", pwwn_buf);
2364                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2365                }
2366                break;
2367
2368        case BFA_FCPORT_SM_HWFAIL:
2369                bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2370                bfa_fcport_reset_linkinfo(fcport);
2371                bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2372                wwn2str(pwwn_buf, fcport->pwwn);
2373                if (BFA_PORT_IS_DISABLED(fcport->bfa)) {
2374                        BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2375                                "Base port offline: WWN = %s\n", pwwn_buf);
2376                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
2377                } else {
2378                        BFA_LOG(KERN_ERR, bfad, bfa_log_level,
2379                                "Base port (WWN = %s) "
2380                                "lost fabric connectivity\n", pwwn_buf);
2381                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2382                }
2383                break;
2384
2385        case BFA_FCPORT_SM_FAA_MISCONFIG:
2386                bfa_fcport_reset_linkinfo(fcport);
2387                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2388                bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig);
2389                break;
2390
2391        default:
2392                bfa_sm_fault(fcport->bfa, event);
2393        }
2394}
2395
2396static void
2397bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
2398                                 enum bfa_fcport_sm_event event)
2399{
2400        bfa_trc(fcport->bfa, event);
2401
2402        switch (event) {
2403        case BFA_FCPORT_SM_QRESUME:
2404                bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2405                bfa_fcport_send_disable(fcport);
2406                break;
2407
2408        case BFA_FCPORT_SM_STOP:
2409                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2410                bfa_reqq_wcancel(&fcport->reqq_wait);
2411                break;
2412
2413        case BFA_FCPORT_SM_ENABLE:
2414                bfa_sm_set_state(fcport, bfa_fcport_sm_toggling_qwait);
2415                break;
2416
2417        case BFA_FCPORT_SM_DISABLE:
2418                /*
2419                 * Already being disabled.
2420                 */
2421                break;
2422
2423        case BFA_FCPORT_SM_LINKUP:
2424        case BFA_FCPORT_SM_LINKDOWN:
2425                /*
2426                 * Possible to get link events when doing back-to-back
2427                 * enable/disables.
2428                 */
2429                break;
2430
2431        case BFA_FCPORT_SM_HWFAIL:
2432                bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2433                bfa_reqq_wcancel(&fcport->reqq_wait);
2434                break;
2435
2436        case BFA_FCPORT_SM_FAA_MISCONFIG:
2437                bfa_fcport_reset_linkinfo(fcport);
2438                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2439                bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig);
2440                break;
2441
2442        default:
2443                bfa_sm_fault(fcport->bfa, event);
2444        }
2445}
2446
2447static void
2448bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s *fcport,
2449                                 enum bfa_fcport_sm_event event)
2450{
2451        bfa_trc(fcport->bfa, event);
2452
2453        switch (event) {
2454        case BFA_FCPORT_SM_QRESUME:
2455                bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2456                bfa_fcport_send_disable(fcport);
2457                if (bfa_fcport_send_enable(fcport))
2458                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2459                else
2460                        bfa_sm_set_state(fcport,
2461                                         bfa_fcport_sm_enabling_qwait);
2462                break;
2463
2464        case BFA_FCPORT_SM_STOP:
2465                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2466                bfa_reqq_wcancel(&fcport->reqq_wait);
2467                break;
2468
2469        case BFA_FCPORT_SM_ENABLE:
2470                break;
2471
2472        case BFA_FCPORT_SM_DISABLE:
2473                bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
2474                break;
2475
2476        case BFA_FCPORT_SM_LINKUP:
2477        case BFA_FCPORT_SM_LINKDOWN:
2478                /*
2479                 * Possible to get link events when doing back-to-back
2480                 * enable/disables.
2481                 */
2482                break;
2483
2484        case BFA_FCPORT_SM_HWFAIL:
2485                bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2486                bfa_reqq_wcancel(&fcport->reqq_wait);
2487                break;
2488
2489        default:
2490                bfa_sm_fault(fcport->bfa, event);
2491        }
2492}
2493
2494static void
2495bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
2496                                                enum bfa_fcport_sm_event event)
2497{
2498        char pwwn_buf[BFA_STRING_32];
2499        struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2500        bfa_trc(fcport->bfa, event);
2501
2502        switch (event) {
2503        case BFA_FCPORT_SM_FWRSP:
2504                bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2505                break;
2506
2507        case BFA_FCPORT_SM_DISABLE:
2508                /*
2509                 * Already being disabled.
2510                 */
2511                break;
2512
2513        case BFA_FCPORT_SM_ENABLE:
2514                if (bfa_fcport_send_enable(fcport))
2515                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2516                else
2517                        bfa_sm_set_state(fcport,
2518                                         bfa_fcport_sm_enabling_qwait);
2519
2520                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2521                                BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
2522                wwn2str(pwwn_buf, fcport->pwwn);
2523                BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2524                        "Base port enabled: WWN = %s\n", pwwn_buf);
2525                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE);
2526                break;
2527
2528        case BFA_FCPORT_SM_STOP:
2529                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2530                break;
2531
2532        case BFA_FCPORT_SM_LINKUP:
2533        case BFA_FCPORT_SM_LINKDOWN:
2534                /*
2535                 * Possible to get link events when doing back-to-back
2536                 * enable/disables.
2537                 */
2538                break;
2539
2540        case BFA_FCPORT_SM_HWFAIL:
2541                bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2542                break;
2543
2544        default:
2545                bfa_sm_fault(fcport->bfa, event);
2546        }
2547}
2548
2549static void
2550bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
2551                                                enum bfa_fcport_sm_event event)
2552{
2553        char pwwn_buf[BFA_STRING_32];
2554        struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2555        bfa_trc(fcport->bfa, event);
2556
2557        switch (event) {
2558        case BFA_FCPORT_SM_START:
2559                /*
2560                 * Ignore start event for a port that is disabled.
2561                 */
2562                break;
2563
2564        case BFA_FCPORT_SM_STOP:
2565                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2566                break;
2567
2568        case BFA_FCPORT_SM_ENABLE:
2569                if (bfa_fcport_send_enable(fcport))
2570                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2571                else
2572                        bfa_sm_set_state(fcport,
2573                                         bfa_fcport_sm_enabling_qwait);
2574
2575                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2576                                BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
2577                wwn2str(pwwn_buf, fcport->pwwn);
2578                BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2579                        "Base port enabled: WWN = %s\n", pwwn_buf);
2580                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE);
2581                break;
2582
2583        case BFA_FCPORT_SM_DISABLE:
2584                /*
2585                 * Already disabled.
2586                 */
2587                break;
2588
2589        case BFA_FCPORT_SM_HWFAIL:
2590                bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2591                break;
2592
2593        case BFA_FCPORT_SM_DPORTENABLE:
2594                bfa_sm_set_state(fcport, bfa_fcport_sm_dport);
2595                break;
2596
2597        case BFA_FCPORT_SM_DDPORTENABLE:
2598                bfa_sm_set_state(fcport, bfa_fcport_sm_ddport);
2599                break;
2600
2601        default:
2602                bfa_sm_fault(fcport->bfa, event);
2603        }
2604}
2605
2606static void
2607bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
2608                         enum bfa_fcport_sm_event event)
2609{
2610        bfa_trc(fcport->bfa, event);
2611
2612        switch (event) {
2613        case BFA_FCPORT_SM_START:
2614                if (bfa_fcport_send_enable(fcport))
2615                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2616                else
2617                        bfa_sm_set_state(fcport,
2618                                         bfa_fcport_sm_enabling_qwait);
2619                break;
2620
2621        default:
2622                /*
2623                 * Ignore all other events.
2624                 */
2625                ;
2626        }
2627}
2628
2629/*
2630 * Port is enabled. IOC is down/failed.
2631 */
2632static void
2633bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
2634                         enum bfa_fcport_sm_event event)
2635{
2636        bfa_trc(fcport->bfa, event);
2637
2638        switch (event) {
2639        case BFA_FCPORT_SM_START:
2640                if (bfa_fcport_send_enable(fcport))
2641                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2642                else
2643                        bfa_sm_set_state(fcport,
2644                                         bfa_fcport_sm_enabling_qwait);
2645                break;
2646
2647        default:
2648                /*
2649                 * Ignore all events.
2650                 */
2651                ;
2652        }
2653}
2654
2655/*
2656 * Port is disabled. IOC is down/failed.
2657 */
2658static void
2659bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
2660                         enum bfa_fcport_sm_event event)
2661{
2662        bfa_trc(fcport->bfa, event);
2663
2664        switch (event) {
2665        case BFA_FCPORT_SM_START:
2666                bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2667                break;
2668
2669        case BFA_FCPORT_SM_ENABLE:
2670                bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2671                break;
2672
2673        default:
2674                /*
2675                 * Ignore all events.
2676                 */
2677                ;
2678        }
2679}
2680
2681static void
2682bfa_fcport_sm_dport(struct bfa_fcport_s *fcport, enum bfa_fcport_sm_event event)
2683{
2684        bfa_trc(fcport->bfa, event);
2685
2686        switch (event) {
2687        case BFA_FCPORT_SM_DPORTENABLE:
2688        case BFA_FCPORT_SM_DISABLE:
2689        case BFA_FCPORT_SM_ENABLE:
2690        case BFA_FCPORT_SM_START:
2691                /*
2692                 * Ignore event for a port that is dport
2693                 */
2694                break;
2695
2696        case BFA_FCPORT_SM_STOP:
2697                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2698                break;
2699
2700        case BFA_FCPORT_SM_HWFAIL:
2701                bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2702                break;
2703
2704        case BFA_FCPORT_SM_DPORTDISABLE:
2705                bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2706                break;
2707
2708        default:
2709                bfa_sm_fault(fcport->bfa, event);
2710        }
2711}
2712
2713static void
2714bfa_fcport_sm_ddport(struct bfa_fcport_s *fcport,
2715                        enum bfa_fcport_sm_event event)
2716{
2717        bfa_trc(fcport->bfa, event);
2718
2719        switch (event) {
2720        case BFA_FCPORT_SM_DISABLE:
2721        case BFA_FCPORT_SM_DDPORTDISABLE:
2722                bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2723                break;
2724
2725        case BFA_FCPORT_SM_DPORTENABLE:
2726        case BFA_FCPORT_SM_DPORTDISABLE:
2727        case BFA_FCPORT_SM_ENABLE:
2728        case BFA_FCPORT_SM_START:
2729                /**
2730                 * Ignore event for a port that is ddport
2731                 */
2732                break;
2733
2734        case BFA_FCPORT_SM_STOP:
2735                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2736                break;
2737
2738        case BFA_FCPORT_SM_HWFAIL:
2739                bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2740                break;
2741
2742        default:
2743                bfa_sm_fault(fcport->bfa, event);
2744        }
2745}
2746
2747static void
2748bfa_fcport_sm_faa_misconfig(struct bfa_fcport_s *fcport,
2749                            enum bfa_fcport_sm_event event)
2750{
2751        bfa_trc(fcport->bfa, event);
2752
2753        switch (event) {
2754        case BFA_FCPORT_SM_DPORTENABLE:
2755        case BFA_FCPORT_SM_ENABLE:
2756        case BFA_FCPORT_SM_START:
2757                /*
2758                 * Ignore event for a port as there is FAA misconfig
2759                 */
2760                break;
2761
2762        case BFA_FCPORT_SM_DISABLE:
2763                if (bfa_fcport_send_disable(fcport))
2764                        bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2765                else
2766                        bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
2767
2768                bfa_fcport_reset_linkinfo(fcport);
2769                bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2770                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2771                             BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2772                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
2773                break;
2774
2775        case BFA_FCPORT_SM_STOP:
2776                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2777                break;
2778
2779        case BFA_FCPORT_SM_HWFAIL:
2780                bfa_fcport_reset_linkinfo(fcport);
2781                bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2782                bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2783                break;
2784
2785        default:
2786                bfa_sm_fault(fcport->bfa, event);
2787        }
2788}
2789
2790/*
2791 * Link state is down
2792 */
2793static void
2794bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
2795                enum bfa_fcport_ln_sm_event event)
2796{
2797        bfa_trc(ln->fcport->bfa, event);
2798
2799        switch (event) {
2800        case BFA_FCPORT_LN_SM_LINKUP:
2801                bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
2802                bfa_fcport_queue_cb(ln, BFA_PORT_LINKUP);
2803                break;
2804
2805        default:
2806                bfa_sm_fault(ln->fcport->bfa, event);
2807        }
2808}
2809
2810/*
2811 * Link state is waiting for down notification
2812 */
2813static void
2814bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
2815                enum bfa_fcport_ln_sm_event event)
2816{
2817        bfa_trc(ln->fcport->bfa, event);
2818
2819        switch (event) {
2820        case BFA_FCPORT_LN_SM_LINKUP:
2821                bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
2822                break;
2823
2824        case BFA_FCPORT_LN_SM_NOTIFICATION:
2825                bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
2826                break;
2827
2828        default:
2829                bfa_sm_fault(ln->fcport->bfa, event);
2830        }
2831}
2832
2833/*
2834 * Link state is waiting for down notification and there is a pending up
2835 */
2836static void
2837bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
2838                enum bfa_fcport_ln_sm_event event)
2839{
2840        bfa_trc(ln->fcport->bfa, event);
2841
2842        switch (event) {
2843        case BFA_FCPORT_LN_SM_LINKDOWN:
2844                bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2845                break;
2846
2847        case BFA_FCPORT_LN_SM_NOTIFICATION:
2848                bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
2849                bfa_fcport_queue_cb(ln, BFA_PORT_LINKUP);
2850                break;
2851
2852        default:
2853                bfa_sm_fault(ln->fcport->bfa, event);
2854        }
2855}
2856
2857/*
2858 * Link state is up
2859 */
2860static void
2861bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
2862                enum bfa_fcport_ln_sm_event event)
2863{
2864        bfa_trc(ln->fcport->bfa, event);
2865
2866        switch (event) {
2867        case BFA_FCPORT_LN_SM_LINKDOWN:
2868                bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2869                bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2870                break;
2871
2872        default:
2873                bfa_sm_fault(ln->fcport->bfa, event);
2874        }
2875}
2876
2877/*
2878 * Link state is waiting for up notification
2879 */
2880static void
2881bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
2882                enum bfa_fcport_ln_sm_event event)
2883{
2884        bfa_trc(ln->fcport->bfa, event);
2885
2886        switch (event) {
2887        case BFA_FCPORT_LN_SM_LINKDOWN:
2888                bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
2889                break;
2890
2891        case BFA_FCPORT_LN_SM_NOTIFICATION:
2892                bfa_sm_set_state(ln, bfa_fcport_ln_sm_up);
2893                break;
2894
2895        default:
2896                bfa_sm_fault(ln->fcport->bfa, event);
2897        }
2898}
2899
2900/*
2901 * Link state is waiting for up notification and there is a pending down
2902 */
2903static void
2904bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
2905                enum bfa_fcport_ln_sm_event event)
2906{
2907        bfa_trc(ln->fcport->bfa, event);
2908
2909        switch (event) {
2910        case BFA_FCPORT_LN_SM_LINKUP:
2911                bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_up_nf);
2912                break;
2913
2914        case BFA_FCPORT_LN_SM_NOTIFICATION:
2915                bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2916                bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2917                break;
2918
2919        default:
2920                bfa_sm_fault(ln->fcport->bfa, event);
2921        }
2922}
2923
2924/*
2925 * Link state is waiting for up notification and there are pending down and up
2926 */
2927static void
2928bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
2929                        enum bfa_fcport_ln_sm_event event)
2930{
2931        bfa_trc(ln->fcport->bfa, event);
2932
2933        switch (event) {
2934        case BFA_FCPORT_LN_SM_LINKDOWN:
2935                bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
2936                break;
2937
2938        case BFA_FCPORT_LN_SM_NOTIFICATION:
2939                bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
2940                bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2941                break;
2942
2943        default:
2944                bfa_sm_fault(ln->fcport->bfa, event);
2945        }
2946}
2947
2948static void
2949__bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete)
2950{
2951        struct bfa_fcport_ln_s *ln = cbarg;
2952
2953        if (complete)
2954                ln->fcport->event_cbfn(ln->fcport->event_cbarg, ln->ln_event);
2955        else
2956                bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
2957}
2958
2959/*
2960 * Send SCN notification to upper layers.
2961 * trunk - false if caller is fcport to ignore fcport event in trunked mode
2962 */
2963static void
2964bfa_fcport_scn(struct bfa_fcport_s *fcport, enum bfa_port_linkstate event,
2965        bfa_boolean_t trunk)
2966{
2967        if (fcport->cfg.trunked && !trunk)
2968                return;
2969
2970        switch (event) {
2971        case BFA_PORT_LINKUP:
2972                bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKUP);
2973                break;
2974        case BFA_PORT_LINKDOWN:
2975                bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKDOWN);
2976                break;
2977        default:
2978                WARN_ON(1);
2979        }
2980}
2981
2982static void
2983bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln, enum bfa_port_linkstate event)
2984{
2985        struct bfa_fcport_s *fcport = ln->fcport;
2986
2987        if (fcport->bfa->fcs) {
2988                fcport->event_cbfn(fcport->event_cbarg, event);
2989                bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
2990        } else {
2991                ln->ln_event = event;
2992                bfa_cb_queue(fcport->bfa, &ln->ln_qe,
2993                        __bfa_cb_fcport_event, ln);
2994        }
2995}
2996
2997#define FCPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_fcport_stats_u), \
2998                                                        BFA_CACHELINE_SZ))
2999
3000void
3001bfa_fcport_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
3002                   struct bfa_s *bfa)
3003{
3004        struct bfa_mem_dma_s *fcport_dma = BFA_MEM_FCPORT_DMA(bfa);
3005
3006        bfa_mem_dma_setup(minfo, fcport_dma, FCPORT_STATS_DMA_SZ);
3007}
3008
3009static void
3010bfa_fcport_qresume(void *cbarg)
3011{
3012        struct bfa_fcport_s *fcport = cbarg;
3013
3014        bfa_sm_send_event(fcport, BFA_FCPORT_SM_QRESUME);
3015}
3016
3017static void
3018bfa_fcport_mem_claim(struct bfa_fcport_s *fcport)
3019{
3020        struct bfa_mem_dma_s *fcport_dma = &fcport->fcport_dma;
3021
3022        fcport->stats_kva = bfa_mem_dma_virt(fcport_dma);
3023        fcport->stats_pa  = bfa_mem_dma_phys(fcport_dma);
3024        fcport->stats = (union bfa_fcport_stats_u *)
3025                                bfa_mem_dma_virt(fcport_dma);
3026}
3027
3028/*
3029 * Memory initialization.
3030 */
3031void
3032bfa_fcport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
3033                struct bfa_pcidev_s *pcidev)
3034{
3035        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3036        struct bfa_port_cfg_s *port_cfg = &fcport->cfg;
3037        struct bfa_fcport_ln_s *ln = &fcport->ln;
3038
3039        fcport->bfa = bfa;
3040        ln->fcport = fcport;
3041
3042        bfa_fcport_mem_claim(fcport);
3043
3044        bfa_sm_set_state(fcport, bfa_fcport_sm_uninit);
3045        bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
3046
3047        /*
3048         * initialize time stamp for stats reset
3049         */
3050        fcport->stats_reset_time = ktime_get_seconds();
3051        fcport->stats_dma_ready = BFA_FALSE;
3052
3053        /*
3054         * initialize and set default configuration
3055         */
3056        port_cfg->topology = BFA_PORT_TOPOLOGY_P2P;
3057        port_cfg->speed = BFA_PORT_SPEED_AUTO;
3058        port_cfg->trunked = BFA_FALSE;
3059        port_cfg->maxfrsize = 0;
3060
3061        port_cfg->trl_def_speed = BFA_PORT_SPEED_1GBPS;
3062        port_cfg->qos_bw.high = BFA_QOS_BW_HIGH;
3063        port_cfg->qos_bw.med = BFA_QOS_BW_MED;
3064        port_cfg->qos_bw.low = BFA_QOS_BW_LOW;
3065
3066        fcport->fec_state = BFA_FEC_OFFLINE;
3067
3068        INIT_LIST_HEAD(&fcport->stats_pending_q);
3069        INIT_LIST_HEAD(&fcport->statsclr_pending_q);
3070
3071        bfa_reqq_winit(&fcport->reqq_wait, bfa_fcport_qresume, fcport);
3072}
3073
3074void
3075bfa_fcport_start(struct bfa_s *bfa)
3076{
3077        bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_START);
3078}
3079
3080/*
3081 * Called when IOC failure is detected.
3082 */
3083void
3084bfa_fcport_iocdisable(struct bfa_s *bfa)
3085{
3086        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3087
3088        bfa_sm_send_event(fcport, BFA_FCPORT_SM_HWFAIL);
3089        bfa_trunk_iocdisable(bfa);
3090}
3091
3092/*
3093 * Update loop info in fcport for SCN online
3094 */
3095static void
3096bfa_fcport_update_loop_info(struct bfa_fcport_s *fcport,
3097                        struct bfa_fcport_loop_info_s *loop_info)
3098{
3099        fcport->myalpa = loop_info->myalpa;
3100        fcport->alpabm_valid =
3101                        loop_info->alpabm_val;
3102        memcpy(fcport->alpabm.alpa_bm,
3103                        loop_info->alpabm.alpa_bm,
3104                        sizeof(struct fc_alpabm_s));
3105}
3106
3107static void
3108bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport)
3109{
3110        struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
3111        struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
3112
3113        fcport->speed = pevent->link_state.speed;
3114        fcport->topology = pevent->link_state.topology;
3115
3116        if (fcport->topology == BFA_PORT_TOPOLOGY_LOOP) {
3117                bfa_fcport_update_loop_info(fcport,
3118                                &pevent->link_state.attr.loop_info);
3119                return;
3120        }
3121
3122        /* QoS Details */
3123        fcport->qos_attr = pevent->link_state.qos_attr;
3124        fcport->qos_vc_attr = pevent->link_state.attr.vc_fcf.qos_vc_attr;
3125
3126        if (fcport->cfg.bb_cr_enabled)
3127                fcport->bbcr_attr = pevent->link_state.attr.bbcr_attr;
3128
3129        fcport->fec_state = pevent->link_state.fec_state;
3130
3131        /*
3132         * update trunk state if applicable
3133         */
3134        if (!fcport->cfg.trunked)
3135                trunk->attr.state = BFA_TRUNK_DISABLED;
3136
3137        /* update FCoE specific */
3138        fcport->fcoe_vlan =
3139                be16_to_cpu(pevent->link_state.attr.vc_fcf.fcf.vlan);
3140
3141        bfa_trc(fcport->bfa, fcport->speed);
3142        bfa_trc(fcport->bfa, fcport->topology);
3143}
3144
3145static void
3146bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport)
3147{
3148        fcport->speed = BFA_PORT_SPEED_UNKNOWN;
3149        fcport->topology = BFA_PORT_TOPOLOGY_NONE;
3150        fcport->fec_state = BFA_FEC_OFFLINE;
3151}
3152
3153/*
3154 * Send port enable message to firmware.
3155 */
3156static bfa_boolean_t
3157bfa_fcport_send_enable(struct bfa_fcport_s *fcport)
3158{
3159        struct bfi_fcport_enable_req_s *m;
3160
3161        /*
3162         * Increment message tag before queue check, so that responses to old
3163         * requests are discarded.
3164         */
3165        fcport->msgtag++;
3166
3167        /*
3168         * check for room in queue to send request now
3169         */
3170        m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3171        if (!m) {
3172                bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3173                                                        &fcport->reqq_wait);
3174                return BFA_FALSE;
3175        }
3176
3177        bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_ENABLE_REQ,
3178                        bfa_fn_lpu(fcport->bfa));
3179        m->nwwn = fcport->nwwn;
3180        m->pwwn = fcport->pwwn;
3181        m->port_cfg = fcport->cfg;
3182        m->msgtag = fcport->msgtag;
3183        m->port_cfg.maxfrsize = cpu_to_be16(fcport->cfg.maxfrsize);
3184         m->use_flash_cfg = fcport->use_flash_cfg;
3185        bfa_dma_be_addr_set(m->stats_dma_addr, fcport->stats_pa);
3186        bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_lo);
3187        bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_hi);
3188
3189        /*
3190         * queue I/O message to firmware
3191         */
3192        bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, m->mh);
3193        return BFA_TRUE;
3194}
3195
3196/*
3197 * Send port disable message to firmware.
3198 */
3199static  bfa_boolean_t
3200bfa_fcport_send_disable(struct bfa_fcport_s *fcport)
3201{
3202        struct bfi_fcport_req_s *m;
3203
3204        /*
3205         * Increment message tag before queue check, so that responses to old
3206         * requests are discarded.
3207         */
3208        fcport->msgtag++;
3209
3210        /*
3211         * check for room in queue to send request now
3212         */
3213        m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3214        if (!m) {
3215                bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3216                                                        &fcport->reqq_wait);
3217                return BFA_FALSE;
3218        }
3219
3220        bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_DISABLE_REQ,
3221                        bfa_fn_lpu(fcport->bfa));
3222        m->msgtag = fcport->msgtag;
3223
3224        /*
3225         * queue I/O message to firmware
3226         */
3227        bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, m->mh);
3228
3229        return BFA_TRUE;
3230}
3231
3232static void
3233bfa_fcport_set_wwns(struct bfa_fcport_s *fcport)
3234{
3235        fcport->pwwn = fcport->bfa->ioc.attr->pwwn;
3236        fcport->nwwn = fcport->bfa->ioc.attr->nwwn;
3237
3238        bfa_trc(fcport->bfa, fcport->pwwn);
3239        bfa_trc(fcport->bfa, fcport->nwwn);
3240}
3241
3242static void
3243bfa_fcport_qos_stats_swap(struct bfa_qos_stats_s *d,
3244        struct bfa_qos_stats_s *s)
3245{
3246        u32     *dip = (u32 *) d;
3247        __be32  *sip = (__be32 *) s;
3248        int             i;
3249
3250        /* Now swap the 32 bit fields */
3251        for (i = 0; i < (sizeof(struct bfa_qos_stats_s)/sizeof(u32)); ++i)
3252                dip[i] = be32_to_cpu(sip[i]);
3253}
3254
3255static void
3256bfa_fcport_fcoe_stats_swap(struct bfa_fcoe_stats_s *d,
3257        struct bfa_fcoe_stats_s *s)
3258{
3259        u32     *dip = (u32 *) d;
3260        __be32  *sip = (__be32 *) s;
3261        int             i;
3262
3263        for (i = 0; i < ((sizeof(struct bfa_fcoe_stats_s))/sizeof(u32));
3264             i = i + 2) {
3265#ifdef __BIG_ENDIAN
3266                dip[i] = be32_to_cpu(sip[i]);
3267                dip[i + 1] = be32_to_cpu(sip[i + 1]);
3268#else
3269                dip[i] = be32_to_cpu(sip[i + 1]);
3270                dip[i + 1] = be32_to_cpu(sip[i]);
3271#endif
3272        }
3273}
3274
3275static void
3276__bfa_cb_fcport_stats_get(void *cbarg, bfa_boolean_t complete)
3277{
3278        struct bfa_fcport_s *fcport = (struct bfa_fcport_s *)cbarg;
3279        struct bfa_cb_pending_q_s *cb;
3280        struct list_head *qe, *qen;
3281        union bfa_fcport_stats_u *ret;
3282
3283        if (complete) {
3284                time64_t time = ktime_get_seconds();
3285
3286                list_for_each_safe(qe, qen, &fcport->stats_pending_q) {
3287                        bfa_q_deq(&fcport->stats_pending_q, &qe);
3288                        cb = (struct bfa_cb_pending_q_s *)qe;
3289                        if (fcport->stats_status == BFA_STATUS_OK) {
3290                                ret = (union bfa_fcport_stats_u *)cb->data;
3291                                /* Swap FC QoS or FCoE stats */
3292                                if (bfa_ioc_get_fcmode(&fcport->bfa->ioc))
3293                                        bfa_fcport_qos_stats_swap(&ret->fcqos,
3294                                                        &fcport->stats->fcqos);
3295                                else {
3296                                        bfa_fcport_fcoe_stats_swap(&ret->fcoe,
3297                                                        &fcport->stats->fcoe);
3298                                        ret->fcoe.secs_reset =
3299                                                time - fcport->stats_reset_time;
3300                                }
3301                        }
3302                        bfa_cb_queue_status(fcport->bfa, &cb->hcb_qe,
3303                                        fcport->stats_status);
3304                }
3305                fcport->stats_status = BFA_STATUS_OK;
3306        } else {
3307                INIT_LIST_HEAD(&fcport->stats_pending_q);
3308                fcport->stats_status = BFA_STATUS_OK;
3309        }
3310}
3311
3312static void
3313bfa_fcport_stats_get_timeout(void *cbarg)
3314{
3315        struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3316
3317        bfa_trc(fcport->bfa, fcport->stats_qfull);
3318
3319        if (fcport->stats_qfull) {
3320                bfa_reqq_wcancel(&fcport->stats_reqq_wait);
3321                fcport->stats_qfull = BFA_FALSE;
3322        }
3323
3324        fcport->stats_status = BFA_STATUS_ETIMER;
3325        __bfa_cb_fcport_stats_get(fcport, BFA_TRUE);
3326}
3327
3328static void
3329bfa_fcport_send_stats_get(void *cbarg)
3330{
3331        struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3332        struct bfi_fcport_req_s *msg;
3333
3334        msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3335
3336        if (!msg) {
3337                fcport->stats_qfull = BFA_TRUE;
3338                bfa_reqq_winit(&fcport->stats_reqq_wait,
3339                                bfa_fcport_send_stats_get, fcport);
3340                bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3341                                &fcport->stats_reqq_wait);
3342                return;
3343        }
3344        fcport->stats_qfull = BFA_FALSE;
3345
3346        memset(msg, 0, sizeof(struct bfi_fcport_req_s));
3347        bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_GET_REQ,
3348                        bfa_fn_lpu(fcport->bfa));
3349        bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, msg->mh);
3350}
3351
3352static void
3353__bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete)
3354{
3355        struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3356        struct bfa_cb_pending_q_s *cb;
3357        struct list_head *qe, *qen;
3358
3359        if (complete) {
3360                /*
3361                 * re-initialize time stamp for stats reset
3362                 */
3363                fcport->stats_reset_time = ktime_get_seconds();
3364                list_for_each_safe(qe, qen, &fcport->statsclr_pending_q) {
3365                        bfa_q_deq(&fcport->statsclr_pending_q, &qe);
3366                        cb = (struct bfa_cb_pending_q_s *)qe;
3367                        bfa_cb_queue_status(fcport->bfa, &cb->hcb_qe,
3368                                                fcport->stats_status);
3369                }
3370                fcport->stats_status = BFA_STATUS_OK;
3371        } else {
3372                INIT_LIST_HEAD(&fcport->statsclr_pending_q);
3373                fcport->stats_status = BFA_STATUS_OK;
3374        }
3375}
3376
3377static void
3378bfa_fcport_stats_clr_timeout(void *cbarg)
3379{
3380        struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3381
3382        bfa_trc(fcport->bfa, fcport->stats_qfull);
3383
3384        if (fcport->stats_qfull) {
3385                bfa_reqq_wcancel(&fcport->stats_reqq_wait);
3386                fcport->stats_qfull = BFA_FALSE;
3387        }
3388
3389        fcport->stats_status = BFA_STATUS_ETIMER;
3390        __bfa_cb_fcport_stats_clr(fcport, BFA_TRUE);
3391}
3392
3393static void
3394bfa_fcport_send_stats_clear(void *cbarg)
3395{
3396        struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3397        struct bfi_fcport_req_s *msg;
3398
3399        msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3400
3401        if (!msg) {
3402                fcport->stats_qfull = BFA_TRUE;
3403                bfa_reqq_winit(&fcport->stats_reqq_wait,
3404                                bfa_fcport_send_stats_clear, fcport);
3405                bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3406                                                &fcport->stats_reqq_wait);
3407                return;
3408        }
3409        fcport->stats_qfull = BFA_FALSE;
3410
3411        memset(msg, 0, sizeof(struct bfi_fcport_req_s));
3412        bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_CLEAR_REQ,
3413                        bfa_fn_lpu(fcport->bfa));
3414        bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, msg->mh);
3415}
3416
3417/*
3418 * Handle trunk SCN event from firmware.
3419 */
3420static void
3421bfa_trunk_scn(struct bfa_fcport_s *fcport, struct bfi_fcport_trunk_scn_s *scn)
3422{
3423        struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
3424        struct bfi_fcport_trunk_link_s *tlink;
3425        struct bfa_trunk_link_attr_s *lattr;
3426        enum bfa_trunk_state state_prev;
3427        int i;
3428        int link_bm = 0;
3429
3430        bfa_trc(fcport->bfa, fcport->cfg.trunked);
3431        WARN_ON(scn->trunk_state != BFA_TRUNK_ONLINE &&
3432                   scn->trunk_state != BFA_TRUNK_OFFLINE);
3433
3434        bfa_trc(fcport->bfa, trunk->attr.state);
3435        bfa_trc(fcport->bfa, scn->trunk_state);
3436        bfa_trc(fcport->bfa, scn->trunk_speed);
3437
3438        /*
3439         * Save off new state for trunk attribute query
3440         */
3441        state_prev = trunk->attr.state;
3442        if (fcport->cfg.trunked && (trunk->attr.state != BFA_TRUNK_DISABLED))
3443                trunk->attr.state = scn->trunk_state;
3444        trunk->attr.speed = scn->trunk_speed;
3445        for (i = 0; i < BFA_TRUNK_MAX_PORTS; i++) {
3446                lattr = &trunk->attr.link_attr[i];
3447                tlink = &scn->tlink[i];
3448
3449                lattr->link_state = tlink->state;
3450                lattr->trunk_wwn  = tlink->trunk_wwn;
3451                lattr->fctl       = tlink->fctl;
3452                lattr->speed      = tlink->speed;
3453                lattr->deskew     = be32_to_cpu(tlink->deskew);
3454
3455                if (tlink->state == BFA_TRUNK_LINK_STATE_UP) {
3456                        fcport->speed    = tlink->speed;
3457                        fcport->topology = BFA_PORT_TOPOLOGY_P2P;
3458                        link_bm |= 1 << i;
3459                }
3460
3461                bfa_trc(fcport->bfa, lattr->link_state);
3462                bfa_trc(fcport->bfa, lattr->trunk_wwn);
3463                bfa_trc(fcport->bfa, lattr->fctl);
3464                bfa_trc(fcport->bfa, lattr->speed);
3465                bfa_trc(fcport->bfa, lattr->deskew);
3466        }
3467
3468        switch (link_bm) {
3469        case 3:
3470                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3471                        BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,1)");
3472                break;
3473        case 2:
3474                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3475                        BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(-,1)");
3476                break;
3477        case 1:
3478                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3479                        BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,-)");
3480                break;
3481        default:
3482                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3483                        BFA_PL_EID_TRUNK_SCN, 0, "Trunk down");
3484        }
3485
3486        /*
3487         * Notify upper layers if trunk state changed.
3488         */
3489        if ((state_prev != trunk->attr.state) ||
3490                (scn->trunk_state == BFA_TRUNK_OFFLINE)) {
3491                bfa_fcport_scn(fcport, (scn->trunk_state == BFA_TRUNK_ONLINE) ?
3492                        BFA_PORT_LINKUP : BFA_PORT_LINKDOWN, BFA_TRUE);
3493        }
3494}
3495
3496static void
3497bfa_trunk_iocdisable(struct bfa_s *bfa)
3498{
3499        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3500        int i = 0;
3501
3502        /*
3503         * In trunked mode, notify upper layers that link is down
3504         */
3505        if (fcport->cfg.trunked) {
3506                if (fcport->trunk.attr.state == BFA_TRUNK_ONLINE)
3507                        bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_TRUE);
3508
3509                fcport->trunk.attr.state = BFA_TRUNK_OFFLINE;
3510                fcport->trunk.attr.speed = BFA_PORT_SPEED_UNKNOWN;
3511                for (i = 0; i < BFA_TRUNK_MAX_PORTS; i++) {
3512                        fcport->trunk.attr.link_attr[i].trunk_wwn = 0;
3513                        fcport->trunk.attr.link_attr[i].fctl =
3514                                                BFA_TRUNK_LINK_FCTL_NORMAL;
3515                        fcport->trunk.attr.link_attr[i].link_state =
3516                                                BFA_TRUNK_LINK_STATE_DN_LINKDN;
3517                        fcport->trunk.attr.link_attr[i].speed =
3518                                                BFA_PORT_SPEED_UNKNOWN;
3519                        fcport->trunk.attr.link_attr[i].deskew = 0;
3520                }
3521        }
3522}
3523
3524/*
3525 * Called to initialize port attributes
3526 */
3527void
3528bfa_fcport_init(struct bfa_s *bfa)
3529{
3530        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3531
3532        /*
3533         * Initialize port attributes from IOC hardware data.
3534         */
3535        bfa_fcport_set_wwns(fcport);
3536        if (fcport->cfg.maxfrsize == 0)
3537                fcport->cfg.maxfrsize = bfa_ioc_maxfrsize(&bfa->ioc);
3538        fcport->cfg.rx_bbcredit = bfa_ioc_rx_bbcredit(&bfa->ioc);
3539        fcport->speed_sup = bfa_ioc_speed_sup(&bfa->ioc);
3540
3541        if (bfa_fcport_is_pbcdisabled(bfa))
3542                bfa->modules.port.pbc_disabled = BFA_TRUE;
3543
3544        WARN_ON(!fcport->cfg.maxfrsize);
3545        WARN_ON(!fcport->cfg.rx_bbcredit);
3546        WARN_ON(!fcport->speed_sup);
3547}
3548
3549/*
3550 * Firmware message handler.
3551 */
3552void
3553bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
3554{
3555        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3556        union bfi_fcport_i2h_msg_u i2hmsg;
3557
3558        i2hmsg.msg = msg;
3559        fcport->event_arg.i2hmsg = i2hmsg;
3560
3561        bfa_trc(bfa, msg->mhdr.msg_id);
3562        bfa_trc(bfa, bfa_sm_to_state(hal_port_sm_table, fcport->sm));
3563
3564        switch (msg->mhdr.msg_id) {
3565        case BFI_FCPORT_I2H_ENABLE_RSP:
3566                if (fcport->msgtag == i2hmsg.penable_rsp->msgtag) {
3567
3568                        fcport->stats_dma_ready = BFA_TRUE;
3569                        if (fcport->use_flash_cfg) {
3570                                fcport->cfg = i2hmsg.penable_rsp->port_cfg;
3571                                fcport->cfg.maxfrsize =
3572                                        cpu_to_be16(fcport->cfg.maxfrsize);
3573                                fcport->cfg.path_tov =
3574                                        cpu_to_be16(fcport->cfg.path_tov);
3575                                fcport->cfg.q_depth =
3576                                        cpu_to_be16(fcport->cfg.q_depth);
3577
3578                                if (fcport->cfg.trunked)
3579                                        fcport->trunk.attr.state =
3580                                                BFA_TRUNK_OFFLINE;
3581                                else
3582                                        fcport->trunk.attr.state =
3583                                                BFA_TRUNK_DISABLED;
3584                                fcport->qos_attr.qos_bw =
3585                                        i2hmsg.penable_rsp->port_cfg.qos_bw;
3586                                fcport->use_flash_cfg = BFA_FALSE;
3587                        }
3588
3589                        if (fcport->cfg.qos_enabled)
3590                                fcport->qos_attr.state = BFA_QOS_OFFLINE;
3591                        else
3592                                fcport->qos_attr.state = BFA_QOS_DISABLED;
3593
3594                        fcport->qos_attr.qos_bw_op =
3595                                        i2hmsg.penable_rsp->port_cfg.qos_bw;
3596
3597                        if (fcport->cfg.bb_cr_enabled)
3598                                fcport->bbcr_attr.state = BFA_BBCR_OFFLINE;
3599                        else
3600                                fcport->bbcr_attr.state = BFA_BBCR_DISABLED;
3601
3602                        bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
3603                }
3604                break;
3605
3606        case BFI_FCPORT_I2H_DISABLE_RSP:
3607                if (fcport->msgtag == i2hmsg.penable_rsp->msgtag)
3608                        bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
3609                break;
3610
3611        case BFI_FCPORT_I2H_EVENT:
3612                if (fcport->cfg.bb_cr_enabled)
3613                        fcport->bbcr_attr.state = BFA_BBCR_OFFLINE;
3614                else
3615                        fcport->bbcr_attr.state = BFA_BBCR_DISABLED;
3616
3617                if (i2hmsg.event->link_state.linkstate == BFA_PORT_LINKUP)
3618                        bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKUP);
3619                else {
3620                        if (i2hmsg.event->link_state.linkstate_rsn ==
3621                            BFA_PORT_LINKSTATE_RSN_FAA_MISCONFIG)
3622                                bfa_sm_send_event(fcport,
3623                                                  BFA_FCPORT_SM_FAA_MISCONFIG);
3624                        else
3625                                bfa_sm_send_event(fcport,
3626                                                  BFA_FCPORT_SM_LINKDOWN);
3627                }
3628                fcport->qos_attr.qos_bw_op =
3629                                i2hmsg.event->link_state.qos_attr.qos_bw_op;
3630                break;
3631
3632        case BFI_FCPORT_I2H_TRUNK_SCN:
3633                bfa_trunk_scn(fcport, i2hmsg.trunk_scn);
3634                break;
3635
3636        case BFI_FCPORT_I2H_STATS_GET_RSP:
3637                /*
3638                 * check for timer pop before processing the rsp
3639                 */
3640                if (list_empty(&fcport->stats_pending_q) ||
3641                    (fcport->stats_status == BFA_STATUS_ETIMER))
3642                        break;
3643
3644                bfa_timer_stop(&fcport->timer);
3645                fcport->stats_status = i2hmsg.pstatsget_rsp->status;
3646                __bfa_cb_fcport_stats_get(fcport, BFA_TRUE);
3647                break;
3648
3649        case BFI_FCPORT_I2H_STATS_CLEAR_RSP:
3650                /*
3651                 * check for timer pop before processing the rsp
3652                 */
3653                if (list_empty(&fcport->statsclr_pending_q) ||
3654                    (fcport->stats_status == BFA_STATUS_ETIMER))
3655                        break;
3656
3657                bfa_timer_stop(&fcport->timer);
3658                fcport->stats_status = BFA_STATUS_OK;
3659                __bfa_cb_fcport_stats_clr(fcport, BFA_TRUE);
3660                break;
3661
3662        case BFI_FCPORT_I2H_ENABLE_AEN:
3663                bfa_sm_send_event(fcport, BFA_FCPORT_SM_ENABLE);
3664                break;
3665
3666        case BFI_FCPORT_I2H_DISABLE_AEN:
3667                bfa_sm_send_event(fcport, BFA_FCPORT_SM_DISABLE);
3668                break;
3669
3670        default:
3671                WARN_ON(1);
3672        break;
3673        }
3674}
3675
3676/*
3677 * Registered callback for port events.
3678 */
3679void
3680bfa_fcport_event_register(struct bfa_s *bfa,
3681                                void (*cbfn) (void *cbarg,
3682                                enum bfa_port_linkstate event),
3683                                void *cbarg)
3684{
3685        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3686
3687        fcport->event_cbfn = cbfn;
3688        fcport->event_cbarg = cbarg;
3689}
3690
3691bfa_status_t
3692bfa_fcport_enable(struct bfa_s *bfa)
3693{
3694        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3695
3696        if (bfa_fcport_is_pbcdisabled(bfa))
3697                return BFA_STATUS_PBC;
3698
3699        if (bfa_ioc_is_disabled(&bfa->ioc))
3700                return BFA_STATUS_IOC_DISABLED;
3701
3702        if (fcport->diag_busy)
3703                return BFA_STATUS_DIAG_BUSY;
3704
3705        bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_ENABLE);
3706        return BFA_STATUS_OK;
3707}
3708
3709bfa_status_t
3710bfa_fcport_disable(struct bfa_s *bfa)
3711{
3712        if (bfa_fcport_is_pbcdisabled(bfa))
3713                return BFA_STATUS_PBC;
3714
3715        if (bfa_ioc_is_disabled(&bfa->ioc))
3716                return BFA_STATUS_IOC_DISABLED;
3717
3718        bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DISABLE);
3719        return BFA_STATUS_OK;
3720}
3721
3722/* If PBC is disabled on port, return error */
3723bfa_status_t
3724bfa_fcport_is_pbcdisabled(struct bfa_s *bfa)
3725{
3726        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3727        struct bfa_iocfc_s *iocfc = &bfa->iocfc;
3728        struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp;
3729
3730        if (cfgrsp->pbc_cfg.port_enabled == BFI_PBC_PORT_DISABLED) {
3731                bfa_trc(bfa, fcport->pwwn);
3732                return BFA_STATUS_PBC;
3733        }
3734        return BFA_STATUS_OK;
3735}
3736
3737/*
3738 * Configure port speed.
3739 */
3740bfa_status_t
3741bfa_fcport_cfg_speed(struct bfa_s *bfa, enum bfa_port_speed speed)
3742{
3743        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3744
3745        bfa_trc(bfa, speed);
3746
3747        if (fcport->cfg.trunked == BFA_TRUE)
3748                return BFA_STATUS_TRUNK_ENABLED;
3749        if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
3750                        (speed == BFA_PORT_SPEED_16GBPS))
3751                return BFA_STATUS_UNSUPP_SPEED;
3752        if ((speed != BFA_PORT_SPEED_AUTO) && (speed > fcport->speed_sup)) {
3753                bfa_trc(bfa, fcport->speed_sup);
3754                return BFA_STATUS_UNSUPP_SPEED;
3755        }
3756
3757        /* Port speed entered needs to be checked */
3758        if (bfa_ioc_get_type(&fcport->bfa->ioc) == BFA_IOC_TYPE_FC) {
3759                /* For CT2, 1G is not supported */
3760                if ((speed == BFA_PORT_SPEED_1GBPS) &&
3761                    (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id)))
3762                        return BFA_STATUS_UNSUPP_SPEED;
3763
3764                /* Already checked for Auto Speed and Max Speed supp */
3765                if (!(speed == BFA_PORT_SPEED_1GBPS ||
3766                      speed == BFA_PORT_SPEED_2GBPS ||
3767                      speed == BFA_PORT_SPEED_4GBPS ||
3768                      speed == BFA_PORT_SPEED_8GBPS ||
3769                      speed == BFA_PORT_SPEED_16GBPS ||
3770                      speed == BFA_PORT_SPEED_AUTO))
3771                        return BFA_STATUS_UNSUPP_SPEED;
3772        } else {
3773                if (speed != BFA_PORT_SPEED_10GBPS)
3774                        return BFA_STATUS_UNSUPP_SPEED;
3775        }
3776
3777        fcport->cfg.speed = speed;
3778
3779        return BFA_STATUS_OK;
3780}
3781
3782/*
3783 * Get current speed.
3784 */
3785enum bfa_port_speed
3786bfa_fcport_get_speed(struct bfa_s *bfa)
3787{
3788        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3789
3790        return fcport->speed;
3791}
3792
3793/*
3794 * Configure port topology.
3795 */
3796bfa_status_t
3797bfa_fcport_cfg_topology(struct bfa_s *bfa, enum bfa_port_topology topology)
3798{
3799        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3800
3801        bfa_trc(bfa, topology);
3802        bfa_trc(bfa, fcport->cfg.topology);
3803
3804        switch (topology) {
3805        case BFA_PORT_TOPOLOGY_P2P:
3806                break;
3807
3808        case BFA_PORT_TOPOLOGY_LOOP:
3809                if ((bfa_fcport_is_qos_enabled(bfa) != BFA_FALSE) ||
3810                        (fcport->qos_attr.state != BFA_QOS_DISABLED))
3811                        return BFA_STATUS_ERROR_QOS_ENABLED;
3812                if (fcport->cfg.ratelimit != BFA_FALSE)
3813                        return BFA_STATUS_ERROR_TRL_ENABLED;
3814                if ((bfa_fcport_is_trunk_enabled(bfa) != BFA_FALSE) ||
3815                        (fcport->trunk.attr.state != BFA_TRUNK_DISABLED))
3816                        return BFA_STATUS_ERROR_TRUNK_ENABLED;
3817                if ((bfa_fcport_get_speed(bfa) == BFA_PORT_SPEED_16GBPS) ||
3818                        (fcport->cfg.speed == BFA_PORT_SPEED_16GBPS))
3819                        return BFA_STATUS_UNSUPP_SPEED;
3820                if (bfa_mfg_is_mezz(bfa->ioc.attr->card_type))
3821                        return BFA_STATUS_LOOP_UNSUPP_MEZZ;
3822                if (bfa_fcport_is_dport(bfa) != BFA_FALSE)
3823                        return BFA_STATUS_DPORT_ERR;
3824                if (bfa_fcport_is_ddport(bfa) != BFA_FALSE)
3825                        return BFA_STATUS_DPORT_ERR;
3826                break;
3827
3828        case BFA_PORT_TOPOLOGY_AUTO:
3829                break;
3830
3831        default:
3832                return BFA_STATUS_EINVAL;
3833        }
3834
3835        fcport->cfg.topology = topology;
3836        return BFA_STATUS_OK;
3837}
3838
3839/*
3840 * Get current topology.
3841 */
3842enum bfa_port_topology
3843bfa_fcport_get_topology(struct bfa_s *bfa)
3844{
3845        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3846
3847        return fcport->topology;
3848}
3849
3850/**
3851 * Get config topology.
3852 */
3853enum bfa_port_topology
3854bfa_fcport_get_cfg_topology(struct bfa_s *bfa)
3855{
3856        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3857
3858        return fcport->cfg.topology;
3859}
3860
3861bfa_status_t
3862bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa)
3863{
3864        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3865
3866        bfa_trc(bfa, alpa);
3867        bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
3868        bfa_trc(bfa, fcport->cfg.hardalpa);
3869
3870        fcport->cfg.cfg_hardalpa = BFA_TRUE;
3871        fcport->cfg.hardalpa = alpa;
3872
3873        return BFA_STATUS_OK;
3874}
3875
3876bfa_status_t
3877bfa_fcport_clr_hardalpa(struct bfa_s *bfa)
3878{
3879        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3880
3881        bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
3882        bfa_trc(bfa, fcport->cfg.hardalpa);
3883
3884        fcport->cfg.cfg_hardalpa = BFA_FALSE;
3885        return BFA_STATUS_OK;
3886}
3887
3888bfa_boolean_t
3889bfa_fcport_get_hardalpa(struct bfa_s *bfa, u8 *alpa)
3890{
3891        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3892
3893        *alpa = fcport->cfg.hardalpa;
3894        return fcport->cfg.cfg_hardalpa;
3895}
3896
3897u8
3898bfa_fcport_get_myalpa(struct bfa_s *bfa)
3899{
3900        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3901
3902        return fcport->myalpa;
3903}
3904
3905bfa_status_t
3906bfa_fcport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxfrsize)
3907{
3908        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3909
3910        bfa_trc(bfa, maxfrsize);
3911        bfa_trc(bfa, fcport->cfg.maxfrsize);
3912
3913        /* with in range */
3914        if ((maxfrsize > FC_MAX_PDUSZ) || (maxfrsize < FC_MIN_PDUSZ))
3915                return BFA_STATUS_INVLD_DFSZ;
3916
3917        /* power of 2, if not the max frame size of 2112 */
3918        if ((maxfrsize != FC_MAX_PDUSZ) && (maxfrsize & (maxfrsize - 1)))
3919                return BFA_STATUS_INVLD_DFSZ;
3920
3921        fcport->cfg.maxfrsize = maxfrsize;
3922        return BFA_STATUS_OK;
3923}
3924
3925u16
3926bfa_fcport_get_maxfrsize(struct bfa_s *bfa)
3927{
3928        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3929
3930        return fcport->cfg.maxfrsize;
3931}
3932
3933u8
3934bfa_fcport_get_rx_bbcredit(struct bfa_s *bfa)
3935{
3936        if (bfa_fcport_get_topology(bfa) != BFA_PORT_TOPOLOGY_LOOP)
3937                return (BFA_FCPORT_MOD(bfa))->cfg.rx_bbcredit;
3938
3939        else
3940                return 0;
3941}
3942
3943void
3944bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit)
3945{
3946        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3947
3948        fcport->cfg.tx_bbcredit = (u8)tx_bbcredit;
3949}
3950
3951/*
3952 * Get port attributes.
3953 */
3954
3955wwn_t
3956bfa_fcport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node)
3957{
3958        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3959        if (node)
3960                return fcport->nwwn;
3961        else
3962                return fcport->pwwn;
3963}
3964
3965void
3966bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_port_attr_s *attr)
3967{
3968        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3969
3970        memset(attr, 0, sizeof(struct bfa_port_attr_s));
3971
3972        attr->nwwn = fcport->nwwn;
3973        attr->pwwn = fcport->pwwn;
3974
3975        attr->factorypwwn =  bfa->ioc.attr->mfg_pwwn;
3976        attr->factorynwwn =  bfa->ioc.attr->mfg_nwwn;
3977
3978        memcpy(&attr->pport_cfg, &fcport->cfg,
3979                sizeof(struct bfa_port_cfg_s));
3980        /* speed attributes */
3981        attr->pport_cfg.speed = fcport->cfg.speed;
3982        attr->speed_supported = fcport->speed_sup;
3983        attr->speed = fcport->speed;
3984        attr->cos_supported = FC_CLASS_3;
3985
3986        /* topology attributes */
3987        attr->pport_cfg.topology = fcport->cfg.topology;
3988        attr->topology = fcport->topology;
3989        attr->pport_cfg.trunked = fcport->cfg.trunked;
3990
3991        /* beacon attributes */
3992        attr->beacon = fcport->beacon;
3993        attr->link_e2e_beacon = fcport->link_e2e_beacon;
3994
3995        attr->pport_cfg.path_tov  = bfa_fcpim_path_tov_get(bfa);
3996        attr->pport_cfg.q_depth  = bfa_fcpim_qdepth_get(bfa);
3997        attr->port_state = bfa_sm_to_state(hal_port_sm_table, fcport->sm);
3998
3999        attr->fec_state = fcport->fec_state;
4000
4001        /* PBC Disabled State */
4002        if (bfa_fcport_is_pbcdisabled(bfa))
4003                attr->port_state = BFA_PORT_ST_PREBOOT_DISABLED;
4004        else {
4005                if (bfa_ioc_is_disabled(&fcport->bfa->ioc))
4006                        attr->port_state = BFA_PORT_ST_IOCDIS;
4007                else if (bfa_ioc_fw_mismatch(&fcport->bfa->ioc))
4008                        attr->port_state = BFA_PORT_ST_FWMISMATCH;
4009        }
4010
4011        /* FCoE vlan */
4012        attr->fcoe_vlan = fcport->fcoe_vlan;
4013}
4014
4015#define BFA_FCPORT_STATS_TOV    1000
4016
4017/*
4018 * Fetch port statistics (FCQoS or FCoE).
4019 */
4020bfa_status_t
4021bfa_fcport_get_stats(struct bfa_s *bfa, struct bfa_cb_pending_q_s *cb)
4022{
4023        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4024
4025        if (!bfa_iocfc_is_operational(bfa) ||
4026            !fcport->stats_dma_ready)
4027                return BFA_STATUS_IOC_NON_OP;
4028
4029        if (!list_empty(&fcport->statsclr_pending_q))
4030                return BFA_STATUS_DEVBUSY;
4031
4032        if (list_empty(&fcport->stats_pending_q)) {
4033                list_add_tail(&cb->hcb_qe.qe, &fcport->stats_pending_q);
4034                bfa_fcport_send_stats_get(fcport);
4035                bfa_timer_start(bfa, &fcport->timer,
4036                                bfa_fcport_stats_get_timeout,
4037                                fcport, BFA_FCPORT_STATS_TOV);
4038        } else
4039                list_add_tail(&cb->hcb_qe.qe, &fcport->stats_pending_q);
4040
4041        return BFA_STATUS_OK;
4042}
4043
4044/*
4045 * Reset port statistics (FCQoS or FCoE).
4046 */
4047bfa_status_t
4048bfa_fcport_clear_stats(struct bfa_s *bfa, struct bfa_cb_pending_q_s *cb)
4049{
4050        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4051
4052        if (!bfa_iocfc_is_operational(bfa) ||
4053            !fcport->stats_dma_ready)
4054                return BFA_STATUS_IOC_NON_OP;
4055
4056        if (!list_empty(&fcport->stats_pending_q))
4057                return BFA_STATUS_DEVBUSY;
4058
4059        if (list_empty(&fcport->statsclr_pending_q)) {
4060                list_add_tail(&cb->hcb_qe.qe, &fcport->statsclr_pending_q);
4061                bfa_fcport_send_stats_clear(fcport);
4062                bfa_timer_start(bfa, &fcport->timer,
4063                                bfa_fcport_stats_clr_timeout,
4064                                fcport, BFA_FCPORT_STATS_TOV);
4065        } else
4066                list_add_tail(&cb->hcb_qe.qe, &fcport->statsclr_pending_q);
4067
4068        return BFA_STATUS_OK;
4069}
4070
4071/*
4072 * Fetch port attributes.
4073 */
4074bfa_boolean_t
4075bfa_fcport_is_disabled(struct bfa_s *bfa)
4076{
4077        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4078
4079        return bfa_sm_to_state(hal_port_sm_table, fcport->sm) ==
4080                BFA_PORT_ST_DISABLED;
4081
4082}
4083
4084bfa_boolean_t
4085bfa_fcport_is_dport(struct bfa_s *bfa)
4086{
4087        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4088
4089        return (bfa_sm_to_state(hal_port_sm_table, fcport->sm) ==
4090                BFA_PORT_ST_DPORT);
4091}
4092
4093bfa_boolean_t
4094bfa_fcport_is_ddport(struct bfa_s *bfa)
4095{
4096        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4097
4098        return (bfa_sm_to_state(hal_port_sm_table, fcport->sm) ==
4099                BFA_PORT_ST_DDPORT);
4100}
4101
4102bfa_status_t
4103bfa_fcport_set_qos_bw(struct bfa_s *bfa, struct bfa_qos_bw_s *qos_bw)
4104{
4105        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4106        enum bfa_ioc_type_e ioc_type = bfa_get_type(bfa);
4107
4108        bfa_trc(bfa, ioc_type);
4109
4110        if ((qos_bw->high == 0) || (qos_bw->med == 0) || (qos_bw->low == 0))
4111                return BFA_STATUS_QOS_BW_INVALID;
4112
4113        if ((qos_bw->high + qos_bw->med + qos_bw->low) != 100)
4114                return BFA_STATUS_QOS_BW_INVALID;
4115
4116        if ((qos_bw->med > qos_bw->high) || (qos_bw->low > qos_bw->med) ||
4117            (qos_bw->low > qos_bw->high))
4118                return BFA_STATUS_QOS_BW_INVALID;
4119
4120        if ((ioc_type == BFA_IOC_TYPE_FC) &&
4121            (fcport->cfg.topology != BFA_PORT_TOPOLOGY_LOOP))
4122                fcport->cfg.qos_bw = *qos_bw;
4123
4124        return BFA_STATUS_OK;
4125}
4126
4127bfa_boolean_t
4128bfa_fcport_is_ratelim(struct bfa_s *bfa)
4129{
4130        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4131
4132        return fcport->cfg.ratelimit ? BFA_TRUE : BFA_FALSE;
4133
4134}
4135
4136/*
4137 *      Enable/Disable FAA feature in port config
4138 */
4139void
4140bfa_fcport_cfg_faa(struct bfa_s *bfa, u8 state)
4141{
4142        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4143
4144        bfa_trc(bfa, state);
4145        fcport->cfg.faa_state = state;
4146}
4147
4148/*
4149 * Get default minimum ratelim speed
4150 */
4151enum bfa_port_speed
4152bfa_fcport_get_ratelim_speed(struct bfa_s *bfa)
4153{
4154        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4155
4156        bfa_trc(bfa, fcport->cfg.trl_def_speed);
4157        return fcport->cfg.trl_def_speed;
4158
4159}
4160
4161void
4162bfa_fcport_beacon(void *dev, bfa_boolean_t beacon,
4163                  bfa_boolean_t link_e2e_beacon)
4164{
4165        struct bfa_s *bfa = dev;
4166        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4167
4168        bfa_trc(bfa, beacon);
4169        bfa_trc(bfa, link_e2e_beacon);
4170        bfa_trc(bfa, fcport->beacon);
4171        bfa_trc(bfa, fcport->link_e2e_beacon);
4172
4173        fcport->beacon = beacon;
4174        fcport->link_e2e_beacon = link_e2e_beacon;
4175}
4176
4177bfa_boolean_t
4178bfa_fcport_is_linkup(struct bfa_s *bfa)
4179{
4180        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4181
4182        return  (!fcport->cfg.trunked &&
4183                 bfa_sm_cmp_state(fcport, bfa_fcport_sm_linkup)) ||
4184                (fcport->cfg.trunked &&
4185                 fcport->trunk.attr.state == BFA_TRUNK_ONLINE);
4186}
4187
4188bfa_boolean_t
4189bfa_fcport_is_qos_enabled(struct bfa_s *bfa)
4190{
4191        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4192
4193        return fcport->cfg.qos_enabled;
4194}
4195
4196bfa_boolean_t
4197bfa_fcport_is_trunk_enabled(struct bfa_s *bfa)
4198{
4199        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4200
4201        return fcport->cfg.trunked;
4202}
4203
4204bfa_status_t
4205bfa_fcport_cfg_bbcr(struct bfa_s *bfa, bfa_boolean_t on_off, u8 bb_scn)
4206{
4207        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4208
4209        bfa_trc(bfa, on_off);
4210
4211        if (bfa_ioc_get_type(&fcport->bfa->ioc) != BFA_IOC_TYPE_FC)
4212                return BFA_STATUS_BBCR_FC_ONLY;
4213
4214        if (bfa_mfg_is_mezz(bfa->ioc.attr->card_type) &&
4215                (bfa->ioc.attr->card_type != BFA_MFG_TYPE_CHINOOK))
4216                return BFA_STATUS_CMD_NOTSUPP_MEZZ;
4217
4218        if (on_off) {
4219                if (fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP)
4220                        return BFA_STATUS_TOPOLOGY_LOOP;
4221
4222                if (fcport->cfg.qos_enabled)
4223                        return BFA_STATUS_ERROR_QOS_ENABLED;
4224
4225                if (fcport->cfg.trunked)
4226                        return BFA_STATUS_TRUNK_ENABLED;
4227
4228                if ((fcport->cfg.speed != BFA_PORT_SPEED_AUTO) &&
4229                        (fcport->cfg.speed < bfa_ioc_speed_sup(&bfa->ioc)))
4230                        return BFA_STATUS_ERR_BBCR_SPEED_UNSUPPORT;
4231
4232                if (bfa_ioc_speed_sup(&bfa->ioc) < BFA_PORT_SPEED_8GBPS)
4233                        return BFA_STATUS_FEATURE_NOT_SUPPORTED;
4234
4235                if (fcport->cfg.bb_cr_enabled) {
4236                        if (bb_scn != fcport->cfg.bb_scn)
4237                                return BFA_STATUS_BBCR_CFG_NO_CHANGE;
4238                        else
4239                                return BFA_STATUS_NO_CHANGE;
4240                }
4241
4242                if ((bb_scn == 0) || (bb_scn > BFA_BB_SCN_MAX))
4243                        bb_scn = BFA_BB_SCN_DEF;
4244
4245                fcport->cfg.bb_cr_enabled = on_off;
4246                fcport->cfg.bb_scn = bb_scn;
4247        } else {
4248                if (!fcport->cfg.bb_cr_enabled)
4249                        return BFA_STATUS_NO_CHANGE;
4250
4251                fcport->cfg.bb_cr_enabled = on_off;
4252                fcport->cfg.bb_scn = 0;
4253        }
4254
4255        return BFA_STATUS_OK;
4256}
4257
4258bfa_status_t
4259bfa_fcport_get_bbcr_attr(struct bfa_s *bfa,
4260                struct bfa_bbcr_attr_s *bbcr_attr)
4261{
4262        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4263
4264        if (bfa_ioc_get_type(&fcport->bfa->ioc) != BFA_IOC_TYPE_FC)
4265                return BFA_STATUS_BBCR_FC_ONLY;
4266
4267        if (fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP)
4268                return BFA_STATUS_TOPOLOGY_LOOP;
4269
4270        *bbcr_attr = fcport->bbcr_attr;
4271
4272        return BFA_STATUS_OK;
4273}
4274
4275void
4276bfa_fcport_dportenable(struct bfa_s *bfa)
4277{
4278        /*
4279         * Assume caller check for port is in disable state
4280         */
4281        bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DPORTENABLE);
4282        bfa_port_set_dportenabled(&bfa->modules.port, BFA_TRUE);
4283}
4284
4285void
4286bfa_fcport_dportdisable(struct bfa_s *bfa)
4287{
4288        /*
4289         * Assume caller check for port is in disable state
4290         */
4291        bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DPORTDISABLE);
4292        bfa_port_set_dportenabled(&bfa->modules.port, BFA_FALSE);
4293}
4294
4295void
4296bfa_fcport_ddportenable(struct bfa_s *bfa)
4297{
4298        /*
4299         * Assume caller check for port is in disable state
4300         */
4301        bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DDPORTENABLE);
4302}
4303
4304void
4305bfa_fcport_ddportdisable(struct bfa_s *bfa)
4306{
4307        /*
4308         * Assume caller check for port is in disable state
4309         */
4310        bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DDPORTDISABLE);
4311}
4312
4313/*
4314 * Rport State machine functions
4315 */
4316/*
4317 * Beginning state, only online event expected.
4318 */
4319static void
4320bfa_rport_sm_uninit(struct bfa_rport_s *rp, enum bfa_rport_event event)
4321{
4322        bfa_trc(rp->bfa, rp->rport_tag);
4323        bfa_trc(rp->bfa, event);
4324
4325        switch (event) {
4326        case BFA_RPORT_SM_CREATE:
4327                bfa_stats(rp, sm_un_cr);
4328                bfa_sm_set_state(rp, bfa_rport_sm_created);
4329                break;
4330
4331        default:
4332                bfa_stats(rp, sm_un_unexp);
4333                bfa_sm_fault(rp->bfa, event);
4334        }
4335}
4336
4337static void
4338bfa_rport_sm_created(struct bfa_rport_s *rp, enum bfa_rport_event event)
4339{
4340        bfa_trc(rp->bfa, rp->rport_tag);
4341        bfa_trc(rp->bfa, event);
4342
4343        switch (event) {
4344        case BFA_RPORT_SM_ONLINE:
4345                bfa_stats(rp, sm_cr_on);
4346                if (bfa_rport_send_fwcreate(rp))
4347                        bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4348                else
4349                        bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4350                break;
4351
4352        case BFA_RPORT_SM_DELETE:
4353                bfa_stats(rp, sm_cr_del);
4354                bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4355                bfa_rport_free(rp);
4356                break;
4357
4358        case BFA_RPORT_SM_HWFAIL:
4359                bfa_stats(rp, sm_cr_hwf);
4360                bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4361                break;
4362
4363        default:
4364                bfa_stats(rp, sm_cr_unexp);
4365                bfa_sm_fault(rp->bfa, event);
4366        }
4367}
4368
4369/*
4370 * Waiting for rport create response from firmware.
4371 */
4372static void
4373bfa_rport_sm_fwcreate(struct bfa_rport_s *rp, enum bfa_rport_event event)
4374{
4375        bfa_trc(rp->bfa, rp->rport_tag);
4376        bfa_trc(rp->bfa, event);
4377
4378        switch (event) {
4379        case BFA_RPORT_SM_FWRSP:
4380                bfa_stats(rp, sm_fwc_rsp);
4381                bfa_sm_set_state(rp, bfa_rport_sm_online);
4382                bfa_rport_online_cb(rp);
4383                break;
4384
4385        case BFA_RPORT_SM_DELETE:
4386                bfa_stats(rp, sm_fwc_del);
4387                bfa_sm_set_state(rp, bfa_rport_sm_delete_pending);
4388                break;
4389
4390        case BFA_RPORT_SM_OFFLINE:
4391                bfa_stats(rp, sm_fwc_off);
4392                bfa_sm_set_state(rp, bfa_rport_sm_offline_pending);
4393                break;
4394
4395        case BFA_RPORT_SM_HWFAIL:
4396                bfa_stats(rp, sm_fwc_hwf);
4397                bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4398                break;
4399
4400        default:
4401                bfa_stats(rp, sm_fwc_unexp);
4402                bfa_sm_fault(rp->bfa, event);
4403        }
4404}
4405
4406/*
4407 * Request queue is full, awaiting queue resume to send create request.
4408 */
4409static void
4410bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4411{
4412        bfa_trc(rp->bfa, rp->rport_tag);
4413        bfa_trc(rp->bfa, event);
4414
4415        switch (event) {
4416        case BFA_RPORT_SM_QRESUME:
4417                bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4418                bfa_rport_send_fwcreate(rp);
4419                break;
4420
4421        case BFA_RPORT_SM_DELETE:
4422                bfa_stats(rp, sm_fwc_del);
4423                bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4424                bfa_reqq_wcancel(&rp->reqq_wait);
4425                bfa_rport_free(rp);
4426                break;
4427
4428        case BFA_RPORT_SM_OFFLINE:
4429                bfa_stats(rp, sm_fwc_off);
4430                bfa_sm_set_state(rp, bfa_rport_sm_offline);
4431                bfa_reqq_wcancel(&rp->reqq_wait);
4432                bfa_rport_offline_cb(rp);
4433                break;
4434
4435        case BFA_RPORT_SM_HWFAIL:
4436                bfa_stats(rp, sm_fwc_hwf);
4437                bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4438                bfa_reqq_wcancel(&rp->reqq_wait);
4439                break;
4440
4441        default:
4442                bfa_stats(rp, sm_fwc_unexp);
4443                bfa_sm_fault(rp->bfa, event);
4444        }
4445}
4446
4447/*
4448 * Online state - normal parking state.
4449 */
4450static void
4451bfa_rport_sm_online(struct bfa_rport_s *rp, enum bfa_rport_event event)
4452{
4453        struct bfi_rport_qos_scn_s *qos_scn;
4454
4455        bfa_trc(rp->bfa, rp->rport_tag);
4456        bfa_trc(rp->bfa, event);
4457
4458        switch (event) {
4459        case BFA_RPORT_SM_OFFLINE:
4460                bfa_stats(rp, sm_on_off);
4461                if (bfa_rport_send_fwdelete(rp))
4462                        bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4463                else
4464                        bfa_sm_set_state(rp, bfa_rport_sm_fwdelete_qfull);
4465                break;
4466
4467        case BFA_RPORT_SM_DELETE:
4468                bfa_stats(rp, sm_on_del);
4469                if (bfa_rport_send_fwdelete(rp))
4470                        bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4471                else
4472                        bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4473                break;
4474
4475        case BFA_RPORT_SM_HWFAIL:
4476                bfa_stats(rp, sm_on_hwf);
4477                bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4478                break;
4479
4480        case BFA_RPORT_SM_SET_SPEED:
4481                bfa_rport_send_fwspeed(rp);
4482                break;
4483
4484        case BFA_RPORT_SM_QOS_SCN:
4485                qos_scn = (struct bfi_rport_qos_scn_s *) rp->event_arg.fw_msg;
4486                rp->qos_attr = qos_scn->new_qos_attr;
4487                bfa_trc(rp->bfa, qos_scn->old_qos_attr.qos_flow_id);
4488                bfa_trc(rp->bfa, qos_scn->new_qos_attr.qos_flow_id);
4489                bfa_trc(rp->bfa, qos_scn->old_qos_attr.qos_priority);
4490                bfa_trc(rp->bfa, qos_scn->new_qos_attr.qos_priority);
4491
4492                qos_scn->old_qos_attr.qos_flow_id  =
4493                        be32_to_cpu(qos_scn->old_qos_attr.qos_flow_id);
4494                qos_scn->new_qos_attr.qos_flow_id  =
4495                        be32_to_cpu(qos_scn->new_qos_attr.qos_flow_id);
4496
4497                if (qos_scn->old_qos_attr.qos_flow_id !=
4498                        qos_scn->new_qos_attr.qos_flow_id)
4499                        bfa_cb_rport_qos_scn_flowid(rp->rport_drv,
4500                                                    qos_scn->old_qos_attr,
4501                                                    qos_scn->new_qos_attr);
4502                if (qos_scn->old_qos_attr.qos_priority !=
4503                        qos_scn->new_qos_attr.qos_priority)
4504                        bfa_cb_rport_qos_scn_prio(rp->rport_drv,
4505                                                  qos_scn->old_qos_attr,
4506                                                  qos_scn->new_qos_attr);
4507                break;
4508
4509        default:
4510                bfa_stats(rp, sm_on_unexp);
4511                bfa_sm_fault(rp->bfa, event);
4512        }
4513}
4514
4515/*
4516 * Firmware rport is being deleted - awaiting f/w response.
4517 */
4518static void
4519bfa_rport_sm_fwdelete(struct bfa_rport_s *rp, enum bfa_rport_event event)
4520{
4521        bfa_trc(rp->bfa, rp->rport_tag);
4522        bfa_trc(rp->bfa, event);
4523
4524        switch (event) {
4525        case BFA_RPORT_SM_FWRSP:
4526                bfa_stats(rp, sm_fwd_rsp);
4527                bfa_sm_set_state(rp, bfa_rport_sm_offline);
4528                bfa_rport_offline_cb(rp);
4529                break;
4530
4531        case BFA_RPORT_SM_DELETE:
4532                bfa_stats(rp, sm_fwd_del);
4533                bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4534                break;
4535
4536        case BFA_RPORT_SM_HWFAIL:
4537                bfa_stats(rp, sm_fwd_hwf);
4538                bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4539                bfa_rport_offline_cb(rp);
4540                break;
4541
4542        default:
4543                bfa_stats(rp, sm_fwd_unexp);
4544                bfa_sm_fault(rp->bfa, event);
4545        }
4546}
4547
4548static void
4549bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4550{
4551        bfa_trc(rp->bfa, rp->rport_tag);
4552        bfa_trc(rp->bfa, event);
4553
4554        switch (event) {
4555        case BFA_RPORT_SM_QRESUME:
4556                bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4557                bfa_rport_send_fwdelete(rp);
4558                break;
4559
4560        case BFA_RPORT_SM_DELETE:
4561                bfa_stats(rp, sm_fwd_del);
4562                bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4563                break;
4564
4565        case BFA_RPORT_SM_HWFAIL:
4566                bfa_stats(rp, sm_fwd_hwf);
4567                bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4568                bfa_reqq_wcancel(&rp->reqq_wait);
4569                bfa_rport_offline_cb(rp);
4570                break;
4571
4572        default:
4573                bfa_stats(rp, sm_fwd_unexp);
4574                bfa_sm_fault(rp->bfa, event);
4575        }
4576}
4577
4578/*
4579 * Offline state.
4580 */
4581static void
4582bfa_rport_sm_offline(struct bfa_rport_s *rp, enum bfa_rport_event event)
4583{
4584        bfa_trc(rp->bfa, rp->rport_tag);
4585        bfa_trc(rp->bfa, event);
4586
4587        switch (event) {
4588        case BFA_RPORT_SM_DELETE:
4589                bfa_stats(rp, sm_off_del);
4590                bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4591                bfa_rport_free(rp);
4592                break;
4593
4594        case BFA_RPORT_SM_ONLINE:
4595                bfa_stats(rp, sm_off_on);
4596                if (bfa_rport_send_fwcreate(rp))
4597                        bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4598                else
4599                        bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4600                break;
4601
4602        case BFA_RPORT_SM_HWFAIL:
4603                bfa_stats(rp, sm_off_hwf);
4604                bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4605                break;
4606
4607        case BFA_RPORT_SM_OFFLINE:
4608                bfa_rport_offline_cb(rp);
4609                break;
4610
4611        default:
4612                bfa_stats(rp, sm_off_unexp);
4613                bfa_sm_fault(rp->bfa, event);
4614        }
4615}
4616
4617/*
4618 * Rport is deleted, waiting for firmware response to delete.
4619 */
4620static void
4621bfa_rport_sm_deleting(struct bfa_rport_s *rp, enum bfa_rport_event event)
4622{
4623        bfa_trc(rp->bfa, rp->rport_tag);
4624        bfa_trc(rp->bfa, event);
4625
4626        switch (event) {
4627        case BFA_RPORT_SM_FWRSP:
4628                bfa_stats(rp, sm_del_fwrsp);
4629                bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4630                bfa_rport_free(rp);
4631                break;
4632
4633        case BFA_RPORT_SM_HWFAIL:
4634                bfa_stats(rp, sm_del_hwf);
4635                bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4636                bfa_rport_free(rp);
4637                break;
4638
4639        default:
4640                bfa_sm_fault(rp->bfa, event);
4641        }
4642}
4643
4644static void
4645bfa_rport_sm_deleting_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4646{
4647        bfa_trc(rp->bfa, rp->rport_tag);
4648        bfa_trc(rp->bfa, event);
4649
4650        switch (event) {
4651        case BFA_RPORT_SM_QRESUME:
4652                bfa_stats(rp, sm_del_fwrsp);
4653                bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4654                bfa_rport_send_fwdelete(rp);
4655                break;
4656
4657        case BFA_RPORT_SM_HWFAIL:
4658                bfa_stats(rp, sm_del_hwf);
4659                bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4660                bfa_reqq_wcancel(&rp->reqq_wait);
4661                bfa_rport_free(rp);
4662                break;
4663
4664        default:
4665                bfa_sm_fault(rp->bfa, event);
4666        }
4667}
4668
4669/*
4670 * Waiting for rport create response from firmware. A delete is pending.
4671 */
4672static void
4673bfa_rport_sm_delete_pending(struct bfa_rport_s *rp,
4674                                enum bfa_rport_event event)
4675{
4676        bfa_trc(rp->bfa, rp->rport_tag);
4677        bfa_trc(rp->bfa, event);
4678
4679        switch (event) {
4680        case BFA_RPORT_SM_FWRSP:
4681                bfa_stats(rp, sm_delp_fwrsp);
4682                if (bfa_rport_send_fwdelete(rp))
4683                        bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4684                else
4685                        bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4686                break;
4687
4688        case BFA_RPORT_SM_HWFAIL:
4689                bfa_stats(rp, sm_delp_hwf);
4690                bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4691                bfa_rport_free(rp);
4692                break;
4693
4694        default:
4695                bfa_stats(rp, sm_delp_unexp);
4696                bfa_sm_fault(rp->bfa, event);
4697        }
4698}
4699
4700/*
4701 * Waiting for rport create response from firmware. Rport offline is pending.
4702 */
4703static void
4704bfa_rport_sm_offline_pending(struct bfa_rport_s *rp,
4705                                 enum bfa_rport_event event)
4706{
4707        bfa_trc(rp->bfa, rp->rport_tag);
4708        bfa_trc(rp->bfa, event);
4709
4710        switch (event) {
4711        case BFA_RPORT_SM_FWRSP:
4712                bfa_stats(rp, sm_offp_fwrsp);
4713                if (bfa_rport_send_fwdelete(rp))
4714                        bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4715                else
4716                        bfa_sm_set_state(rp, bfa_rport_sm_fwdelete_qfull);
4717                break;
4718
4719        case BFA_RPORT_SM_DELETE:
4720                bfa_stats(rp, sm_offp_del);
4721                bfa_sm_set_state(rp, bfa_rport_sm_delete_pending);
4722                break;
4723
4724        case BFA_RPORT_SM_HWFAIL:
4725                bfa_stats(rp, sm_offp_hwf);
4726                bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4727                bfa_rport_offline_cb(rp);
4728                break;
4729
4730        default:
4731                bfa_stats(rp, sm_offp_unexp);
4732                bfa_sm_fault(rp->bfa, event);
4733        }
4734}
4735
4736/*
4737 * IOC h/w failed.
4738 */
4739static void
4740bfa_rport_sm_iocdisable(struct bfa_rport_s *rp, enum bfa_rport_event event)
4741{
4742        bfa_trc(rp->bfa, rp->rport_tag);
4743        bfa_trc(rp->bfa, event);
4744
4745        switch (event) {
4746        case BFA_RPORT_SM_OFFLINE:
4747                bfa_stats(rp, sm_iocd_off);
4748                bfa_rport_offline_cb(rp);
4749                break;
4750
4751        case BFA_RPORT_SM_DELETE:
4752                bfa_stats(rp, sm_iocd_del);
4753                bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4754                bfa_rport_free(rp);
4755                break;
4756
4757        case BFA_RPORT_SM_ONLINE:
4758                bfa_stats(rp, sm_iocd_on);
4759                if (bfa_rport_send_fwcreate(rp))
4760                        bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4761                else
4762                        bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4763                break;
4764
4765        case BFA_RPORT_SM_HWFAIL:
4766                break;
4767
4768        default:
4769                bfa_stats(rp, sm_iocd_unexp);
4770                bfa_sm_fault(rp->bfa, event);
4771        }
4772}
4773
4774
4775
4776/*
4777 *  bfa_rport_private BFA rport private functions
4778 */
4779
4780static void
4781__bfa_cb_rport_online(void *cbarg, bfa_boolean_t complete)
4782{
4783        struct bfa_rport_s *rp = cbarg;
4784
4785        if (complete)
4786                bfa_cb_rport_online(rp->rport_drv);
4787}
4788
4789static void
4790__bfa_cb_rport_offline(void *cbarg, bfa_boolean_t complete)
4791{
4792        struct bfa_rport_s *rp = cbarg;
4793
4794        if (complete)
4795                bfa_cb_rport_offline(rp->rport_drv);
4796}
4797
4798static void
4799bfa_rport_qresume(void *cbarg)
4800{
4801        struct bfa_rport_s      *rp = cbarg;
4802
4803        bfa_sm_send_event(rp, BFA_RPORT_SM_QRESUME);
4804}
4805
4806void
4807bfa_rport_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
4808                struct bfa_s *bfa)
4809{
4810        struct bfa_mem_kva_s *rport_kva = BFA_MEM_RPORT_KVA(bfa);
4811
4812        if (cfg->fwcfg.num_rports < BFA_RPORT_MIN)
4813                cfg->fwcfg.num_rports = BFA_RPORT_MIN;
4814
4815        /* kva memory */
4816        bfa_mem_kva_setup(minfo, rport_kva,
4817                cfg->fwcfg.num_rports * sizeof(struct bfa_rport_s));
4818}
4819
4820void
4821bfa_rport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4822                struct bfa_pcidev_s *pcidev)
4823{
4824        struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa);
4825        struct bfa_rport_s *rp;
4826        u16 i;
4827
4828        INIT_LIST_HEAD(&mod->rp_free_q);
4829        INIT_LIST_HEAD(&mod->rp_active_q);
4830        INIT_LIST_HEAD(&mod->rp_unused_q);
4831
4832        rp = (struct bfa_rport_s *) bfa_mem_kva_curp(mod);
4833        mod->rps_list = rp;
4834        mod->num_rports = cfg->fwcfg.num_rports;
4835
4836        WARN_ON(!mod->num_rports ||
4837                   (mod->num_rports & (mod->num_rports - 1)));
4838
4839        for (i = 0; i < mod->num_rports; i++, rp++) {
4840                memset(rp, 0, sizeof(struct bfa_rport_s));
4841                rp->bfa = bfa;
4842                rp->rport_tag = i;
4843                bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4844
4845                /*
4846                 *  - is unused
4847                 */
4848                if (i)
4849                        list_add_tail(&rp->qe, &mod->rp_free_q);
4850
4851                bfa_reqq_winit(&rp->reqq_wait, bfa_rport_qresume, rp);
4852        }
4853
4854        /*
4855         * consume memory
4856         */
4857        bfa_mem_kva_curp(mod) = (u8 *) rp;
4858}
4859
4860void
4861bfa_rport_iocdisable(struct bfa_s *bfa)
4862{
4863        struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa);
4864        struct bfa_rport_s *rport;
4865        struct list_head *qe, *qen;
4866
4867        /* Enqueue unused rport resources to free_q */
4868        list_splice_tail_init(&mod->rp_unused_q, &mod->rp_free_q);
4869
4870        list_for_each_safe(qe, qen, &mod->rp_active_q) {
4871                rport = (struct bfa_rport_s *) qe;
4872                bfa_sm_send_event(rport, BFA_RPORT_SM_HWFAIL);
4873        }
4874}
4875
4876static struct bfa_rport_s *
4877bfa_rport_alloc(struct bfa_rport_mod_s *mod)
4878{
4879        struct bfa_rport_s *rport;
4880
4881        bfa_q_deq(&mod->rp_free_q, &rport);
4882        if (rport)
4883                list_add_tail(&rport->qe, &mod->rp_active_q);
4884
4885        return rport;
4886}
4887
4888static void
4889bfa_rport_free(struct bfa_rport_s *rport)
4890{
4891        struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(rport->bfa);
4892
4893        WARN_ON(!bfa_q_is_on_q(&mod->rp_active_q, rport));
4894        list_del(&rport->qe);
4895        list_add_tail(&rport->qe, &mod->rp_free_q);
4896}
4897
4898static bfa_boolean_t
4899bfa_rport_send_fwcreate(struct bfa_rport_s *rp)
4900{
4901        struct bfi_rport_create_req_s *m;
4902
4903        /*
4904         * check for room in queue to send request now
4905         */
4906        m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4907        if (!m) {
4908                bfa_reqq_wait(rp->bfa, BFA_REQQ_RPORT, &rp->reqq_wait);
4909                return BFA_FALSE;
4910        }
4911
4912        bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_CREATE_REQ,
4913                        bfa_fn_lpu(rp->bfa));
4914        m->bfa_handle = rp->rport_tag;
4915        m->max_frmsz = cpu_to_be16(rp->rport_info.max_frmsz);
4916        m->pid = rp->rport_info.pid;
4917        m->lp_fwtag = bfa_lps_get_fwtag(rp->bfa, (u8)rp->rport_info.lp_tag);
4918        m->local_pid = rp->rport_info.local_pid;
4919        m->fc_class = rp->rport_info.fc_class;
4920        m->vf_en = rp->rport_info.vf_en;
4921        m->vf_id = rp->rport_info.vf_id;
4922        m->cisc = rp->rport_info.cisc;
4923
4924        /*
4925         * queue I/O message to firmware
4926         */
4927        bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT, m->mh);
4928        return BFA_TRUE;
4929}
4930
4931static bfa_boolean_t
4932bfa_rport_send_fwdelete(struct bfa_rport_s *rp)
4933{
4934        struct bfi_rport_delete_req_s *m;
4935
4936        /*
4937         * check for room in queue to send request now
4938         */
4939        m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4940        if (!m) {
4941                bfa_reqq_wait(rp->bfa, BFA_REQQ_RPORT, &rp->reqq_wait);
4942                return BFA_FALSE;
4943        }
4944
4945        bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_DELETE_REQ,
4946                        bfa_fn_lpu(rp->bfa));
4947        m->fw_handle = rp->fw_handle;
4948
4949        /*
4950         * queue I/O message to firmware
4951         */
4952        bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT, m->mh);
4953        return BFA_TRUE;
4954}
4955
4956static bfa_boolean_t
4957bfa_rport_send_fwspeed(struct bfa_rport_s *rp)
4958{
4959        struct bfa_rport_speed_req_s *m;
4960
4961        /*
4962         * check for room in queue to send request now
4963         */
4964        m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4965        if (!m) {
4966                bfa_trc(rp->bfa, rp->rport_info.speed);
4967                return BFA_FALSE;
4968        }
4969
4970        bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_SET_SPEED_REQ,
4971                        bfa_fn_lpu(rp->bfa));
4972        m->fw_handle = rp->fw_handle;
4973        m->speed = (u8)rp->rport_info.speed;
4974
4975        /*
4976         * queue I/O message to firmware
4977         */
4978        bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT, m->mh);
4979        return BFA_TRUE;
4980}
4981
4982
4983
4984/*
4985 *  bfa_rport_public
4986 */
4987
4988/*
4989 * Rport interrupt processing.
4990 */
4991void
4992bfa_rport_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
4993{
4994        union bfi_rport_i2h_msg_u msg;
4995        struct bfa_rport_s *rp;
4996
4997        bfa_trc(bfa, m->mhdr.msg_id);
4998
4999        msg.msg = m;
5000
5001        switch (m->mhdr.msg_id) {
5002        case BFI_RPORT_I2H_CREATE_RSP:
5003                rp = BFA_RPORT_FROM_TAG(bfa, msg.create_rsp->bfa_handle);
5004                rp->fw_handle = msg.create_rsp->fw_handle;
5005                rp->qos_attr = msg.create_rsp->qos_attr;
5006                bfa_rport_set_lunmask(bfa, rp);
5007                WARN_ON(msg.create_rsp->status != BFA_STATUS_OK);
5008                bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
5009                break;
5010
5011        case BFI_RPORT_I2H_DELETE_RSP:
5012                rp = BFA_RPORT_FROM_TAG(bfa, msg.delete_rsp->bfa_handle);
5013                WARN_ON(msg.delete_rsp->status != BFA_STATUS_OK);
5014                bfa_rport_unset_lunmask(bfa, rp);
5015                bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
5016                break;
5017
5018        case BFI_RPORT_I2H_QOS_SCN:
5019                rp = BFA_RPORT_FROM_TAG(bfa, msg.qos_scn_evt->bfa_handle);
5020                rp->event_arg.fw_msg = msg.qos_scn_evt;
5021                bfa_sm_send_event(rp, BFA_RPORT_SM_QOS_SCN);
5022                break;
5023
5024        case BFI_RPORT_I2H_LIP_SCN_ONLINE:
5025                bfa_fcport_update_loop_info(BFA_FCPORT_MOD(bfa),
5026                                &msg.lip_scn->loop_info);
5027                bfa_cb_rport_scn_online(bfa);
5028                break;
5029
5030        case BFI_RPORT_I2H_LIP_SCN_OFFLINE:
5031                bfa_cb_rport_scn_offline(bfa);
5032                break;
5033
5034        case BFI_RPORT_I2H_NO_DEV:
5035                rp = BFA_RPORT_FROM_TAG(bfa, msg.lip_scn->bfa_handle);
5036                bfa_cb_rport_scn_no_dev(rp->rport_drv);
5037                break;
5038
5039        default:
5040                bfa_trc(bfa, m->mhdr.msg_id);
5041                WARN_ON(1);
5042        }
5043}
5044
5045void
5046bfa_rport_res_recfg(struct bfa_s *bfa, u16 num_rport_fw)
5047{
5048        struct bfa_rport_mod_s  *mod = BFA_RPORT_MOD(bfa);
5049        struct list_head        *qe;
5050        int     i;
5051
5052        for (i = 0; i < (mod->num_rports - num_rport_fw); i++) {
5053                bfa_q_deq_tail(&mod->rp_free_q, &qe);
5054                list_add_tail(qe, &mod->rp_unused_q);
5055        }
5056}
5057
5058/*
5059 *  bfa_rport_api
5060 */
5061
5062struct bfa_rport_s *
5063bfa_rport_create(struct bfa_s *bfa, void *rport_drv)
5064{
5065        struct bfa_rport_s *rp;
5066
5067        rp = bfa_rport_alloc(BFA_RPORT_MOD(bfa));
5068
5069        if (rp == NULL)
5070                return NULL;
5071
5072        rp->bfa = bfa;
5073        rp->rport_drv = rport_drv;
5074        memset(&rp->stats, 0, sizeof(rp->stats));
5075
5076        WARN_ON(!bfa_sm_cmp_state(rp, bfa_rport_sm_uninit));
5077        bfa_sm_send_event(rp, BFA_RPORT_SM_CREATE);
5078
5079        return rp;
5080}
5081
5082void
5083bfa_rport_online(struct bfa_rport_s *rport, struct bfa_rport_info_s *rport_info)
5084{
5085        WARN_ON(rport_info->max_frmsz == 0);
5086
5087        /*
5088         * Some JBODs are seen to be not setting PDU size correctly in PLOGI
5089         * responses. Default to minimum size.
5090         */
5091        if (rport_info->max_frmsz == 0) {
5092                bfa_trc(rport->bfa, rport->rport_tag);
5093                rport_info->max_frmsz = FC_MIN_PDUSZ;
5094        }
5095
5096        rport->rport_info = *rport_info;
5097        bfa_sm_send_event(rport, BFA_RPORT_SM_ONLINE);
5098}
5099
5100void
5101bfa_rport_speed(struct bfa_rport_s *rport, enum bfa_port_speed speed)
5102{
5103        WARN_ON(speed == 0);
5104        WARN_ON(speed == BFA_PORT_SPEED_AUTO);
5105
5106        if (rport) {
5107                rport->rport_info.speed = speed;
5108                bfa_sm_send_event(rport, BFA_RPORT_SM_SET_SPEED);
5109        }
5110}
5111
5112/* Set Rport LUN Mask */
5113void
5114bfa_rport_set_lunmask(struct bfa_s *bfa, struct bfa_rport_s *rp)
5115{
5116        struct bfa_lps_mod_s    *lps_mod = BFA_LPS_MOD(bfa);
5117        wwn_t   lp_wwn, rp_wwn;
5118        u8 lp_tag = (u8)rp->rport_info.lp_tag;
5119
5120        rp_wwn = ((struct bfa_fcs_rport_s *)rp->rport_drv)->pwwn;
5121        lp_wwn = (BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag))->pwwn;
5122
5123        BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag)->lun_mask =
5124                                        rp->lun_mask = BFA_TRUE;
5125        bfa_fcpim_lunmask_rp_update(bfa, lp_wwn, rp_wwn, rp->rport_tag, lp_tag);
5126}
5127
5128/* Unset Rport LUN mask */
5129void
5130bfa_rport_unset_lunmask(struct bfa_s *bfa, struct bfa_rport_s *rp)
5131{
5132        struct bfa_lps_mod_s    *lps_mod = BFA_LPS_MOD(bfa);
5133        wwn_t   lp_wwn, rp_wwn;
5134
5135        rp_wwn = ((struct bfa_fcs_rport_s *)rp->rport_drv)->pwwn;
5136        lp_wwn = (BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag))->pwwn;
5137
5138        BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag)->lun_mask =
5139                                rp->lun_mask = BFA_FALSE;
5140        bfa_fcpim_lunmask_rp_update(bfa, lp_wwn, rp_wwn,
5141                        BFA_RPORT_TAG_INVALID, BFA_LP_TAG_INVALID);
5142}
5143
5144/*
5145 * SGPG related functions
5146 */
5147
5148/*
5149 * Compute and return memory needed by FCP(im) module.
5150 */
5151void
5152bfa_sgpg_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
5153                struct bfa_s *bfa)
5154{
5155        struct bfa_sgpg_mod_s *sgpg_mod = BFA_SGPG_MOD(bfa);
5156        struct bfa_mem_kva_s *sgpg_kva = BFA_MEM_SGPG_KVA(bfa);
5157        struct bfa_mem_dma_s *seg_ptr;
5158        u16     nsegs, idx, per_seg_sgpg, num_sgpg;
5159        u32     sgpg_sz = sizeof(struct bfi_sgpg_s);
5160
5161        if (cfg->drvcfg.num_sgpgs < BFA_SGPG_MIN)
5162                cfg->drvcfg.num_sgpgs = BFA_SGPG_MIN;
5163        else if (cfg->drvcfg.num_sgpgs > BFA_SGPG_MAX)
5164                cfg->drvcfg.num_sgpgs = BFA_SGPG_MAX;
5165
5166        num_sgpg = cfg->drvcfg.num_sgpgs;
5167
5168        nsegs = BFI_MEM_DMA_NSEGS(num_sgpg, sgpg_sz);
5169        per_seg_sgpg = BFI_MEM_NREQS_SEG(sgpg_sz);
5170
5171        bfa_mem_dma_seg_iter(sgpg_mod, seg_ptr, nsegs, idx) {
5172                if (num_sgpg >= per_seg_sgpg) {
5173                        num_sgpg -= per_seg_sgpg;
5174                        bfa_mem_dma_setup(minfo, seg_ptr,
5175                                        per_seg_sgpg * sgpg_sz);
5176                } else
5177                        bfa_mem_dma_setup(minfo, seg_ptr,
5178                                        num_sgpg * sgpg_sz);
5179        }
5180
5181        /* kva memory */
5182        bfa_mem_kva_setup(minfo, sgpg_kva,
5183                cfg->drvcfg.num_sgpgs * sizeof(struct bfa_sgpg_s));
5184}
5185
5186void
5187bfa_sgpg_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
5188                struct bfa_pcidev_s *pcidev)
5189{
5190        struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
5191        struct bfa_sgpg_s *hsgpg;
5192        struct bfi_sgpg_s *sgpg;
5193        u64 align_len;
5194        struct bfa_mem_dma_s *seg_ptr;
5195        u32     sgpg_sz = sizeof(struct bfi_sgpg_s);
5196        u16     i, idx, nsegs, per_seg_sgpg, num_sgpg;
5197
5198        union {
5199                u64 pa;
5200                union bfi_addr_u addr;
5201        } sgpg_pa, sgpg_pa_tmp;
5202
5203        INIT_LIST_HEAD(&mod->sgpg_q);
5204        INIT_LIST_HEAD(&mod->sgpg_wait_q);
5205
5206        bfa_trc(bfa, cfg->drvcfg.num_sgpgs);
5207
5208        mod->free_sgpgs = mod->num_sgpgs = cfg->drvcfg.num_sgpgs;
5209
5210        num_sgpg = cfg->drvcfg.num_sgpgs;
5211        nsegs = BFI_MEM_DMA_NSEGS(num_sgpg, sgpg_sz);
5212
5213        /* dma/kva mem claim */
5214        hsgpg = (struct bfa_sgpg_s *) bfa_mem_kva_curp(mod);
5215
5216        bfa_mem_dma_seg_iter(mod, seg_ptr, nsegs, idx) {
5217
5218                if (!bfa_mem_dma_virt(seg_ptr))
5219                        break;
5220
5221                align_len = BFA_SGPG_ROUNDUP(bfa_mem_dma_phys(seg_ptr)) -
5222                                             bfa_mem_dma_phys(seg_ptr);
5223
5224                sgpg = (struct bfi_sgpg_s *)
5225                        (((u8 *) bfa_mem_dma_virt(seg_ptr)) + align_len);
5226                sgpg_pa.pa = bfa_mem_dma_phys(seg_ptr) + align_len;
5227                WARN_ON(sgpg_pa.pa & (sgpg_sz - 1));
5228
5229                per_seg_sgpg = (seg_ptr->mem_len - (u32)align_len) / sgpg_sz;
5230
5231                for (i = 0; num_sgpg > 0 && i < per_seg_sgpg; i++, num_sgpg--) {
5232                        memset(hsgpg, 0, sizeof(*hsgpg));
5233                        memset(sgpg, 0, sizeof(*sgpg));
5234
5235                        hsgpg->sgpg = sgpg;
5236                        sgpg_pa_tmp.pa = bfa_sgaddr_le(sgpg_pa.pa);
5237                        hsgpg->sgpg_pa = sgpg_pa_tmp.addr;
5238                        list_add_tail(&hsgpg->qe, &mod->sgpg_q);
5239
5240                        sgpg++;
5241                        hsgpg++;
5242                        sgpg_pa.pa += sgpg_sz;
5243                }
5244        }
5245
5246        bfa_mem_kva_curp(mod) = (u8 *) hsgpg;
5247}
5248
5249bfa_status_t
5250bfa_sgpg_malloc(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpgs)
5251{
5252        struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
5253        struct bfa_sgpg_s *hsgpg;
5254        int i;
5255
5256        if (mod->free_sgpgs < nsgpgs)
5257                return BFA_STATUS_ENOMEM;
5258
5259        for (i = 0; i < nsgpgs; i++) {
5260                bfa_q_deq(&mod->sgpg_q, &hsgpg);
5261                WARN_ON(!hsgpg);
5262                list_add_tail(&hsgpg->qe, sgpg_q);
5263        }
5264
5265        mod->free_sgpgs -= nsgpgs;
5266        return BFA_STATUS_OK;
5267}
5268
5269void
5270bfa_sgpg_mfree(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpg)
5271{
5272        struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
5273        struct bfa_sgpg_wqe_s *wqe;
5274
5275        mod->free_sgpgs += nsgpg;
5276        WARN_ON(mod->free_sgpgs > mod->num_sgpgs);
5277
5278        list_splice_tail_init(sgpg_q, &mod->sgpg_q);
5279
5280        if (list_empty(&mod->sgpg_wait_q))
5281                return;
5282
5283        /*
5284         * satisfy as many waiting requests as possible
5285         */
5286        do {
5287                wqe = bfa_q_first(&mod->sgpg_wait_q);
5288                if (mod->free_sgpgs < wqe->nsgpg)
5289                        nsgpg = mod->free_sgpgs;
5290                else
5291                        nsgpg = wqe->nsgpg;
5292                bfa_sgpg_malloc(bfa, &wqe->sgpg_q, nsgpg);
5293                wqe->nsgpg -= nsgpg;
5294                if (wqe->nsgpg == 0) {
5295                        list_del(&wqe->qe);
5296                        wqe->cbfn(wqe->cbarg);
5297                }
5298        } while (mod->free_sgpgs && !list_empty(&mod->sgpg_wait_q));
5299}
5300
5301void
5302bfa_sgpg_wait(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe, int nsgpg)
5303{
5304        struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
5305
5306        WARN_ON(nsgpg <= 0);
5307        WARN_ON(nsgpg <= mod->free_sgpgs);
5308
5309        wqe->nsgpg_total = wqe->nsgpg = nsgpg;
5310
5311        /*
5312         * allocate any left to this one first
5313         */
5314        if (mod->free_sgpgs) {
5315                /*
5316                 * no one else is waiting for SGPG
5317                 */
5318                WARN_ON(!list_empty(&mod->sgpg_wait_q));
5319                list_splice_tail_init(&mod->sgpg_q, &wqe->sgpg_q);
5320                wqe->nsgpg -= mod->free_sgpgs;
5321                mod->free_sgpgs = 0;
5322        }
5323
5324        list_add_tail(&wqe->qe, &mod->sgpg_wait_q);
5325}
5326
5327void
5328bfa_sgpg_wcancel(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe)
5329{
5330        struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
5331
5332        WARN_ON(!bfa_q_is_on_q(&mod->sgpg_wait_q, wqe));
5333        list_del(&wqe->qe);
5334
5335        if (wqe->nsgpg_total != wqe->nsgpg)
5336                bfa_sgpg_mfree(bfa, &wqe->sgpg_q,
5337                                   wqe->nsgpg_total - wqe->nsgpg);
5338}
5339
5340void
5341bfa_sgpg_winit(struct bfa_sgpg_wqe_s *wqe, void (*cbfn) (void *cbarg),
5342                   void *cbarg)
5343{
5344        INIT_LIST_HEAD(&wqe->sgpg_q);
5345        wqe->cbfn = cbfn;
5346        wqe->cbarg = cbarg;
5347}
5348
5349/*
5350 *  UF related functions
5351 */
5352/*
5353 *****************************************************************************
5354 * Internal functions
5355 *****************************************************************************
5356 */
5357static void
5358__bfa_cb_uf_recv(void *cbarg, bfa_boolean_t complete)
5359{
5360        struct bfa_uf_s   *uf = cbarg;
5361        struct bfa_uf_mod_s *ufm = BFA_UF_MOD(uf->bfa);
5362
5363        if (complete)
5364                ufm->ufrecv(ufm->cbarg, uf);
5365}
5366
5367static void
5368claim_uf_post_msgs(struct bfa_uf_mod_s *ufm)
5369{
5370        struct bfi_uf_buf_post_s *uf_bp_msg;
5371        u16 i;
5372        u16 buf_len;
5373
5374        ufm->uf_buf_posts = (struct bfi_uf_buf_post_s *) bfa_mem_kva_curp(ufm);
5375        uf_bp_msg = ufm->uf_buf_posts;
5376
5377        for (i = 0, uf_bp_msg = ufm->uf_buf_posts; i < ufm->num_ufs;
5378             i++, uf_bp_msg++) {
5379                memset(uf_bp_msg, 0, sizeof(struct bfi_uf_buf_post_s));
5380
5381                uf_bp_msg->buf_tag = i;
5382                buf_len = sizeof(struct bfa_uf_buf_s);
5383                uf_bp_msg->buf_len = cpu_to_be16(buf_len);
5384                bfi_h2i_set(uf_bp_msg->mh, BFI_MC_UF, BFI_UF_H2I_BUF_POST,
5385                            bfa_fn_lpu(ufm->bfa));
5386                bfa_alen_set(&uf_bp_msg->alen, buf_len, ufm_pbs_pa(ufm, i));
5387        }
5388
5389        /*
5390         * advance pointer beyond consumed memory
5391         */
5392        bfa_mem_kva_curp(ufm) = (u8 *) uf_bp_msg;
5393}
5394
5395static void
5396claim_ufs(struct bfa_uf_mod_s *ufm)
5397{
5398        u16 i;
5399        struct bfa_uf_s   *uf;
5400
5401        /*
5402         * Claim block of memory for UF list
5403         */
5404        ufm->uf_list = (struct bfa_uf_s *) bfa_mem_kva_curp(ufm);
5405
5406        /*
5407         * Initialize UFs and queue it in UF free queue
5408         */
5409        for (i = 0, uf = ufm->uf_list; i < ufm->num_ufs; i++, uf++) {
5410                memset(uf, 0, sizeof(struct bfa_uf_s));
5411                uf->bfa = ufm->bfa;
5412                uf->uf_tag = i;
5413                uf->pb_len = BFA_PER_UF_DMA_SZ;
5414                uf->buf_kva = bfa_mem_get_dmabuf_kva(ufm, i, BFA_PER_UF_DMA_SZ);
5415                uf->buf_pa = ufm_pbs_pa(ufm, i);
5416                list_add_tail(&uf->qe, &ufm->uf_free_q);
5417        }
5418
5419        /*
5420         * advance memory pointer
5421         */
5422        bfa_mem_kva_curp(ufm) = (u8 *) uf;
5423}
5424
5425static void
5426uf_mem_claim(struct bfa_uf_mod_s *ufm)
5427{
5428        claim_ufs(ufm);
5429        claim_uf_post_msgs(ufm);
5430}
5431
5432void
5433bfa_uf_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
5434                struct bfa_s *bfa)
5435{
5436        struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5437        struct bfa_mem_kva_s *uf_kva = BFA_MEM_UF_KVA(bfa);
5438        u32     num_ufs = cfg->fwcfg.num_uf_bufs;
5439        struct bfa_mem_dma_s *seg_ptr;
5440        u16     nsegs, idx, per_seg_uf = 0;
5441
5442        nsegs = BFI_MEM_DMA_NSEGS(num_ufs, BFA_PER_UF_DMA_SZ);
5443        per_seg_uf = BFI_MEM_NREQS_SEG(BFA_PER_UF_DMA_SZ);
5444
5445        bfa_mem_dma_seg_iter(ufm, seg_ptr, nsegs, idx) {
5446                if (num_ufs >= per_seg_uf) {
5447                        num_ufs -= per_seg_uf;
5448                        bfa_mem_dma_setup(minfo, seg_ptr,
5449                                per_seg_uf * BFA_PER_UF_DMA_SZ);
5450                } else
5451                        bfa_mem_dma_setup(minfo, seg_ptr,
5452                                num_ufs * BFA_PER_UF_DMA_SZ);
5453        }
5454
5455        /* kva memory */
5456        bfa_mem_kva_setup(minfo, uf_kva, cfg->fwcfg.num_uf_bufs *
5457                (sizeof(struct bfa_uf_s) + sizeof(struct bfi_uf_buf_post_s)));
5458}
5459
5460void
5461bfa_uf_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
5462                struct bfa_pcidev_s *pcidev)
5463{
5464        struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5465
5466        ufm->bfa = bfa;
5467        ufm->num_ufs = cfg->fwcfg.num_uf_bufs;
5468        INIT_LIST_HEAD(&ufm->uf_free_q);
5469        INIT_LIST_HEAD(&ufm->uf_posted_q);
5470        INIT_LIST_HEAD(&ufm->uf_unused_q);
5471
5472        uf_mem_claim(ufm);
5473}
5474
5475static struct bfa_uf_s *
5476bfa_uf_get(struct bfa_uf_mod_s *uf_mod)
5477{
5478        struct bfa_uf_s   *uf;
5479
5480        bfa_q_deq(&uf_mod->uf_free_q, &uf);
5481        return uf;
5482}
5483
5484static void
5485bfa_uf_put(struct bfa_uf_mod_s *uf_mod, struct bfa_uf_s *uf)
5486{
5487        list_add_tail(&uf->qe, &uf_mod->uf_free_q);
5488}
5489
5490static bfa_status_t
5491bfa_uf_post(struct bfa_uf_mod_s *ufm, struct bfa_uf_s *uf)
5492{
5493        struct bfi_uf_buf_post_s *uf_post_msg;
5494
5495        uf_post_msg = bfa_reqq_next(ufm->bfa, BFA_REQQ_FCXP);
5496        if (!uf_post_msg)
5497                return BFA_STATUS_FAILED;
5498
5499        memcpy(uf_post_msg, &ufm->uf_buf_posts[uf->uf_tag],
5500                      sizeof(struct bfi_uf_buf_post_s));
5501        bfa_reqq_produce(ufm->bfa, BFA_REQQ_FCXP, uf_post_msg->mh);
5502
5503        bfa_trc(ufm->bfa, uf->uf_tag);
5504
5505        list_add_tail(&uf->qe, &ufm->uf_posted_q);
5506        return BFA_STATUS_OK;
5507}
5508
5509static void
5510bfa_uf_post_all(struct bfa_uf_mod_s *uf_mod)
5511{
5512        struct bfa_uf_s   *uf;
5513
5514        while ((uf = bfa_uf_get(uf_mod)) != NULL) {
5515                if (bfa_uf_post(uf_mod, uf) != BFA_STATUS_OK)
5516                        break;
5517        }
5518}
5519
5520static void
5521uf_recv(struct bfa_s *bfa, struct bfi_uf_frm_rcvd_s *m)
5522{
5523        struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5524        u16 uf_tag = m->buf_tag;
5525        struct bfa_uf_s *uf = &ufm->uf_list[uf_tag];
5526        struct bfa_uf_buf_s *uf_buf;
5527        uint8_t *buf;
5528        struct fchs_s *fchs;
5529
5530        uf_buf = (struct bfa_uf_buf_s *)
5531                        bfa_mem_get_dmabuf_kva(ufm, uf_tag, uf->pb_len);
5532        buf = &uf_buf->d[0];
5533
5534        m->frm_len = be16_to_cpu(m->frm_len);
5535        m->xfr_len = be16_to_cpu(m->xfr_len);
5536
5537        fchs = (struct fchs_s *)uf_buf;
5538
5539        list_del(&uf->qe);      /* dequeue from posted queue */
5540
5541        uf->data_ptr = buf;
5542        uf->data_len = m->xfr_len;
5543
5544        WARN_ON(uf->data_len < sizeof(struct fchs_s));
5545
5546        if (uf->data_len == sizeof(struct fchs_s)) {
5547                bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_UF, BFA_PL_EID_RX,
5548                               uf->data_len, (struct fchs_s *)buf);
5549        } else {
5550                u32 pld_w0 = *((u32 *) (buf + sizeof(struct fchs_s)));
5551                bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_UF,
5552                                      BFA_PL_EID_RX, uf->data_len,
5553                                      (struct fchs_s *)buf, pld_w0);
5554        }
5555
5556        if (bfa->fcs)
5557                __bfa_cb_uf_recv(uf, BFA_TRUE);
5558        else
5559                bfa_cb_queue(bfa, &uf->hcb_qe, __bfa_cb_uf_recv, uf);
5560}
5561
5562void
5563bfa_uf_iocdisable(struct bfa_s *bfa)
5564{
5565        struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5566        struct bfa_uf_s *uf;
5567        struct list_head *qe, *qen;
5568
5569        /* Enqueue unused uf resources to free_q */
5570        list_splice_tail_init(&ufm->uf_unused_q, &ufm->uf_free_q);
5571
5572        list_for_each_safe(qe, qen, &ufm->uf_posted_q) {
5573                uf = (struct bfa_uf_s *) qe;
5574                list_del(&uf->qe);
5575                bfa_uf_put(ufm, uf);
5576        }
5577}
5578
5579void
5580bfa_uf_start(struct bfa_s *bfa)
5581{
5582        bfa_uf_post_all(BFA_UF_MOD(bfa));
5583}
5584
5585/*
5586 * Register handler for all unsolicted receive frames.
5587 *
5588 * @param[in]   bfa             BFA instance
5589 * @param[in]   ufrecv  receive handler function
5590 * @param[in]   cbarg   receive handler arg
5591 */
5592void
5593bfa_uf_recv_register(struct bfa_s *bfa, bfa_cb_uf_recv_t ufrecv, void *cbarg)
5594{
5595        struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5596
5597        ufm->ufrecv = ufrecv;
5598        ufm->cbarg = cbarg;
5599}
5600
5601/*
5602 *      Free an unsolicited frame back to BFA.
5603 *
5604 * @param[in]           uf              unsolicited frame to be freed
5605 *
5606 * @return None
5607 */
5608void
5609bfa_uf_free(struct bfa_uf_s *uf)
5610{
5611        bfa_uf_put(BFA_UF_MOD(uf->bfa), uf);
5612        bfa_uf_post_all(BFA_UF_MOD(uf->bfa));
5613}
5614
5615
5616
5617/*
5618 *  uf_pub BFA uf module public functions
5619 */
5620void
5621bfa_uf_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
5622{
5623        bfa_trc(bfa, msg->mhdr.msg_id);
5624
5625        switch (msg->mhdr.msg_id) {
5626        case BFI_UF_I2H_FRM_RCVD:
5627                uf_recv(bfa, (struct bfi_uf_frm_rcvd_s *) msg);
5628                break;
5629
5630        default:
5631                bfa_trc(bfa, msg->mhdr.msg_id);
5632                WARN_ON(1);
5633        }
5634}
5635
5636void
5637bfa_uf_res_recfg(struct bfa_s *bfa, u16 num_uf_fw)
5638{
5639        struct bfa_uf_mod_s     *mod = BFA_UF_MOD(bfa);
5640        struct list_head        *qe;
5641        int     i;
5642
5643        for (i = 0; i < (mod->num_ufs - num_uf_fw); i++) {
5644                bfa_q_deq_tail(&mod->uf_free_q, &qe);
5645                list_add_tail(qe, &mod->uf_unused_q);
5646        }
5647}
5648
5649/*
5650 *      Dport forward declaration
5651 */
5652
5653enum bfa_dport_test_state_e {
5654        BFA_DPORT_ST_DISABLED   = 0,    /*!< dport is disabled */
5655        BFA_DPORT_ST_INP        = 1,    /*!< test in progress */
5656        BFA_DPORT_ST_COMP       = 2,    /*!< test complete successfully */
5657        BFA_DPORT_ST_NO_SFP     = 3,    /*!< sfp is not present */
5658        BFA_DPORT_ST_NOTSTART   = 4,    /*!< test not start dport is enabled */
5659};
5660
5661/*
5662 * BFA DPORT state machine events
5663 */
5664enum bfa_dport_sm_event {
5665        BFA_DPORT_SM_ENABLE     = 1,    /* dport enable event         */
5666        BFA_DPORT_SM_DISABLE    = 2,    /* dport disable event        */
5667        BFA_DPORT_SM_FWRSP      = 3,    /* fw enable/disable rsp      */
5668        BFA_DPORT_SM_QRESUME    = 4,    /* CQ space available         */
5669        BFA_DPORT_SM_HWFAIL     = 5,    /* IOC h/w failure            */
5670        BFA_DPORT_SM_START      = 6,    /* re-start dport test        */
5671        BFA_DPORT_SM_REQFAIL    = 7,    /* request failure            */
5672        BFA_DPORT_SM_SCN        = 8,    /* state change notify frm fw */
5673};
5674
5675static void bfa_dport_sm_disabled(struct bfa_dport_s *dport,
5676                                  enum bfa_dport_sm_event event);
5677static void bfa_dport_sm_enabling_qwait(struct bfa_dport_s *dport,
5678                                  enum bfa_dport_sm_event event);
5679static void bfa_dport_sm_enabling(struct bfa_dport_s *dport,
5680                                  enum bfa_dport_sm_event event);
5681static void bfa_dport_sm_enabled(struct bfa_dport_s *dport,
5682                                 enum bfa_dport_sm_event event);
5683static void bfa_dport_sm_disabling_qwait(struct bfa_dport_s *dport,
5684                                 enum bfa_dport_sm_event event);
5685static void bfa_dport_sm_disabling(struct bfa_dport_s *dport,
5686                                   enum bfa_dport_sm_event event);
5687static void bfa_dport_sm_starting_qwait(struct bfa_dport_s *dport,
5688                                        enum bfa_dport_sm_event event);
5689static void bfa_dport_sm_starting(struct bfa_dport_s *dport,
5690                                  enum bfa_dport_sm_event event);
5691static void bfa_dport_sm_dynamic_disabling(struct bfa_dport_s *dport,
5692                                   enum bfa_dport_sm_event event);
5693static void bfa_dport_sm_dynamic_disabling_qwait(struct bfa_dport_s *dport,
5694                                   enum bfa_dport_sm_event event);
5695static void bfa_dport_qresume(void *cbarg);
5696static void bfa_dport_req_comp(struct bfa_dport_s *dport,
5697                                struct bfi_diag_dport_rsp_s *msg);
5698static void bfa_dport_scn(struct bfa_dport_s *dport,
5699                                struct bfi_diag_dport_scn_s *msg);
5700
5701/*
5702 *      BFA fcdiag module
5703 */
5704#define BFA_DIAG_QTEST_TOV      1000    /* msec */
5705
5706/*
5707 *      Set port status to busy
5708 */
5709static void
5710bfa_fcdiag_set_busy_status(struct bfa_fcdiag_s *fcdiag)
5711{
5712        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(fcdiag->bfa);
5713
5714        if (fcdiag->lb.lock)
5715                fcport->diag_busy = BFA_TRUE;
5716        else
5717                fcport->diag_busy = BFA_FALSE;
5718}
5719
5720void
5721bfa_fcdiag_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
5722                struct bfa_pcidev_s *pcidev)
5723{
5724        struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5725        struct bfa_dport_s  *dport = &fcdiag->dport;
5726
5727        fcdiag->bfa             = bfa;
5728        fcdiag->trcmod  = bfa->trcmod;
5729        /* The common DIAG attach bfa_diag_attach() will do all memory claim */
5730        dport->bfa = bfa;
5731        bfa_sm_set_state(dport, bfa_dport_sm_disabled);
5732        bfa_reqq_winit(&dport->reqq_wait, bfa_dport_qresume, dport);
5733        dport->cbfn = NULL;
5734        dport->cbarg = NULL;
5735        dport->test_state = BFA_DPORT_ST_DISABLED;
5736        memset(&dport->result, 0, sizeof(struct bfa_diag_dport_result_s));
5737}
5738
5739void
5740bfa_fcdiag_iocdisable(struct bfa_s *bfa)
5741{
5742        struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5743        struct bfa_dport_s *dport = &fcdiag->dport;
5744
5745        bfa_trc(fcdiag, fcdiag->lb.lock);
5746        if (fcdiag->lb.lock) {
5747                fcdiag->lb.status = BFA_STATUS_IOC_FAILURE;
5748                fcdiag->lb.cbfn(fcdiag->lb.cbarg, fcdiag->lb.status);
5749                fcdiag->lb.lock = 0;
5750                bfa_fcdiag_set_busy_status(fcdiag);
5751        }
5752
5753        bfa_sm_send_event(dport, BFA_DPORT_SM_HWFAIL);
5754}
5755
5756static void
5757bfa_fcdiag_queuetest_timeout(void *cbarg)
5758{
5759        struct bfa_fcdiag_s       *fcdiag = cbarg;
5760        struct bfa_diag_qtest_result_s *res = fcdiag->qtest.result;
5761
5762        bfa_trc(fcdiag, fcdiag->qtest.all);
5763        bfa_trc(fcdiag, fcdiag->qtest.count);
5764
5765        fcdiag->qtest.timer_active = 0;
5766
5767        res->status = BFA_STATUS_ETIMER;
5768        res->count  = QTEST_CNT_DEFAULT - fcdiag->qtest.count;
5769        if (fcdiag->qtest.all)
5770                res->queue  = fcdiag->qtest.all;
5771
5772        bfa_trc(fcdiag, BFA_STATUS_ETIMER);
5773        fcdiag->qtest.status = BFA_STATUS_ETIMER;
5774        fcdiag->qtest.cbfn(fcdiag->qtest.cbarg, fcdiag->qtest.status);
5775        fcdiag->qtest.lock = 0;
5776}
5777
5778static bfa_status_t
5779bfa_fcdiag_queuetest_send(struct bfa_fcdiag_s *fcdiag)
5780{
5781        u32     i;
5782        struct bfi_diag_qtest_req_s *req;
5783
5784        req = bfa_reqq_next(fcdiag->bfa, fcdiag->qtest.queue);
5785        if (!req)
5786                return BFA_STATUS_DEVBUSY;
5787
5788        /* build host command */
5789        bfi_h2i_set(req->mh, BFI_MC_DIAG, BFI_DIAG_H2I_QTEST,
5790                bfa_fn_lpu(fcdiag->bfa));
5791
5792        for (i = 0; i < BFI_LMSG_PL_WSZ; i++)
5793                req->data[i] = QTEST_PAT_DEFAULT;
5794
5795        bfa_trc(fcdiag, fcdiag->qtest.queue);
5796        /* ring door bell */
5797        bfa_reqq_produce(fcdiag->bfa, fcdiag->qtest.queue, req->mh);
5798        return BFA_STATUS_OK;
5799}
5800
5801static void
5802bfa_fcdiag_queuetest_comp(struct bfa_fcdiag_s *fcdiag,
5803                        bfi_diag_qtest_rsp_t *rsp)
5804{
5805        struct bfa_diag_qtest_result_s *res = fcdiag->qtest.result;
5806        bfa_status_t status = BFA_STATUS_OK;
5807        int i;
5808
5809        /* Check timer, should still be active   */
5810        if (!fcdiag->qtest.timer_active) {
5811                bfa_trc(fcdiag, fcdiag->qtest.timer_active);
5812                return;
5813        }
5814
5815        /* update count */
5816        fcdiag->qtest.count--;
5817
5818        /* Check result */
5819        for (i = 0; i < BFI_LMSG_PL_WSZ; i++) {
5820                if (rsp->data[i] != ~(QTEST_PAT_DEFAULT)) {
5821                        res->status = BFA_STATUS_DATACORRUPTED;
5822                        break;
5823                }
5824        }
5825
5826        if (res->status == BFA_STATUS_OK) {
5827                if (fcdiag->qtest.count > 0) {
5828                        status = bfa_fcdiag_queuetest_send(fcdiag);
5829                        if (status == BFA_STATUS_OK)
5830                                return;
5831                        else
5832                                res->status = status;
5833                } else if (fcdiag->qtest.all > 0 &&
5834                        fcdiag->qtest.queue < (BFI_IOC_MAX_CQS - 1)) {
5835                        fcdiag->qtest.count = QTEST_CNT_DEFAULT;
5836                        fcdiag->qtest.queue++;
5837                        status = bfa_fcdiag_queuetest_send(fcdiag);
5838                        if (status == BFA_STATUS_OK)
5839                                return;
5840                        else
5841                                res->status = status;
5842                }
5843        }
5844
5845        /* Stop timer when we comp all queue */
5846        if (fcdiag->qtest.timer_active) {
5847                bfa_timer_stop(&fcdiag->qtest.timer);
5848                fcdiag->qtest.timer_active = 0;
5849        }
5850        res->queue = fcdiag->qtest.queue;
5851        res->count = QTEST_CNT_DEFAULT - fcdiag->qtest.count;
5852        bfa_trc(fcdiag, res->count);
5853        bfa_trc(fcdiag, res->status);
5854        fcdiag->qtest.status = res->status;
5855        fcdiag->qtest.cbfn(fcdiag->qtest.cbarg, fcdiag->qtest.status);
5856        fcdiag->qtest.lock = 0;
5857}
5858
5859static void
5860bfa_fcdiag_loopback_comp(struct bfa_fcdiag_s *fcdiag,
5861                        struct bfi_diag_lb_rsp_s *rsp)
5862{
5863        struct bfa_diag_loopback_result_s *res = fcdiag->lb.result;
5864
5865        res->numtxmfrm  = be32_to_cpu(rsp->res.numtxmfrm);
5866        res->numosffrm  = be32_to_cpu(rsp->res.numosffrm);
5867        res->numrcvfrm  = be32_to_cpu(rsp->res.numrcvfrm);
5868        res->badfrminf  = be32_to_cpu(rsp->res.badfrminf);
5869        res->badfrmnum  = be32_to_cpu(rsp->res.badfrmnum);
5870        res->status     = rsp->res.status;
5871        fcdiag->lb.status = rsp->res.status;
5872        bfa_trc(fcdiag, fcdiag->lb.status);
5873        fcdiag->lb.cbfn(fcdiag->lb.cbarg, fcdiag->lb.status);
5874        fcdiag->lb.lock = 0;
5875        bfa_fcdiag_set_busy_status(fcdiag);
5876}
5877
5878static bfa_status_t
5879bfa_fcdiag_loopback_send(struct bfa_fcdiag_s *fcdiag,
5880                        struct bfa_diag_loopback_s *loopback)
5881{
5882        struct bfi_diag_lb_req_s *lb_req;
5883
5884        lb_req = bfa_reqq_next(fcdiag->bfa, BFA_REQQ_DIAG);
5885        if (!lb_req)
5886                return BFA_STATUS_DEVBUSY;
5887
5888        /* build host command */
5889        bfi_h2i_set(lb_req->mh, BFI_MC_DIAG, BFI_DIAG_H2I_LOOPBACK,
5890                bfa_fn_lpu(fcdiag->bfa));
5891
5892        lb_req->lb_mode = loopback->lb_mode;
5893        lb_req->speed = loopback->speed;
5894        lb_req->loopcnt = loopback->loopcnt;
5895        lb_req->pattern = loopback->pattern;
5896
5897        /* ring door bell */
5898        bfa_reqq_produce(fcdiag->bfa, BFA_REQQ_DIAG, lb_req->mh);
5899
5900        bfa_trc(fcdiag, loopback->lb_mode);
5901        bfa_trc(fcdiag, loopback->speed);
5902        bfa_trc(fcdiag, loopback->loopcnt);
5903        bfa_trc(fcdiag, loopback->pattern);
5904        return BFA_STATUS_OK;
5905}
5906
5907/*
5908 *      cpe/rme intr handler
5909 */
5910void
5911bfa_fcdiag_intr(struct bfa_s *bfa, struct bfi_msg_s *msg)
5912{
5913        struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5914
5915        switch (msg->mhdr.msg_id) {
5916        case BFI_DIAG_I2H_LOOPBACK:
5917                bfa_fcdiag_loopback_comp(fcdiag,
5918                                (struct bfi_diag_lb_rsp_s *) msg);
5919                break;
5920        case BFI_DIAG_I2H_QTEST:
5921                bfa_fcdiag_queuetest_comp(fcdiag, (bfi_diag_qtest_rsp_t *)msg);
5922                break;
5923        case BFI_DIAG_I2H_DPORT:
5924                bfa_dport_req_comp(&fcdiag->dport,
5925                                (struct bfi_diag_dport_rsp_s *)msg);
5926                break;
5927        case BFI_DIAG_I2H_DPORT_SCN:
5928                bfa_dport_scn(&fcdiag->dport,
5929                                (struct bfi_diag_dport_scn_s *)msg);
5930                break;
5931        default:
5932                bfa_trc(fcdiag, msg->mhdr.msg_id);
5933                WARN_ON(1);
5934        }
5935}
5936
5937/*
5938 *      Loopback test
5939 *
5940 *   @param[in] *bfa            - bfa data struct
5941 *   @param[in] opmode          - port operation mode
5942 *   @param[in] speed           - port speed
5943 *   @param[in] lpcnt           - loop count
5944 *   @param[in] pat                     - pattern to build packet
5945 *   @param[in] *result         - pt to bfa_diag_loopback_result_t data struct
5946 *   @param[in] cbfn            - callback function
5947 *   @param[in] cbarg           - callback functioin arg
5948 *
5949 *   @param[out]
5950 */
5951bfa_status_t
5952bfa_fcdiag_loopback(struct bfa_s *bfa, enum bfa_port_opmode opmode,
5953                enum bfa_port_speed speed, u32 lpcnt, u32 pat,
5954                struct bfa_diag_loopback_result_s *result, bfa_cb_diag_t cbfn,
5955                void *cbarg)
5956{
5957        struct  bfa_diag_loopback_s loopback;
5958        struct bfa_port_attr_s attr;
5959        bfa_status_t status;
5960        struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5961
5962        if (!bfa_iocfc_is_operational(bfa))
5963                return BFA_STATUS_IOC_NON_OP;
5964
5965        /* if port is PBC disabled, return error */
5966        if (bfa_fcport_is_pbcdisabled(bfa)) {
5967                bfa_trc(fcdiag, BFA_STATUS_PBC);
5968                return BFA_STATUS_PBC;
5969        }
5970
5971        if (bfa_fcport_is_disabled(bfa) == BFA_FALSE) {
5972                bfa_trc(fcdiag, opmode);
5973                return BFA_STATUS_PORT_NOT_DISABLED;
5974        }
5975
5976        /*
5977         * Check if input speed is supported by the port mode
5978         */
5979        if (bfa_ioc_get_type(&bfa->ioc) == BFA_IOC_TYPE_FC) {
5980                if (!(speed == BFA_PORT_SPEED_1GBPS ||
5981                      speed == BFA_PORT_SPEED_2GBPS ||
5982                      speed == BFA_PORT_SPEED_4GBPS ||
5983                      speed == BFA_PORT_SPEED_8GBPS ||
5984                      speed == BFA_PORT_SPEED_16GBPS ||
5985                      speed == BFA_PORT_SPEED_AUTO)) {
5986                        bfa_trc(fcdiag, speed);
5987                        return BFA_STATUS_UNSUPP_SPEED;
5988                }
5989                bfa_fcport_get_attr(bfa, &attr);
5990                bfa_trc(fcdiag, attr.speed_supported);
5991                if (speed > attr.speed_supported)
5992                        return BFA_STATUS_UNSUPP_SPEED;
5993        } else {
5994                if (speed != BFA_PORT_SPEED_10GBPS) {
5995                        bfa_trc(fcdiag, speed);
5996                        return BFA_STATUS_UNSUPP_SPEED;
5997                }
5998        }
5999
6000        /*
6001         * For CT2, 1G is not supported
6002         */
6003        if ((speed == BFA_PORT_SPEED_1GBPS) &&
6004            (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id))) {
6005                bfa_trc(fcdiag, speed);
6006                return BFA_STATUS_UNSUPP_SPEED;
6007        }
6008
6009        /* For Mezz card, port speed entered needs to be checked */
6010        if (bfa_mfg_is_mezz(bfa->ioc.attr->card_type)) {
6011                if (bfa_ioc_get_type(&bfa->ioc) == BFA_IOC_TYPE_FC) {
6012                        if (!(speed == BFA_PORT_SPEED_1GBPS ||
6013                              speed == BFA_PORT_SPEED_2GBPS ||
6014                              speed == BFA_PORT_SPEED_4GBPS ||
6015                              speed == BFA_PORT_SPEED_8GBPS ||
6016                              speed == BFA_PORT_SPEED_16GBPS ||
6017                              speed == BFA_PORT_SPEED_AUTO))
6018                                return BFA_STATUS_UNSUPP_SPEED;
6019                } else {
6020                        if (speed != BFA_PORT_SPEED_10GBPS)
6021                                return BFA_STATUS_UNSUPP_SPEED;
6022                }
6023        }
6024        /* check to see if fcport is dport */
6025        if (bfa_fcport_is_dport(bfa)) {
6026                bfa_trc(fcdiag, fcdiag->lb.lock);
6027                return BFA_STATUS_DPORT_ENABLED;
6028        }
6029        /* check to see if there is another destructive diag cmd running */
6030        if (fcdiag->lb.lock) {
6031                bfa_trc(fcdiag, fcdiag->lb.lock);
6032                return BFA_STATUS_DEVBUSY;
6033        }
6034
6035        fcdiag->lb.lock = 1;
6036        loopback.lb_mode = opmode;
6037        loopback.speed = speed;
6038        loopback.loopcnt = lpcnt;
6039        loopback.pattern = pat;
6040        fcdiag->lb.result = result;
6041        fcdiag->lb.cbfn = cbfn;
6042        fcdiag->lb.cbarg = cbarg;
6043        memset(result, 0, sizeof(struct bfa_diag_loopback_result_s));
6044        bfa_fcdiag_set_busy_status(fcdiag);
6045
6046        /* Send msg to fw */
6047        status = bfa_fcdiag_loopback_send(fcdiag, &loopback);
6048        return status;
6049}
6050
6051/*
6052 *      DIAG queue test command
6053 *
6054 *   @param[in] *bfa            - bfa data struct
6055 *   @param[in] force           - 1: don't do ioc op checking
6056 *   @param[in] queue           - queue no. to test
6057 *   @param[in] *result         - pt to bfa_diag_qtest_result_t data struct
6058 *   @param[in] cbfn            - callback function
6059 *   @param[in] *cbarg          - callback functioin arg
6060 *
6061 *   @param[out]
6062 */
6063bfa_status_t
6064bfa_fcdiag_queuetest(struct bfa_s *bfa, u32 force, u32 queue,
6065                struct bfa_diag_qtest_result_s *result, bfa_cb_diag_t cbfn,
6066                void *cbarg)
6067{
6068        struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6069        bfa_status_t status;
6070        bfa_trc(fcdiag, force);
6071        bfa_trc(fcdiag, queue);
6072
6073        if (!force && !bfa_iocfc_is_operational(bfa))
6074                return BFA_STATUS_IOC_NON_OP;
6075
6076        /* check to see if there is another destructive diag cmd running */
6077        if (fcdiag->qtest.lock) {
6078                bfa_trc(fcdiag, fcdiag->qtest.lock);
6079                return BFA_STATUS_DEVBUSY;
6080        }
6081
6082        /* Initialization */
6083        fcdiag->qtest.lock = 1;
6084        fcdiag->qtest.cbfn = cbfn;
6085        fcdiag->qtest.cbarg = cbarg;
6086        fcdiag->qtest.result = result;
6087        fcdiag->qtest.count = QTEST_CNT_DEFAULT;
6088
6089        /* Init test results */
6090        fcdiag->qtest.result->status = BFA_STATUS_OK;
6091        fcdiag->qtest.result->count  = 0;
6092
6093        /* send */
6094        if (queue < BFI_IOC_MAX_CQS) {
6095                fcdiag->qtest.result->queue  = (u8)queue;
6096                fcdiag->qtest.queue = (u8)queue;
6097                fcdiag->qtest.all   = 0;
6098        } else {
6099                fcdiag->qtest.result->queue  = 0;
6100                fcdiag->qtest.queue = 0;
6101                fcdiag->qtest.all   = 1;
6102        }
6103        status = bfa_fcdiag_queuetest_send(fcdiag);
6104
6105        /* Start a timer */
6106        if (status == BFA_STATUS_OK) {
6107                bfa_timer_start(bfa, &fcdiag->qtest.timer,
6108                                bfa_fcdiag_queuetest_timeout, fcdiag,
6109                                BFA_DIAG_QTEST_TOV);
6110                fcdiag->qtest.timer_active = 1;
6111        }
6112        return status;
6113}
6114
6115/*
6116 * DIAG PLB is running
6117 *
6118 *   @param[in] *bfa    - bfa data struct
6119 *
6120 *   @param[out]
6121 */
6122bfa_status_t
6123bfa_fcdiag_lb_is_running(struct bfa_s *bfa)
6124{
6125        struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6126        return fcdiag->lb.lock ?  BFA_STATUS_DIAG_BUSY : BFA_STATUS_OK;
6127}
6128
6129/*
6130 *      D-port
6131 */
6132#define bfa_dport_result_start(__dport, __mode) do {                            \
6133                (__dport)->result.start_time = ktime_get_real_seconds();        \
6134                (__dport)->result.status = DPORT_TEST_ST_INPRG;                 \
6135                (__dport)->result.mode = (__mode);                              \
6136                (__dport)->result.rp_pwwn = (__dport)->rp_pwwn;                 \
6137                (__dport)->result.rp_nwwn = (__dport)->rp_nwwn;                 \
6138                (__dport)->result.lpcnt = (__dport)->lpcnt;                     \
6139} while (0)
6140
6141static bfa_boolean_t bfa_dport_send_req(struct bfa_dport_s *dport,
6142                                        enum bfi_dport_req req);
6143static void
6144bfa_cb_fcdiag_dport(struct bfa_dport_s *dport, bfa_status_t bfa_status)
6145{
6146        if (dport->cbfn != NULL) {
6147                dport->cbfn(dport->cbarg, bfa_status);
6148                dport->cbfn = NULL;
6149                dport->cbarg = NULL;
6150        }
6151}
6152
6153static void
6154bfa_dport_sm_disabled(struct bfa_dport_s *dport, enum bfa_dport_sm_event event)
6155{
6156        bfa_trc(dport->bfa, event);
6157
6158        switch (event) {
6159        case BFA_DPORT_SM_ENABLE:
6160                bfa_fcport_dportenable(dport->bfa);
6161                if (bfa_dport_send_req(dport, BFI_DPORT_ENABLE))
6162                        bfa_sm_set_state(dport, bfa_dport_sm_enabling);
6163                else
6164                        bfa_sm_set_state(dport, bfa_dport_sm_enabling_qwait);
6165                break;
6166
6167        case BFA_DPORT_SM_DISABLE:
6168                /* Already disabled */
6169                break;
6170
6171        case BFA_DPORT_SM_HWFAIL:
6172                /* ignore */
6173                break;
6174
6175        case BFA_DPORT_SM_SCN:
6176                if (dport->i2hmsg.scn.state ==  BFI_DPORT_SCN_DDPORT_ENABLE) {
6177                        bfa_fcport_ddportenable(dport->bfa);
6178                        dport->dynamic = BFA_TRUE;
6179                        dport->test_state = BFA_DPORT_ST_NOTSTART;
6180                        bfa_sm_set_state(dport, bfa_dport_sm_enabled);
6181                } else {
6182                        bfa_trc(dport->bfa, dport->i2hmsg.scn.state);
6183                        WARN_ON(1);
6184                }
6185                break;
6186
6187        default:
6188                bfa_sm_fault(dport->bfa, event);
6189        }
6190}
6191
6192static void
6193bfa_dport_sm_enabling_qwait(struct bfa_dport_s *dport,
6194                            enum bfa_dport_sm_event event)
6195{
6196        bfa_trc(dport->bfa, event);
6197
6198        switch (event) {
6199        case BFA_DPORT_SM_QRESUME:
6200                bfa_sm_set_state(dport, bfa_dport_sm_enabling);
6201                bfa_dport_send_req(dport, BFI_DPORT_ENABLE);
6202                break;
6203
6204        case BFA_DPORT_SM_HWFAIL:
6205                bfa_reqq_wcancel(&dport->reqq_wait);
6206                bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6207                bfa_cb_fcdiag_dport(dport, BFA_STATUS_FAILED);
6208                break;
6209
6210        default:
6211                bfa_sm_fault(dport->bfa, event);
6212        }
6213}
6214
6215static void
6216bfa_dport_sm_enabling(struct bfa_dport_s *dport, enum bfa_dport_sm_event event)
6217{
6218        bfa_trc(dport->bfa, event);
6219
6220        switch (event) {
6221        case BFA_DPORT_SM_FWRSP:
6222                memset(&dport->result, 0,
6223                                sizeof(struct bfa_diag_dport_result_s));
6224                if (dport->i2hmsg.rsp.status == BFA_STATUS_DPORT_INV_SFP) {
6225                        dport->test_state = BFA_DPORT_ST_NO_SFP;
6226                } else {
6227                        dport->test_state = BFA_DPORT_ST_INP;
6228                        bfa_dport_result_start(dport, BFA_DPORT_OPMODE_AUTO);
6229                }
6230                bfa_sm_set_state(dport, bfa_dport_sm_enabled);
6231                break;
6232
6233        case BFA_DPORT_SM_REQFAIL:
6234                dport->test_state = BFA_DPORT_ST_DISABLED;
6235                bfa_fcport_dportdisable(dport->bfa);
6236                bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6237                break;
6238
6239        case BFA_DPORT_SM_HWFAIL:
6240                bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6241                bfa_cb_fcdiag_dport(dport, BFA_STATUS_FAILED);
6242                break;
6243
6244        default:
6245                bfa_sm_fault(dport->bfa, event);
6246        }
6247}
6248
6249static void
6250bfa_dport_sm_enabled(struct bfa_dport_s *dport, enum bfa_dport_sm_event event)
6251{
6252        bfa_trc(dport->bfa, event);
6253
6254        switch (event) {
6255        case BFA_DPORT_SM_START:
6256                if (bfa_dport_send_req(dport, BFI_DPORT_START))
6257                        bfa_sm_set_state(dport, bfa_dport_sm_starting);
6258                else
6259                        bfa_sm_set_state(dport, bfa_dport_sm_starting_qwait);
6260                break;
6261
6262        case BFA_DPORT_SM_DISABLE:
6263                bfa_fcport_dportdisable(dport->bfa);
6264                if (bfa_dport_send_req(dport, BFI_DPORT_DISABLE))
6265                        bfa_sm_set_state(dport, bfa_dport_sm_disabling);
6266                else
6267                        bfa_sm_set_state(dport, bfa_dport_sm_disabling_qwait);
6268                break;
6269
6270        case BFA_DPORT_SM_HWFAIL:
6271                bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6272                break;
6273
6274        case BFA_DPORT_SM_SCN:
6275                switch (dport->i2hmsg.scn.state) {
6276                case BFI_DPORT_SCN_TESTCOMP:
6277                        dport->test_state = BFA_DPORT_ST_COMP;
6278                        break;
6279
6280                case BFI_DPORT_SCN_TESTSTART:
6281                        dport->test_state = BFA_DPORT_ST_INP;
6282                        break;
6283
6284                case BFI_DPORT_SCN_TESTSKIP:
6285                case BFI_DPORT_SCN_SUBTESTSTART:
6286                        /* no state change */
6287                        break;
6288
6289                case BFI_DPORT_SCN_SFP_REMOVED:
6290                        dport->test_state = BFA_DPORT_ST_NO_SFP;
6291                        break;
6292
6293                case BFI_DPORT_SCN_DDPORT_DISABLE:
6294                        bfa_fcport_ddportdisable(dport->bfa);
6295
6296                        if (bfa_dport_send_req(dport, BFI_DPORT_DYN_DISABLE))
6297                                bfa_sm_set_state(dport,
6298                                         bfa_dport_sm_dynamic_disabling);
6299                        else
6300                                bfa_sm_set_state(dport,
6301                                         bfa_dport_sm_dynamic_disabling_qwait);
6302                        break;
6303
6304                case BFI_DPORT_SCN_FCPORT_DISABLE:
6305                        bfa_fcport_ddportdisable(dport->bfa);
6306
6307                        bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6308                        dport->dynamic = BFA_FALSE;
6309                        break;
6310
6311                default:
6312                        bfa_trc(dport->bfa, dport->i2hmsg.scn.state);
6313                        bfa_sm_fault(dport->bfa, event);
6314                }
6315                break;
6316        default:
6317                bfa_sm_fault(dport->bfa, event);
6318        }
6319}
6320
6321static void
6322bfa_dport_sm_disabling_qwait(struct bfa_dport_s *dport,
6323                             enum bfa_dport_sm_event event)
6324{
6325        bfa_trc(dport->bfa, event);
6326
6327        switch (event) {
6328        case BFA_DPORT_SM_QRESUME:
6329                bfa_sm_set_state(dport, bfa_dport_sm_disabling);
6330                bfa_dport_send_req(dport, BFI_DPORT_DISABLE);
6331                break;
6332
6333        case BFA_DPORT_SM_HWFAIL:
6334                bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6335                bfa_reqq_wcancel(&dport->reqq_wait);
6336                bfa_cb_fcdiag_dport(dport, BFA_STATUS_OK);
6337                break;
6338
6339        case BFA_DPORT_SM_SCN:
6340                /* ignore */
6341                break;
6342
6343        default:
6344                bfa_sm_fault(dport->bfa, event);
6345        }
6346}
6347
6348static void
6349bfa_dport_sm_disabling(struct bfa_dport_s *dport, enum bfa_dport_sm_event event)
6350{
6351        bfa_trc(dport->bfa, event);
6352
6353        switch (event) {
6354        case BFA_DPORT_SM_FWRSP:
6355                dport->test_state = BFA_DPORT_ST_DISABLED;
6356                bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6357                break;
6358
6359        case BFA_DPORT_SM_HWFAIL:
6360                bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6361                bfa_cb_fcdiag_dport(dport, BFA_STATUS_OK);
6362                break;
6363
6364        case BFA_DPORT_SM_SCN:
6365                /* no state change */
6366                break;
6367
6368        default:
6369                bfa_sm_fault(dport->bfa, event);
6370        }
6371}
6372
6373static void
6374bfa_dport_sm_starting_qwait(struct bfa_dport_s *dport,
6375                            enum bfa_dport_sm_event event)
6376{
6377        bfa_trc(dport->bfa, event);
6378
6379        switch (event) {
6380        case BFA_DPORT_SM_QRESUME:
6381                bfa_sm_set_state(dport, bfa_dport_sm_starting);
6382                bfa_dport_send_req(dport, BFI_DPORT_START);
6383                break;
6384
6385        case BFA_DPORT_SM_HWFAIL:
6386                bfa_reqq_wcancel(&dport->reqq_wait);
6387                bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6388                bfa_cb_fcdiag_dport(dport, BFA_STATUS_FAILED);
6389                break;
6390
6391        default:
6392                bfa_sm_fault(dport->bfa, event);
6393        }
6394}
6395
6396static void
6397bfa_dport_sm_starting(struct bfa_dport_s *dport, enum bfa_dport_sm_event event)
6398{
6399        bfa_trc(dport->bfa, event);
6400
6401        switch (event) {
6402        case BFA_DPORT_SM_FWRSP:
6403                memset(&dport->result, 0,
6404                                sizeof(struct bfa_diag_dport_result_s));
6405                if (dport->i2hmsg.rsp.status == BFA_STATUS_DPORT_INV_SFP) {
6406                        dport->test_state = BFA_DPORT_ST_NO_SFP;
6407                } else {
6408                        dport->test_state = BFA_DPORT_ST_INP;
6409                        bfa_dport_result_start(dport, BFA_DPORT_OPMODE_MANU);
6410                }
6411                /* fall thru */
6412
6413        case BFA_DPORT_SM_REQFAIL:
6414                bfa_sm_set_state(dport, bfa_dport_sm_enabled);
6415                break;
6416
6417        case BFA_DPORT_SM_HWFAIL:
6418                bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6419                bfa_cb_fcdiag_dport(dport, BFA_STATUS_FAILED);
6420                break;
6421
6422        default:
6423                bfa_sm_fault(dport->bfa, event);
6424        }
6425}
6426
6427static void
6428bfa_dport_sm_dynamic_disabling(struct bfa_dport_s *dport,
6429                               enum bfa_dport_sm_event event)
6430{
6431        bfa_trc(dport->bfa, event);
6432
6433        switch (event) {
6434        case BFA_DPORT_SM_SCN:
6435                switch (dport->i2hmsg.scn.state) {
6436                case BFI_DPORT_SCN_DDPORT_DISABLED:
6437                        bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6438                        dport->dynamic = BFA_FALSE;
6439                        bfa_fcport_enable(dport->bfa);
6440                        break;
6441
6442                default:
6443                        bfa_trc(dport->bfa, dport->i2hmsg.scn.state);
6444                        bfa_sm_fault(dport->bfa, event);
6445
6446                }
6447                break;
6448
6449        case BFA_DPORT_SM_HWFAIL:
6450                bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6451                bfa_cb_fcdiag_dport(dport, BFA_STATUS_OK);
6452                break;
6453
6454        default:
6455                bfa_sm_fault(dport->bfa, event);
6456        }
6457}
6458
6459static void
6460bfa_dport_sm_dynamic_disabling_qwait(struct bfa_dport_s *dport,
6461                            enum bfa_dport_sm_event event)
6462{
6463        bfa_trc(dport->bfa, event);
6464
6465        switch (event) {
6466        case BFA_DPORT_SM_QRESUME:
6467                bfa_sm_set_state(dport, bfa_dport_sm_dynamic_disabling);
6468                bfa_dport_send_req(dport, BFI_DPORT_DYN_DISABLE);
6469                break;
6470
6471        case BFA_DPORT_SM_HWFAIL:
6472                bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6473                bfa_reqq_wcancel(&dport->reqq_wait);
6474                bfa_cb_fcdiag_dport(dport, BFA_STATUS_OK);
6475                break;
6476
6477        case BFA_DPORT_SM_SCN:
6478                /* ignore */
6479                break;
6480
6481        default:
6482                bfa_sm_fault(dport->bfa, event);
6483        }
6484}
6485
6486static bfa_boolean_t
6487bfa_dport_send_req(struct bfa_dport_s *dport, enum bfi_dport_req req)
6488{
6489        struct bfi_diag_dport_req_s *m;
6490
6491        /*
6492         * check for room in queue to send request now
6493         */
6494        m = bfa_reqq_next(dport->bfa, BFA_REQQ_DIAG);
6495        if (!m) {
6496                bfa_reqq_wait(dport->bfa, BFA_REQQ_PORT, &dport->reqq_wait);
6497                return BFA_FALSE;
6498        }
6499
6500        bfi_h2i_set(m->mh, BFI_MC_DIAG, BFI_DIAG_H2I_DPORT,
6501                    bfa_fn_lpu(dport->bfa));
6502        m->req  = req;
6503        if ((req == BFI_DPORT_ENABLE) || (req == BFI_DPORT_START)) {
6504                m->lpcnt = cpu_to_be32(dport->lpcnt);
6505                m->payload = cpu_to_be32(dport->payload);
6506        }
6507
6508        /*
6509         * queue I/O message to firmware
6510         */
6511        bfa_reqq_produce(dport->bfa, BFA_REQQ_DIAG, m->mh);
6512
6513        return BFA_TRUE;
6514}
6515
6516static void
6517bfa_dport_qresume(void *cbarg)
6518{
6519        struct bfa_dport_s *dport = cbarg;
6520
6521        bfa_sm_send_event(dport, BFA_DPORT_SM_QRESUME);
6522}
6523
6524static void
6525bfa_dport_req_comp(struct bfa_dport_s *dport, struct bfi_diag_dport_rsp_s *msg)
6526{
6527        msg->status = cpu_to_be32(msg->status);
6528        dport->i2hmsg.rsp.status = msg->status;
6529        dport->rp_pwwn = msg->pwwn;
6530        dport->rp_nwwn = msg->nwwn;
6531
6532        if ((msg->status == BFA_STATUS_OK) ||
6533            (msg->status == BFA_STATUS_DPORT_NO_SFP)) {
6534                bfa_trc(dport->bfa, msg->status);
6535                bfa_trc(dport->bfa, dport->rp_pwwn);
6536                bfa_trc(dport->bfa, dport->rp_nwwn);
6537                bfa_sm_send_event(dport, BFA_DPORT_SM_FWRSP);
6538
6539        } else {
6540                bfa_trc(dport->bfa, msg->status);
6541                bfa_sm_send_event(dport, BFA_DPORT_SM_REQFAIL);
6542        }
6543        bfa_cb_fcdiag_dport(dport, msg->status);
6544}
6545
6546static bfa_boolean_t
6547bfa_dport_is_sending_req(struct bfa_dport_s *dport)
6548{
6549        if (bfa_sm_cmp_state(dport, bfa_dport_sm_enabling)      ||
6550            bfa_sm_cmp_state(dport, bfa_dport_sm_enabling_qwait) ||
6551            bfa_sm_cmp_state(dport, bfa_dport_sm_disabling)     ||
6552            bfa_sm_cmp_state(dport, bfa_dport_sm_disabling_qwait) ||
6553            bfa_sm_cmp_state(dport, bfa_dport_sm_starting)      ||
6554            bfa_sm_cmp_state(dport, bfa_dport_sm_starting_qwait)) {
6555                return BFA_TRUE;
6556        } else {
6557                return BFA_FALSE;
6558        }
6559}
6560
6561static void
6562bfa_dport_scn(struct bfa_dport_s *dport, struct bfi_diag_dport_scn_s *msg)
6563{
6564        int i;
6565        uint8_t subtesttype;
6566
6567        bfa_trc(dport->bfa, msg->state);
6568        dport->i2hmsg.scn.state = msg->state;
6569
6570        switch (dport->i2hmsg.scn.state) {
6571        case BFI_DPORT_SCN_TESTCOMP:
6572                dport->result.end_time = ktime_get_real_seconds();
6573                bfa_trc(dport->bfa, dport->result.end_time);
6574
6575                dport->result.status = msg->info.testcomp.status;
6576                bfa_trc(dport->bfa, dport->result.status);
6577
6578                dport->result.roundtrip_latency =
6579                        cpu_to_be32(msg->info.testcomp.latency);
6580                dport->result.est_cable_distance =
6581                        cpu_to_be32(msg->info.testcomp.distance);
6582                dport->result.buffer_required =
6583                        be16_to_cpu(msg->info.testcomp.numbuffer);
6584
6585                dport->result.frmsz = be16_to_cpu(msg->info.testcomp.frm_sz);
6586                dport->result.speed = msg->info.testcomp.speed;
6587
6588                bfa_trc(dport->bfa, dport->result.roundtrip_latency);
6589                bfa_trc(dport->bfa, dport->result.est_cable_distance);
6590                bfa_trc(dport->bfa, dport->result.buffer_required);
6591                bfa_trc(dport->bfa, dport->result.frmsz);
6592                bfa_trc(dport->bfa, dport->result.speed);
6593
6594                for (i = DPORT_TEST_ELOOP; i < DPORT_TEST_MAX; i++) {
6595                        dport->result.subtest[i].status =
6596                                msg->info.testcomp.subtest_status[i];
6597                        bfa_trc(dport->bfa, dport->result.subtest[i].status);
6598                }
6599                break;
6600
6601        case BFI_DPORT_SCN_TESTSKIP:
6602        case BFI_DPORT_SCN_DDPORT_ENABLE:
6603                memset(&dport->result, 0,
6604                                sizeof(struct bfa_diag_dport_result_s));
6605                break;
6606
6607        case BFI_DPORT_SCN_TESTSTART:
6608                memset(&dport->result, 0,
6609                                sizeof(struct bfa_diag_dport_result_s));
6610                dport->rp_pwwn = msg->info.teststart.pwwn;
6611                dport->rp_nwwn = msg->info.teststart.nwwn;
6612                dport->lpcnt = cpu_to_be32(msg->info.teststart.numfrm);
6613                bfa_dport_result_start(dport, msg->info.teststart.mode);
6614                break;
6615
6616        case BFI_DPORT_SCN_SUBTESTSTART:
6617                subtesttype = msg->info.teststart.type;
6618                dport->result.subtest[subtesttype].start_time =
6619                        ktime_get_real_seconds();
6620                dport->result.subtest[subtesttype].status =
6621                        DPORT_TEST_ST_INPRG;
6622
6623                bfa_trc(dport->bfa, subtesttype);
6624                bfa_trc(dport->bfa,
6625                        dport->result.subtest[subtesttype].start_time);
6626                break;
6627
6628        case BFI_DPORT_SCN_SFP_REMOVED:
6629        case BFI_DPORT_SCN_DDPORT_DISABLED:
6630        case BFI_DPORT_SCN_DDPORT_DISABLE:
6631        case BFI_DPORT_SCN_FCPORT_DISABLE:
6632                dport->result.status = DPORT_TEST_ST_IDLE;
6633                break;
6634
6635        default:
6636                bfa_sm_fault(dport->bfa, msg->state);
6637        }
6638
6639        bfa_sm_send_event(dport, BFA_DPORT_SM_SCN);
6640}
6641
6642/*
6643 * Dport enable
6644 *
6645 * @param[in] *bfa            - bfa data struct
6646 */
6647bfa_status_t
6648bfa_dport_enable(struct bfa_s *bfa, u32 lpcnt, u32 pat,
6649                                bfa_cb_diag_t cbfn, void *cbarg)
6650{
6651        struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6652        struct bfa_dport_s  *dport = &fcdiag->dport;
6653
6654        /*
6655         * Dport is not support in MEZZ card
6656         */
6657        if (bfa_mfg_is_mezz(dport->bfa->ioc.attr->card_type)) {
6658                bfa_trc(dport->bfa, BFA_STATUS_PBC);
6659                return BFA_STATUS_CMD_NOTSUPP_MEZZ;
6660        }
6661
6662        /*
6663         * Dport is supported in CT2 or above
6664         */
6665        if (!(bfa_asic_id_ct2(dport->bfa->ioc.pcidev.device_id))) {
6666                bfa_trc(dport->bfa, dport->bfa->ioc.pcidev.device_id);
6667                return BFA_STATUS_FEATURE_NOT_SUPPORTED;
6668        }
6669
6670        /*
6671         * Check to see if IOC is down
6672        */
6673        if (!bfa_iocfc_is_operational(bfa))
6674                return BFA_STATUS_IOC_NON_OP;
6675
6676        /* if port is PBC disabled, return error */
6677        if (bfa_fcport_is_pbcdisabled(bfa)) {
6678                bfa_trc(dport->bfa, BFA_STATUS_PBC);
6679                return BFA_STATUS_PBC;
6680        }
6681
6682        /*
6683         * Check if port mode is FC port
6684         */
6685        if (bfa_ioc_get_type(&bfa->ioc) != BFA_IOC_TYPE_FC) {
6686                bfa_trc(dport->bfa, bfa_ioc_get_type(&bfa->ioc));
6687                return BFA_STATUS_CMD_NOTSUPP_CNA;
6688        }
6689
6690        /*
6691         * Check if port is in LOOP mode
6692         */
6693        if ((bfa_fcport_get_cfg_topology(bfa) == BFA_PORT_TOPOLOGY_LOOP) ||
6694            (bfa_fcport_get_topology(bfa) == BFA_PORT_TOPOLOGY_LOOP)) {
6695                bfa_trc(dport->bfa, 0);
6696                return BFA_STATUS_TOPOLOGY_LOOP;
6697        }
6698
6699        /*
6700         * Check if port is TRUNK mode
6701         */
6702        if (bfa_fcport_is_trunk_enabled(bfa)) {
6703                bfa_trc(dport->bfa, 0);
6704                return BFA_STATUS_ERROR_TRUNK_ENABLED;
6705        }
6706
6707        /*
6708         * Check if diag loopback is running
6709         */
6710        if (bfa_fcdiag_lb_is_running(bfa)) {
6711                bfa_trc(dport->bfa, 0);
6712                return BFA_STATUS_DIAG_BUSY;
6713        }
6714
6715        /*
6716         * Check to see if port is disable or in dport state
6717         */
6718        if ((bfa_fcport_is_disabled(bfa) == BFA_FALSE) &&
6719            (bfa_fcport_is_dport(bfa) == BFA_FALSE)) {
6720                bfa_trc(dport->bfa, 0);
6721                return BFA_STATUS_PORT_NOT_DISABLED;
6722        }
6723
6724        /*
6725         * Check if dport is in dynamic mode
6726         */
6727        if (dport->dynamic)
6728                return BFA_STATUS_DDPORT_ERR;
6729
6730        /*
6731         * Check if dport is busy
6732         */
6733        if (bfa_dport_is_sending_req(dport))
6734                return BFA_STATUS_DEVBUSY;
6735
6736        /*
6737         * Check if dport is already enabled
6738         */
6739        if (bfa_sm_cmp_state(dport, bfa_dport_sm_enabled)) {
6740                bfa_trc(dport->bfa, 0);
6741                return BFA_STATUS_DPORT_ENABLED;
6742        }
6743
6744        bfa_trc(dport->bfa, lpcnt);
6745        bfa_trc(dport->bfa, pat);
6746        dport->lpcnt = (lpcnt) ? lpcnt : DPORT_ENABLE_LOOPCNT_DEFAULT;
6747        dport->payload = (pat) ? pat : LB_PATTERN_DEFAULT;
6748        dport->cbfn = cbfn;
6749        dport->cbarg = cbarg;
6750
6751        bfa_sm_send_event(dport, BFA_DPORT_SM_ENABLE);
6752        return BFA_STATUS_OK;
6753}
6754
6755/*
6756 *      Dport disable
6757 *
6758 *      @param[in] *bfa            - bfa data struct
6759 */
6760bfa_status_t
6761bfa_dport_disable(struct bfa_s *bfa, bfa_cb_diag_t cbfn, void *cbarg)
6762{
6763        struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6764        struct bfa_dport_s *dport = &fcdiag->dport;
6765
6766        if (bfa_ioc_is_disabled(&bfa->ioc))
6767                return BFA_STATUS_IOC_DISABLED;
6768
6769        /* if port is PBC disabled, return error */
6770        if (bfa_fcport_is_pbcdisabled(bfa)) {
6771                bfa_trc(dport->bfa, BFA_STATUS_PBC);
6772                return BFA_STATUS_PBC;
6773        }
6774
6775        /*
6776         * Check if dport is in dynamic mode
6777         */
6778        if (dport->dynamic) {
6779                return BFA_STATUS_DDPORT_ERR;
6780        }
6781
6782        /*
6783         * Check to see if port is disable or in dport state
6784         */
6785        if ((bfa_fcport_is_disabled(bfa) == BFA_FALSE) &&
6786            (bfa_fcport_is_dport(bfa) == BFA_FALSE)) {
6787                bfa_trc(dport->bfa, 0);
6788                return BFA_STATUS_PORT_NOT_DISABLED;
6789        }
6790
6791        /*
6792         * Check if dport is busy
6793         */
6794        if (bfa_dport_is_sending_req(dport))
6795                return BFA_STATUS_DEVBUSY;
6796
6797        /*
6798         * Check if dport is already disabled
6799         */
6800        if (bfa_sm_cmp_state(dport, bfa_dport_sm_disabled)) {
6801                bfa_trc(dport->bfa, 0);
6802                return BFA_STATUS_DPORT_DISABLED;
6803        }
6804
6805        dport->cbfn = cbfn;
6806        dport->cbarg = cbarg;
6807
6808        bfa_sm_send_event(dport, BFA_DPORT_SM_DISABLE);
6809        return BFA_STATUS_OK;
6810}
6811
6812/*
6813 * Dport start -- restart dport test
6814 *
6815 *   @param[in] *bfa            - bfa data struct
6816 */
6817bfa_status_t
6818bfa_dport_start(struct bfa_s *bfa, u32 lpcnt, u32 pat,
6819                        bfa_cb_diag_t cbfn, void *cbarg)
6820{
6821        struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6822        struct bfa_dport_s *dport = &fcdiag->dport;
6823
6824        /*
6825         * Check to see if IOC is down
6826         */
6827        if (!bfa_iocfc_is_operational(bfa))
6828                return BFA_STATUS_IOC_NON_OP;
6829
6830        /*
6831         * Check if dport is in dynamic mode
6832         */
6833        if (dport->dynamic)
6834                return BFA_STATUS_DDPORT_ERR;
6835
6836        /*
6837         * Check if dport is busy
6838         */
6839        if (bfa_dport_is_sending_req(dport))
6840                return BFA_STATUS_DEVBUSY;
6841
6842        /*
6843         * Check if dport is in enabled state.
6844         * Test can only be restart when previous test has completed
6845         */
6846        if (!bfa_sm_cmp_state(dport, bfa_dport_sm_enabled)) {
6847                bfa_trc(dport->bfa, 0);
6848                return BFA_STATUS_DPORT_DISABLED;
6849
6850        } else {
6851                if (dport->test_state == BFA_DPORT_ST_NO_SFP)
6852                        return BFA_STATUS_DPORT_INV_SFP;
6853
6854                if (dport->test_state == BFA_DPORT_ST_INP)
6855                        return BFA_STATUS_DEVBUSY;
6856
6857                WARN_ON(dport->test_state != BFA_DPORT_ST_COMP);
6858        }
6859
6860        bfa_trc(dport->bfa, lpcnt);
6861        bfa_trc(dport->bfa, pat);
6862
6863        dport->lpcnt = (lpcnt) ? lpcnt : DPORT_ENABLE_LOOPCNT_DEFAULT;
6864        dport->payload = (pat) ? pat : LB_PATTERN_DEFAULT;
6865
6866        dport->cbfn = cbfn;
6867        dport->cbarg = cbarg;
6868
6869        bfa_sm_send_event(dport, BFA_DPORT_SM_START);
6870        return BFA_STATUS_OK;
6871}
6872
6873/*
6874 * Dport show -- return dport test result
6875 *
6876 *   @param[in] *bfa            - bfa data struct
6877 */
6878bfa_status_t
6879bfa_dport_show(struct bfa_s *bfa, struct bfa_diag_dport_result_s *result)
6880{
6881        struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6882        struct bfa_dport_s *dport = &fcdiag->dport;
6883
6884        /*
6885         * Check to see if IOC is down
6886         */
6887        if (!bfa_iocfc_is_operational(bfa))
6888                return BFA_STATUS_IOC_NON_OP;
6889
6890        /*
6891         * Check if dport is busy
6892         */
6893        if (bfa_dport_is_sending_req(dport))
6894                return BFA_STATUS_DEVBUSY;
6895
6896        /*
6897         * Check if dport is in enabled state.
6898         */
6899        if (!bfa_sm_cmp_state(dport, bfa_dport_sm_enabled)) {
6900                bfa_trc(dport->bfa, 0);
6901                return BFA_STATUS_DPORT_DISABLED;
6902
6903        }
6904
6905        /*
6906         * Check if there is SFP
6907         */
6908        if (dport->test_state == BFA_DPORT_ST_NO_SFP)
6909                return BFA_STATUS_DPORT_INV_SFP;
6910
6911        memcpy(result, &dport->result, sizeof(struct bfa_diag_dport_result_s));
6912
6913        return BFA_STATUS_OK;
6914}
6915