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 "bfa_plog.h"
  20 #include "bfa_cs.h"
  21 #include "bfa_modules.h"
  22
  23 BFA_TRC_FILE(HAL, FCXP);
  24 BFA_MODULE(fcxp);
  25 BFA_MODULE(sgpg);
  26 BFA_MODULE(lps);
  27 BFA_MODULE(fcport);
  28 BFA_MODULE(rport);
  29 BFA_MODULE(uf);
  30
  31 /*
  32  * LPS related definitions
  33  */
  34 #define BFA_LPS_MIN_LPORTS      (1)
  35 #define BFA_LPS_MAX_LPORTS      (256)
  36
  37 /*
  38  * Maximum Vports supported per physical port or vf.
  39  */
  40 #define BFA_LPS_MAX_VPORTS_SUPP_CB  255
  41 #define BFA_LPS_MAX_VPORTS_SUPP_CT  190
  42
  43
  44 /*
  45  * FC PORT related definitions
  46  */
  47 /*
  48  * The port is considered disabled if corresponding physical port or IOC are
  49  * disabled explicitly
  50  */
  51 #define BFA_PORT_IS_DISABLED(bfa) \
  52         ((bfa_fcport_is_disabled(bfa) == BFA_TRUE) || \
  53         (bfa_ioc_is_disabled(&bfa->ioc) == BFA_TRUE))
  54
  55 /*
  56  * BFA port state machine events
  57  */
  58 enum bfa_fcport_sm_event {
  59         BFA_FCPORT_SM_START     = 1,    /*  start port state machine    */
  60         BFA_FCPORT_SM_STOP      = 2,    /*  stop port state machine     */
  61         BFA_FCPORT_SM_ENABLE    = 3,    /*  enable port         */
  62         BFA_FCPORT_SM_DISABLE   = 4,    /*  disable port state machine */
  63         BFA_FCPORT_SM_FWRSP     = 5,    /*  firmware enable/disable rsp */
  64         BFA_FCPORT_SM_LINKUP    = 6,    /*  firmware linkup event       */
  65         BFA_FCPORT_SM_LINKDOWN  = 7,    /*  firmware linkup down        */
  66         BFA_FCPORT_SM_QRESUME   = 8,    /*  CQ space available  */
  67         BFA_FCPORT_SM_HWFAIL    = 9,    /*  IOC h/w failure             */
  68 };
  69
  70 /*
  71  * BFA port link notification state machine events
  72  */
  73
  74 enum bfa_fcport_ln_sm_event {
  75         BFA_FCPORT_LN_SM_LINKUP         = 1,    /*  linkup event        */
  76         BFA_FCPORT_LN_SM_LINKDOWN       = 2,    /*  linkdown event      */
  77         BFA_FCPORT_LN_SM_NOTIFICATION   = 3     /*  done notification   */
  78 };
  79
  80 /*
  81  * RPORT related definitions
  82  */
  83 #define bfa_rport_offline_cb(__rp) do {                                 \
  84         if ((__rp)->bfa->fcs)                                           \
  85                 bfa_cb_rport_offline((__rp)->rport_drv);      \
  86         else {                                                          \
  87                 bfa_cb_queue((__rp)->bfa, &(__rp)->hcb_qe,              \
  88                                 __bfa_cb_rport_offline, (__rp));      \
  89         }                                                               \
  90 } while (0)
  91
  92 #define bfa_rport_online_cb(__rp) do {                                  \
  93         if ((__rp)->bfa->fcs)                                           \
  94                 bfa_cb_rport_online((__rp)->rport_drv);      \
  95         else {                                                          \
  96                 bfa_cb_queue((__rp)->bfa, &(__rp)->hcb_qe,              \
  97                                   __bfa_cb_rport_online, (__rp));      \
  98                 }                                                       \
  99 } while (0)
 100
 101 /*
 102  * forward declarations FCXP related functions
 103  */
 104 static void     __bfa_fcxp_send_cbfn(void *cbarg, bfa_boolean_t complete);
 105 static void     hal_fcxp_rx_plog(struct bfa_s *bfa, struct bfa_fcxp_s *fcxp,
 106                                 struct bfi_fcxp_send_rsp_s *fcxp_rsp);
 107 static void     hal_fcxp_tx_plog(struct bfa_s *bfa, u32 reqlen,
 108                                 struct bfa_fcxp_s *fcxp, struct fchs_s *fchs);
 109 static void     bfa_fcxp_qresume(void *cbarg);
 110 static void     bfa_fcxp_queue(struct bfa_fcxp_s *fcxp,
 111                                 struct bfi_fcxp_send_req_s *send_req);
 112
 113 /*
 114  * forward declarations for LPS functions
 115  */
 116 static void bfa_lps_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
 117                                 u32 *dm_len);
 118 static void bfa_lps_attach(struct bfa_s *bfa, void *bfad,
 119                                 struct bfa_iocfc_cfg_s *cfg,
 120                                 struct bfa_meminfo_s *meminfo,
 121                                 struct bfa_pcidev_s *pcidev);
 122 static void bfa_lps_detach(struct bfa_s *bfa);
 123 static void bfa_lps_start(struct bfa_s *bfa);
 124 static void bfa_lps_stop(struct bfa_s *bfa);
 125 static void bfa_lps_iocdisable(struct bfa_s *bfa);
 126 static void bfa_lps_login_rsp(struct bfa_s *bfa,
 127                                 struct bfi_lps_login_rsp_s *rsp);
 128 static void bfa_lps_logout_rsp(struct bfa_s *bfa,
 129                                 struct bfi_lps_logout_rsp_s *rsp);
 130 static void bfa_lps_reqq_resume(void *lps_arg);
 131 static void bfa_lps_free(struct bfa_lps_s *lps);
 132 static void bfa_lps_send_login(struct bfa_lps_s *lps);
 133 static void bfa_lps_send_logout(struct bfa_lps_s *lps);
 134 static void bfa_lps_send_set_n2n_pid(struct bfa_lps_s *lps);
 135 static void bfa_lps_login_comp(struct bfa_lps_s *lps);
 136 static void bfa_lps_logout_comp(struct bfa_lps_s *lps);
 137 static void bfa_lps_cvl_event(struct bfa_lps_s *lps);
 138
 139 /*
 140  * forward declaration for LPS state machine
 141  */
 142 static void bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event);
 143 static void bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event);
 144 static void bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event
 145                                         event);
 146 static void bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event);
 147 static void bfa_lps_sm_online_n2n_pid_wait(struct bfa_lps_s *lps,
 148                                         enum bfa_lps_event event);
 149 static void bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event);
 150 static void bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event
 151                                         event);
 152
 153 /*
 154  * forward declaration for FC Port functions
 155  */
 156 static bfa_boolean_t bfa_fcport_send_enable(struct bfa_fcport_s *fcport);
 157 static bfa_boolean_t bfa_fcport_send_disable(struct bfa_fcport_s *fcport);
 158 static void bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport);
 159 static void bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport);
 160 static void bfa_fcport_set_wwns(struct bfa_fcport_s *fcport);
 161 static void __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete);
 162 static void bfa_fcport_scn(struct bfa_fcport_s *fcport,
 163                         enum bfa_port_linkstate event, bfa_boolean_t trunk);
 164 static void bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln,
 165                                 enum bfa_port_linkstate event);
 166 static void __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete);
 167 static void bfa_fcport_stats_get_timeout(void *cbarg);
 168 static void bfa_fcport_stats_clr_timeout(void *cbarg);
 169 static void bfa_trunk_iocdisable(struct bfa_s *bfa);
 170
 171 /*
 172  * forward declaration for FC PORT state machine
 173  */
 174 static void     bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
 175                                         enum bfa_fcport_sm_event event);
 176 static void     bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
 177                                         enum bfa_fcport_sm_event event);
 178 static void     bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
 179                                         enum bfa_fcport_sm_event event);
 180 static void     bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
 181                                         enum bfa_fcport_sm_event event);
 182 static void     bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
 183                                         enum bfa_fcport_sm_event event);
 184 static void     bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
 185                                         enum bfa_fcport_sm_event event);
 186 static void     bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
 187                                         enum bfa_fcport_sm_event event);
 188 static void     bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s *fcport,
 189                                         enum bfa_fcport_sm_event event);
 190 static void     bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
 191                                         enum bfa_fcport_sm_event event);
 192 static void     bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
 193                                         enum bfa_fcport_sm_event event);
 194 static void     bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
 195                                         enum bfa_fcport_sm_event event);
 196 static void     bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
 197                                         enum bfa_fcport_sm_event event);
 198
 199 static void     bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
 200                                         enum bfa_fcport_ln_sm_event event);
 201 static void     bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
 202                                         enum bfa_fcport_ln_sm_event event);
 203 static void     bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
 204                                         enum bfa_fcport_ln_sm_event event);
 205 static void     bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
 206                                         enum bfa_fcport_ln_sm_event event);
 207 static void     bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
 208                                         enum bfa_fcport_ln_sm_event event);
 209 static void     bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
 210                                         enum bfa_fcport_ln_sm_event event);
 211 static void     bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
 212                                         enum bfa_fcport_ln_sm_event event);
 213
 214 static struct bfa_sm_table_s hal_port_sm_table[] = {
 215         {BFA_SM(bfa_fcport_sm_uninit), BFA_PORT_ST_UNINIT},
 216         {BFA_SM(bfa_fcport_sm_enabling_qwait), BFA_PORT_ST_ENABLING_QWAIT},
 217         {BFA_SM(bfa_fcport_sm_enabling), BFA_PORT_ST_ENABLING},
 218         {BFA_SM(bfa_fcport_sm_linkdown), BFA_PORT_ST_LINKDOWN},
 219         {BFA_SM(bfa_fcport_sm_linkup), BFA_PORT_ST_LINKUP},
 220         {BFA_SM(bfa_fcport_sm_disabling_qwait), BFA_PORT_ST_DISABLING_QWAIT},
 221         {BFA_SM(bfa_fcport_sm_toggling_qwait), BFA_PORT_ST_TOGGLING_QWAIT},
 222         {BFA_SM(bfa_fcport_sm_disabling), BFA_PORT_ST_DISABLING},
 223         {BFA_SM(bfa_fcport_sm_disabled), BFA_PORT_ST_DISABLED},
 224         {BFA_SM(bfa_fcport_sm_stopped), BFA_PORT_ST_STOPPED},
 225         {BFA_SM(bfa_fcport_sm_iocdown), BFA_PORT_ST_IOCDOWN},
 226         {BFA_SM(bfa_fcport_sm_iocfail), BFA_PORT_ST_IOCDOWN},
 227 };
 228
 229
 230 /*
 231  * forward declaration for RPORT related functions
 232  */
 233 static struct bfa_rport_s *bfa_rport_alloc(struct bfa_rport_mod_s *rp_mod);
 234 static void             bfa_rport_free(struct bfa_rport_s *rport);
 235 static bfa_boolean_t    bfa_rport_send_fwcreate(struct bfa_rport_s *rp);
 236 static bfa_boolean_t    bfa_rport_send_fwdelete(struct bfa_rport_s *rp);
 237 static bfa_boolean_t    bfa_rport_send_fwspeed(struct bfa_rport_s *rp);
 238 static void             __bfa_cb_rport_online(void *cbarg,
 239                                                 bfa_boolean_t complete);
 240 static void             __bfa_cb_rport_offline(void *cbarg,
 241                                                 bfa_boolean_t complete);
 242
 243 /*
 244  * forward declaration for RPORT state machine
 245  */
 246 static void     bfa_rport_sm_uninit(struct bfa_rport_s *rp,
 247                                         enum bfa_rport_event event);
 248 static void     bfa_rport_sm_created(struct bfa_rport_s *rp,
 249                                         enum bfa_rport_event event);
 250 static void     bfa_rport_sm_fwcreate(struct bfa_rport_s *rp,
 251                                         enum bfa_rport_event event);
 252 static void     bfa_rport_sm_online(struct bfa_rport_s *rp,
 253                                         enum bfa_rport_event event);
 254 static void     bfa_rport_sm_fwdelete(struct bfa_rport_s *rp,
 255                                         enum bfa_rport_event event);
 256 static void     bfa_rport_sm_offline(struct bfa_rport_s *rp,
 257                                         enum bfa_rport_event event);
 258 static void     bfa_rport_sm_deleting(struct bfa_rport_s *rp,
 259                                         enum bfa_rport_event event);
 260 static void     bfa_rport_sm_offline_pending(struct bfa_rport_s *rp,
 261                                         enum bfa_rport_event event);
 262 static void     bfa_rport_sm_delete_pending(struct bfa_rport_s *rp,
 263                                         enum bfa_rport_event event);
 264 static void     bfa_rport_sm_iocdisable(struct bfa_rport_s *rp,
 265                                         enum bfa_rport_event event);
 266 static void     bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s *rp,
 267                                         enum bfa_rport_event event);
 268 static void     bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s *rp,
 269                                         enum bfa_rport_event event);
 270 static void     bfa_rport_sm_deleting_qfull(struct bfa_rport_s *rp,
 271                                         enum bfa_rport_event event);
 272
 273 /*
 274  * PLOG related definitions
 275  */
 276 static int
 277 plkd_validate_logrec(struct bfa_plog_rec_s *pl_rec)
 278 {
 279         if ((pl_rec->log_type != BFA_PL_LOG_TYPE_INT) &&
 280                 (pl_rec->log_type != BFA_PL_LOG_TYPE_STRING))
 281                 return 1;
 282
 283         if ((pl_rec->log_type != BFA_PL_LOG_TYPE_INT) &&
 284                 (pl_rec->log_num_ints > BFA_PL_INT_LOG_SZ))
 285                 return 1;
 286
 287         return 0;
 288 }
 289
 290 static u64
 291 bfa_get_log_time(void)
 292 {
 293         u64 system_time = 0;
 294         struct timeval tv;
 295         do_gettimeofday(&tv);
 296
 297         /* We are interested in seconds only. */
 298         system_time = tv.tv_sec;
 299         return system_time;
 300 }
 301
 302 static void
 303 bfa_plog_add(struct bfa_plog_s *plog, struct bfa_plog_rec_s *pl_rec)
 304 {
 305         u16 tail;
 306         struct bfa_plog_rec_s *pl_recp;
 307
 308         if (plog->plog_enabled == 0)
 309                 return;
 310
 311         if (plkd_validate_logrec(pl_rec)) {
 312                 WARN_ON(1);
 313                 return;
 314         }
 315
 316         tail = plog->tail;
 317
 318         pl_recp = &(plog->plog_recs[tail]);
 319
 320         memcpy(pl_recp, pl_rec, sizeof(struct bfa_plog_rec_s));
 321
 322         pl_recp->tv = bfa_get_log_time();
 323         BFA_PL_LOG_REC_INCR(plog->tail);
 324
 325         if (plog->head == plog->tail)
 326                 BFA_PL_LOG_REC_INCR(plog->head);
 327 }
 328
 329 void
 330 bfa_plog_init(struct bfa_plog_s *plog)
 331 {
 332         memset((char *)plog, 0, sizeof(struct bfa_plog_s));
 333
 334         memcpy(plog->plog_sig, BFA_PL_SIG_STR, BFA_PL_SIG_LEN);
 335         plog->head = plog->tail = 0;
 336         plog->plog_enabled = 1;
 337 }
 338
 339 void
 340 bfa_plog_str(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
 341                 enum bfa_plog_eid event,
 342                 u16 misc, char *log_str)
 343 {
 344         struct bfa_plog_rec_s  lp;
 345
 346         if (plog->plog_enabled) {
 347                 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
 348                 lp.mid = mid;
 349                 lp.eid = event;
 350                 lp.log_type = BFA_PL_LOG_TYPE_STRING;
 351                 lp.misc = misc;
 352                 strncpy(lp.log_entry.string_log, log_str,
 353                         BFA_PL_STRING_LOG_SZ - 1);
 354                 lp.log_entry.string_log[BFA_PL_STRING_LOG_SZ - 1] = '\0';
 355                 bfa_plog_add(plog, &lp);
 356         }
 357 }
 358
 359 void
 360 bfa_plog_intarr(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
 361                 enum bfa_plog_eid event,
 362                 u16 misc, u32 *intarr, u32 num_ints)
 363 {
 364         struct bfa_plog_rec_s  lp;
 365         u32 i;
 366
 367         if (num_ints > BFA_PL_INT_LOG_SZ)
 368                 num_ints = BFA_PL_INT_LOG_SZ;
 369
 370         if (plog->plog_enabled) {
 371                 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
 372                 lp.mid = mid;
 373                 lp.eid = event;
 374                 lp.log_type = BFA_PL_LOG_TYPE_INT;
 375                 lp.misc = misc;
 376
 377                 for (i = 0; i < num_ints; i++)
 378                         lp.log_entry.int_log[i] = intarr[i];
 379
 380                 lp.log_num_ints = (u8) num_ints;
 381
 382                 bfa_plog_add(plog, &lp);
 383         }
 384 }
 385
 386 void
 387 bfa_plog_fchdr(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
 388                         enum bfa_plog_eid event,
 389                         u16 misc, struct fchs_s *fchdr)
 390 {
 391         struct bfa_plog_rec_s  lp;
 392         u32     *tmp_int = (u32 *) fchdr;
 393         u32     ints[BFA_PL_INT_LOG_SZ];
 394
 395         if (plog->plog_enabled) {
 396                 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
 397
 398                 ints[0] = tmp_int[0];
 399                 ints[1] = tmp_int[1];
 400                 ints[2] = tmp_int[4];
 401
 402                 bfa_plog_intarr(plog, mid, event, misc, ints, 3);
 403         }
 404 }
 405
 406 void
 407 bfa_plog_fchdr_and_pl(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
 408                       enum bfa_plog_eid event, u16 misc, struct fchs_s *fchdr,
 409                       u32 pld_w0)
 410 {
 411         struct bfa_plog_rec_s  lp;
 412         u32     *tmp_int = (u32 *) fchdr;
 413         u32     ints[BFA_PL_INT_LOG_SZ];
 414
 415         if (plog->plog_enabled) {
 416                 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
 417
 418                 ints[0] = tmp_int[0];
 419                 ints[1] = tmp_int[1];
 420                 ints[2] = tmp_int[4];
 421                 ints[3] = pld_w0;
 422
 423                 bfa_plog_intarr(plog, mid, event, misc, ints, 4);
 424         }
 425 }
 426
 427
 428 /*
 429  *  fcxp_pvt BFA FCXP private functions
 430  */
 431
 432 static void
 433 claim_fcxp_req_rsp_mem(struct bfa_fcxp_mod_s *mod, struct bfa_meminfo_s *mi)
 434 {
 435         u8             *dm_kva = NULL;
 436         u64     dm_pa;
 437         u32     buf_pool_sz;
 438
 439         dm_kva = bfa_meminfo_dma_virt(mi);
 440         dm_pa = bfa_meminfo_dma_phys(mi);
 441
 442         buf_pool_sz = mod->req_pld_sz * mod->num_fcxps;
 443
 444         /*
 445          * Initialize the fcxp req payload list
 446          */
 447         mod->req_pld_list_kva = dm_kva;
 448         mod->req_pld_list_pa = dm_pa;
 449         dm_kva += buf_pool_sz;
 450         dm_pa += buf_pool_sz;
 451         memset(mod->req_pld_list_kva, 0, buf_pool_sz);
 452
 453         /*
 454          * Initialize the fcxp rsp payload list
 455          */
 456         buf_pool_sz = mod->rsp_pld_sz * mod->num_fcxps;
 457         mod->rsp_pld_list_kva = dm_kva;
 458         mod->rsp_pld_list_pa = dm_pa;
 459         dm_kva += buf_pool_sz;
 460         dm_pa += buf_pool_sz;
 461         memset(mod->rsp_pld_list_kva, 0, buf_pool_sz);
 462
 463         bfa_meminfo_dma_virt(mi) = dm_kva;
 464         bfa_meminfo_dma_phys(mi) = dm_pa;
 465 }
 466
 467 static void
 468 claim_fcxps_mem(struct bfa_fcxp_mod_s *mod, struct bfa_meminfo_s *mi)
 469 {
 470         u16     i;
 471         struct bfa_fcxp_s *fcxp;
 472
 473         fcxp = (struct bfa_fcxp_s *) bfa_meminfo_kva(mi);
 474         memset(fcxp, 0, sizeof(struct bfa_fcxp_s) * mod->num_fcxps);
 475
 476         INIT_LIST_HEAD(&mod->fcxp_free_q);
 477         INIT_LIST_HEAD(&mod->fcxp_active_q);
 478
 479         mod->fcxp_list = fcxp;
 480
 481         for (i = 0; i < mod->num_fcxps; i++) {
 482                 fcxp->fcxp_mod = mod;
 483                 fcxp->fcxp_tag = i;
 484
 485                 list_add_tail(&fcxp->qe, &mod->fcxp_free_q);
 486                 bfa_reqq_winit(&fcxp->reqq_wqe, bfa_fcxp_qresume, fcxp);
 487                 fcxp->reqq_waiting = BFA_FALSE;
 488
 489                 fcxp = fcxp + 1;
 490         }
 491
 492         bfa_meminfo_kva(mi) = (void *)fcxp;
 493 }
 494
 495 static void
 496 bfa_fcxp_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
 497                  u32 *dm_len)
 498 {
 499         u16     num_fcxp_reqs = cfg->fwcfg.num_fcxp_reqs;
 500
 501         if (num_fcxp_reqs == 0)
 502                 return;
 503
 504         /*
 505          * Account for req/rsp payload
 506          */
 507         *dm_len += BFA_FCXP_MAX_IBUF_SZ * num_fcxp_reqs;
 508         if (cfg->drvcfg.min_cfg)
 509                 *dm_len += BFA_FCXP_MAX_IBUF_SZ * num_fcxp_reqs;
 510         else
 511                 *dm_len += BFA_FCXP_MAX_LBUF_SZ * num_fcxp_reqs;
 512
 513         /*
 514          * Account for fcxp structs
 515          */
 516         *ndm_len += sizeof(struct bfa_fcxp_s) * num_fcxp_reqs;
 517 }
 518
 519 static void
 520 bfa_fcxp_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
 521                 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
 522 {
 523         struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
 524
 525         memset(mod, 0, sizeof(struct bfa_fcxp_mod_s));
 526         mod->bfa = bfa;
 527         mod->num_fcxps = cfg->fwcfg.num_fcxp_reqs;
 528
 529         /*
 530          * Initialize FCXP request and response payload sizes.
 531          */
 532         mod->req_pld_sz = mod->rsp_pld_sz = BFA_FCXP_MAX_IBUF_SZ;
 533         if (!cfg->drvcfg.min_cfg)
 534                 mod->rsp_pld_sz = BFA_FCXP_MAX_LBUF_SZ;
 535
 536         INIT_LIST_HEAD(&mod->wait_q);
 537
 538         claim_fcxp_req_rsp_mem(mod, meminfo);
 539         claim_fcxps_mem(mod, meminfo);
 540 }
 541
 542 static void
 543 bfa_fcxp_detach(struct bfa_s *bfa)
 544 {
 545 }
 546
 547 static void
 548 bfa_fcxp_start(struct bfa_s *bfa)
 549 {
 550 }
 551
 552 static void
 553 bfa_fcxp_stop(struct bfa_s *bfa)
 554 {
 555 }
 556
 557 static void
 558 bfa_fcxp_iocdisable(struct bfa_s *bfa)
 559 {
 560         struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
 561         struct bfa_fcxp_s *fcxp;
 562         struct list_head              *qe, *qen;
 563
 564         list_for_each_safe(qe, qen, &mod->fcxp_active_q) {
 565                 fcxp = (struct bfa_fcxp_s *) qe;
 566                 if (fcxp->caller == NULL) {
 567                         fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
 568                                         BFA_STATUS_IOC_FAILURE, 0, 0, NULL);
 569                         bfa_fcxp_free(fcxp);
 570                 } else {
 571                         fcxp->rsp_status = BFA_STATUS_IOC_FAILURE;
 572                         bfa_cb_queue(bfa, &fcxp->hcb_qe,
 573                                      __bfa_fcxp_send_cbfn, fcxp);
 574                 }
 575         }
 576 }
 577
 578 static struct bfa_fcxp_s *
 579 bfa_fcxp_get(struct bfa_fcxp_mod_s *fm)
 580 {
 581         struct bfa_fcxp_s *fcxp;
 582
 583         bfa_q_deq(&fm->fcxp_free_q, &fcxp);
 584
 585         if (fcxp)
 586                 list_add_tail(&fcxp->qe, &fm->fcxp_active_q);
 587
 588         return fcxp;
 589 }
 590
 591 static void
 592 bfa_fcxp_init_reqrsp(struct bfa_fcxp_s *fcxp,
 593                struct bfa_s *bfa,
 594                u8 *use_ibuf,
 595                u32 *nr_sgles,
 596                bfa_fcxp_get_sgaddr_t *r_sga_cbfn,
 597                bfa_fcxp_get_sglen_t *r_sglen_cbfn,
 598                struct list_head *r_sgpg_q,
 599                int n_sgles,
 600                bfa_fcxp_get_sgaddr_t sga_cbfn,
 601                bfa_fcxp_get_sglen_t sglen_cbfn)
 602 {
 603
 604         WARN_ON(bfa == NULL);
 605
 606         bfa_trc(bfa, fcxp->fcxp_tag);
 607
 608         if (n_sgles == 0) {
 609                 *use_ibuf = 1;
 610         } else {
 611                 WARN_ON(*sga_cbfn == NULL);
 612                 WARN_ON(*sglen_cbfn == NULL);
 613
 614                 *use_ibuf = 0;
 615                 *r_sga_cbfn = sga_cbfn;
 616                 *r_sglen_cbfn = sglen_cbfn;
 617
 618                 *nr_sgles = n_sgles;
 619
 620                 /*
 621                  * alloc required sgpgs
 622                  */
 623                 if (n_sgles > BFI_SGE_INLINE)
 624                         WARN_ON(1);
 625         }
 626
 627 }
 628
 629 static void
 630 bfa_fcxp_init(struct bfa_fcxp_s *fcxp,
 631                void *caller, struct bfa_s *bfa, int nreq_sgles,
 632                int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
 633                bfa_fcxp_get_sglen_t req_sglen_cbfn,
 634                bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
 635                bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
 636 {
 637
 638         WARN_ON(bfa == NULL);
 639
 640         bfa_trc(bfa, fcxp->fcxp_tag);
 641
 642         fcxp->caller = caller;
 643
 644         bfa_fcxp_init_reqrsp(fcxp, bfa,
 645                 &fcxp->use_ireqbuf, &fcxp->nreq_sgles, &fcxp->req_sga_cbfn,
 646                 &fcxp->req_sglen_cbfn, &fcxp->req_sgpg_q,
 647                 nreq_sgles, req_sga_cbfn, req_sglen_cbfn);
 648
 649         bfa_fcxp_init_reqrsp(fcxp, bfa,
 650                 &fcxp->use_irspbuf, &fcxp->nrsp_sgles, &fcxp->rsp_sga_cbfn,
 651                 &fcxp->rsp_sglen_cbfn, &fcxp->rsp_sgpg_q,
 652                 nrsp_sgles, rsp_sga_cbfn, rsp_sglen_cbfn);
 653
 654 }
 655
 656 static void
 657 bfa_fcxp_put(struct bfa_fcxp_s *fcxp)
 658 {
 659         struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
 660         struct bfa_fcxp_wqe_s *wqe;
 661
 662         bfa_q_deq(&mod->wait_q, &wqe);
 663         if (wqe) {
 664                 bfa_trc(mod->bfa, fcxp->fcxp_tag);
 665
 666                 bfa_fcxp_init(fcxp, wqe->caller, wqe->bfa, wqe->nreq_sgles,
 667                         wqe->nrsp_sgles, wqe->req_sga_cbfn,
 668                         wqe->req_sglen_cbfn, wqe->rsp_sga_cbfn,
 669                         wqe->rsp_sglen_cbfn);
 670
 671                 wqe->alloc_cbfn(wqe->alloc_cbarg, fcxp);
 672                 return;
 673         }
 674
 675         WARN_ON(!bfa_q_is_on_q(&mod->fcxp_active_q, fcxp));
 676         list_del(&fcxp->qe);
 677         list_add_tail(&fcxp->qe, &mod->fcxp_free_q);
 678 }
 679
 680 static void
 681 bfa_fcxp_null_comp(void *bfad_fcxp, struct bfa_fcxp_s *fcxp, void *cbarg,
 682                    bfa_status_t req_status, u32 rsp_len,
 683                    u32 resid_len, struct fchs_s *rsp_fchs)
 684 {
 685         /* discarded fcxp completion */
 686 }
 687
 688 static void
 689 __bfa_fcxp_send_cbfn(void *cbarg, bfa_boolean_t complete)
 690 {
 691         struct bfa_fcxp_s *fcxp = cbarg;
 692
 693         if (complete) {
 694                 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
 695                                 fcxp->rsp_status, fcxp->rsp_len,
 696                                 fcxp->residue_len, &fcxp->rsp_fchs);
 697         } else {
 698                 bfa_fcxp_free(fcxp);
 699         }
 700 }
 701
 702 static void
 703 hal_fcxp_send_comp(struct bfa_s *bfa, struct bfi_fcxp_send_rsp_s *fcxp_rsp)
 704 {
 705         struct bfa_fcxp_mod_s   *mod = BFA_FCXP_MOD(bfa);
 706         struct bfa_fcxp_s       *fcxp;
 707         u16             fcxp_tag = be16_to_cpu(fcxp_rsp->fcxp_tag);
 708
 709         bfa_trc(bfa, fcxp_tag);
 710
 711         fcxp_rsp->rsp_len = be32_to_cpu(fcxp_rsp->rsp_len);
 712
 713         /*
 714          * @todo f/w should not set residue to non-0 when everything
 715          *       is received.
 716          */
 717         if (fcxp_rsp->req_status == BFA_STATUS_OK)
 718                 fcxp_rsp->residue_len = 0;
 719         else
 720                 fcxp_rsp->residue_len = be32_to_cpu(fcxp_rsp->residue_len);
 721
 722         fcxp = BFA_FCXP_FROM_TAG(mod, fcxp_tag);
 723
 724         WARN_ON(fcxp->send_cbfn == NULL);
 725
 726         hal_fcxp_rx_plog(mod->bfa, fcxp, fcxp_rsp);
 727
 728         if (fcxp->send_cbfn != NULL) {
 729                 bfa_trc(mod->bfa, (NULL == fcxp->caller));
 730                 if (fcxp->caller == NULL) {
 731                         fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
 732                                         fcxp_rsp->req_status, fcxp_rsp->rsp_len,
 733                                         fcxp_rsp->residue_len, &fcxp_rsp->fchs);
 734                         /*
 735                          * fcxp automatically freed on return from the callback
 736                          */
 737                         bfa_fcxp_free(fcxp);
 738                 } else {
 739                         fcxp->rsp_status = fcxp_rsp->req_status;
 740                         fcxp->rsp_len = fcxp_rsp->rsp_len;
 741                         fcxp->residue_len = fcxp_rsp->residue_len;
 742                         fcxp->rsp_fchs = fcxp_rsp->fchs;
 743
 744                         bfa_cb_queue(bfa, &fcxp->hcb_qe,
 745                                         __bfa_fcxp_send_cbfn, fcxp);
 746                 }
 747         } else {
 748                 bfa_trc(bfa, (NULL == fcxp->send_cbfn));
 749         }
 750 }
 751
 752 static void
 753 hal_fcxp_set_local_sges(struct bfi_sge_s *sge, u32 reqlen, u64 req_pa)
 754 {
 755         union bfi_addr_u      sga_zero = { {0} };
 756
 757         sge->sg_len = reqlen;
 758         sge->flags = BFI_SGE_DATA_LAST;
 759         bfa_dma_addr_set(sge[0].sga, req_pa);
 760         bfa_sge_to_be(sge);
 761         sge++;
 762
 763         sge->sga = sga_zero;
 764         sge->sg_len = reqlen;
 765         sge->flags = BFI_SGE_PGDLEN;
 766         bfa_sge_to_be(sge);
 767 }
 768
 769 static void
 770 hal_fcxp_tx_plog(struct bfa_s *bfa, u32 reqlen, struct bfa_fcxp_s *fcxp,
 771                  struct fchs_s *fchs)
 772 {
 773         /*
 774          * TODO: TX ox_id
 775          */
 776         if (reqlen > 0) {
 777                 if (fcxp->use_ireqbuf) {
 778                         u32     pld_w0 =
 779                                 *((u32 *) BFA_FCXP_REQ_PLD(fcxp));
 780
 781                         bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_FCXP,
 782                                         BFA_PL_EID_TX,
 783                                         reqlen + sizeof(struct fchs_s), fchs,
 784                                         pld_w0);
 785                 } else {
 786                         bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP,
 787                                         BFA_PL_EID_TX,
 788                                         reqlen + sizeof(struct fchs_s),
 789                                         fchs);
 790                 }
 791         } else {
 792                 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_TX,
 793                                reqlen + sizeof(struct fchs_s), fchs);
 794         }
 795 }
 796
 797 static void
 798 hal_fcxp_rx_plog(struct bfa_s *bfa, struct bfa_fcxp_s *fcxp,
 799                  struct bfi_fcxp_send_rsp_s *fcxp_rsp)
 800 {
 801         if (fcxp_rsp->rsp_len > 0) {
 802                 if (fcxp->use_irspbuf) {
 803                         u32     pld_w0 =
 804                                 *((u32 *) BFA_FCXP_RSP_PLD(fcxp));
 805
 806                         bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_FCXP,
 807                                               BFA_PL_EID_RX,
 808                                               (u16) fcxp_rsp->rsp_len,
 809                                               &fcxp_rsp->fchs, pld_w0);
 810                 } else {
 811                         bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP,
 812                                        BFA_PL_EID_RX,
 813                                        (u16) fcxp_rsp->rsp_len,
 814                                        &fcxp_rsp->fchs);
 815                 }
 816         } else {
 817                 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_RX,
 818                                (u16) fcxp_rsp->rsp_len, &fcxp_rsp->fchs);
 819         }
 820 }
 821
 822 /*
 823  * Handler to resume sending fcxp when space in available in cpe queue.
 824  */
 825 static void
 826 bfa_fcxp_qresume(void *cbarg)
 827 {
 828         struct bfa_fcxp_s               *fcxp = cbarg;
 829         struct bfa_s                    *bfa = fcxp->fcxp_mod->bfa;
 830         struct bfi_fcxp_send_req_s      *send_req;
 831
 832         fcxp->reqq_waiting = BFA_FALSE;
 833         send_req = bfa_reqq_next(bfa, BFA_REQQ_FCXP);
 834         bfa_fcxp_queue(fcxp, send_req);
 835 }
 836
 837 /*
 838  * Queue fcxp send request to foimrware.
 839  */
 840 static void
 841 bfa_fcxp_queue(struct bfa_fcxp_s *fcxp, struct bfi_fcxp_send_req_s *send_req)
 842 {
 843         struct bfa_s                    *bfa = fcxp->fcxp_mod->bfa;
 844         struct bfa_fcxp_req_info_s      *reqi = &fcxp->req_info;
 845         struct bfa_fcxp_rsp_info_s      *rspi = &fcxp->rsp_info;
 846         struct bfa_rport_s              *rport = reqi->bfa_rport;
 847
 848         bfi_h2i_set(send_req->mh, BFI_MC_FCXP, BFI_FCXP_H2I_SEND_REQ,
 849                     bfa_lpuid(bfa));
 850
 851         send_req->fcxp_tag = cpu_to_be16(fcxp->fcxp_tag);
 852         if (rport) {
 853                 send_req->rport_fw_hndl = rport->fw_handle;
 854                 send_req->max_frmsz = cpu_to_be16(rport->rport_info.max_frmsz);
 855                 if (send_req->max_frmsz == 0)
 856                         send_req->max_frmsz = cpu_to_be16(FC_MAX_PDUSZ);
 857         } else {
 858                 send_req->rport_fw_hndl = 0;
 859                 send_req->max_frmsz = cpu_to_be16(FC_MAX_PDUSZ);
 860         }
 861
 862         send_req->vf_id = cpu_to_be16(reqi->vf_id);
 863         send_req->lp_tag = reqi->lp_tag;
 864         send_req->class = reqi->class;
 865         send_req->rsp_timeout = rspi->rsp_timeout;
 866         send_req->cts = reqi->cts;
 867         send_req->fchs = reqi->fchs;
 868
 869         send_req->req_len = cpu_to_be32(reqi->req_tot_len);
 870         send_req->rsp_maxlen = cpu_to_be32(rspi->rsp_maxlen);
 871
 872         /*
 873          * setup req sgles
 874          */
 875         if (fcxp->use_ireqbuf == 1) {
 876                 hal_fcxp_set_local_sges(send_req->req_sge, reqi->req_tot_len,
 877                                         BFA_FCXP_REQ_PLD_PA(fcxp));
 878         } else {
 879                 if (fcxp->nreq_sgles > 0) {
 880                         WARN_ON(fcxp->nreq_sgles != 1);
 881                         hal_fcxp_set_local_sges(send_req->req_sge,
 882                                                 reqi->req_tot_len,
 883                                                 fcxp->req_sga_cbfn(fcxp->caller,
 884                                                                    0));
 885                 } else {
 886                         WARN_ON(reqi->req_tot_len != 0);
 887                         hal_fcxp_set_local_sges(send_req->rsp_sge, 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                 hal_fcxp_set_local_sges(send_req->rsp_sge, rspi->rsp_maxlen,
 898                                         BFA_FCXP_RSP_PLD_PA(fcxp));
 899
 900         } else {
 901                 if (fcxp->nrsp_sgles > 0) {
 902                         WARN_ON(fcxp->nrsp_sgles != 1);
 903                         hal_fcxp_set_local_sges(send_req->rsp_sge,
 904                                                 rspi->rsp_maxlen,
 905                                                 fcxp->rsp_sga_cbfn(fcxp->caller,
 906                                                                    0));
 907                 } else {
 908                         WARN_ON(rspi->rsp_maxlen != 0);
 909                         hal_fcxp_set_local_sges(send_req->rsp_sge, 0, 0);
 910                 }
 911         }
 912
 913         hal_fcxp_tx_plog(bfa, reqi->req_tot_len, fcxp, &reqi->fchs);
 914
 915         bfa_reqq_produce(bfa, BFA_REQQ_FCXP);
 916
 917         bfa_trc(bfa, bfa_reqq_pi(bfa, BFA_REQQ_FCXP));
 918         bfa_trc(bfa, bfa_reqq_ci(bfa, BFA_REQQ_FCXP));
 919 }
 920
 921 /*
 922  * Allocate an FCXP instance to send a response or to send a request
 923  * that has a response. Request/response buffers are allocated by caller.
 924  *
 925  * @param[in]   bfa             BFA bfa instance
 926  * @param[in]   nreq_sgles      Number of SG elements required for request
 927  *                              buffer. 0, if fcxp internal buffers are used.
 928  *                              Use bfa_fcxp_get_reqbuf() to get the
 929  *                              internal req buffer.
 930  * @param[in]   req_sgles       SG elements describing request buffer. Will be
 931  *                              copied in by BFA and hence can be freed on
 932  *                              return from this function.
 933  * @param[in]   get_req_sga     function ptr to be called to get a request SG
 934  *                              Address (given the sge index).
 935  * @param[in]   get_req_sglen   function ptr to be called to get a request SG
 936  *                              len (given the sge index).
 937  * @param[in]   get_rsp_sga     function ptr to be called to get a response SG
 938  *                              Address (given the sge index).
 939  * @param[in]   get_rsp_sglen   function ptr to be called to get a response SG
 940  *                              len (given the sge index).
 941  *
 942  * @return FCXP instance. NULL on failure.
 943  */
 944 struct bfa_fcxp_s *
 945 bfa_fcxp_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)
 950 {
 951         struct bfa_fcxp_s *fcxp = NULL;
 952
 953         WARN_ON(bfa == NULL);
 954
 955         fcxp = bfa_fcxp_get(BFA_FCXP_MOD(bfa));
 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 = ((u8 *)mod->req_pld_list_kva) +
 982                 fcxp->fcxp_tag * mod->req_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    *rspbuf;
1006
1007         WARN_ON(fcxp->use_irspbuf != 1);
1008
1009         rspbuf = ((u8 *)mod->rsp_pld_list_kva) +
1010                 fcxp->fcxp_tag * mod->rsp_pld_sz;
1011         return rspbuf;
1012 }
1013
1014 /*
1015  * Free the BFA FCXP
1016  *
1017  * @param[in]   fcxp                    BFA fcxp pointer
1018  *
1019  * @return              void
1020  */
1021 void
1022 bfa_fcxp_free(struct bfa_fcxp_s *fcxp)
1023 {
1024         struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
1025
1026         WARN_ON(fcxp == NULL);
1027         bfa_trc(mod->bfa, fcxp->fcxp_tag);
1028         bfa_fcxp_put(fcxp);
1029 }
1030
1031 /*
1032  * Send a FCXP request
1033  *
1034  * @param[in]   fcxp    BFA fcxp pointer
1035  * @param[in]   rport   BFA rport pointer. Could be left NULL for WKA rports
1036  * @param[in]   vf_id   virtual Fabric ID
1037  * @param[in]   lp_tag  lport tag
1038  * @param[in]   cts     use Continous sequence
1039  * @param[in]   cos     fc Class of Service
1040  * @param[in]   reqlen  request length, does not include FCHS length
1041  * @param[in]   fchs    fc Header Pointer. The header content will be copied
1042  *                      in by BFA.
1043  *
1044  * @param[in]   cbfn    call back function to be called on receiving
1045  *                                                              the response
1046  * @param[in]   cbarg   arg for cbfn
1047  * @param[in]   rsp_timeout
1048  *                      response timeout
1049  *
1050  * @return              bfa_status_t
1051  */
1052 void
1053 bfa_fcxp_send(struct bfa_fcxp_s *fcxp, struct bfa_rport_s *rport,
1054               u16 vf_id, u8 lp_tag, bfa_boolean_t cts, enum fc_cos cos,
1055               u32 reqlen, struct fchs_s *fchs, bfa_cb_fcxp_send_t cbfn,
1056               void *cbarg, u32 rsp_maxlen, u8 rsp_timeout)
1057 {
1058         struct bfa_s                    *bfa  = fcxp->fcxp_mod->bfa;
1059         struct bfa_fcxp_req_info_s      *reqi = &fcxp->req_info;
1060         struct bfa_fcxp_rsp_info_s      *rspi = &fcxp->rsp_info;
1061         struct bfi_fcxp_send_req_s      *send_req;
1062
1063         bfa_trc(bfa, fcxp->fcxp_tag);
1064
1065         /*
1066          * setup request/response info
1067          */
1068         reqi->bfa_rport = rport;
1069         reqi->vf_id = vf_id;
1070         reqi->lp_tag = lp_tag;
1071         reqi->class = cos;
1072         rspi->rsp_timeout = rsp_timeout;
1073         reqi->cts = cts;
1074         reqi->fchs = *fchs;
1075         reqi->req_tot_len = reqlen;
1076         rspi->rsp_maxlen = rsp_maxlen;
1077         fcxp->send_cbfn = cbfn ? cbfn : bfa_fcxp_null_comp;
1078         fcxp->send_cbarg = cbarg;
1079
1080         /*
1081          * If no room in CPE queue, wait for space in request queue
1082          */
1083         send_req = bfa_reqq_next(bfa, BFA_REQQ_FCXP);
1084         if (!send_req) {
1085                 bfa_trc(bfa, fcxp->fcxp_tag);
1086                 fcxp->reqq_waiting = BFA_TRUE;
1087                 bfa_reqq_wait(bfa, BFA_REQQ_FCXP, &fcxp->reqq_wqe);
1088                 return;
1089         }
1090
1091         bfa_fcxp_queue(fcxp, send_req);
1092 }
1093
1094 /*
1095  * Abort a BFA FCXP
1096  *
1097  * @param[in]   fcxp    BFA fcxp pointer
1098  *
1099  * @return              void
1100  */
1101 bfa_status_t
1102 bfa_fcxp_abort(struct bfa_fcxp_s *fcxp)
1103 {
1104         bfa_trc(fcxp->fcxp_mod->bfa, fcxp->fcxp_tag);
1105         WARN_ON(1);
1106         return BFA_STATUS_OK;
1107 }
1108
1109 void
1110 bfa_fcxp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
1111                bfa_fcxp_alloc_cbfn_t alloc_cbfn, void *alloc_cbarg,
1112                void *caller, int nreq_sgles,
1113                int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
1114                bfa_fcxp_get_sglen_t req_sglen_cbfn,
1115                bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
1116                bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
1117 {
1118         struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1119
1120         WARN_ON(!list_empty(&mod->fcxp_free_q));
1121
1122         wqe->alloc_cbfn = alloc_cbfn;
1123         wqe->alloc_cbarg = alloc_cbarg;
1124         wqe->caller = caller;
1125         wqe->bfa = bfa;
1126         wqe->nreq_sgles = nreq_sgles;
1127         wqe->nrsp_sgles = nrsp_sgles;
1128         wqe->req_sga_cbfn = req_sga_cbfn;
1129         wqe->req_sglen_cbfn = req_sglen_cbfn;
1130         wqe->rsp_sga_cbfn = rsp_sga_cbfn;
1131         wqe->rsp_sglen_cbfn = rsp_sglen_cbfn;
1132
1133         list_add_tail(&wqe->qe, &mod->wait_q);
1134 }
1135
1136 void
1137 bfa_fcxp_walloc_cancel(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe)
1138 {
1139         struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1140
1141         WARN_ON(!bfa_q_is_on_q(&mod->wait_q, wqe));
1142         list_del(&wqe->qe);
1143 }
1144
1145 void
1146 bfa_fcxp_discard(struct bfa_fcxp_s *fcxp)
1147 {
1148         /*
1149          * If waiting for room in request queue, cancel reqq wait
1150          * and free fcxp.
1151          */
1152         if (fcxp->reqq_waiting) {
1153                 fcxp->reqq_waiting = BFA_FALSE;
1154                 bfa_reqq_wcancel(&fcxp->reqq_wqe);
1155                 bfa_fcxp_free(fcxp);
1156                 return;
1157         }
1158
1159         fcxp->send_cbfn = bfa_fcxp_null_comp;
1160 }
1161
1162 void
1163 bfa_fcxp_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
1164 {
1165         switch (msg->mhdr.msg_id) {
1166         case BFI_FCXP_I2H_SEND_RSP:
1167                 hal_fcxp_send_comp(bfa, (struct bfi_fcxp_send_rsp_s *) msg);
1168                 break;
1169
1170         default:
1171                 bfa_trc(bfa, msg->mhdr.msg_id);
1172                 WARN_ON(1);
1173         }
1174 }
1175
1176 u32
1177 bfa_fcxp_get_maxrsp(struct bfa_s *bfa)
1178 {
1179         struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1180
1181         return mod->rsp_pld_sz;
1182 }
1183
1184
1185 /*
1186  *  BFA LPS state machine functions
1187  */
1188
1189 /*
1190  * Init state -- no login
1191  */
1192 static void
1193 bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event)
1194 {
1195         bfa_trc(lps->bfa, lps->lp_tag);
1196         bfa_trc(lps->bfa, event);
1197
1198         switch (event) {
1199         case BFA_LPS_SM_LOGIN:
1200                 if (bfa_reqq_full(lps->bfa, lps->reqq)) {
1201                         bfa_sm_set_state(lps, bfa_lps_sm_loginwait);
1202                         bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe);
1203                 } else {
1204                         bfa_sm_set_state(lps, bfa_lps_sm_login);
1205                         bfa_lps_send_login(lps);
1206                 }
1207
1208                 if (lps->fdisc)
1209                         bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1210                                 BFA_PL_EID_LOGIN, 0, "FDISC Request");
1211                 else
1212                         bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1213                                 BFA_PL_EID_LOGIN, 0, "FLOGI Request");
1214                 break;
1215
1216         case BFA_LPS_SM_LOGOUT:
1217                 bfa_lps_logout_comp(lps);
1218                 break;
1219
1220         case BFA_LPS_SM_DELETE:
1221                 bfa_lps_free(lps);
1222                 break;
1223
1224         case BFA_LPS_SM_RX_CVL:
1225         case BFA_LPS_SM_OFFLINE:
1226                 break;
1227
1228         case BFA_LPS_SM_FWRSP:
1229                 /*
1230                  * Could happen when fabric detects loopback and discards
1231                  * the lps request. Fw will eventually sent out the timeout
1232                  * Just ignore
1233                  */
1234                 break;
1235
1236         default:
1237                 bfa_sm_fault(lps->bfa, event);
1238         }
1239 }
1240
1241 /*
1242  * login is in progress -- awaiting response from firmware
1243  */
1244 static void
1245 bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event)
1246 {
1247         bfa_trc(lps->bfa, lps->lp_tag);
1248         bfa_trc(lps->bfa, event);
1249
1250         switch (event) {
1251         case BFA_LPS_SM_FWRSP:
1252                 if (lps->status == BFA_STATUS_OK) {
1253                         bfa_sm_set_state(lps, bfa_lps_sm_online);
1254                         if (lps->fdisc)
1255                                 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1256                                         BFA_PL_EID_LOGIN, 0, "FDISC Accept");
1257                         else
1258                                 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1259                                         BFA_PL_EID_LOGIN, 0, "FLOGI Accept");
1260                         /* If N2N, send the assigned PID to FW */
1261                         bfa_trc(lps->bfa, lps->fport);
1262                         bfa_trc(lps->bfa, lps->lp_pid);
1263
1264                         if (!lps->fport && lps->lp_pid)
1265                                 bfa_sm_send_event(lps, BFA_LPS_SM_SET_N2N_PID);
1266                 } else {
1267                         bfa_sm_set_state(lps, bfa_lps_sm_init);
1268                         if (lps->fdisc)
1269                                 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1270                                         BFA_PL_EID_LOGIN, 0,
1271                                         "FDISC Fail (RJT or timeout)");
1272                         else
1273                                 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1274                                         BFA_PL_EID_LOGIN, 0,
1275                                         "FLOGI Fail (RJT or timeout)");
1276                 }
1277                 bfa_lps_login_comp(lps);
1278                 break;
1279
1280         case BFA_LPS_SM_OFFLINE:
1281                 bfa_sm_set_state(lps, bfa_lps_sm_init);
1282                 break;
1283
1284         case BFA_LPS_SM_SET_N2N_PID:
1285                 bfa_trc(lps->bfa, lps->fport);
1286                 bfa_trc(lps->bfa, lps->lp_pid);
1287                 break;
1288
1289         default:
1290                 bfa_sm_fault(lps->bfa, event);
1291         }
1292 }
1293
1294 /*
1295  * login pending - awaiting space in request queue
1296  */
1297 static void
1298 bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1299 {
1300         bfa_trc(lps->bfa, lps->lp_tag);
1301         bfa_trc(lps->bfa, event);
1302
1303         switch (event) {
1304         case BFA_LPS_SM_RESUME:
1305                 bfa_sm_set_state(lps, bfa_lps_sm_login);
1306                 break;
1307
1308         case BFA_LPS_SM_OFFLINE:
1309                 bfa_sm_set_state(lps, bfa_lps_sm_init);
1310                 bfa_reqq_wcancel(&lps->wqe);
1311                 break;
1312
1313         case BFA_LPS_SM_RX_CVL:
1314                 /*
1315                  * Login was not even sent out; so when getting out
1316                  * of this state, it will appear like a login retry
1317                  * after Clear virtual link
1318                  */
1319                 break;
1320
1321         default:
1322                 bfa_sm_fault(lps->bfa, event);
1323         }
1324 }
1325
1326 /*
1327  * login complete
1328  */
1329 static void
1330 bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event)
1331 {
1332         bfa_trc(lps->bfa, lps->lp_tag);
1333         bfa_trc(lps->bfa, event);
1334
1335         switch (event) {
1336         case BFA_LPS_SM_LOGOUT:
1337                 if (bfa_reqq_full(lps->bfa, lps->reqq)) {
1338                         bfa_sm_set_state(lps, bfa_lps_sm_logowait);
1339                         bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe);
1340                 } else {
1341                         bfa_sm_set_state(lps, bfa_lps_sm_logout);
1342                         bfa_lps_send_logout(lps);
1343                 }
1344                 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1345                         BFA_PL_EID_LOGO, 0, "Logout");
1346                 break;
1347
1348         case BFA_LPS_SM_RX_CVL:
1349                 bfa_sm_set_state(lps, bfa_lps_sm_init);
1350
1351                 /* Let the vport module know about this event */
1352                 bfa_lps_cvl_event(lps);
1353                 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1354                         BFA_PL_EID_FIP_FCF_CVL, 0, "FCF Clear Virt. Link Rx");
1355                 break;
1356
1357         case BFA_LPS_SM_SET_N2N_PID:
1358                 if (bfa_reqq_full(lps->bfa, lps->reqq)) {
1359                         bfa_sm_set_state(lps, bfa_lps_sm_online_n2n_pid_wait);
1360                         bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe);
1361                 } else
1362                         bfa_lps_send_set_n2n_pid(lps);
1363                 break;
1364
1365         case BFA_LPS_SM_OFFLINE:
1366         case BFA_LPS_SM_DELETE:
1367                 bfa_sm_set_state(lps, bfa_lps_sm_init);
1368                 break;
1369
1370         default:
1371                 bfa_sm_fault(lps->bfa, event);
1372         }
1373 }
1374
1375 /*
1376  * login complete
1377  */
1378 static void
1379 bfa_lps_sm_online_n2n_pid_wait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1380 {
1381         bfa_trc(lps->bfa, lps->lp_tag);
1382         bfa_trc(lps->bfa, event);
1383
1384         switch (event) {
1385         case BFA_LPS_SM_RESUME:
1386                 bfa_sm_set_state(lps, bfa_lps_sm_online);
1387                 bfa_lps_send_set_n2n_pid(lps);
1388                 break;
1389
1390         case BFA_LPS_SM_LOGOUT:
1391                 bfa_sm_set_state(lps, bfa_lps_sm_logowait);
1392                 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1393                         BFA_PL_EID_LOGO, 0, "Logout");
1394                 break;
1395
1396         case BFA_LPS_SM_RX_CVL:
1397                 bfa_sm_set_state(lps, bfa_lps_sm_init);
1398                 bfa_reqq_wcancel(&lps->wqe);
1399
1400                 /* Let the vport module know about this event */
1401                 bfa_lps_cvl_event(lps);
1402                 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1403                         BFA_PL_EID_FIP_FCF_CVL, 0, "FCF Clear Virt. Link Rx");
1404                 break;
1405
1406         case BFA_LPS_SM_OFFLINE:
1407         case BFA_LPS_SM_DELETE:
1408                 bfa_sm_set_state(lps, bfa_lps_sm_init);
1409                 bfa_reqq_wcancel(&lps->wqe);
1410                 break;
1411
1412         default:
1413                 bfa_sm_fault(lps->bfa, event);
1414         }
1415 }
1416
1417 /*
1418  * logout in progress - awaiting firmware response
1419  */
1420 static void
1421 bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event)
1422 {
1423         bfa_trc(lps->bfa, lps->lp_tag);
1424         bfa_trc(lps->bfa, event);
1425
1426         switch (event) {
1427         case BFA_LPS_SM_FWRSP:
1428                 bfa_sm_set_state(lps, bfa_lps_sm_init);
1429                 bfa_lps_logout_comp(lps);
1430                 break;
1431
1432         case BFA_LPS_SM_OFFLINE:
1433                 bfa_sm_set_state(lps, bfa_lps_sm_init);
1434                 break;
1435
1436         default:
1437                 bfa_sm_fault(lps->bfa, event);
1438         }
1439 }
1440
1441 /*
1442  * logout pending -- awaiting space in request queue
1443  */
1444 static void
1445 bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1446 {
1447         bfa_trc(lps->bfa, lps->lp_tag);
1448         bfa_trc(lps->bfa, event);
1449
1450         switch (event) {
1451         case BFA_LPS_SM_RESUME:
1452                 bfa_sm_set_state(lps, bfa_lps_sm_logout);
1453                 bfa_lps_send_logout(lps);
1454                 break;
1455
1456         case BFA_LPS_SM_OFFLINE:
1457                 bfa_sm_set_state(lps, bfa_lps_sm_init);
1458                 bfa_reqq_wcancel(&lps->wqe);
1459                 break;
1460
1461         default:
1462                 bfa_sm_fault(lps->bfa, event);
1463         }
1464 }
1465
1466
1467
1468 /*
1469  *  lps_pvt BFA LPS private functions
1470  */
1471
1472 /*
1473  * return memory requirement
1474  */
1475 static void
1476 bfa_lps_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
1477         u32 *dm_len)
1478 {
1479         if (cfg->drvcfg.min_cfg)
1480                 *ndm_len += sizeof(struct bfa_lps_s) * BFA_LPS_MIN_LPORTS;
1481         else
1482                 *ndm_len += sizeof(struct bfa_lps_s) * BFA_LPS_MAX_LPORTS;
1483 }
1484
1485 /*
1486  * bfa module attach at initialization time
1487  */
1488 static void
1489 bfa_lps_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1490         struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
1491 {
1492         struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1493         struct bfa_lps_s        *lps;
1494         int                     i;
1495
1496         memset(mod, 0, sizeof(struct bfa_lps_mod_s));
1497         mod->num_lps = BFA_LPS_MAX_LPORTS;
1498         if (cfg->drvcfg.min_cfg)
1499                 mod->num_lps = BFA_LPS_MIN_LPORTS;
1500         else
1501                 mod->num_lps = BFA_LPS_MAX_LPORTS;
1502         mod->lps_arr = lps = (struct bfa_lps_s *) bfa_meminfo_kva(meminfo);
1503
1504         bfa_meminfo_kva(meminfo) += mod->num_lps * sizeof(struct bfa_lps_s);
1505
1506         INIT_LIST_HEAD(&mod->lps_free_q);
1507         INIT_LIST_HEAD(&mod->lps_active_q);
1508
1509         for (i = 0; i < mod->num_lps; i++, lps++) {
1510                 lps->bfa        = bfa;
1511                 lps->lp_tag     = (u8) i;
1512                 lps->reqq       = BFA_REQQ_LPS;
1513                 bfa_reqq_winit(&lps->wqe, bfa_lps_reqq_resume, lps);
1514                 list_add_tail(&lps->qe, &mod->lps_free_q);
1515         }
1516 }
1517
1518 static void
1519 bfa_lps_detach(struct bfa_s *bfa)
1520 {
1521 }
1522
1523 static void
1524 bfa_lps_start(struct bfa_s *bfa)
1525 {
1526 }
1527
1528 static void
1529 bfa_lps_stop(struct bfa_s *bfa)
1530 {
1531 }
1532
1533 /*
1534  * IOC in disabled state -- consider all lps offline
1535  */
1536 static void
1537 bfa_lps_iocdisable(struct bfa_s *bfa)
1538 {
1539         struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1540         struct bfa_lps_s        *lps;
1541         struct list_head                *qe, *qen;
1542
1543         list_for_each_safe(qe, qen, &mod->lps_active_q) {
1544                 lps = (struct bfa_lps_s *) qe;
1545                 bfa_sm_send_event(lps, BFA_LPS_SM_OFFLINE);
1546         }
1547 }
1548
1549 /*
1550  * Firmware login response
1551  */
1552 static void
1553 bfa_lps_login_rsp(struct bfa_s *bfa, struct bfi_lps_login_rsp_s *rsp)
1554 {
1555         struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1556         struct bfa_lps_s        *lps;
1557
1558         WARN_ON(rsp->lp_tag >= mod->num_lps);
1559         lps = BFA_LPS_FROM_TAG(mod, rsp->lp_tag);
1560
1561         lps->status = rsp->status;
1562         switch (rsp->status) {
1563         case BFA_STATUS_OK:
1564                 lps->fport      = rsp->f_port;
1565                 if (lps->fport)
1566                         lps->lp_pid = rsp->lp_pid;
1567                 lps->npiv_en    = rsp->npiv_en;
1568                 lps->pr_bbcred  = be16_to_cpu(rsp->bb_credit);
1569                 lps->pr_pwwn    = rsp->port_name;
1570                 lps->pr_nwwn    = rsp->node_name;
1571                 lps->auth_req   = rsp->auth_req;
1572                 lps->lp_mac     = rsp->lp_mac;
1573                 lps->brcd_switch = rsp->brcd_switch;
1574                 lps->fcf_mac    = rsp->fcf_mac;
1575
1576                 break;
1577
1578         case BFA_STATUS_FABRIC_RJT:
1579                 lps->lsrjt_rsn = rsp->lsrjt_rsn;
1580                 lps->lsrjt_expl = rsp->lsrjt_expl;
1581
1582                 break;
1583
1584         case BFA_STATUS_EPROTOCOL:
1585                 lps->ext_status = rsp->ext_status;
1586
1587                 break;
1588
1589         default:
1590                 /* Nothing to do with other status */
1591                 break;
1592         }
1593
1594         bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
1595 }
1596
1597 /*
1598  * Firmware logout response
1599  */
1600 static void
1601 bfa_lps_logout_rsp(struct bfa_s *bfa, struct bfi_lps_logout_rsp_s *rsp)
1602 {
1603         struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1604         struct bfa_lps_s        *lps;
1605
1606         WARN_ON(rsp->lp_tag >= mod->num_lps);
1607         lps = BFA_LPS_FROM_TAG(mod, rsp->lp_tag);
1608
1609         bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
1610 }
1611
1612 /*
1613  * Firmware received a Clear virtual link request (for FCoE)
1614  */
1615 static void
1616 bfa_lps_rx_cvl_event(struct bfa_s *bfa, struct bfi_lps_cvl_event_s *cvl)
1617 {
1618         struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1619         struct bfa_lps_s        *lps;
1620
1621         lps = BFA_LPS_FROM_TAG(mod, cvl->lp_tag);
1622
1623         bfa_sm_send_event(lps, BFA_LPS_SM_RX_CVL);
1624 }
1625
1626 /*
1627  * Space is available in request queue, resume queueing request to firmware.
1628  */
1629 static void
1630 bfa_lps_reqq_resume(void *lps_arg)
1631 {
1632         struct bfa_lps_s        *lps = lps_arg;
1633
1634         bfa_sm_send_event(lps, BFA_LPS_SM_RESUME);
1635 }
1636
1637 /*
1638  * lps is freed -- triggered by vport delete
1639  */
1640 static void
1641 bfa_lps_free(struct bfa_lps_s *lps)
1642 {
1643         struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(lps->bfa);
1644
1645         lps->lp_pid = 0;
1646         list_del(&lps->qe);
1647         list_add_tail(&lps->qe, &mod->lps_free_q);
1648 }
1649
1650 /*
1651  * send login request to firmware
1652  */
1653 static void
1654 bfa_lps_send_login(struct bfa_lps_s *lps)
1655 {
1656         struct bfi_lps_login_req_s      *m;
1657
1658         m = bfa_reqq_next(lps->bfa, lps->reqq);
1659         WARN_ON(!m);
1660
1661         bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGIN_REQ,
1662                 bfa_lpuid(lps->bfa));
1663
1664         m->lp_tag       = lps->lp_tag;
1665         m->alpa         = lps->alpa;
1666         m->pdu_size     = cpu_to_be16(lps->pdusz);
1667         m->pwwn         = lps->pwwn;
1668         m->nwwn         = lps->nwwn;
1669         m->fdisc        = lps->fdisc;
1670         m->auth_en      = lps->auth_en;
1671
1672         bfa_reqq_produce(lps->bfa, lps->reqq);
1673 }
1674
1675 /*
1676  * send logout request to firmware
1677  */
1678 static void
1679 bfa_lps_send_logout(struct bfa_lps_s *lps)
1680 {
1681         struct bfi_lps_logout_req_s *m;
1682
1683         m = bfa_reqq_next(lps->bfa, lps->reqq);
1684         WARN_ON(!m);
1685
1686         bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGOUT_REQ,
1687                 bfa_lpuid(lps->bfa));
1688
1689         m->lp_tag    = lps->lp_tag;
1690         m->port_name = lps->pwwn;
1691         bfa_reqq_produce(lps->bfa, lps->reqq);
1692 }
1693
1694 /*
1695  * send n2n pid set request to firmware
1696  */
1697 static void
1698 bfa_lps_send_set_n2n_pid(struct bfa_lps_s *lps)
1699 {
1700         struct bfi_lps_n2n_pid_req_s *m;
1701
1702         m = bfa_reqq_next(lps->bfa, lps->reqq);
1703         WARN_ON(!m);
1704
1705         bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_N2N_PID_REQ,
1706                 bfa_lpuid(lps->bfa));
1707
1708         m->lp_tag = lps->lp_tag;
1709         m->lp_pid = lps->lp_pid;
1710         bfa_reqq_produce(lps->bfa, lps->reqq);
1711 }
1712
1713 /*
1714  * Indirect login completion handler for non-fcs
1715  */
1716 static void
1717 bfa_lps_login_comp_cb(void *arg, bfa_boolean_t complete)
1718 {
1719         struct bfa_lps_s *lps   = arg;
1720
1721         if (!complete)
1722                 return;
1723
1724         if (lps->fdisc)
1725                 bfa_cb_lps_fdisc_comp(lps->bfa->bfad, lps->uarg, lps->status);
1726         else
1727                 bfa_cb_lps_flogi_comp(lps->bfa->bfad, lps->uarg, lps->status);
1728 }
1729
1730 /*
1731  * Login completion handler -- direct call for fcs, queue for others
1732  */
1733 static void
1734 bfa_lps_login_comp(struct bfa_lps_s *lps)
1735 {
1736         if (!lps->bfa->fcs) {
1737                 bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_login_comp_cb,
1738                         lps);
1739                 return;
1740         }
1741
1742         if (lps->fdisc)
1743                 bfa_cb_lps_fdisc_comp(lps->bfa->bfad, lps->uarg, lps->status);
1744         else
1745                 bfa_cb_lps_flogi_comp(lps->bfa->bfad, lps->uarg, lps->status);
1746 }
1747
1748 /*
1749  * Indirect logout completion handler for non-fcs
1750  */
1751 static void
1752 bfa_lps_logout_comp_cb(void *arg, bfa_boolean_t complete)
1753 {
1754         struct bfa_lps_s *lps   = arg;
1755
1756         if (!complete)
1757                 return;
1758
1759         if (lps->fdisc)
1760                 bfa_cb_lps_fdisclogo_comp(lps->bfa->bfad, lps->uarg);
1761 }
1762
1763 /*
1764  * Logout completion handler -- direct call for fcs, queue for others
1765  */
1766 static void
1767 bfa_lps_logout_comp(struct bfa_lps_s *lps)
1768 {
1769         if (!lps->bfa->fcs) {
1770                 bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_logout_comp_cb,
1771                         lps);
1772                 return;
1773         }
1774         if (lps->fdisc)
1775                 bfa_cb_lps_fdisclogo_comp(lps->bfa->bfad, lps->uarg);
1776 }
1777
1778 /*
1779  * Clear virtual link completion handler for non-fcs
1780  */
1781 static void
1782 bfa_lps_cvl_event_cb(void *arg, bfa_boolean_t complete)
1783 {
1784         struct bfa_lps_s *lps   = arg;
1785
1786         if (!complete)
1787                 return;
1788
1789         /* Clear virtual link to base port will result in link down */
1790         if (lps->fdisc)
1791                 bfa_cb_lps_cvl_event(lps->bfa->bfad, lps->uarg);
1792 }
1793
1794 /*
1795  * Received Clear virtual link event --direct call for fcs,
1796  * queue for others
1797  */
1798 static void
1799 bfa_lps_cvl_event(struct bfa_lps_s *lps)
1800 {
1801         if (!lps->bfa->fcs) {
1802                 bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_cvl_event_cb,
1803                         lps);
1804                 return;
1805         }
1806
1807         /* Clear virtual link to base port will result in link down */
1808         if (lps->fdisc)
1809                 bfa_cb_lps_cvl_event(lps->bfa->bfad, lps->uarg);
1810 }
1811
1812
1813
1814 /*
1815  *  lps_public BFA LPS public functions
1816  */
1817
1818 u32
1819 bfa_lps_get_max_vport(struct bfa_s *bfa)
1820 {
1821         if (bfa_ioc_devid(&bfa->ioc) == BFA_PCI_DEVICE_ID_CT)
1822                 return BFA_LPS_MAX_VPORTS_SUPP_CT;
1823         else
1824                 return BFA_LPS_MAX_VPORTS_SUPP_CB;
1825 }
1826
1827 /*
1828  * Allocate a lport srvice tag.
1829  */
1830 struct bfa_lps_s  *
1831 bfa_lps_alloc(struct bfa_s *bfa)
1832 {
1833         struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1834         struct bfa_lps_s        *lps = NULL;
1835
1836         bfa_q_deq(&mod->lps_free_q, &lps);
1837
1838         if (lps == NULL)
1839                 return NULL;
1840
1841         list_add_tail(&lps->qe, &mod->lps_active_q);
1842
1843         bfa_sm_set_state(lps, bfa_lps_sm_init);
1844         return lps;
1845 }
1846
1847 /*
1848  * Free lport service tag. This can be called anytime after an alloc.
1849  * No need to wait for any pending login/logout completions.
1850  */
1851 void
1852 bfa_lps_delete(struct bfa_lps_s *lps)
1853 {
1854         bfa_sm_send_event(lps, BFA_LPS_SM_DELETE);
1855 }
1856
1857 /*
1858  * Initiate a lport login.
1859  */
1860 void
1861 bfa_lps_flogi(struct bfa_lps_s *lps, void *uarg, u8 alpa, u16 pdusz,
1862         wwn_t pwwn, wwn_t nwwn, bfa_boolean_t auth_en)
1863 {
1864         lps->uarg       = uarg;
1865         lps->alpa       = alpa;
1866         lps->pdusz      = pdusz;
1867         lps->pwwn       = pwwn;
1868         lps->nwwn       = nwwn;
1869         lps->fdisc      = BFA_FALSE;
1870         lps->auth_en    = auth_en;
1871         bfa_sm_send_event(lps, BFA_LPS_SM_LOGIN);
1872 }
1873
1874 /*
1875  * Initiate a lport fdisc login.
1876  */
1877 void
1878 bfa_lps_fdisc(struct bfa_lps_s *lps, void *uarg, u16 pdusz, wwn_t pwwn,
1879         wwn_t nwwn)
1880 {
1881         lps->uarg       = uarg;
1882         lps->alpa       = 0;
1883         lps->pdusz      = pdusz;
1884         lps->pwwn       = pwwn;
1885         lps->nwwn       = nwwn;
1886         lps->fdisc      = BFA_TRUE;
1887         lps->auth_en    = BFA_FALSE;
1888         bfa_sm_send_event(lps, BFA_LPS_SM_LOGIN);
1889 }
1890
1891
1892 /*
1893  * Initiate a lport FDSIC logout.
1894  */
1895 void
1896 bfa_lps_fdisclogo(struct bfa_lps_s *lps)
1897 {
1898         bfa_sm_send_event(lps, BFA_LPS_SM_LOGOUT);
1899 }
1900
1901
1902 /*
1903  * Return lport services tag given the pid
1904  */
1905 u8
1906 bfa_lps_get_tag_from_pid(struct bfa_s *bfa, u32 pid)
1907 {
1908         struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1909         struct bfa_lps_s        *lps;
1910         int                     i;
1911
1912         for (i = 0, lps = mod->lps_arr; i < mod->num_lps; i++, lps++) {
1913                 if (lps->lp_pid == pid)
1914                         return lps->lp_tag;
1915         }
1916
1917         /* Return base port tag anyway */
1918         return 0;
1919 }
1920
1921
1922 /*
1923  * return port id assigned to the base lport
1924  */
1925 u32
1926 bfa_lps_get_base_pid(struct bfa_s *bfa)
1927 {
1928         struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
1929
1930         return BFA_LPS_FROM_TAG(mod, 0)->lp_pid;
1931 }
1932
1933 /*
1934  * Set PID in case of n2n (which is assigned during PLOGI)
1935  */
1936 void
1937 bfa_lps_set_n2n_pid(struct bfa_lps_s *lps, uint32_t n2n_pid)
1938 {
1939         bfa_trc(lps->bfa, lps->lp_tag);
1940         bfa_trc(lps->bfa, n2n_pid);
1941
1942         lps->lp_pid = n2n_pid;
1943         bfa_sm_send_event(lps, BFA_LPS_SM_SET_N2N_PID);
1944 }
1945
1946 /*
1947  * LPS firmware message class handler.
1948  */
1949 void
1950 bfa_lps_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
1951 {
1952         union bfi_lps_i2h_msg_u msg;
1953
1954         bfa_trc(bfa, m->mhdr.msg_id);
1955         msg.msg = m;
1956
1957         switch (m->mhdr.msg_id) {
1958         case BFI_LPS_H2I_LOGIN_RSP:
1959                 bfa_lps_login_rsp(bfa, msg.login_rsp);
1960                 break;
1961
1962         case BFI_LPS_H2I_LOGOUT_RSP:
1963                 bfa_lps_logout_rsp(bfa, msg.logout_rsp);
1964                 break;
1965
1966         case BFI_LPS_H2I_CVL_EVENT:
1967                 bfa_lps_rx_cvl_event(bfa, msg.cvl_event);
1968                 break;
1969
1970         default:
1971                 bfa_trc(bfa, m->mhdr.msg_id);
1972                 WARN_ON(1);
1973         }
1974 }
1975
1976 /*
1977  * FC PORT state machine functions
1978  */
1979 static void
1980 bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
1981                         enum bfa_fcport_sm_event event)
1982 {
1983         bfa_trc(fcport->bfa, event);
1984
1985         switch (event) {
1986         case BFA_FCPORT_SM_START:
1987                 /*
1988                  * Start event after IOC is configured and BFA is started.
1989                  */
1990                 fcport->use_flash_cfg = BFA_TRUE;
1991
1992                 if (bfa_fcport_send_enable(fcport)) {
1993                         bfa_trc(fcport->bfa, BFA_TRUE);
1994                         bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
1995                 } else {
1996                         bfa_trc(fcport->bfa, BFA_FALSE);
1997                         bfa_sm_set_state(fcport,
1998                                         bfa_fcport_sm_enabling_qwait);
1999                 }
2000                 break;
2001
2002         case BFA_FCPORT_SM_ENABLE:
2003                 /*
2004                  * Port is persistently configured to be in enabled state. Do
2005                  * not change state. Port enabling is done when START event is
2006                  * received.
2007                  */
2008                 break;
2009
2010         case BFA_FCPORT_SM_DISABLE:
2011                 /*
2012                  * If a port is persistently configured to be disabled, the
2013                  * first event will a port disable request.
2014                  */
2015                 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2016                 break;
2017
2018         case BFA_FCPORT_SM_HWFAIL:
2019                 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2020                 break;
2021
2022         default:
2023                 bfa_sm_fault(fcport->bfa, event);
2024         }
2025 }
2026
2027 static void
2028 bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
2029                                 enum bfa_fcport_sm_event event)
2030 {
2031         char pwwn_buf[BFA_STRING_32];
2032         struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2033         bfa_trc(fcport->bfa, event);
2034
2035         switch (event) {
2036         case BFA_FCPORT_SM_QRESUME:
2037                 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2038                 bfa_fcport_send_enable(fcport);
2039                 break;
2040
2041         case BFA_FCPORT_SM_STOP:
2042                 bfa_reqq_wcancel(&fcport->reqq_wait);
2043                 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2044                 break;
2045
2046         case BFA_FCPORT_SM_ENABLE:
2047                 /*
2048                  * Already enable is in progress.
2049                  */
2050                 break;
2051
2052         case BFA_FCPORT_SM_DISABLE:
2053                 /*
2054                  * Just send disable request to firmware when room becomes
2055                  * available in request queue.
2056                  */
2057                 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2058                 bfa_reqq_wcancel(&fcport->reqq_wait);
2059                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2060                                 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2061                 wwn2str(pwwn_buf, fcport->pwwn);
2062                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2063                         "Base port disabled: WWN = %s\n", pwwn_buf);
2064                 break;
2065
2066         case BFA_FCPORT_SM_LINKUP:
2067         case BFA_FCPORT_SM_LINKDOWN:
2068                 /*
2069                  * Possible to get link events when doing back-to-back
2070                  * enable/disables.
2071                  */
2072                 break;
2073
2074         case BFA_FCPORT_SM_HWFAIL:
2075                 bfa_reqq_wcancel(&fcport->reqq_wait);
2076                 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2077                 break;
2078
2079         default:
2080                 bfa_sm_fault(fcport->bfa, event);
2081         }
2082 }
2083
2084 static void
2085 bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
2086                                                 enum bfa_fcport_sm_event event)
2087 {
2088         char pwwn_buf[BFA_STRING_32];
2089         struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2090         bfa_trc(fcport->bfa, event);
2091
2092         switch (event) {
2093         case BFA_FCPORT_SM_FWRSP:
2094         case BFA_FCPORT_SM_LINKDOWN:
2095                 bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
2096                 break;
2097
2098         case BFA_FCPORT_SM_LINKUP:
2099                 bfa_fcport_update_linkinfo(fcport);
2100                 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
2101
2102                 WARN_ON(!fcport->event_cbfn);
2103                 bfa_fcport_scn(fcport, BFA_PORT_LINKUP, BFA_FALSE);
2104                 break;
2105
2106         case BFA_FCPORT_SM_ENABLE:
2107                 /*
2108                  * Already being enabled.
2109                  */
2110                 break;
2111
2112         case BFA_FCPORT_SM_DISABLE:
2113                 if (bfa_fcport_send_disable(fcport))
2114                         bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2115                 else
2116                         bfa_sm_set_state(fcport,
2117                                          bfa_fcport_sm_disabling_qwait);
2118
2119                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2120                                 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2121                 wwn2str(pwwn_buf, fcport->pwwn);
2122                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2123                         "Base port disabled: WWN = %s\n", pwwn_buf);
2124                 break;
2125
2126         case BFA_FCPORT_SM_STOP:
2127                 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2128                 break;
2129
2130         case BFA_FCPORT_SM_HWFAIL:
2131                 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2132                 break;
2133
2134         default:
2135                 bfa_sm_fault(fcport->bfa, event);
2136         }
2137 }
2138
2139 static void
2140 bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
2141                                                 enum bfa_fcport_sm_event event)
2142 {
2143         struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
2144         char pwwn_buf[BFA_STRING_32];
2145         struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2146
2147         bfa_trc(fcport->bfa, event);
2148
2149         switch (event) {
2150         case BFA_FCPORT_SM_LINKUP:
2151                 bfa_fcport_update_linkinfo(fcport);
2152                 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
2153                 WARN_ON(!fcport->event_cbfn);
2154                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2155                                 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkup");
2156                 if (!bfa_ioc_get_fcmode(&fcport->bfa->ioc)) {
2157
2158                         bfa_trc(fcport->bfa,
2159                                 pevent->link_state.vc_fcf.fcf.fipenabled);
2160                         bfa_trc(fcport->bfa,
2161                                 pevent->link_state.vc_fcf.fcf.fipfailed);
2162
2163                         if (pevent->link_state.vc_fcf.fcf.fipfailed)
2164                                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2165                                         BFA_PL_EID_FIP_FCF_DISC, 0,
2166                                         "FIP FCF Discovery Failed");
2167                         else
2168                                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2169                                         BFA_PL_EID_FIP_FCF_DISC, 0,
2170                                         "FIP FCF Discovered");
2171                 }
2172
2173                 bfa_fcport_scn(fcport, BFA_PORT_LINKUP, BFA_FALSE);
2174                 wwn2str(pwwn_buf, fcport->pwwn);
2175                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2176                         "Base port online: WWN = %s\n", pwwn_buf);
2177                 break;
2178
2179         case BFA_FCPORT_SM_LINKDOWN:
2180                 /*
2181                  * Possible to get link down event.
2182                  */
2183                 break;
2184
2185         case BFA_FCPORT_SM_ENABLE:
2186                 /*
2187                  * Already enabled.
2188                  */
2189                 break;
2190
2191         case BFA_FCPORT_SM_DISABLE:
2192                 if (bfa_fcport_send_disable(fcport))
2193                         bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2194                 else
2195                         bfa_sm_set_state(fcport,
2196                                          bfa_fcport_sm_disabling_qwait);
2197
2198                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2199                                 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2200                 wwn2str(pwwn_buf, fcport->pwwn);
2201                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2202                         "Base port disabled: WWN = %s\n", pwwn_buf);
2203                 break;
2204
2205         case BFA_FCPORT_SM_STOP:
2206                 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2207                 break;
2208
2209         case BFA_FCPORT_SM_HWFAIL:
2210                 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2211                 break;
2212
2213         default:
2214                 bfa_sm_fault(fcport->bfa, event);
2215         }
2216 }
2217
2218 static void
2219 bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
2220         enum bfa_fcport_sm_event event)
2221 {
2222         char pwwn_buf[BFA_STRING_32];
2223         struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2224
2225         bfa_trc(fcport->bfa, event);
2226
2227         switch (event) {
2228         case BFA_FCPORT_SM_ENABLE:
2229                 /*
2230                  * Already enabled.
2231                  */
2232                 break;
2233
2234         case BFA_FCPORT_SM_DISABLE:
2235                 if (bfa_fcport_send_disable(fcport))
2236                         bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2237                 else
2238                         bfa_sm_set_state(fcport,
2239                                          bfa_fcport_sm_disabling_qwait);
2240
2241                 bfa_fcport_reset_linkinfo(fcport);
2242                 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2243                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2244                                 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2245                 wwn2str(pwwn_buf, fcport->pwwn);
2246                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2247                         "Base port offline: WWN = %s\n", pwwn_buf);
2248                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2249                         "Base port disabled: WWN = %s\n", pwwn_buf);
2250                 break;
2251
2252         case BFA_FCPORT_SM_LINKDOWN:
2253                 bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
2254                 bfa_fcport_reset_linkinfo(fcport);
2255                 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2256                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2257                                 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkdown");
2258                 wwn2str(pwwn_buf, fcport->pwwn);
2259                 if (BFA_PORT_IS_DISABLED(fcport->bfa))
2260                         BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2261                                 "Base port offline: WWN = %s\n", pwwn_buf);
2262                 else
2263                         BFA_LOG(KERN_ERR, bfad, bfa_log_level,
2264                                 "Base port (WWN = %s) "
2265                                 "lost fabric connectivity\n", pwwn_buf);
2266                 break;
2267
2268         case BFA_FCPORT_SM_STOP:
2269                 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2270                 bfa_fcport_reset_linkinfo(fcport);
2271                 wwn2str(pwwn_buf, fcport->pwwn);
2272                 if (BFA_PORT_IS_DISABLED(fcport->bfa))
2273                         BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2274                                 "Base port offline: WWN = %s\n", pwwn_buf);
2275                 else
2276                         BFA_LOG(KERN_ERR, bfad, bfa_log_level,
2277                                 "Base port (WWN = %s) "
2278                                 "lost fabric connectivity\n", pwwn_buf);
2279                 break;
2280
2281         case BFA_FCPORT_SM_HWFAIL:
2282                 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2283                 bfa_fcport_reset_linkinfo(fcport);
2284                 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2285                 wwn2str(pwwn_buf, fcport->pwwn);
2286                 if (BFA_PORT_IS_DISABLED(fcport->bfa))
2287                         BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2288                                 "Base port offline: WWN = %s\n", pwwn_buf);
2289                 else
2290                         BFA_LOG(KERN_ERR, bfad, bfa_log_level,
2291                                 "Base port (WWN = %s) "
2292                                 "lost fabric connectivity\n", pwwn_buf);
2293                 break;
2294
2295         default:
2296                 bfa_sm_fault(fcport->bfa, event);
2297         }
2298 }
2299
2300 static void
2301 bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
2302                                  enum bfa_fcport_sm_event event)
2303 {
2304         bfa_trc(fcport->bfa, event);
2305
2306         switch (event) {
2307         case BFA_FCPORT_SM_QRESUME:
2308                 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2309                 bfa_fcport_send_disable(fcport);
2310                 break;
2311
2312         case BFA_FCPORT_SM_STOP:
2313                 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2314                 bfa_reqq_wcancel(&fcport->reqq_wait);
2315                 break;
2316
2317         case BFA_FCPORT_SM_ENABLE:
2318                 bfa_sm_set_state(fcport, bfa_fcport_sm_toggling_qwait);
2319                 break;
2320
2321         case BFA_FCPORT_SM_DISABLE:
2322                 /*
2323                  * Already being disabled.
2324                  */
2325                 break;
2326
2327         case BFA_FCPORT_SM_LINKUP:
2328         case BFA_FCPORT_SM_LINKDOWN:
2329                 /*
2330                  * Possible to get link events when doing back-to-back
2331                  * enable/disables.
2332                  */
2333                 break;
2334
2335         case BFA_FCPORT_SM_HWFAIL:
2336                 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2337                 bfa_reqq_wcancel(&fcport->reqq_wait);
2338                 break;
2339
2340         default:
2341                 bfa_sm_fault(fcport->bfa, event);
2342         }
2343 }
2344
2345 static void
2346 bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s *fcport,
2347                                  enum bfa_fcport_sm_event event)
2348 {
2349         bfa_trc(fcport->bfa, event);
2350
2351         switch (event) {
2352         case BFA_FCPORT_SM_QRESUME:
2353                 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2354                 bfa_fcport_send_disable(fcport);
2355                 if (bfa_fcport_send_enable(fcport))
2356                         bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2357                 else
2358                         bfa_sm_set_state(fcport,
2359                                          bfa_fcport_sm_enabling_qwait);
2360                 break;
2361
2362         case BFA_FCPORT_SM_STOP:
2363                 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2364                 bfa_reqq_wcancel(&fcport->reqq_wait);
2365                 break;
2366
2367         case BFA_FCPORT_SM_ENABLE:
2368                 break;
2369
2370         case BFA_FCPORT_SM_DISABLE:
2371                 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
2372                 break;
2373
2374         case BFA_FCPORT_SM_LINKUP:
2375         case BFA_FCPORT_SM_LINKDOWN:
2376                 /*
2377                  * Possible to get link events when doing back-to-back
2378                  * enable/disables.
2379                  */
2380                 break;
2381
2382         case BFA_FCPORT_SM_HWFAIL:
2383                 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2384                 bfa_reqq_wcancel(&fcport->reqq_wait);
2385                 break;
2386
2387         default:
2388                 bfa_sm_fault(fcport->bfa, event);
2389         }
2390 }
2391
2392 static void
2393 bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
2394                                                 enum bfa_fcport_sm_event event)
2395 {
2396         char pwwn_buf[BFA_STRING_32];
2397         struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2398         bfa_trc(fcport->bfa, event);
2399
2400         switch (event) {
2401         case BFA_FCPORT_SM_FWRSP:
2402                 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2403                 break;
2404
2405         case BFA_FCPORT_SM_DISABLE:
2406                 /*
2407                  * Already being disabled.
2408                  */
2409                 break;
2410
2411         case BFA_FCPORT_SM_ENABLE:
2412                 if (bfa_fcport_send_enable(fcport))
2413                         bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2414                 else
2415                         bfa_sm_set_state(fcport,
2416                                          bfa_fcport_sm_enabling_qwait);
2417
2418                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2419                                 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
2420                 wwn2str(pwwn_buf, fcport->pwwn);
2421                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2422                         "Base port enabled: WWN = %s\n", pwwn_buf);
2423                 break;
2424
2425         case BFA_FCPORT_SM_STOP:
2426                 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2427                 break;
2428
2429         case BFA_FCPORT_SM_LINKUP:
2430         case BFA_FCPORT_SM_LINKDOWN:
2431                 /*
2432                  * Possible to get link events when doing back-to-back
2433                  * enable/disables.
2434                  */
2435                 break;
2436
2437         case BFA_FCPORT_SM_HWFAIL:
2438                 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2439                 break;
2440
2441         default:
2442                 bfa_sm_fault(fcport->bfa, event);
2443         }
2444 }
2445
2446 static void
2447 bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
2448                                                 enum bfa_fcport_sm_event event)
2449 {
2450         char pwwn_buf[BFA_STRING_32];
2451         struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2452         bfa_trc(fcport->bfa, event);
2453
2454         switch (event) {
2455         case BFA_FCPORT_SM_START:
2456                 /*
2457                  * Ignore start event for a port that is disabled.
2458                  */
2459                 break;
2460
2461         case BFA_FCPORT_SM_STOP:
2462                 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2463                 break;
2464
2465         case BFA_FCPORT_SM_ENABLE:
2466                 if (bfa_fcport_send_enable(fcport))
2467                         bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2468                 else
2469                         bfa_sm_set_state(fcport,
2470                                          bfa_fcport_sm_enabling_qwait);
2471
2472                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2473                                 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
2474                 wwn2str(pwwn_buf, fcport->pwwn);
2475                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2476                         "Base port enabled: WWN = %s\n", pwwn_buf);
2477                 break;
2478
2479         case BFA_FCPORT_SM_DISABLE:
2480                 /*
2481                  * Already disabled.
2482                  */
2483                 break;
2484
2485         case BFA_FCPORT_SM_HWFAIL:
2486                 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2487                 break;
2488
2489         default:
2490                 bfa_sm_fault(fcport->bfa, event);
2491         }
2492 }
2493
2494 static void
2495 bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
2496                          enum bfa_fcport_sm_event event)
2497 {
2498         bfa_trc(fcport->bfa, event);
2499
2500         switch (event) {
2501         case BFA_FCPORT_SM_START:
2502                 if (bfa_fcport_send_enable(fcport))
2503                         bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2504                 else
2505                         bfa_sm_set_state(fcport,
2506                                          bfa_fcport_sm_enabling_qwait);
2507                 break;
2508
2509         default:
2510                 /*
2511                  * Ignore all other events.
2512                  */
2513                 ;
2514         }
2515 }
2516
2517 /*
2518  * Port is enabled. IOC is down/failed.
2519  */
2520 static void
2521 bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
2522                          enum bfa_fcport_sm_event event)
2523 {
2524         bfa_trc(fcport->bfa, event);
2525
2526         switch (event) {
2527         case BFA_FCPORT_SM_START:
2528                 if (bfa_fcport_send_enable(fcport))
2529                         bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2530                 else
2531                         bfa_sm_set_state(fcport,
2532                                          bfa_fcport_sm_enabling_qwait);
2533                 break;
2534
2535         default:
2536                 /*
2537                  * Ignore all events.
2538                  */
2539                 ;
2540         }
2541 }
2542
2543 /*
2544  * Port is disabled. IOC is down/failed.
2545  */
2546 static void
2547 bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
2548                          enum bfa_fcport_sm_event event)
2549 {
2550         bfa_trc(fcport->bfa, event);
2551
2552         switch (event) {
2553         case BFA_FCPORT_SM_START:
2554                 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2555                 break;
2556
2557         case BFA_FCPORT_SM_ENABLE:
2558                 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2559                 break;
2560
2561         default:
2562                 /*
2563                  * Ignore all events.
2564                  */
2565                 ;
2566         }
2567 }
2568
2569 /*
2570  * Link state is down
2571  */
2572 static void
2573 bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
2574                 enum bfa_fcport_ln_sm_event event)
2575 {
2576         bfa_trc(ln->fcport->bfa, event);
2577
2578         switch (event) {
2579         case BFA_FCPORT_LN_SM_LINKUP:
2580                 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
2581                 bfa_fcport_queue_cb(ln, BFA_PORT_LINKUP);
2582                 break;
2583
2584         default:
2585                 bfa_sm_fault(ln->fcport->bfa, event);
2586         }
2587 }
2588
2589 /*
2590  * Link state is waiting for down notification
2591  */
2592 static void
2593 bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
2594                 enum bfa_fcport_ln_sm_event event)
2595 {
2596         bfa_trc(ln->fcport->bfa, event);
2597
2598         switch (event) {
2599         case BFA_FCPORT_LN_SM_LINKUP:
2600                 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
2601                 break;
2602
2603         case BFA_FCPORT_LN_SM_NOTIFICATION:
2604                 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
2605                 break;
2606
2607         default:
2608                 bfa_sm_fault(ln->fcport->bfa, event);
2609         }
2610 }
2611
2612 /*
2613  * Link state is waiting for down notification and there is a pending up
2614  */
2615 static void
2616 bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
2617                 enum bfa_fcport_ln_sm_event event)
2618 {
2619         bfa_trc(ln->fcport->bfa, event);
2620
2621         switch (event) {
2622         case BFA_FCPORT_LN_SM_LINKDOWN:
2623                 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2624                 break;
2625
2626         case BFA_FCPORT_LN_SM_NOTIFICATION:
2627                 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
2628                 bfa_fcport_queue_cb(ln, BFA_PORT_LINKUP);
2629                 break;
2630
2631         default:
2632                 bfa_sm_fault(ln->fcport->bfa, event);
2633         }
2634 }
2635
2636 /*
2637  * Link state is up
2638  */
2639 static void
2640 bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
2641                 enum bfa_fcport_ln_sm_event event)
2642 {
2643         bfa_trc(ln->fcport->bfa, event);
2644
2645         switch (event) {
2646         case BFA_FCPORT_LN_SM_LINKDOWN:
2647                 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2648                 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2649                 break;
2650
2651         default:
2652                 bfa_sm_fault(ln->fcport->bfa, event);
2653         }
2654 }
2655
2656 /*
2657  * Link state is waiting for up notification
2658  */
2659 static void
2660 bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
2661                 enum bfa_fcport_ln_sm_event event)
2662 {
2663         bfa_trc(ln->fcport->bfa, event);
2664
2665         switch (event) {
2666         case BFA_FCPORT_LN_SM_LINKDOWN:
2667                 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
2668                 break;
2669
2670         case BFA_FCPORT_LN_SM_NOTIFICATION:
2671                 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up);
2672                 break;
2673
2674         default:
2675                 bfa_sm_fault(ln->fcport->bfa, event);
2676         }
2677 }
2678
2679 /*
2680  * Link state is waiting for up notification and there is a pending down
2681  */
2682 static void
2683 bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
2684                 enum bfa_fcport_ln_sm_event event)
2685 {
2686         bfa_trc(ln->fcport->bfa, event);
2687
2688         switch (event) {
2689         case BFA_FCPORT_LN_SM_LINKUP:
2690                 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_up_nf);
2691                 break;
2692
2693         case BFA_FCPORT_LN_SM_NOTIFICATION:
2694                 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2695                 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2696                 break;
2697
2698         default:
2699                 bfa_sm_fault(ln->fcport->bfa, event);
2700         }
2701 }
2702
2703 /*
2704  * Link state is waiting for up notification and there are pending down and up
2705  */
2706 static void
2707 bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
2708                         enum bfa_fcport_ln_sm_event event)
2709 {
2710         bfa_trc(ln->fcport->bfa, event);
2711
2712         switch (event) {
2713         case BFA_FCPORT_LN_SM_LINKDOWN:
2714                 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
2715                 break;
2716
2717         case BFA_FCPORT_LN_SM_NOTIFICATION:
2718                 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
2719                 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2720                 break;
2721
2722         default:
2723                 bfa_sm_fault(ln->fcport->bfa, event);
2724         }
2725 }
2726
2727 static void
2728 __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete)
2729 {
2730         struct bfa_fcport_ln_s *ln = cbarg;
2731
2732         if (complete)
2733                 ln->fcport->event_cbfn(ln->fcport->event_cbarg, ln->ln_event);
2734         else
2735                 bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
2736 }
2737
2738 /*
2739  * Send SCN notification to upper layers.
2740  * trunk - false if caller is fcport to ignore fcport event in trunked mode
2741  */
2742 static void
2743 bfa_fcport_scn(struct bfa_fcport_s *fcport, enum bfa_port_linkstate event,
2744         bfa_boolean_t trunk)
2745 {
2746         if (fcport->cfg.trunked && !trunk)
2747                 return;
2748
2749         switch (event) {
2750         case BFA_PORT_LINKUP:
2751                 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKUP);
2752                 break;
2753         case BFA_PORT_LINKDOWN:
2754                 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKDOWN);
2755                 break;
2756         default:
2757                 WARN_ON(1);
2758         }
2759 }
2760
2761 static void
2762 bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln, enum bfa_port_linkstate event)
2763 {
2764         struct bfa_fcport_s *fcport = ln->fcport;
2765
2766         if (fcport->bfa->fcs) {
2767                 fcport->event_cbfn(fcport->event_cbarg, event);
2768                 bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
2769         } else {
2770                 ln->ln_event = event;
2771                 bfa_cb_queue(fcport->bfa, &ln->ln_qe,
2772                         __bfa_cb_fcport_event, ln);
2773         }
2774 }
2775
2776 #define FCPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_fcport_stats_u), \
2777                                                         BFA_CACHELINE_SZ))
2778
2779 static void
2780 bfa_fcport_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
2781                 u32 *dm_len)
2782 {
2783         *dm_len += FCPORT_STATS_DMA_SZ;
2784 }
2785
2786 static void
2787 bfa_fcport_qresume(void *cbarg)
2788 {
2789         struct bfa_fcport_s *fcport = cbarg;
2790
2791         bfa_sm_send_event(fcport, BFA_FCPORT_SM_QRESUME);
2792 }
2793
2794 static void
2795 bfa_fcport_mem_claim(struct bfa_fcport_s *fcport, struct bfa_meminfo_s *meminfo)
2796 {
2797         u8              *dm_kva;
2798         u64     dm_pa;
2799
2800         dm_kva = bfa_meminfo_dma_virt(meminfo);
2801         dm_pa  = bfa_meminfo_dma_phys(meminfo);
2802
2803         fcport->stats_kva = dm_kva;
2804         fcport->stats_pa  = dm_pa;
2805         fcport->stats     = (union bfa_fcport_stats_u *) dm_kva;
2806
2807         dm_kva += FCPORT_STATS_DMA_SZ;
2808         dm_pa  += FCPORT_STATS_DMA_SZ;
2809
2810         bfa_meminfo_dma_virt(meminfo) = dm_kva;
2811         bfa_meminfo_dma_phys(meminfo) = dm_pa;
2812 }
2813
2814 /*
2815  * Memory initialization.
2816  */
2817 static void
2818 bfa_fcport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
2819                 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
2820 {
2821         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
2822         struct bfa_port_cfg_s *port_cfg = &fcport->cfg;
2823         struct bfa_fcport_ln_s *ln = &fcport->ln;
2824         struct timeval tv;
2825
2826         memset(fcport, 0, sizeof(struct bfa_fcport_s));
2827         fcport->bfa = bfa;
2828         ln->fcport = fcport;
2829
2830         bfa_fcport_mem_claim(fcport, meminfo);
2831
2832         bfa_sm_set_state(fcport, bfa_fcport_sm_uninit);
2833         bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
2834
2835         /*
2836          * initialize time stamp for stats reset
2837          */
2838         do_gettimeofday(&tv);
2839         fcport->stats_reset_time = tv.tv_sec;
2840
2841         /*
2842          * initialize and set default configuration
2843          */
2844         port_cfg->topology = BFA_PORT_TOPOLOGY_P2P;
2845         port_cfg->speed = BFA_PORT_SPEED_AUTO;
2846         port_cfg->trunked = BFA_FALSE;
2847         port_cfg->maxfrsize = 0;
2848
2849         port_cfg->trl_def_speed = BFA_PORT_SPEED_1GBPS;
2850
2851         bfa_reqq_winit(&fcport->reqq_wait, bfa_fcport_qresume, fcport);
2852 }
2853
2854 static void
2855 bfa_fcport_detach(struct bfa_s *bfa)
2856 {
2857 }
2858
2859 /*
2860  * Called when IOC is ready.
2861  */
2862 static void
2863 bfa_fcport_start(struct bfa_s *bfa)
2864 {
2865         bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_START);
2866 }
2867
2868 /*
2869  * Called before IOC is stopped.
2870  */
2871 static void
2872 bfa_fcport_stop(struct bfa_s *bfa)
2873 {
2874         bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_STOP);
2875         bfa_trunk_iocdisable(bfa);
2876 }
2877
2878 /*
2879  * Called when IOC failure is detected.
2880  */
2881 static void
2882 bfa_fcport_iocdisable(struct bfa_s *bfa)
2883 {
2884         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
2885
2886         bfa_sm_send_event(fcport, BFA_FCPORT_SM_HWFAIL);
2887         bfa_trunk_iocdisable(bfa);
2888 }
2889
2890 static void
2891 bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport)
2892 {
2893         struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
2894         struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
2895
2896         fcport->speed = pevent->link_state.speed;
2897         fcport->topology = pevent->link_state.topology;
2898
2899         if (fcport->topology == BFA_PORT_TOPOLOGY_LOOP)
2900                 fcport->myalpa = 0;
2901
2902         /* QoS Details */
2903         fcport->qos_attr = pevent->link_state.qos_attr;
2904         fcport->qos_vc_attr = pevent->link_state.vc_fcf.qos_vc_attr;
2905
2906         /*
2907          * update trunk state if applicable
2908          */
2909         if (!fcport->cfg.trunked)
2910                 trunk->attr.state = BFA_TRUNK_DISABLED;
2911
2912         /* update FCoE specific */
2913         fcport->fcoe_vlan = be16_to_cpu(pevent->link_state.vc_fcf.fcf.vlan);
2914
2915         bfa_trc(fcport->bfa, fcport->speed);
2916         bfa_trc(fcport->bfa, fcport->topology);
2917 }
2918
2919 static void
2920 bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport)
2921 {
2922         fcport->speed = BFA_PORT_SPEED_UNKNOWN;
2923         fcport->topology = BFA_PORT_TOPOLOGY_NONE;
2924 }
2925
2926 /*
2927  * Send port enable message to firmware.
2928  */
2929 static bfa_boolean_t
2930 bfa_fcport_send_enable(struct bfa_fcport_s *fcport)
2931 {
2932         struct bfi_fcport_enable_req_s *m;
2933
2934         /*
2935          * Increment message tag before queue check, so that responses to old
2936          * requests are discarded.
2937          */
2938         fcport->msgtag++;
2939
2940         /*
2941          * check for room in queue to send request now
2942          */
2943         m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
2944         if (!m) {
2945                 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
2946                                                         &fcport->reqq_wait);
2947                 return BFA_FALSE;
2948         }
2949
2950         bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_ENABLE_REQ,
2951                         bfa_lpuid(fcport->bfa));
2952         m->nwwn = fcport->nwwn;
2953         m->pwwn = fcport->pwwn;
2954         m->port_cfg = fcport->cfg;
2955         m->msgtag = fcport->msgtag;
2956         m->port_cfg.maxfrsize = cpu_to_be16(fcport->cfg.maxfrsize);
2957          m->use_flash_cfg = fcport->use_flash_cfg;
2958         bfa_dma_be_addr_set(m->stats_dma_addr, fcport->stats_pa);
2959         bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_lo);
2960         bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_hi);
2961
2962         /*
2963          * queue I/O message to firmware
2964          */
2965         bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
2966         return BFA_TRUE;
2967 }
2968
2969 /*
2970  * Send port disable message to firmware.
2971  */
2972 static  bfa_boolean_t
2973 bfa_fcport_send_disable(struct bfa_fcport_s *fcport)
2974 {
2975         struct bfi_fcport_req_s *m;
2976
2977         /*
2978          * Increment message tag before queue check, so that responses to old
2979          * requests are discarded.
2980          */
2981         fcport->msgtag++;
2982
2983         /*
2984          * check for room in queue to send request now
2985          */
2986         m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
2987         if (!m) {
2988                 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
2989                                                         &fcport->reqq_wait);
2990                 return BFA_FALSE;
2991         }
2992
2993         bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_DISABLE_REQ,
2994                         bfa_lpuid(fcport->bfa));
2995         m->msgtag = fcport->msgtag;
2996
2997         /*
2998          * queue I/O message to firmware
2999          */
3000         bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
3001
3002         return BFA_TRUE;
3003 }
3004
3005 static void
3006 bfa_fcport_set_wwns(struct bfa_fcport_s *fcport)
3007 {
3008         fcport->pwwn = fcport->bfa->ioc.attr->pwwn;
3009         fcport->nwwn = fcport->bfa->ioc.attr->nwwn;
3010
3011         bfa_trc(fcport->bfa, fcport->pwwn);
3012         bfa_trc(fcport->bfa, fcport->nwwn);
3013 }
3014
3015 static void
3016 bfa_fcport_send_txcredit(void *port_cbarg)
3017 {
3018
3019         struct bfa_fcport_s *fcport = port_cbarg;
3020         struct bfi_fcport_set_svc_params_req_s *m;
3021
3022         /*
3023          * check for room in queue to send request now
3024          */
3025         m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3026         if (!m) {
3027                 bfa_trc(fcport->bfa, fcport->cfg.tx_bbcredit);
3028                 return;
3029         }
3030
3031         bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_SET_SVC_PARAMS_REQ,
3032                         bfa_lpuid(fcport->bfa));
3033         m->tx_bbcredit = cpu_to_be16((u16)fcport->cfg.tx_bbcredit);
3034
3035         /*
3036          * queue I/O message to firmware
3037          */
3038         bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
3039 }
3040
3041 static void
3042 bfa_fcport_qos_stats_swap(struct bfa_qos_stats_s *d,
3043         struct bfa_qos_stats_s *s)
3044 {
3045         u32     *dip = (u32 *) d;
3046         __be32  *sip = (__be32 *) s;
3047         int             i;
3048
3049         /* Now swap the 32 bit fields */
3050         for (i = 0; i < (sizeof(struct bfa_qos_stats_s)/sizeof(u32)); ++i)
3051                 dip[i] = be32_to_cpu(sip[i]);
3052 }
3053
3054 static void
3055 bfa_fcport_fcoe_stats_swap(struct bfa_fcoe_stats_s *d,
3056         struct bfa_fcoe_stats_s *s)
3057 {
3058         u32     *dip = (u32 *) d;
3059         __be32  *sip = (__be32 *) s;
3060         int             i;
3061
3062         for (i = 0; i < ((sizeof(struct bfa_fcoe_stats_s))/sizeof(u32));
3063              i = i + 2) {
3064 #ifdef __BIG_ENDIAN
3065                 dip[i] = be32_to_cpu(sip[i]);
3066                 dip[i + 1] = be32_to_cpu(sip[i + 1]);
3067 #else
3068                 dip[i] = be32_to_cpu(sip[i + 1]);
3069                 dip[i + 1] = be32_to_cpu(sip[i]);
3070 #endif
3071         }
3072 }
3073
3074 static void
3075 __bfa_cb_fcport_stats_get(void *cbarg, bfa_boolean_t complete)
3076 {
3077         struct bfa_fcport_s *fcport = cbarg;
3078
3079         if (complete) {
3080                 if (fcport->stats_status == BFA_STATUS_OK) {
3081                         struct timeval tv;
3082
3083                         /* Swap FC QoS or FCoE stats */
3084                         if (bfa_ioc_get_fcmode(&fcport->bfa->ioc)) {
3085                                 bfa_fcport_qos_stats_swap(
3086                                         &fcport->stats_ret->fcqos,
3087                                         &fcport->stats->fcqos);
3088                         } else {
3089                                 bfa_fcport_fcoe_stats_swap(
3090                                         &fcport->stats_ret->fcoe,
3091                                         &fcport->stats->fcoe);
3092
3093                                 do_gettimeofday(&tv);
3094                                 fcport->stats_ret->fcoe.secs_reset =
3095                                         tv.tv_sec - fcport->stats_reset_time;
3096                         }
3097                 }
3098                 fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
3099         } else {
3100                 fcport->stats_busy = BFA_FALSE;
3101                 fcport->stats_status = BFA_STATUS_OK;
3102         }
3103 }
3104
3105 static void
3106 bfa_fcport_stats_get_timeout(void *cbarg)
3107 {
3108         struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3109
3110         bfa_trc(fcport->bfa, fcport->stats_qfull);
3111
3112         if (fcport->stats_qfull) {
3113                 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
3114                 fcport->stats_qfull = BFA_FALSE;
3115         }
3116
3117         fcport->stats_status = BFA_STATUS_ETIMER;
3118         bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, __bfa_cb_fcport_stats_get,
3119                 fcport);
3120 }
3121
3122 static void
3123 bfa_fcport_send_stats_get(void *cbarg)
3124 {
3125         struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3126         struct bfi_fcport_req_s *msg;
3127
3128         msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3129
3130         if (!msg) {
3131                 fcport->stats_qfull = BFA_TRUE;
3132                 bfa_reqq_winit(&fcport->stats_reqq_wait,
3133                                 bfa_fcport_send_stats_get, fcport);
3134                 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3135                                 &fcport->stats_reqq_wait);
3136                 return;
3137         }
3138         fcport->stats_qfull = BFA_FALSE;
3139
3140         memset(msg, 0, sizeof(struct bfi_fcport_req_s));
3141         bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_GET_REQ,
3142                         bfa_lpuid(fcport->bfa));
3143         bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
3144 }
3145
3146 static void
3147 __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete)
3148 {
3149         struct bfa_fcport_s *fcport = cbarg;
3150
3151         if (complete) {
3152                 struct timeval tv;
3153
3154                 /*
3155                  * re-initialize time stamp for stats reset
3156                  */
3157                 do_gettimeofday(&tv);
3158                 fcport->stats_reset_time = tv.tv_sec;
3159
3160                 fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
3161         } else {
3162                 fcport->stats_busy = BFA_FALSE;
3163                 fcport->stats_status = BFA_STATUS_OK;
3164         }
3165 }
3166
3167 static void
3168 bfa_fcport_stats_clr_timeout(void *cbarg)
3169 {
3170         struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3171
3172         bfa_trc(fcport->bfa, fcport->stats_qfull);
3173
3174         if (fcport->stats_qfull) {
3175                 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
3176                 fcport->stats_qfull = BFA_FALSE;
3177         }
3178
3179         fcport->stats_status = BFA_STATUS_ETIMER;
3180         bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
3181                         __bfa_cb_fcport_stats_clr, fcport);
3182 }
3183
3184 static void
3185 bfa_fcport_send_stats_clear(void *cbarg)
3186 {
3187         struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3188         struct bfi_fcport_req_s *msg;
3189
3190         msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3191
3192         if (!msg) {
3193                 fcport->stats_qfull = BFA_TRUE;
3194                 bfa_reqq_winit(&fcport->stats_reqq_wait,
3195                                 bfa_fcport_send_stats_clear, fcport);
3196                 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3197                                                 &fcport->stats_reqq_wait);
3198                 return;
3199         }
3200         fcport->stats_qfull = BFA_FALSE;
3201
3202         memset(msg, 0, sizeof(struct bfi_fcport_req_s));
3203         bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_CLEAR_REQ,
3204                         bfa_lpuid(fcport->bfa));
3205         bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
3206 }
3207
3208 /*
3209  * Handle trunk SCN event from firmware.
3210  */
3211 static void
3212 bfa_trunk_scn(struct bfa_fcport_s *fcport, struct bfi_fcport_trunk_scn_s *scn)
3213 {
3214         struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
3215         struct bfi_fcport_trunk_link_s *tlink;
3216         struct bfa_trunk_link_attr_s *lattr;
3217         enum bfa_trunk_state state_prev;
3218         int i;
3219         int link_bm = 0;
3220
3221         bfa_trc(fcport->bfa, fcport->cfg.trunked);
3222         WARN_ON(scn->trunk_state != BFA_TRUNK_ONLINE &&
3223                    scn->trunk_state != BFA_TRUNK_OFFLINE);
3224
3225         bfa_trc(fcport->bfa, trunk->attr.state);
3226         bfa_trc(fcport->bfa, scn->trunk_state);
3227         bfa_trc(fcport->bfa, scn->trunk_speed);
3228
3229         /*
3230          * Save off new state for trunk attribute query
3231          */
3232         state_prev = trunk->attr.state;
3233         if (fcport->cfg.trunked && (trunk->attr.state != BFA_TRUNK_DISABLED))
3234                 trunk->attr.state = scn->trunk_state;
3235         trunk->attr.speed = scn->trunk_speed;
3236         for (i = 0; i < BFA_TRUNK_MAX_PORTS; i++) {
3237                 lattr = &trunk->attr.link_attr[i];
3238                 tlink = &scn->tlink[i];
3239
3240                 lattr->link_state = tlink->state;
3241                 lattr->trunk_wwn  = tlink->trunk_wwn;
3242                 lattr->fctl       = tlink->fctl;
3243                 lattr->speed      = tlink->speed;
3244                 lattr->deskew     = be32_to_cpu(tlink->deskew);
3245
3246                 if (tlink->state == BFA_TRUNK_LINK_STATE_UP) {
3247                         fcport->speed    = tlink->speed;
3248                         fcport->topology = BFA_PORT_TOPOLOGY_P2P;
3249                         link_bm |= 1 << i;
3250                 }
3251
3252                 bfa_trc(fcport->bfa, lattr->link_state);
3253                 bfa_trc(fcport->bfa, lattr->trunk_wwn);
3254                 bfa_trc(fcport->bfa, lattr->fctl);
3255                 bfa_trc(fcport->bfa, lattr->speed);
3256                 bfa_trc(fcport->bfa, lattr->deskew);
3257         }
3258
3259         switch (link_bm) {
3260         case 3:
3261                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3262                         BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,1)");
3263                 break;
3264         case 2:
3265                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3266                         BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(-,1)");
3267                 break;
3268         case 1:
3269                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3270                         BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,-)");
3271                 break;
3272         default:
3273                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3274                         BFA_PL_EID_TRUNK_SCN, 0, "Trunk down");
3275         }
3276
3277         /*
3278          * Notify upper layers if trunk state changed.
3279          */
3280         if ((state_prev != trunk->attr.state) ||
3281                 (scn->trunk_state == BFA_TRUNK_OFFLINE)) {
3282                 bfa_fcport_scn(fcport, (scn->trunk_state == BFA_TRUNK_ONLINE) ?
3283                         BFA_PORT_LINKUP : BFA_PORT_LINKDOWN, BFA_TRUE);
3284         }
3285 }
3286
3287 static void
3288 bfa_trunk_iocdisable(struct bfa_s *bfa)
3289 {
3290         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3291         int i = 0;
3292
3293         /*
3294          * In trunked mode, notify upper layers that link is down
3295          */
3296         if (fcport->cfg.trunked) {
3297                 if (fcport->trunk.attr.state == BFA_TRUNK_ONLINE)
3298                         bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_TRUE);
3299
3300                 fcport->trunk.attr.state = BFA_TRUNK_OFFLINE;
3301                 fcport->trunk.attr.speed = BFA_PORT_SPEED_UNKNOWN;
3302                 for (i = 0; i < BFA_TRUNK_MAX_PORTS; i++) {
3303                         fcport->trunk.attr.link_attr[i].trunk_wwn = 0;
3304                         fcport->trunk.attr.link_attr[i].fctl =
3305                                                 BFA_TRUNK_LINK_FCTL_NORMAL;
3306                         fcport->trunk.attr.link_attr[i].link_state =
3307                                                 BFA_TRUNK_LINK_STATE_DN_LINKDN;
3308                         fcport->trunk.attr.link_attr[i].speed =
3309                                                 BFA_PORT_SPEED_UNKNOWN;
3310                         fcport->trunk.attr.link_attr[i].deskew = 0;
3311                 }
3312         }
3313 }
3314
3315 /*
3316  * Called to initialize port attributes
3317  */
3318 void
3319 bfa_fcport_init(struct bfa_s *bfa)
3320 {
3321         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3322
3323         /*
3324          * Initialize port attributes from IOC hardware data.
3325          */
3326         bfa_fcport_set_wwns(fcport);
3327         if (fcport->cfg.maxfrsize == 0)
3328                 fcport->cfg.maxfrsize = bfa_ioc_maxfrsize(&bfa->ioc);
3329         fcport->cfg.rx_bbcredit = bfa_ioc_rx_bbcredit(&bfa->ioc);
3330         fcport->speed_sup = bfa_ioc_speed_sup(&bfa->ioc);
3331
3332         WARN_ON(!fcport->cfg.maxfrsize);
3333         WARN_ON(!fcport->cfg.rx_bbcredit);
3334         WARN_ON(!fcport->speed_sup);
3335 }
3336
3337 /*
3338  * Firmware message handler.
3339  */
3340 void
3341 bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
3342 {
3343         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3344         union bfi_fcport_i2h_msg_u i2hmsg;
3345
3346         i2hmsg.msg = msg;
3347         fcport->event_arg.i2hmsg = i2hmsg;
3348
3349         bfa_trc(bfa, msg->mhdr.msg_id);
3350         bfa_trc(bfa, bfa_sm_to_state(hal_port_sm_table, fcport->sm));
3351
3352         switch (msg->mhdr.msg_id) {
3353         case BFI_FCPORT_I2H_ENABLE_RSP:
3354                 if (fcport->msgtag == i2hmsg.penable_rsp->msgtag) {
3355
3356                         if (fcport->use_flash_cfg) {
3357                                 fcport->cfg = i2hmsg.penable_rsp->port_cfg;
3358                                 fcport->cfg.maxfrsize =
3359                                         cpu_to_be16(fcport->cfg.maxfrsize);
3360                                 fcport->cfg.path_tov =
3361                                         cpu_to_be16(fcport->cfg.path_tov);
3362                                 fcport->cfg.q_depth =
3363                                         cpu_to_be16(fcport->cfg.q_depth);
3364
3365                                 if (fcport->cfg.trunked)
3366                                         fcport->trunk.attr.state =
3367                                                 BFA_TRUNK_OFFLINE;
3368                                 else
3369                                         fcport->trunk.attr.state =
3370                                                 BFA_TRUNK_DISABLED;
3371                                 fcport->use_flash_cfg = BFA_FALSE;
3372                         }
3373
3374                         bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
3375                 }
3376                 break;
3377
3378         case BFI_FCPORT_I2H_DISABLE_RSP:
3379                 if (fcport->msgtag == i2hmsg.penable_rsp->msgtag)
3380                         bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
3381                 break;
3382
3383         case BFI_FCPORT_I2H_EVENT:
3384                 if (i2hmsg.event->link_state.linkstate == BFA_PORT_LINKUP)
3385                         bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKUP);
3386                 else
3387                         bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKDOWN);
3388                 break;
3389
3390         case BFI_FCPORT_I2H_TRUNK_SCN:
3391                 bfa_trunk_scn(fcport, i2hmsg.trunk_scn);
3392                 break;
3393
3394         case BFI_FCPORT_I2H_STATS_GET_RSP:
3395                 /*
3396                  * check for timer pop before processing the rsp
3397                  */
3398                 if (fcport->stats_busy == BFA_FALSE ||
3399                     fcport->stats_status == BFA_STATUS_ETIMER)
3400                         break;
3401
3402                 bfa_timer_stop(&fcport->timer);
3403                 fcport->stats_status = i2hmsg.pstatsget_rsp->status;
3404                 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
3405                                 __bfa_cb_fcport_stats_get, fcport);
3406                 break;
3407
3408         case BFI_FCPORT_I2H_STATS_CLEAR_RSP:
3409                 /*
3410                  * check for timer pop before processing the rsp
3411                  */
3412                 if (fcport->stats_busy == BFA_FALSE ||
3413                     fcport->stats_status == BFA_STATUS_ETIMER)
3414                         break;
3415
3416                 bfa_timer_stop(&fcport->timer);
3417                 fcport->stats_status = BFA_STATUS_OK;
3418                 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
3419                                 __bfa_cb_fcport_stats_clr, fcport);
3420                 break;
3421
3422         case BFI_FCPORT_I2H_ENABLE_AEN:
3423                 bfa_sm_send_event(fcport, BFA_FCPORT_SM_ENABLE);
3424                 break;
3425
3426         case BFI_FCPORT_I2H_DISABLE_AEN:
3427                 bfa_sm_send_event(fcport, BFA_FCPORT_SM_DISABLE);
3428                 break;
3429
3430         default:
3431                 WARN_ON(1);
3432         break;
3433         }
3434 }
3435
3436 /*
3437  * Registered callback for port events.
3438  */
3439 void
3440 bfa_fcport_event_register(struct bfa_s *bfa,
3441                                 void (*cbfn) (void *cbarg,
3442                                 enum bfa_port_linkstate event),
3443                                 void *cbarg)
3444 {
3445         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3446
3447         fcport->event_cbfn = cbfn;
3448         fcport->event_cbarg = cbarg;
3449 }
3450
3451 bfa_status_t
3452 bfa_fcport_enable(struct bfa_s *bfa)
3453 {
3454         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3455
3456         if (bfa_ioc_is_disabled(&bfa->ioc))
3457                 return BFA_STATUS_IOC_DISABLED;
3458
3459         if (fcport->diag_busy)
3460                 return BFA_STATUS_DIAG_BUSY;
3461
3462         bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_ENABLE);
3463         return BFA_STATUS_OK;
3464 }
3465
3466 bfa_status_t
3467 bfa_fcport_disable(struct bfa_s *bfa)
3468 {
3469
3470         if (bfa_ioc_is_disabled(&bfa->ioc))
3471                 return BFA_STATUS_IOC_DISABLED;
3472
3473         bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DISABLE);
3474         return BFA_STATUS_OK;
3475 }
3476
3477 /*
3478  * Configure port speed.
3479  */
3480 bfa_status_t
3481 bfa_fcport_cfg_speed(struct bfa_s *bfa, enum bfa_port_speed speed)
3482 {
3483         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3484
3485         bfa_trc(bfa, speed);
3486
3487         if (fcport->cfg.trunked == BFA_TRUE)
3488                 return BFA_STATUS_TRUNK_ENABLED;
3489         if ((speed != BFA_PORT_SPEED_AUTO) && (speed > fcport->speed_sup)) {
3490                 bfa_trc(bfa, fcport->speed_sup);
3491                 return BFA_STATUS_UNSUPP_SPEED;
3492         }
3493
3494         fcport->cfg.speed = speed;
3495
3496         return BFA_STATUS_OK;
3497 }
3498
3499 /*
3500  * Get current speed.
3501  */
3502 enum bfa_port_speed
3503 bfa_fcport_get_speed(struct bfa_s *bfa)
3504 {
3505         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3506
3507         return fcport->speed;
3508 }
3509
3510 /*
3511  * Configure port topology.
3512  */
3513 bfa_status_t
3514 bfa_fcport_cfg_topology(struct bfa_s *bfa, enum bfa_port_topology topology)
3515 {
3516         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3517
3518         bfa_trc(bfa, topology);
3519         bfa_trc(bfa, fcport->cfg.topology);
3520
3521         switch (topology) {
3522         case BFA_PORT_TOPOLOGY_P2P:
3523         case BFA_PORT_TOPOLOGY_LOOP:
3524         case BFA_PORT_TOPOLOGY_AUTO:
3525                 break;
3526
3527         default:
3528                 return BFA_STATUS_EINVAL;
3529         }
3530
3531         fcport->cfg.topology = topology;
3532         return BFA_STATUS_OK;
3533 }
3534
3535 /*
3536  * Get current topology.
3537  */
3538 enum bfa_port_topology
3539 bfa_fcport_get_topology(struct bfa_s *bfa)
3540 {
3541         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3542
3543         return fcport->topology;
3544 }
3545
3546 bfa_status_t
3547 bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa)
3548 {
3549         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3550
3551         bfa_trc(bfa, alpa);
3552         bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
3553         bfa_trc(bfa, fcport->cfg.hardalpa);
3554
3555         fcport->cfg.cfg_hardalpa = BFA_TRUE;
3556         fcport->cfg.hardalpa = alpa;
3557
3558         return BFA_STATUS_OK;
3559 }
3560
3561 bfa_status_t
3562 bfa_fcport_clr_hardalpa(struct bfa_s *bfa)
3563 {
3564         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3565
3566         bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
3567         bfa_trc(bfa, fcport->cfg.hardalpa);
3568
3569         fcport->cfg.cfg_hardalpa = BFA_FALSE;
3570         return BFA_STATUS_OK;
3571 }
3572
3573 bfa_boolean_t
3574 bfa_fcport_get_hardalpa(struct bfa_s *bfa, u8 *alpa)
3575 {
3576         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3577
3578         *alpa = fcport->cfg.hardalpa;
3579         return fcport->cfg.cfg_hardalpa;
3580 }
3581
3582 u8
3583 bfa_fcport_get_myalpa(struct bfa_s *bfa)
3584 {
3585         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3586
3587         return fcport->myalpa;
3588 }
3589
3590 bfa_status_t
3591 bfa_fcport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxfrsize)
3592 {
3593         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3594
3595         bfa_trc(bfa, maxfrsize);
3596         bfa_trc(bfa, fcport->cfg.maxfrsize);
3597
3598         /* with in range */
3599         if ((maxfrsize > FC_MAX_PDUSZ) || (maxfrsize < FC_MIN_PDUSZ))
3600                 return BFA_STATUS_INVLD_DFSZ;
3601
3602         /* power of 2, if not the max frame size of 2112 */
3603         if ((maxfrsize != FC_MAX_PDUSZ) && (maxfrsize & (maxfrsize - 1)))
3604                 return BFA_STATUS_INVLD_DFSZ;
3605
3606         fcport->cfg.maxfrsize = maxfrsize;
3607         return BFA_STATUS_OK;
3608 }
3609
3610 u16
3611 bfa_fcport_get_maxfrsize(struct bfa_s *bfa)
3612 {
3613         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3614
3615         return fcport->cfg.maxfrsize;
3616 }
3617
3618 u8
3619 bfa_fcport_get_rx_bbcredit(struct bfa_s *bfa)
3620 {
3621         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3622
3623         return fcport->cfg.rx_bbcredit;
3624 }
3625
3626 void
3627 bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit)
3628 {
3629         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3630
3631         fcport->cfg.tx_bbcredit = (u8)tx_bbcredit;
3632         bfa_fcport_send_txcredit(fcport);
3633 }
3634
3635 /*
3636  * Get port attributes.
3637  */
3638
3639 wwn_t
3640 bfa_fcport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node)
3641 {
3642         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3643         if (node)
3644                 return fcport->nwwn;
3645         else
3646                 return fcport->pwwn;
3647 }
3648
3649 void
3650 bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_port_attr_s *attr)
3651 {
3652         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3653
3654         memset(attr, 0, sizeof(struct bfa_port_attr_s));
3655
3656         attr->nwwn = fcport->nwwn;
3657         attr->pwwn = fcport->pwwn;
3658
3659         attr->factorypwwn =  bfa->ioc.attr->mfg_pwwn;
3660         attr->factorynwwn =  bfa->ioc.attr->mfg_nwwn;
3661
3662         memcpy(&attr->pport_cfg, &fcport->cfg,
3663                 sizeof(struct bfa_port_cfg_s));
3664         /* speed attributes */
3665         attr->pport_cfg.speed = fcport->cfg.speed;
3666         attr->speed_supported = fcport->speed_sup;
3667         attr->speed = fcport->speed;
3668         attr->cos_supported = FC_CLASS_3;
3669
3670         /* topology attributes */
3671         attr->pport_cfg.topology = fcport->cfg.topology;
3672         attr->topology = fcport->topology;
3673         attr->pport_cfg.trunked = fcport->cfg.trunked;
3674
3675         /* beacon attributes */
3676         attr->beacon = fcport->beacon;
3677         attr->link_e2e_beacon = fcport->link_e2e_beacon;
3678         attr->plog_enabled = (bfa_boolean_t)fcport->bfa->plog->plog_enabled;
3679         attr->io_profile = bfa_fcpim_get_io_profile(fcport->bfa);
3680
3681         attr->pport_cfg.path_tov  = bfa_fcpim_path_tov_get(bfa);
3682         attr->pport_cfg.q_depth  = bfa_fcpim_qdepth_get(bfa);
3683         attr->port_state = bfa_sm_to_state(hal_port_sm_table, fcport->sm);
3684         if (bfa_ioc_is_disabled(&fcport->bfa->ioc))
3685                 attr->port_state = BFA_PORT_ST_IOCDIS;
3686         else if (bfa_ioc_fw_mismatch(&fcport->bfa->ioc))
3687                 attr->port_state = BFA_PORT_ST_FWMISMATCH;
3688
3689         /* FCoE vlan */
3690         attr->fcoe_vlan = fcport->fcoe_vlan;
3691 }
3692
3693 #define BFA_FCPORT_STATS_TOV    1000
3694
3695 /*
3696  * Fetch port statistics (FCQoS or FCoE).
3697  */
3698 bfa_status_t
3699 bfa_fcport_get_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
3700         bfa_cb_port_t cbfn, void *cbarg)
3701 {
3702         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3703
3704         if (fcport->stats_busy) {
3705                 bfa_trc(bfa, fcport->stats_busy);
3706                 return BFA_STATUS_DEVBUSY;
3707         }
3708
3709         fcport->stats_busy  = BFA_TRUE;
3710         fcport->stats_ret   = stats;
3711         fcport->stats_cbfn  = cbfn;
3712         fcport->stats_cbarg = cbarg;
3713
3714         bfa_fcport_send_stats_get(fcport);
3715
3716         bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_get_timeout,
3717                         fcport, BFA_FCPORT_STATS_TOV);
3718         return BFA_STATUS_OK;
3719 }
3720
3721 /*
3722  * Reset port statistics (FCQoS or FCoE).
3723  */
3724 bfa_status_t
3725 bfa_fcport_clear_stats(struct bfa_s *bfa, bfa_cb_port_t cbfn, void *cbarg)
3726 {
3727         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3728
3729         if (fcport->stats_busy) {
3730                 bfa_trc(bfa, fcport->stats_busy);
3731                 return BFA_STATUS_DEVBUSY;
3732         }
3733
3734         fcport->stats_busy  = BFA_TRUE;
3735         fcport->stats_cbfn  = cbfn;
3736         fcport->stats_cbarg = cbarg;
3737
3738         bfa_fcport_send_stats_clear(fcport);
3739
3740         bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_clr_timeout,
3741                         fcport, BFA_FCPORT_STATS_TOV);
3742         return BFA_STATUS_OK;
3743 }
3744
3745
3746 /*
3747  * Fetch port attributes.
3748  */
3749 bfa_boolean_t
3750 bfa_fcport_is_disabled(struct bfa_s *bfa)
3751 {
3752         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3753
3754         return bfa_sm_to_state(hal_port_sm_table, fcport->sm) ==
3755                 BFA_PORT_ST_DISABLED;
3756
3757 }
3758
3759 bfa_boolean_t
3760 bfa_fcport_is_ratelim(struct bfa_s *bfa)
3761 {
3762         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3763
3764         return fcport->cfg.ratelimit ? BFA_TRUE : BFA_FALSE;
3765
3766 }
3767
3768 /*
3769  * Get default minimum ratelim speed
3770  */
3771 enum bfa_port_speed
3772 bfa_fcport_get_ratelim_speed(struct bfa_s *bfa)
3773 {
3774         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3775
3776         bfa_trc(bfa, fcport->cfg.trl_def_speed);
3777         return fcport->cfg.trl_def_speed;
3778
3779 }
3780
3781 bfa_boolean_t
3782 bfa_fcport_is_linkup(struct bfa_s *bfa)
3783 {
3784         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3785
3786         return  (!fcport->cfg.trunked &&
3787                  bfa_sm_cmp_state(fcport, bfa_fcport_sm_linkup)) ||
3788                 (fcport->cfg.trunked &&
3789                  fcport->trunk.attr.state == BFA_TRUNK_ONLINE);
3790 }
3791
3792 bfa_boolean_t
3793 bfa_fcport_is_qos_enabled(struct bfa_s *bfa)
3794 {
3795         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3796
3797         return fcport->cfg.qos_enabled;
3798 }
3799
3800 /*
3801  * Rport State machine functions
3802  */
3803 /*
3804  * Beginning state, only online event expected.
3805  */
3806 static void
3807 bfa_rport_sm_uninit(struct bfa_rport_s *rp, enum bfa_rport_event event)
3808 {
3809         bfa_trc(rp->bfa, rp->rport_tag);
3810         bfa_trc(rp->bfa, event);
3811
3812         switch (event) {
3813         case BFA_RPORT_SM_CREATE:
3814                 bfa_stats(rp, sm_un_cr);
3815                 bfa_sm_set_state(rp, bfa_rport_sm_created);
3816                 break;
3817
3818         default:
3819                 bfa_stats(rp, sm_un_unexp);
3820                 bfa_sm_fault(rp->bfa, event);
3821         }
3822 }
3823
3824 static void
3825 bfa_rport_sm_created(struct bfa_rport_s *rp, enum bfa_rport_event event)
3826 {
3827         bfa_trc(rp->bfa, rp->rport_tag);
3828         bfa_trc(rp->bfa, event);
3829
3830         switch (event) {
3831         case BFA_RPORT_SM_ONLINE:
3832                 bfa_stats(rp, sm_cr_on);
3833                 if (bfa_rport_send_fwcreate(rp))
3834                         bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
3835                 else
3836                         bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
3837                 break;
3838
3839         case BFA_RPORT_SM_DELETE:
3840                 bfa_stats(rp, sm_cr_del);
3841                 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
3842                 bfa_rport_free(rp);
3843                 break;
3844
3845         case BFA_RPORT_SM_HWFAIL:
3846                 bfa_stats(rp, sm_cr_hwf);
3847                 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
3848                 break;
3849
3850         default:
3851                 bfa_stats(rp, sm_cr_unexp);
3852                 bfa_sm_fault(rp->bfa, event);
3853         }
3854 }
3855
3856 /*
3857  * Waiting for rport create response from firmware.
3858  */
3859 static void
3860 bfa_rport_sm_fwcreate(struct bfa_rport_s *rp, enum bfa_rport_event event)
3861 {
3862         bfa_trc(rp->bfa, rp->rport_tag);
3863         bfa_trc(rp->bfa, event);
3864
3865         switch (event) {
3866         case BFA_RPORT_SM_FWRSP:
3867                 bfa_stats(rp, sm_fwc_rsp);
3868                 bfa_sm_set_state(rp, bfa_rport_sm_online);
3869                 bfa_rport_online_cb(rp);
3870                 break;
3871
3872         case BFA_RPORT_SM_DELETE:
3873                 bfa_stats(rp, sm_fwc_del);
3874                 bfa_sm_set_state(rp, bfa_rport_sm_delete_pending);
3875                 break;
3876
3877         case BFA_RPORT_SM_OFFLINE:
3878                 bfa_stats(rp, sm_fwc_off);
3879                 bfa_sm_set_state(rp, bfa_rport_sm_offline_pending);
3880                 break;
3881
3882         case BFA_RPORT_SM_HWFAIL:
3883                 bfa_stats(rp, sm_fwc_hwf);
3884                 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
3885                 break;
3886
3887         default:
3888                 bfa_stats(rp, sm_fwc_unexp);
3889                 bfa_sm_fault(rp->bfa, event);
3890         }
3891 }
3892
3893 /*
3894  * Request queue is full, awaiting queue resume to send create request.
3895  */
3896 static void
3897 bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
3898 {
3899         bfa_trc(rp->bfa, rp->rport_tag);
3900         bfa_trc(rp->bfa, event);
3901
3902         switch (event) {
3903         case BFA_RPORT_SM_QRESUME:
3904                 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
3905                 bfa_rport_send_fwcreate(rp);
3906                 break;
3907
3908         case BFA_RPORT_SM_DELETE:
3909                 bfa_stats(rp, sm_fwc_del);
3910                 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
3911                 bfa_reqq_wcancel(&rp->reqq_wait);
3912                 bfa_rport_free(rp);
3913                 break;
3914
3915         case BFA_RPORT_SM_OFFLINE:
3916                 bfa_stats(rp, sm_fwc_off);
3917                 bfa_sm_set_state(rp, bfa_rport_sm_offline);
3918                 bfa_reqq_wcancel(&rp->reqq_wait);
3919                 bfa_rport_offline_cb(rp);
3920                 break;
3921
3922         case BFA_RPORT_SM_HWFAIL:
3923                 bfa_stats(rp, sm_fwc_hwf);
3924                 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
3925                 bfa_reqq_wcancel(&rp->reqq_wait);
3926                 break;
3927
3928         default:
3929                 bfa_stats(rp, sm_fwc_unexp);
3930                 bfa_sm_fault(rp->bfa, event);
3931         }
3932 }
3933
3934 /*
3935  * Online state - normal parking state.
3936  */
3937 static void
3938 bfa_rport_sm_online(struct bfa_rport_s *rp, enum bfa_rport_event event)
3939 {
3940         struct bfi_rport_qos_scn_s *qos_scn;
3941
3942         bfa_trc(rp->bfa, rp->rport_tag);
3943         bfa_trc(rp->bfa, event);
3944
3945         switch (event) {
3946         case BFA_RPORT_SM_OFFLINE:
3947                 bfa_stats(rp, sm_on_off);
3948                 if (bfa_rport_send_fwdelete(rp))
3949                         bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
3950                 else
3951                         bfa_sm_set_state(rp, bfa_rport_sm_fwdelete_qfull);
3952                 break;
3953
3954         case BFA_RPORT_SM_DELETE:
3955                 bfa_stats(rp, sm_on_del);
3956                 if (bfa_rport_send_fwdelete(rp))
3957                         bfa_sm_set_state(rp, bfa_rport_sm_deleting);
3958                 else
3959                         bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
3960                 break;
3961
3962         case BFA_RPORT_SM_HWFAIL:
3963                 bfa_stats(rp, sm_on_hwf);
3964                 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
3965                 break;
3966
3967         case BFA_RPORT_SM_SET_SPEED:
3968                 bfa_rport_send_fwspeed(rp);
3969                 break;
3970
3971         case BFA_RPORT_SM_QOS_SCN:
3972                 qos_scn = (struct bfi_rport_qos_scn_s *) rp->event_arg.fw_msg;
3973                 rp->qos_attr = qos_scn->new_qos_attr;
3974                 bfa_trc(rp->bfa, qos_scn->old_qos_attr.qos_flow_id);
3975                 bfa_trc(rp->bfa, qos_scn->new_qos_attr.qos_flow_id);
3976                 bfa_trc(rp->bfa, qos_scn->old_qos_attr.qos_priority);
3977                 bfa_trc(rp->bfa, qos_scn->new_qos_attr.qos_priority);
3978
3979                 qos_scn->old_qos_attr.qos_flow_id  =
3980                         be32_to_cpu(qos_scn->old_qos_attr.qos_flow_id);
3981                 qos_scn->new_qos_attr.qos_flow_id  =
3982                         be32_to_cpu(qos_scn->new_qos_attr.qos_flow_id);
3983
3984                 if (qos_scn->old_qos_attr.qos_flow_id !=
3985                         qos_scn->new_qos_attr.qos_flow_id)
3986                         bfa_cb_rport_qos_scn_flowid(rp->rport_drv,
3987                                                     qos_scn->old_qos_attr,
3988                                                     qos_scn->new_qos_attr);
3989                 if (qos_scn->old_qos_attr.qos_priority !=
3990                         qos_scn->new_qos_attr.qos_priority)
3991                         bfa_cb_rport_qos_scn_prio(rp->rport_drv,
3992                                                   qos_scn->old_qos_attr,
3993                                                   qos_scn->new_qos_attr);
3994                 break;
3995
3996         default:
3997                 bfa_stats(rp, sm_on_unexp);
3998                 bfa_sm_fault(rp->bfa, event);
3999         }
4000 }
4001
4002 /*
4003  * Firmware rport is being deleted - awaiting f/w response.
4004  */
4005 static void
4006 bfa_rport_sm_fwdelete(struct bfa_rport_s *rp, enum bfa_rport_event event)
4007 {
4008         bfa_trc(rp->bfa, rp->rport_tag);
4009         bfa_trc(rp->bfa, event);
4010
4011         switch (event) {
4012         case BFA_RPORT_SM_FWRSP:
4013                 bfa_stats(rp, sm_fwd_rsp);
4014                 bfa_sm_set_state(rp, bfa_rport_sm_offline);
4015                 bfa_rport_offline_cb(rp);
4016                 break;
4017
4018         case BFA_RPORT_SM_DELETE:
4019                 bfa_stats(rp, sm_fwd_del);
4020                 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4021                 break;
4022
4023         case BFA_RPORT_SM_HWFAIL:
4024                 bfa_stats(rp, sm_fwd_hwf);
4025                 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4026                 bfa_rport_offline_cb(rp);
4027                 break;
4028
4029         default:
4030                 bfa_stats(rp, sm_fwd_unexp);
4031                 bfa_sm_fault(rp->bfa, event);
4032         }
4033 }
4034
4035 static void
4036 bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4037 {
4038         bfa_trc(rp->bfa, rp->rport_tag);
4039         bfa_trc(rp->bfa, event);
4040
4041         switch (event) {
4042         case BFA_RPORT_SM_QRESUME:
4043                 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4044                 bfa_rport_send_fwdelete(rp);
4045                 break;
4046
4047         case BFA_RPORT_SM_DELETE:
4048                 bfa_stats(rp, sm_fwd_del);
4049                 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4050                 break;
4051
4052         case BFA_RPORT_SM_HWFAIL:
4053                 bfa_stats(rp, sm_fwd_hwf);
4054                 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4055                 bfa_reqq_wcancel(&rp->reqq_wait);
4056                 bfa_rport_offline_cb(rp);
4057                 break;
4058
4059         default:
4060                 bfa_stats(rp, sm_fwd_unexp);
4061                 bfa_sm_fault(rp->bfa, event);
4062         }
4063 }
4064
4065 /*
4066  * Offline state.
4067  */
4068 static void
4069 bfa_rport_sm_offline(struct bfa_rport_s *rp, enum bfa_rport_event event)
4070 {
4071         bfa_trc(rp->bfa, rp->rport_tag);
4072         bfa_trc(rp->bfa, event);
4073
4074         switch (event) {
4075         case BFA_RPORT_SM_DELETE:
4076                 bfa_stats(rp, sm_off_del);
4077                 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4078                 bfa_rport_free(rp);
4079                 break;
4080
4081         case BFA_RPORT_SM_ONLINE:
4082                 bfa_stats(rp, sm_off_on);
4083                 if (bfa_rport_send_fwcreate(rp))
4084                         bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4085                 else
4086                         bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4087                 break;
4088
4089         case BFA_RPORT_SM_HWFAIL:
4090                 bfa_stats(rp, sm_off_hwf);
4091                 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4092                 break;
4093
4094         default:
4095                 bfa_stats(rp, sm_off_unexp);
4096                 bfa_sm_fault(rp->bfa, event);
4097         }
4098 }
4099
4100 /*
4101  * Rport is deleted, waiting for firmware response to delete.
4102  */
4103 static void
4104 bfa_rport_sm_deleting(struct bfa_rport_s *rp, enum bfa_rport_event event)
4105 {
4106         bfa_trc(rp->bfa, rp->rport_tag);
4107         bfa_trc(rp->bfa, event);
4108
4109         switch (event) {
4110         case BFA_RPORT_SM_FWRSP:
4111                 bfa_stats(rp, sm_del_fwrsp);
4112                 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4113                 bfa_rport_free(rp);
4114                 break;
4115
4116         case BFA_RPORT_SM_HWFAIL:
4117                 bfa_stats(rp, sm_del_hwf);
4118                 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4119                 bfa_rport_free(rp);
4120                 break;
4121
4122         default:
4123                 bfa_sm_fault(rp->bfa, event);
4124         }
4125 }
4126
4127 static void
4128 bfa_rport_sm_deleting_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4129 {
4130         bfa_trc(rp->bfa, rp->rport_tag);
4131         bfa_trc(rp->bfa, event);
4132
4133         switch (event) {
4134         case BFA_RPORT_SM_QRESUME:
4135                 bfa_stats(rp, sm_del_fwrsp);
4136                 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4137                 bfa_rport_send_fwdelete(rp);
4138                 break;
4139
4140         case BFA_RPORT_SM_HWFAIL:
4141                 bfa_stats(rp, sm_del_hwf);
4142                 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4143                 bfa_reqq_wcancel(&rp->reqq_wait);
4144                 bfa_rport_free(rp);
4145                 break;
4146
4147         default:
4148                 bfa_sm_fault(rp->bfa, event);
4149         }
4150 }
4151
4152 /*
4153  * Waiting for rport create response from firmware. A delete is pending.
4154  */
4155 static void
4156 bfa_rport_sm_delete_pending(struct bfa_rport_s *rp,
4157                                 enum bfa_rport_event event)
4158 {
4159         bfa_trc(rp->bfa, rp->rport_tag);
4160         bfa_trc(rp->bfa, event);
4161
4162         switch (event) {
4163         case BFA_RPORT_SM_FWRSP:
4164                 bfa_stats(rp, sm_delp_fwrsp);
4165                 if (bfa_rport_send_fwdelete(rp))
4166                         bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4167                 else
4168                         bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4169                 break;
4170
4171         case BFA_RPORT_SM_HWFAIL:
4172                 bfa_stats(rp, sm_delp_hwf);
4173                 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4174                 bfa_rport_free(rp);
4175                 break;
4176
4177         default:
4178                 bfa_stats(rp, sm_delp_unexp);
4179                 bfa_sm_fault(rp->bfa, event);
4180         }
4181 }
4182
4183 /*
4184  * Waiting for rport create response from firmware. Rport offline is pending.
4185  */
4186 static void
4187 bfa_rport_sm_offline_pending(struct bfa_rport_s *rp,
4188                                  enum bfa_rport_event event)
4189 {
4190         bfa_trc(rp->bfa, rp->rport_tag);
4191         bfa_trc(rp->bfa, event);
4192
4193         switch (event) {
4194         case BFA_RPORT_SM_FWRSP:
4195                 bfa_stats(rp, sm_offp_fwrsp);
4196                 if (bfa_rport_send_fwdelete(rp))
4197                         bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4198                 else
4199                         bfa_sm_set_state(rp, bfa_rport_sm_fwdelete_qfull);
4200                 break;
4201
4202         case BFA_RPORT_SM_DELETE:
4203                 bfa_stats(rp, sm_offp_del);
4204                 bfa_sm_set_state(rp, bfa_rport_sm_delete_pending);
4205                 break;
4206
4207         case BFA_RPORT_SM_HWFAIL:
4208                 bfa_stats(rp, sm_offp_hwf);
4209                 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4210                 break;
4211
4212         default:
4213                 bfa_stats(rp, sm_offp_unexp);
4214                 bfa_sm_fault(rp->bfa, event);
4215         }
4216 }
4217
4218 /*
4219  * IOC h/w failed.
4220  */
4221 static void
4222 bfa_rport_sm_iocdisable(struct bfa_rport_s *rp, enum bfa_rport_event event)
4223 {
4224         bfa_trc(rp->bfa, rp->rport_tag);
4225         bfa_trc(rp->bfa, event);
4226
4227         switch (event) {
4228         case BFA_RPORT_SM_OFFLINE:
4229                 bfa_stats(rp, sm_iocd_off);
4230                 bfa_rport_offline_cb(rp);
4231                 break;
4232
4233         case BFA_RPORT_SM_DELETE:
4234                 bfa_stats(rp, sm_iocd_del);
4235                 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4236                 bfa_rport_free(rp);
4237                 break;
4238
4239         case BFA_RPORT_SM_ONLINE:
4240                 bfa_stats(rp, sm_iocd_on);
4241                 if (bfa_rport_send_fwcreate(rp))
4242                         bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4243                 else
4244                         bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4245                 break;
4246
4247         case BFA_RPORT_SM_HWFAIL:
4248                 break;
4249
4250         default:
4251                 bfa_stats(rp, sm_iocd_unexp);
4252                 bfa_sm_fault(rp->bfa, event);
4253         }
4254 }
4255
4256
4257
4258 /*
4259  *  bfa_rport_private BFA rport private functions
4260  */
4261
4262 static void
4263 __bfa_cb_rport_online(void *cbarg, bfa_boolean_t complete)
4264 {
4265         struct bfa_rport_s *rp = cbarg;
4266
4267         if (complete)
4268                 bfa_cb_rport_online(rp->rport_drv);
4269 }
4270
4271 static void
4272 __bfa_cb_rport_offline(void *cbarg, bfa_boolean_t complete)
4273 {
4274         struct bfa_rport_s *rp = cbarg;
4275
4276         if (complete)
4277                 bfa_cb_rport_offline(rp->rport_drv);
4278 }
4279
4280 static void
4281 bfa_rport_qresume(void *cbarg)
4282 {
4283         struct bfa_rport_s      *rp = cbarg;
4284
4285         bfa_sm_send_event(rp, BFA_RPORT_SM_QRESUME);
4286 }
4287
4288 static void
4289 bfa_rport_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *km_len,
4290                 u32 *dm_len)
4291 {
4292         if (cfg->fwcfg.num_rports < BFA_RPORT_MIN)
4293                 cfg->fwcfg.num_rports = BFA_RPORT_MIN;
4294
4295         *km_len += cfg->fwcfg.num_rports * sizeof(struct bfa_rport_s);
4296 }
4297
4298 static void
4299 bfa_rport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4300                      struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
4301 {
4302         struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa);
4303         struct bfa_rport_s *rp;
4304         u16 i;
4305
4306         INIT_LIST_HEAD(&mod->rp_free_q);
4307         INIT_LIST_HEAD(&mod->rp_active_q);
4308
4309         rp = (struct bfa_rport_s *) bfa_meminfo_kva(meminfo);
4310         mod->rps_list = rp;
4311         mod->num_rports = cfg->fwcfg.num_rports;
4312
4313         WARN_ON(!mod->num_rports ||
4314                    (mod->num_rports & (mod->num_rports - 1)));
4315
4316         for (i = 0; i < mod->num_rports; i++, rp++) {
4317                 memset(rp, 0, sizeof(struct bfa_rport_s));
4318                 rp->bfa = bfa;
4319                 rp->rport_tag = i;
4320                 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4321
4322                 /*
4323                  *  - is unused
4324                  */
4325                 if (i)
4326                         list_add_tail(&rp->qe, &mod->rp_free_q);
4327
4328                 bfa_reqq_winit(&rp->reqq_wait, bfa_rport_qresume, rp);
4329         }
4330
4331         /*
4332          * consume memory
4333          */
4334         bfa_meminfo_kva(meminfo) = (u8 *) rp;
4335 }
4336
4337 static void
4338 bfa_rport_detach(struct bfa_s *bfa)
4339 {
4340 }
4341
4342 static void
4343 bfa_rport_start(struct bfa_s *bfa)
4344 {
4345 }
4346
4347 static void
4348 bfa_rport_stop(struct bfa_s *bfa)
4349 {
4350 }
4351
4352 static void
4353 bfa_rport_iocdisable(struct bfa_s *bfa)
4354 {
4355         struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa);
4356         struct bfa_rport_s *rport;
4357         struct list_head *qe, *qen;
4358
4359         list_for_each_safe(qe, qen, &mod->rp_active_q) {
4360                 rport = (struct bfa_rport_s *) qe;
4361                 bfa_sm_send_event(rport, BFA_RPORT_SM_HWFAIL);
4362         }
4363 }
4364
4365 static struct bfa_rport_s *
4366 bfa_rport_alloc(struct bfa_rport_mod_s *mod)
4367 {
4368         struct bfa_rport_s *rport;
4369
4370         bfa_q_deq(&mod->rp_free_q, &rport);
4371         if (rport)
4372                 list_add_tail(&rport->qe, &mod->rp_active_q);
4373
4374         return rport;
4375 }
4376
4377 static void
4378 bfa_rport_free(struct bfa_rport_s *rport)
4379 {
4380         struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(rport->bfa);
4381
4382         WARN_ON(!bfa_q_is_on_q(&mod->rp_active_q, rport));
4383         list_del(&rport->qe);
4384         list_add_tail(&rport->qe, &mod->rp_free_q);
4385 }
4386
4387 static bfa_boolean_t
4388 bfa_rport_send_fwcreate(struct bfa_rport_s *rp)
4389 {
4390         struct bfi_rport_create_req_s *m;
4391
4392         /*
4393          * check for room in queue to send request now
4394          */
4395         m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4396         if (!m) {
4397                 bfa_reqq_wait(rp->bfa, BFA_REQQ_RPORT, &rp->reqq_wait);
4398                 return BFA_FALSE;
4399         }
4400
4401         bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_CREATE_REQ,
4402                         bfa_lpuid(rp->bfa));
4403         m->bfa_handle = rp->rport_tag;
4404         m->max_frmsz = cpu_to_be16(rp->rport_info.max_frmsz);
4405         m->pid = rp->rport_info.pid;
4406         m->lp_tag = rp->rport_info.lp_tag;
4407         m->local_pid = rp->rport_info.local_pid;
4408         m->fc_class = rp->rport_info.fc_class;
4409         m->vf_en = rp->rport_info.vf_en;
4410         m->vf_id = rp->rport_info.vf_id;
4411         m->cisc = rp->rport_info.cisc;
4412
4413         /*
4414          * queue I/O message to firmware
4415          */
4416         bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT);
4417         return BFA_TRUE;
4418 }
4419
4420 static bfa_boolean_t
4421 bfa_rport_send_fwdelete(struct bfa_rport_s *rp)
4422 {
4423         struct bfi_rport_delete_req_s *m;
4424
4425         /*
4426          * check for room in queue to send request now
4427          */
4428         m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4429         if (!m) {
4430                 bfa_reqq_wait(rp->bfa, BFA_REQQ_RPORT, &rp->reqq_wait);
4431                 return BFA_FALSE;
4432         }
4433
4434         bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_DELETE_REQ,
4435                         bfa_lpuid(rp->bfa));
4436         m->fw_handle = rp->fw_handle;
4437
4438         /*
4439          * queue I/O message to firmware
4440          */
4441         bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT);
4442         return BFA_TRUE;
4443 }
4444
4445 static bfa_boolean_t
4446 bfa_rport_send_fwspeed(struct bfa_rport_s *rp)
4447 {
4448         struct bfa_rport_speed_req_s *m;
4449
4450         /*
4451          * check for room in queue to send request now
4452          */
4453         m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4454         if (!m) {
4455                 bfa_trc(rp->bfa, rp->rport_info.speed);
4456                 return BFA_FALSE;
4457         }
4458
4459         bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_SET_SPEED_REQ,
4460                         bfa_lpuid(rp->bfa));
4461         m->fw_handle = rp->fw_handle;
4462         m->speed = (u8)rp->rport_info.speed;
4463
4464         /*
4465          * queue I/O message to firmware
4466          */
4467         bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT);
4468         return BFA_TRUE;
4469 }
4470
4471
4472
4473 /*
4474  *  bfa_rport_public
4475  */
4476
4477 /*
4478  * Rport interrupt processing.
4479  */
4480 void
4481 bfa_rport_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
4482 {
4483         union bfi_rport_i2h_msg_u msg;
4484         struct bfa_rport_s *rp;
4485
4486         bfa_trc(bfa, m->mhdr.msg_id);
4487
4488         msg.msg = m;
4489
4490         switch (m->mhdr.msg_id) {
4491         case BFI_RPORT_I2H_CREATE_RSP:
4492                 rp = BFA_RPORT_FROM_TAG(bfa, msg.create_rsp->bfa_handle);
4493                 rp->fw_handle = msg.create_rsp->fw_handle;
4494                 rp->qos_attr = msg.create_rsp->qos_attr;
4495                 WARN_ON(msg.create_rsp->status != BFA_STATUS_OK);
4496                 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
4497                 break;
4498
4499         case BFI_RPORT_I2H_DELETE_RSP:
4500                 rp = BFA_RPORT_FROM_TAG(bfa, msg.delete_rsp->bfa_handle);
4501                 WARN_ON(msg.delete_rsp->status != BFA_STATUS_OK);
4502                 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
4503                 break;
4504
4505         case BFI_RPORT_I2H_QOS_SCN:
4506                 rp = BFA_RPORT_FROM_TAG(bfa, msg.qos_scn_evt->bfa_handle);
4507                 rp->event_arg.fw_msg = msg.qos_scn_evt;
4508                 bfa_sm_send_event(rp, BFA_RPORT_SM_QOS_SCN);
4509                 break;
4510
4511         default:
4512                 bfa_trc(bfa, m->mhdr.msg_id);
4513                 WARN_ON(1);
4514         }
4515 }
4516
4517
4518
4519 /*
4520  *  bfa_rport_api
4521  */
4522
4523 struct bfa_rport_s *
4524 bfa_rport_create(struct bfa_s *bfa, void *rport_drv)
4525 {
4526         struct bfa_rport_s *rp;
4527
4528         rp = bfa_rport_alloc(BFA_RPORT_MOD(bfa));
4529
4530         if (rp == NULL)
4531                 return NULL;
4532
4533         rp->bfa = bfa;
4534         rp->rport_drv = rport_drv;
4535         memset(&rp->stats, 0, sizeof(rp->stats));
4536
4537         WARN_ON(!bfa_sm_cmp_state(rp, bfa_rport_sm_uninit));
4538         bfa_sm_send_event(rp, BFA_RPORT_SM_CREATE);
4539
4540         return rp;
4541 }
4542
4543 void
4544 bfa_rport_online(struct bfa_rport_s *rport, struct bfa_rport_info_s *rport_info)
4545 {
4546         WARN_ON(rport_info->max_frmsz == 0);
4547
4548         /*
4549          * Some JBODs are seen to be not setting PDU size correctly in PLOGI
4550          * responses. Default to minimum size.
4551          */
4552         if (rport_info->max_frmsz == 0) {
4553                 bfa_trc(rport->bfa, rport->rport_tag);
4554                 rport_info->max_frmsz = FC_MIN_PDUSZ;
4555         }
4556
4557         rport->rport_info = *rport_info;
4558         bfa_sm_send_event(rport, BFA_RPORT_SM_ONLINE);
4559 }
4560
4561 void
4562 bfa_rport_speed(struct bfa_rport_s *rport, enum bfa_port_speed speed)
4563 {
4564         WARN_ON(speed == 0);
4565         WARN_ON(speed == BFA_PORT_SPEED_AUTO);
4566
4567         rport->rport_info.speed = speed;
4568         bfa_sm_send_event(rport, BFA_RPORT_SM_SET_SPEED);
4569 }
4570
4571
4572 /*
4573  * SGPG related functions
4574  */
4575
4576 /*
4577  * Compute and return memory needed by FCP(im) module.
4578  */
4579 static void
4580 bfa_sgpg_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *km_len,
4581                 u32 *dm_len)
4582 {
4583         if (cfg->drvcfg.num_sgpgs < BFA_SGPG_MIN)
4584                 cfg->drvcfg.num_sgpgs = BFA_SGPG_MIN;
4585
4586         *km_len += (cfg->drvcfg.num_sgpgs + 1) * sizeof(struct bfa_sgpg_s);
4587         *dm_len += (cfg->drvcfg.num_sgpgs + 1) * sizeof(struct bfi_sgpg_s);
4588 }
4589
4590
4591 static void
4592 bfa_sgpg_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4593                     struct bfa_meminfo_s *minfo, struct bfa_pcidev_s *pcidev)
4594 {
4595         struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
4596         int i;
4597         struct bfa_sgpg_s *hsgpg;
4598         struct bfi_sgpg_s *sgpg;
4599         u64 align_len;
4600
4601         union {
4602                 u64 pa;
4603                 union bfi_addr_u addr;
4604         } sgpg_pa, sgpg_pa_tmp;
4605
4606         INIT_LIST_HEAD(&mod->sgpg_q);
4607         INIT_LIST_HEAD(&mod->sgpg_wait_q);
4608
4609         bfa_trc(bfa, cfg->drvcfg.num_sgpgs);
4610
4611         mod->num_sgpgs = cfg->drvcfg.num_sgpgs;
4612         mod->sgpg_arr_pa = bfa_meminfo_dma_phys(minfo);
4613         align_len = (BFA_SGPG_ROUNDUP(mod->sgpg_arr_pa) - mod->sgpg_arr_pa);
4614         mod->sgpg_arr_pa += align_len;
4615         mod->hsgpg_arr = (struct bfa_sgpg_s *) (bfa_meminfo_kva(minfo) +
4616                                                 align_len);
4617         mod->sgpg_arr = (struct bfi_sgpg_s *) (bfa_meminfo_dma_virt(minfo) +
4618                                                 align_len);
4619
4620         hsgpg = mod->hsgpg_arr;
4621         sgpg = mod->sgpg_arr;
4622         sgpg_pa.pa = mod->sgpg_arr_pa;
4623         mod->free_sgpgs = mod->num_sgpgs;
4624
4625         WARN_ON(sgpg_pa.pa & (sizeof(struct bfi_sgpg_s) - 1));
4626
4627         for (i = 0; i < mod->num_sgpgs; i++) {
4628                 memset(hsgpg, 0, sizeof(*hsgpg));
4629                 memset(sgpg, 0, sizeof(*sgpg));
4630
4631                 hsgpg->sgpg = sgpg;
4632                 sgpg_pa_tmp.pa = bfa_sgaddr_le(sgpg_pa.pa);
4633                 hsgpg->sgpg_pa = sgpg_pa_tmp.addr;
4634                 list_add_tail(&hsgpg->qe, &mod->sgpg_q);
4635
4636                 hsgpg++;
4637                 sgpg++;
4638                 sgpg_pa.pa += sizeof(struct bfi_sgpg_s);
4639         }
4640
4641         bfa_meminfo_kva(minfo) = (u8 *) hsgpg;
4642         bfa_meminfo_dma_virt(minfo) = (u8 *) sgpg;
4643         bfa_meminfo_dma_phys(minfo) = sgpg_pa.pa;
4644 }
4645
4646 static void
4647 bfa_sgpg_detach(struct bfa_s *bfa)
4648 {
4649 }
4650
4651 static void
4652 bfa_sgpg_start(struct bfa_s *bfa)
4653 {
4654 }
4655
4656 static void
4657 bfa_sgpg_stop(struct bfa_s *bfa)
4658 {
4659 }
4660
4661 static void
4662 bfa_sgpg_iocdisable(struct bfa_s *bfa)
4663 {
4664 }
4665
4666 bfa_status_t
4667 bfa_sgpg_malloc(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpgs)
4668 {
4669         struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
4670         struct bfa_sgpg_s *hsgpg;
4671         int i;
4672
4673         if (mod->free_sgpgs < nsgpgs)
4674                 return BFA_STATUS_ENOMEM;
4675
4676         for (i = 0; i < nsgpgs; i++) {
4677                 bfa_q_deq(&mod->sgpg_q, &hsgpg);
4678                 WARN_ON(!hsgpg);
4679                 list_add_tail(&hsgpg->qe, sgpg_q);
4680         }
4681
4682         mod->free_sgpgs -= nsgpgs;
4683         return BFA_STATUS_OK;
4684 }
4685
4686 void
4687 bfa_sgpg_mfree(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpg)
4688 {
4689         struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
4690         struct bfa_sgpg_wqe_s *wqe;
4691
4692         mod->free_sgpgs += nsgpg;
4693         WARN_ON(mod->free_sgpgs > mod->num_sgpgs);
4694
4695         list_splice_tail_init(sgpg_q, &mod->sgpg_q);
4696
4697         if (list_empty(&mod->sgpg_wait_q))
4698                 return;
4699
4700         /*
4701          * satisfy as many waiting requests as possible
4702          */
4703         do {
4704                 wqe = bfa_q_first(&mod->sgpg_wait_q);
4705                 if (mod->free_sgpgs < wqe->nsgpg)
4706                         nsgpg = mod->free_sgpgs;
4707                 else
4708                         nsgpg = wqe->nsgpg;
4709                 bfa_sgpg_malloc(bfa, &wqe->sgpg_q, nsgpg);
4710                 wqe->nsgpg -= nsgpg;
4711                 if (wqe->nsgpg == 0) {
4712                         list_del(&wqe->qe);
4713                         wqe->cbfn(wqe->cbarg);
4714                 }
4715         } while (mod->free_sgpgs && !list_empty(&mod->sgpg_wait_q));
4716 }
4717
4718 void
4719 bfa_sgpg_wait(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe, int nsgpg)
4720 {
4721         struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
4722
4723         WARN_ON(nsgpg <= 0);
4724         WARN_ON(nsgpg <= mod->free_sgpgs);
4725
4726         wqe->nsgpg_total = wqe->nsgpg = nsgpg;
4727
4728         /*
4729          * allocate any left to this one first
4730          */
4731         if (mod->free_sgpgs) {
4732                 /*
4733                  * no one else is waiting for SGPG
4734                  */
4735                 WARN_ON(!list_empty(&mod->sgpg_wait_q));
4736                 list_splice_tail_init(&mod->sgpg_q, &wqe->sgpg_q);
4737                 wqe->nsgpg -= mod->free_sgpgs;
4738                 mod->free_sgpgs = 0;
4739         }
4740
4741         list_add_tail(&wqe->qe, &mod->sgpg_wait_q);
4742 }
4743
4744 void
4745 bfa_sgpg_wcancel(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe)
4746 {
4747         struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
4748
4749         WARN_ON(!bfa_q_is_on_q(&mod->sgpg_wait_q, wqe));
4750         list_del(&wqe->qe);
4751
4752         if (wqe->nsgpg_total != wqe->nsgpg)
4753                 bfa_sgpg_mfree(bfa, &wqe->sgpg_q,
4754                                    wqe->nsgpg_total - wqe->nsgpg);
4755 }
4756
4757 void
4758 bfa_sgpg_winit(struct bfa_sgpg_wqe_s *wqe, void (*cbfn) (void *cbarg),
4759                    void *cbarg)
4760 {
4761         INIT_LIST_HEAD(&wqe->sgpg_q);
4762         wqe->cbfn = cbfn;
4763         wqe->cbarg = cbarg;
4764 }
4765
4766 /*
4767  *  UF related functions
4768  */
4769 /*
4770  *****************************************************************************
4771  * Internal functions
4772  *****************************************************************************
4773  */
4774 static void
4775 __bfa_cb_uf_recv(void *cbarg, bfa_boolean_t complete)
4776 {
4777         struct bfa_uf_s   *uf = cbarg;
4778         struct bfa_uf_mod_s *ufm = BFA_UF_MOD(uf->bfa);
4779
4780         if (complete)
4781                 ufm->ufrecv(ufm->cbarg, uf);
4782 }
4783
4784 static void
4785 claim_uf_pbs(struct bfa_uf_mod_s *ufm, struct bfa_meminfo_s *mi)
4786 {
4787         u32 uf_pb_tot_sz;
4788
4789         ufm->uf_pbs_kva = (struct bfa_uf_buf_s *) bfa_meminfo_dma_virt(mi);
4790         ufm->uf_pbs_pa = bfa_meminfo_dma_phys(mi);
4791         uf_pb_tot_sz = BFA_ROUNDUP((sizeof(struct bfa_uf_buf_s) * ufm->num_ufs),
4792                                                         BFA_DMA_ALIGN_SZ);
4793
4794         bfa_meminfo_dma_virt(mi) += uf_pb_tot_sz;
4795         bfa_meminfo_dma_phys(mi) += uf_pb_tot_sz;
4796
4797         memset((void *)ufm->uf_pbs_kva, 0, uf_pb_tot_sz);
4798 }
4799
4800 static void
4801 claim_uf_post_msgs(struct bfa_uf_mod_s *ufm, struct bfa_meminfo_s *mi)
4802 {
4803         struct bfi_uf_buf_post_s *uf_bp_msg;
4804         struct bfi_sge_s      *sge;
4805         union bfi_addr_u      sga_zero = { {0} };
4806         u16 i;
4807         u16 buf_len;
4808
4809         ufm->uf_buf_posts = (struct bfi_uf_buf_post_s *) bfa_meminfo_kva(mi);
4810         uf_bp_msg = ufm->uf_buf_posts;
4811
4812         for (i = 0, uf_bp_msg = ufm->uf_buf_posts; i < ufm->num_ufs;
4813              i++, uf_bp_msg++) {
4814                 memset(uf_bp_msg, 0, sizeof(struct bfi_uf_buf_post_s));
4815
4816                 uf_bp_msg->buf_tag = i;
4817                 buf_len = sizeof(struct bfa_uf_buf_s);
4818                 uf_bp_msg->buf_len = cpu_to_be16(buf_len);
4819                 bfi_h2i_set(uf_bp_msg->mh, BFI_MC_UF, BFI_UF_H2I_BUF_POST,
4820                             bfa_lpuid(ufm->bfa));
4821
4822                 sge = uf_bp_msg->sge;
4823                 sge[0].sg_len = buf_len;
4824                 sge[0].flags = BFI_SGE_DATA_LAST;
4825                 bfa_dma_addr_set(sge[0].sga, ufm_pbs_pa(ufm, i));
4826                 bfa_sge_to_be(sge);
4827
4828                 sge[1].sg_len = buf_len;
4829                 sge[1].flags = BFI_SGE_PGDLEN;
4830                 sge[1].sga = sga_zero;
4831                 bfa_sge_to_be(&sge[1]);
4832         }
4833
4834         /*
4835          * advance pointer beyond consumed memory
4836          */
4837         bfa_meminfo_kva(mi) = (u8 *) uf_bp_msg;
4838 }
4839
4840 static void
4841 claim_ufs(struct bfa_uf_mod_s *ufm, struct bfa_meminfo_s *mi)
4842 {
4843         u16 i;
4844         struct bfa_uf_s   *uf;
4845
4846         /*
4847          * Claim block of memory for UF list
4848          */
4849         ufm->uf_list = (struct bfa_uf_s *) bfa_meminfo_kva(mi);
4850
4851         /*
4852          * Initialize UFs and queue it in UF free queue
4853          */
4854         for (i = 0, uf = ufm->uf_list; i < ufm->num_ufs; i++, uf++) {
4855                 memset(uf, 0, sizeof(struct bfa_uf_s));
4856                 uf->bfa = ufm->bfa;
4857                 uf->uf_tag = i;
4858                 uf->pb_len = sizeof(struct bfa_uf_buf_s);
4859                 uf->buf_kva = (void *)&ufm->uf_pbs_kva[i];
4860                 uf->buf_pa = ufm_pbs_pa(ufm, i);
4861                 list_add_tail(&uf->qe, &ufm->uf_free_q);
4862         }
4863
4864         /*
4865          * advance memory pointer
4866          */
4867         bfa_meminfo_kva(mi) = (u8 *) uf;
4868 }
4869
4870 static void
4871 uf_mem_claim(struct bfa_uf_mod_s *ufm, struct bfa_meminfo_s *mi)
4872 {
4873         claim_uf_pbs(ufm, mi);
4874         claim_ufs(ufm, mi);
4875         claim_uf_post_msgs(ufm, mi);
4876 }
4877
4878 static void
4879 bfa_uf_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len, u32 *dm_len)
4880 {
4881         u32 num_ufs = cfg->fwcfg.num_uf_bufs;
4882
4883         /*
4884          * dma-able memory for UF posted bufs
4885          */
4886         *dm_len += BFA_ROUNDUP((sizeof(struct bfa_uf_buf_s) * num_ufs),
4887                                                         BFA_DMA_ALIGN_SZ);
4888
4889         /*
4890          * kernel Virtual memory for UFs and UF buf post msg copies
4891          */
4892         *ndm_len += sizeof(struct bfa_uf_s) * num_ufs;
4893         *ndm_len += sizeof(struct bfi_uf_buf_post_s) * num_ufs;
4894 }
4895
4896 static void
4897 bfa_uf_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4898                   struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
4899 {
4900         struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
4901
4902         memset(ufm, 0, sizeof(struct bfa_uf_mod_s));
4903         ufm->bfa = bfa;
4904         ufm->num_ufs = cfg->fwcfg.num_uf_bufs;
4905         INIT_LIST_HEAD(&ufm->uf_free_q);
4906         INIT_LIST_HEAD(&ufm->uf_posted_q);
4907
4908         uf_mem_claim(ufm, meminfo);
4909 }
4910
4911 static void
4912 bfa_uf_detach(struct bfa_s *bfa)
4913 {
4914 }
4915
4916 static struct bfa_uf_s *
4917 bfa_uf_get(struct bfa_uf_mod_s *uf_mod)
4918 {
4919         struct bfa_uf_s   *uf;
4920
4921         bfa_q_deq(&uf_mod->uf_free_q, &uf);
4922         return uf;
4923 }
4924
4925 static void
4926 bfa_uf_put(struct bfa_uf_mod_s *uf_mod, struct bfa_uf_s *uf)
4927 {
4928         list_add_tail(&uf->qe, &uf_mod->uf_free_q);
4929 }
4930
4931 static bfa_status_t
4932 bfa_uf_post(struct bfa_uf_mod_s *ufm, struct bfa_uf_s *uf)
4933 {
4934         struct bfi_uf_buf_post_s *uf_post_msg;
4935
4936         uf_post_msg = bfa_reqq_next(ufm->bfa, BFA_REQQ_FCXP);
4937         if (!uf_post_msg)
4938                 return BFA_STATUS_FAILED;
4939
4940         memcpy(uf_post_msg, &ufm->uf_buf_posts[uf->uf_tag],
4941                       sizeof(struct bfi_uf_buf_post_s));
4942         bfa_reqq_produce(ufm->bfa, BFA_REQQ_FCXP);
4943
4944         bfa_trc(ufm->bfa, uf->uf_tag);
4945
4946         list_add_tail(&uf->qe, &ufm->uf_posted_q);
4947         return BFA_STATUS_OK;
4948 }
4949
4950 static void
4951 bfa_uf_post_all(struct bfa_uf_mod_s *uf_mod)
4952 {
4953         struct bfa_uf_s   *uf;
4954
4955         while ((uf = bfa_uf_get(uf_mod)) != NULL) {
4956                 if (bfa_uf_post(uf_mod, uf) != BFA_STATUS_OK)
4957                         break;
4958         }
4959 }
4960
4961 static void
4962 uf_recv(struct bfa_s *bfa, struct bfi_uf_frm_rcvd_s *m)
4963 {
4964         struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
4965         u16 uf_tag = m->buf_tag;
4966         struct bfa_uf_buf_s *uf_buf = &ufm->uf_pbs_kva[uf_tag];
4967         struct bfa_uf_s *uf = &ufm->uf_list[uf_tag];
4968         u8 *buf = &uf_buf->d[0];
4969         struct fchs_s *fchs;
4970
4971         m->frm_len = be16_to_cpu(m->frm_len);
4972         m->xfr_len = be16_to_cpu(m->xfr_len);
4973
4974         fchs = (struct fchs_s *)uf_buf;
4975
4976         list_del(&uf->qe);      /* dequeue from posted queue */
4977
4978         uf->data_ptr = buf;
4979         uf->data_len = m->xfr_len;
4980
4981         WARN_ON(uf->data_len < sizeof(struct fchs_s));
4982
4983         if (uf->data_len == sizeof(struct fchs_s)) {
4984                 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_UF, BFA_PL_EID_RX,
4985                                uf->data_len, (struct fchs_s *)buf);
4986         } else {
4987                 u32 pld_w0 = *((u32 *) (buf + sizeof(struct fchs_s)));
4988                 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_UF,
4989                                       BFA_PL_EID_RX, uf->data_len,
4990                                       (struct fchs_s *)buf, pld_w0);
4991         }
4992
4993         if (bfa->fcs)
4994                 __bfa_cb_uf_recv(uf, BFA_TRUE);
4995         else
4996                 bfa_cb_queue(bfa, &uf->hcb_qe, __bfa_cb_uf_recv, uf);
4997 }
4998
4999 static void
5000 bfa_uf_stop(struct bfa_s *bfa)
5001 {
5002 }
5003
5004 static void
5005 bfa_uf_iocdisable(struct bfa_s *bfa)
5006 {
5007         struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5008         struct bfa_uf_s *uf;
5009         struct list_head *qe, *qen;
5010
5011         list_for_each_safe(qe, qen, &ufm->uf_posted_q) {
5012                 uf = (struct bfa_uf_s *) qe;
5013                 list_del(&uf->qe);
5014                 bfa_uf_put(ufm, uf);
5015         }
5016 }
5017
5018 static void
5019 bfa_uf_start(struct bfa_s *bfa)
5020 {
5021         bfa_uf_post_all(BFA_UF_MOD(bfa));
5022 }
5023
5024 /*
5025  * Register handler for all unsolicted recieve frames.
5026  *
5027  * @param[in]   bfa             BFA instance
5028  * @param[in]   ufrecv  receive handler function
5029  * @param[in]   cbarg   receive handler arg
5030  */
5031 void
5032 bfa_uf_recv_register(struct bfa_s *bfa, bfa_cb_uf_recv_t ufrecv, void *cbarg)
5033 {
5034         struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5035
5036         ufm->ufrecv = ufrecv;
5037         ufm->cbarg = cbarg;
5038 }
5039
5040 /*
5041  *      Free an unsolicited frame back to BFA.
5042  *
5043  * @param[in]           uf              unsolicited frame to be freed
5044  *
5045  * @return None
5046  */
5047 void
5048 bfa_uf_free(struct bfa_uf_s *uf)
5049 {
5050         bfa_uf_put(BFA_UF_MOD(uf->bfa), uf);
5051         bfa_uf_post_all(BFA_UF_MOD(uf->bfa));
5052 }
5053
5054
5055
5056 /*
5057  *  uf_pub BFA uf module public functions
5058  */
5059 void
5060 bfa_uf_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
5061 {
5062         bfa_trc(bfa, msg->mhdr.msg_id);
5063
5064         switch (msg->mhdr.msg_id) {
5065         case BFI_UF_I2H_FRM_RCVD:
5066                 uf_recv(bfa, (struct bfi_uf_frm_rcvd_s *) msg);
5067                 break;
5068
5069         default:
5070                 bfa_trc(bfa, msg->mhdr.msg_id);
5071                 WARN_ON(1);
5072         }
5073 }
5074
5075