kernel/drivers/scsi/bfa/bfa_svc.c

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