drivers/scsi/bfa/bfa_fcs_rport.c

   1 /*
   2  * Copyright (c) 2005-2014 Brocade Communications Systems, Inc.
   3  * Copyright (c) 2014- QLogic Corporation.
   4  * All rights reserved
   5  * www.qlogic.com
   6  *
   7  * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter.
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License (GPL) Version 2 as
  11  * published by the Free Software Foundation
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  */
  18
  19 /*
  20  *  rport.c Remote port implementation.
  21  */
  22
  23 #include "bfad_drv.h"
  24 #include "bfad_im.h"
  25 #include "bfa_fcs.h"
  26 #include "bfa_fcbuild.h"
  27
  28 BFA_TRC_FILE(FCS, RPORT);
  29
  30 static u32
  31 bfa_fcs_rport_del_timeout = BFA_FCS_RPORT_DEF_DEL_TIMEOUT * 1000;
  32          /* In millisecs */
  33 /*
  34  * bfa_fcs_rport_max_logins is max count of bfa_fcs_rports
  35  * whereas DEF_CFG_NUM_RPORTS is max count of bfa_rports
  36  */
  37 static u32 bfa_fcs_rport_max_logins = BFA_FCS_MAX_RPORT_LOGINS;
  38
  39 /*
  40  * forward declarations
  41  */
  42 static struct bfa_fcs_rport_s *bfa_fcs_rport_alloc(
  43                 struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid);
  44 static void     bfa_fcs_rport_free(struct bfa_fcs_rport_s *rport);
  45 static void     bfa_fcs_rport_hal_online(struct bfa_fcs_rport_s *rport);
  46 static void     bfa_fcs_rport_fcs_online_action(struct bfa_fcs_rport_s *rport);
  47 static void     bfa_fcs_rport_hal_online_action(struct bfa_fcs_rport_s *rport);
  48 static void     bfa_fcs_rport_fcs_offline_action(struct bfa_fcs_rport_s *rport);
  49 static void     bfa_fcs_rport_hal_offline_action(struct bfa_fcs_rport_s *rport);
  50 static void     bfa_fcs_rport_update(struct bfa_fcs_rport_s *rport,
  51                                         struct fc_logi_s *plogi);
  52 static void     bfa_fcs_rport_timeout(void *arg);
  53 static void     bfa_fcs_rport_send_plogi(void *rport_cbarg,
  54                                          struct bfa_fcxp_s *fcxp_alloced);
  55 static void     bfa_fcs_rport_send_plogiacc(void *rport_cbarg,
  56                                         struct bfa_fcxp_s *fcxp_alloced);
  57 static void     bfa_fcs_rport_plogi_response(void *fcsarg,
  58                                 struct bfa_fcxp_s *fcxp, void *cbarg,
  59                                 bfa_status_t req_status, u32 rsp_len,
  60                                 u32 resid_len, struct fchs_s *rsp_fchs);
  61 static void     bfa_fcs_rport_send_adisc(void *rport_cbarg,
  62                                          struct bfa_fcxp_s *fcxp_alloced);
  63 static void     bfa_fcs_rport_adisc_response(void *fcsarg,
  64                                 struct bfa_fcxp_s *fcxp, void *cbarg,
  65                                 bfa_status_t req_status, u32 rsp_len,
  66                                 u32 resid_len, struct fchs_s *rsp_fchs);
  67 static void     bfa_fcs_rport_send_nsdisc(void *rport_cbarg,
  68                                          struct bfa_fcxp_s *fcxp_alloced);
  69 static void     bfa_fcs_rport_gidpn_response(void *fcsarg,
  70                                 struct bfa_fcxp_s *fcxp, void *cbarg,
  71                                 bfa_status_t req_status, u32 rsp_len,
  72                                 u32 resid_len, struct fchs_s *rsp_fchs);
  73 static void     bfa_fcs_rport_gpnid_response(void *fcsarg,
  74                                 struct bfa_fcxp_s *fcxp, void *cbarg,
  75                                 bfa_status_t req_status, u32 rsp_len,
  76                                 u32 resid_len, struct fchs_s *rsp_fchs);
  77 static void     bfa_fcs_rport_send_logo(void *rport_cbarg,
  78                                         struct bfa_fcxp_s *fcxp_alloced);
  79 static void     bfa_fcs_rport_send_logo_acc(void *rport_cbarg);
  80 static void     bfa_fcs_rport_process_prli(struct bfa_fcs_rport_s *rport,
  81                                         struct fchs_s *rx_fchs, u16 len);
  82 static void     bfa_fcs_rport_send_ls_rjt(struct bfa_fcs_rport_s *rport,
  83                                 struct fchs_s *rx_fchs, u8 reason_code,
  84                                           u8 reason_code_expl);
  85 static void     bfa_fcs_rport_process_adisc(struct bfa_fcs_rport_s *rport,
  86                                 struct fchs_s *rx_fchs, u16 len);
  87 static void bfa_fcs_rport_send_prlo_acc(struct bfa_fcs_rport_s *rport);
  88 static void     bfa_fcs_rport_hal_offline(struct bfa_fcs_rport_s *rport);
  89
  90 static void     bfa_fcs_rport_sm_uninit(struct bfa_fcs_rport_s *rport,
  91                                         enum rport_event event);
  92 static void     bfa_fcs_rport_sm_plogi_sending(struct bfa_fcs_rport_s *rport,
  93                                                 enum rport_event event);
  94 static void     bfa_fcs_rport_sm_plogiacc_sending(struct bfa_fcs_rport_s *rport,
  95                                                   enum rport_event event);
  96 static void     bfa_fcs_rport_sm_plogi_retry(struct bfa_fcs_rport_s *rport,
  97                                                 enum rport_event event);
  98 static void     bfa_fcs_rport_sm_plogi(struct bfa_fcs_rport_s *rport,
  99                                         enum rport_event event);
 100 static void     bfa_fcs_rport_sm_fc4_fcs_online(struct bfa_fcs_rport_s *rport,
 101                                         enum rport_event event);
 102 static void     bfa_fcs_rport_sm_hal_online(struct bfa_fcs_rport_s *rport,
 103                                                 enum rport_event event);
 104 static void     bfa_fcs_rport_sm_online(struct bfa_fcs_rport_s *rport,
 105                                         enum rport_event event);
 106 static void     bfa_fcs_rport_sm_nsquery_sending(struct bfa_fcs_rport_s *rport,
 107                                                  enum rport_event event);
 108 static void     bfa_fcs_rport_sm_nsquery(struct bfa_fcs_rport_s *rport,
 109                                          enum rport_event event);
 110 static void     bfa_fcs_rport_sm_adisc_online_sending(
 111                         struct bfa_fcs_rport_s *rport, enum rport_event event);
 112 static void     bfa_fcs_rport_sm_adisc_online(struct bfa_fcs_rport_s *rport,
 113                                         enum rport_event event);
 114 static void     bfa_fcs_rport_sm_adisc_offline_sending(struct bfa_fcs_rport_s
 115                                         *rport, enum rport_event event);
 116 static void     bfa_fcs_rport_sm_adisc_offline(struct bfa_fcs_rport_s *rport,
 117                                         enum rport_event event);
 118 static void     bfa_fcs_rport_sm_fc4_logorcv(struct bfa_fcs_rport_s *rport,
 119                                                 enum rport_event event);
 120 static void     bfa_fcs_rport_sm_fc4_logosend(struct bfa_fcs_rport_s *rport,
 121                                                 enum rport_event event);
 122 static void     bfa_fcs_rport_sm_fc4_offline(struct bfa_fcs_rport_s *rport,
 123                                                 enum rport_event event);
 124 static void     bfa_fcs_rport_sm_hcb_offline(struct bfa_fcs_rport_s *rport,
 125                                                 enum rport_event event);
 126 static void     bfa_fcs_rport_sm_hcb_logorcv(struct bfa_fcs_rport_s *rport,
 127                                                 enum rport_event event);
 128 static void     bfa_fcs_rport_sm_hcb_logosend(struct bfa_fcs_rport_s *rport,
 129                                                 enum rport_event event);
 130 static void     bfa_fcs_rport_sm_logo_sending(struct bfa_fcs_rport_s *rport,
 131                                                 enum rport_event event);
 132 static void     bfa_fcs_rport_sm_offline(struct bfa_fcs_rport_s *rport,
 133                                          enum rport_event event);
 134 static void     bfa_fcs_rport_sm_nsdisc_sending(struct bfa_fcs_rport_s *rport,
 135                                                 enum rport_event event);
 136 static void     bfa_fcs_rport_sm_nsdisc_retry(struct bfa_fcs_rport_s *rport,
 137                                                 enum rport_event event);
 138 static void     bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport,
 139                                                 enum rport_event event);
 140 static void     bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport,
 141                                                 enum rport_event event);
 142 static void     bfa_fcs_rport_sm_fc4_off_delete(struct bfa_fcs_rport_s *rport,
 143                                                 enum rport_event event);
 144 static void     bfa_fcs_rport_sm_delete_pending(struct bfa_fcs_rport_s *rport,
 145                                                 enum rport_event event);
 146
 147 static struct bfa_sm_table_s rport_sm_table[] = {
 148         {BFA_SM(bfa_fcs_rport_sm_uninit), BFA_RPORT_UNINIT},
 149         {BFA_SM(bfa_fcs_rport_sm_plogi_sending), BFA_RPORT_PLOGI},
 150         {BFA_SM(bfa_fcs_rport_sm_plogiacc_sending), BFA_RPORT_ONLINE},
 151         {BFA_SM(bfa_fcs_rport_sm_plogi_retry), BFA_RPORT_PLOGI_RETRY},
 152         {BFA_SM(bfa_fcs_rport_sm_plogi), BFA_RPORT_PLOGI},
 153         {BFA_SM(bfa_fcs_rport_sm_fc4_fcs_online), BFA_RPORT_ONLINE},
 154         {BFA_SM(bfa_fcs_rport_sm_hal_online), BFA_RPORT_ONLINE},
 155         {BFA_SM(bfa_fcs_rport_sm_online), BFA_RPORT_ONLINE},
 156         {BFA_SM(bfa_fcs_rport_sm_nsquery_sending), BFA_RPORT_NSQUERY},
 157         {BFA_SM(bfa_fcs_rport_sm_nsquery), BFA_RPORT_NSQUERY},
 158         {BFA_SM(bfa_fcs_rport_sm_adisc_online_sending), BFA_RPORT_ADISC},
 159         {BFA_SM(bfa_fcs_rport_sm_adisc_online), BFA_RPORT_ADISC},
 160         {BFA_SM(bfa_fcs_rport_sm_adisc_offline_sending), BFA_RPORT_ADISC},
 161         {BFA_SM(bfa_fcs_rport_sm_adisc_offline), BFA_RPORT_ADISC},
 162         {BFA_SM(bfa_fcs_rport_sm_fc4_logorcv), BFA_RPORT_LOGORCV},
 163         {BFA_SM(bfa_fcs_rport_sm_fc4_logosend), BFA_RPORT_LOGO},
 164         {BFA_SM(bfa_fcs_rport_sm_fc4_offline), BFA_RPORT_OFFLINE},
 165         {BFA_SM(bfa_fcs_rport_sm_hcb_offline), BFA_RPORT_OFFLINE},
 166         {BFA_SM(bfa_fcs_rport_sm_hcb_logorcv), BFA_RPORT_LOGORCV},
 167         {BFA_SM(bfa_fcs_rport_sm_hcb_logosend), BFA_RPORT_LOGO},
 168         {BFA_SM(bfa_fcs_rport_sm_logo_sending), BFA_RPORT_LOGO},
 169         {BFA_SM(bfa_fcs_rport_sm_offline), BFA_RPORT_OFFLINE},
 170         {BFA_SM(bfa_fcs_rport_sm_nsdisc_sending), BFA_RPORT_NSDISC},
 171         {BFA_SM(bfa_fcs_rport_sm_nsdisc_retry), BFA_RPORT_NSDISC},
 172         {BFA_SM(bfa_fcs_rport_sm_nsdisc_sent), BFA_RPORT_NSDISC},
 173 };
 174
 175 /*
 176  *              Beginning state.
 177  */
 178 static void
 179 bfa_fcs_rport_sm_uninit(struct bfa_fcs_rport_s *rport, enum rport_event event)
 180 {
 181         bfa_trc(rport->fcs, rport->pwwn);
 182         bfa_trc(rport->fcs, rport->pid);
 183         bfa_trc(rport->fcs, event);
 184
 185         switch (event) {
 186         case RPSM_EVENT_PLOGI_SEND:
 187                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_sending);
 188                 rport->plogi_retries = 0;
 189                 bfa_fcs_rport_send_plogi(rport, NULL);
 190                 break;
 191
 192         case RPSM_EVENT_PLOGI_RCVD:
 193                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
 194                 bfa_fcs_rport_send_plogiacc(rport, NULL);
 195                 break;
 196
 197         case RPSM_EVENT_PLOGI_COMP:
 198                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
 199                 bfa_fcs_rport_hal_online(rport);
 200                 break;
 201
 202         case RPSM_EVENT_ADDRESS_CHANGE:
 203         case RPSM_EVENT_ADDRESS_DISC:
 204                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
 205                 rport->ns_retries = 0;
 206                 bfa_fcs_rport_send_nsdisc(rport, NULL);
 207                 break;
 208         default:
 209                 bfa_sm_fault(rport->fcs, event);
 210         }
 211 }
 212
 213 /*
 214  *              PLOGI is being sent.
 215  */
 216 static void
 217 bfa_fcs_rport_sm_plogi_sending(struct bfa_fcs_rport_s *rport,
 218          enum rport_event event)
 219 {
 220         bfa_trc(rport->fcs, rport->pwwn);
 221         bfa_trc(rport->fcs, rport->pid);
 222         bfa_trc(rport->fcs, event);
 223
 224         switch (event) {
 225         case RPSM_EVENT_FCXP_SENT:
 226                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi);
 227                 break;
 228
 229         case RPSM_EVENT_DELETE:
 230                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
 231                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 232                 bfa_fcs_rport_free(rport);
 233                 break;
 234
 235         case RPSM_EVENT_PLOGI_RCVD:
 236                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
 237                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 238                 bfa_fcs_rport_send_plogiacc(rport, NULL);
 239                 break;
 240
 241         case RPSM_EVENT_SCN_OFFLINE:
 242                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
 243                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 244                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
 245                                 bfa_fcs_rport_timeout, rport,
 246                                 bfa_fcs_rport_del_timeout);
 247                 break;
 248         case RPSM_EVENT_ADDRESS_CHANGE:
 249         case RPSM_EVENT_FAB_SCN:
 250                 /* query the NS */
 251                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 252                 WARN_ON(!(bfa_fcport_get_topology(rport->port->fcs->bfa) !=
 253                                         BFA_PORT_TOPOLOGY_LOOP));
 254                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
 255                 rport->ns_retries = 0;
 256                 bfa_fcs_rport_send_nsdisc(rport, NULL);
 257                 break;
 258
 259         case RPSM_EVENT_LOGO_IMP:
 260                 rport->pid = 0;
 261                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
 262                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 263                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
 264                                 bfa_fcs_rport_timeout, rport,
 265                                 bfa_fcs_rport_del_timeout);
 266                 break;
 267
 268
 269         default:
 270                 bfa_sm_fault(rport->fcs, event);
 271         }
 272 }
 273
 274 /*
 275  *              PLOGI is being sent.
 276  */
 277 static void
 278 bfa_fcs_rport_sm_plogiacc_sending(struct bfa_fcs_rport_s *rport,
 279          enum rport_event event)
 280 {
 281         bfa_trc(rport->fcs, rport->pwwn);
 282         bfa_trc(rport->fcs, rport->pid);
 283         bfa_trc(rport->fcs, event);
 284
 285         switch (event) {
 286         case RPSM_EVENT_FCXP_SENT:
 287                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
 288                 bfa_fcs_rport_fcs_online_action(rport);
 289                 break;
 290
 291         case RPSM_EVENT_DELETE:
 292                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
 293                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 294                 bfa_fcs_rport_free(rport);
 295                 break;
 296
 297         case RPSM_EVENT_PLOGI_RCVD:
 298         case RPSM_EVENT_PLOGI_COMP:
 299         case RPSM_EVENT_FAB_SCN:
 300                 /*
 301                  * Ignore, SCN is possibly online notification.
 302                  */
 303                 break;
 304
 305         case RPSM_EVENT_SCN_OFFLINE:
 306                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
 307                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 308                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
 309                                 bfa_fcs_rport_timeout, rport,
 310                                 bfa_fcs_rport_del_timeout);
 311                 break;
 312
 313         case RPSM_EVENT_ADDRESS_CHANGE:
 314                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 315                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
 316                 rport->ns_retries = 0;
 317                 bfa_fcs_rport_send_nsdisc(rport, NULL);
 318                 break;
 319
 320         case RPSM_EVENT_LOGO_IMP:
 321                 rport->pid = 0;
 322                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
 323                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 324                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
 325                                 bfa_fcs_rport_timeout, rport,
 326                                 bfa_fcs_rport_del_timeout);
 327                 break;
 328
 329         case RPSM_EVENT_HCB_OFFLINE:
 330                 /*
 331                  * Ignore BFA callback, on a PLOGI receive we call bfa offline.
 332                  */
 333                 break;
 334
 335         default:
 336                 bfa_sm_fault(rport->fcs, event);
 337         }
 338 }
 339
 340 /*
 341  *              PLOGI is sent.
 342  */
 343 static void
 344 bfa_fcs_rport_sm_plogi_retry(struct bfa_fcs_rport_s *rport,
 345                         enum rport_event event)
 346 {
 347         bfa_trc(rport->fcs, rport->pwwn);
 348         bfa_trc(rport->fcs, rport->pid);
 349         bfa_trc(rport->fcs, event);
 350
 351         switch (event) {
 352         case RPSM_EVENT_TIMEOUT:
 353                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_sending);
 354                 bfa_fcs_rport_send_plogi(rport, NULL);
 355                 break;
 356
 357         case RPSM_EVENT_DELETE:
 358                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
 359                 bfa_timer_stop(&rport->timer);
 360                 bfa_fcs_rport_free(rport);
 361                 break;
 362
 363         case RPSM_EVENT_PRLO_RCVD:
 364         case RPSM_EVENT_LOGO_RCVD:
 365                 break;
 366
 367         case RPSM_EVENT_PLOGI_RCVD:
 368                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
 369                 bfa_timer_stop(&rport->timer);
 370                 bfa_fcs_rport_send_plogiacc(rport, NULL);
 371                 break;
 372
 373         case RPSM_EVENT_SCN_OFFLINE:
 374                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
 375                 bfa_timer_stop(&rport->timer);
 376                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
 377                                 bfa_fcs_rport_timeout, rport,
 378                                 bfa_fcs_rport_del_timeout);
 379                 break;
 380
 381         case RPSM_EVENT_ADDRESS_CHANGE:
 382         case RPSM_EVENT_FAB_SCN:
 383                 bfa_timer_stop(&rport->timer);
 384                 WARN_ON(!(bfa_fcport_get_topology(rport->port->fcs->bfa) !=
 385                                         BFA_PORT_TOPOLOGY_LOOP));
 386                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
 387                 rport->ns_retries = 0;
 388                 bfa_fcs_rport_send_nsdisc(rport, NULL);
 389                 break;
 390
 391         case RPSM_EVENT_LOGO_IMP:
 392                 rport->pid = 0;
 393                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
 394                 bfa_timer_stop(&rport->timer);
 395                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
 396                                 bfa_fcs_rport_timeout, rport,
 397                                 bfa_fcs_rport_del_timeout);
 398                 break;
 399
 400         case RPSM_EVENT_PLOGI_COMP:
 401                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
 402                 bfa_timer_stop(&rport->timer);
 403                 bfa_fcs_rport_fcs_online_action(rport);
 404                 break;
 405
 406         default:
 407                 bfa_sm_fault(rport->fcs, event);
 408         }
 409 }
 410
 411 /*
 412  *              PLOGI is sent.
 413  */
 414 static void
 415 bfa_fcs_rport_sm_plogi(struct bfa_fcs_rport_s *rport, enum rport_event event)
 416 {
 417         bfa_trc(rport->fcs, rport->pwwn);
 418         bfa_trc(rport->fcs, rport->pid);
 419         bfa_trc(rport->fcs, event);
 420
 421         switch (event) {
 422         case RPSM_EVENT_ACCEPTED:
 423                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
 424                 rport->plogi_retries = 0;
 425                 bfa_fcs_rport_fcs_online_action(rport);
 426                 break;
 427
 428         case RPSM_EVENT_LOGO_RCVD:
 429                 bfa_fcs_rport_send_logo_acc(rport);
 430                 /* fall through */
 431         case RPSM_EVENT_PRLO_RCVD:
 432                 if (rport->prlo == BFA_TRUE)
 433                         bfa_fcs_rport_send_prlo_acc(rport);
 434
 435                 bfa_fcxp_discard(rport->fcxp);
 436                 /* fall through */
 437         case RPSM_EVENT_FAILED:
 438                 if (rport->plogi_retries < BFA_FCS_RPORT_MAX_RETRIES) {
 439                         rport->plogi_retries++;
 440                         bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_retry);
 441                         bfa_timer_start(rport->fcs->bfa, &rport->timer,
 442                                         bfa_fcs_rport_timeout, rport,
 443                                         BFA_FCS_RETRY_TIMEOUT);
 444                 } else {
 445                         bfa_stats(rport->port, rport_del_max_plogi_retry);
 446                         rport->old_pid = rport->pid;
 447                         rport->pid = 0;
 448                         bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
 449                         bfa_timer_start(rport->fcs->bfa, &rport->timer,
 450                                         bfa_fcs_rport_timeout, rport,
 451                                         bfa_fcs_rport_del_timeout);
 452                 }
 453                 break;
 454
 455         case RPSM_EVENT_SCN_ONLINE:
 456                 break;
 457
 458         case RPSM_EVENT_SCN_OFFLINE:
 459                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
 460                 bfa_fcxp_discard(rport->fcxp);
 461                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
 462                                 bfa_fcs_rport_timeout, rport,
 463                                 bfa_fcs_rport_del_timeout);
 464                 break;
 465
 466         case RPSM_EVENT_PLOGI_RETRY:
 467                 rport->plogi_retries = 0;
 468                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_retry);
 469                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
 470                                 bfa_fcs_rport_timeout, rport,
 471                                 (FC_RA_TOV * 1000));
 472                 break;
 473
 474         case RPSM_EVENT_LOGO_IMP:
 475                 rport->pid = 0;
 476                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
 477                 bfa_fcxp_discard(rport->fcxp);
 478                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
 479                                 bfa_fcs_rport_timeout, rport,
 480                                 bfa_fcs_rport_del_timeout);
 481                 break;
 482
 483         case RPSM_EVENT_ADDRESS_CHANGE:
 484         case RPSM_EVENT_FAB_SCN:
 485                 bfa_fcxp_discard(rport->fcxp);
 486                 WARN_ON(!(bfa_fcport_get_topology(rport->port->fcs->bfa) !=
 487                                         BFA_PORT_TOPOLOGY_LOOP));
 488                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
 489                 rport->ns_retries = 0;
 490                 bfa_fcs_rport_send_nsdisc(rport, NULL);
 491                 break;
 492
 493         case RPSM_EVENT_PLOGI_RCVD:
 494                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
 495                 bfa_fcxp_discard(rport->fcxp);
 496                 bfa_fcs_rport_send_plogiacc(rport, NULL);
 497                 break;
 498
 499         case RPSM_EVENT_DELETE:
 500                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
 501                 bfa_fcxp_discard(rport->fcxp);
 502                 bfa_fcs_rport_free(rport);
 503                 break;
 504
 505         case RPSM_EVENT_PLOGI_COMP:
 506                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
 507                 bfa_fcxp_discard(rport->fcxp);
 508                 bfa_fcs_rport_fcs_online_action(rport);
 509                 break;
 510
 511         default:
 512                 bfa_sm_fault(rport->fcs, event);
 513         }
 514 }
 515
 516 /*
 517  * PLOGI is done. Await bfa_fcs_itnim to ascertain the scsi function
 518  */
 519 static void
 520 bfa_fcs_rport_sm_fc4_fcs_online(struct bfa_fcs_rport_s *rport,
 521                                 enum rport_event event)
 522 {
 523         bfa_trc(rport->fcs, rport->pwwn);
 524         bfa_trc(rport->fcs, rport->pid);
 525         bfa_trc(rport->fcs, event);
 526
 527         switch (event) {
 528         case RPSM_EVENT_FC4_FCS_ONLINE:
 529                 if (rport->scsi_function == BFA_RPORT_INITIATOR) {
 530                         if (!BFA_FCS_PID_IS_WKA(rport->pid))
 531                                 bfa_fcs_rpf_rport_online(rport);
 532                         bfa_sm_set_state(rport, bfa_fcs_rport_sm_online);
 533                         break;
 534                 }
 535
 536                 if (!rport->bfa_rport)
 537                         rport->bfa_rport =
 538                                 bfa_rport_create(rport->fcs->bfa, rport);
 539
 540                 if (rport->bfa_rport) {
 541                         bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
 542                         bfa_fcs_rport_hal_online(rport);
 543                 } else {
 544                         bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
 545                         bfa_fcs_rport_fcs_offline_action(rport);
 546                 }
 547                 break;
 548
 549         case RPSM_EVENT_PLOGI_RCVD:
 550                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
 551                 rport->plogi_pending = BFA_TRUE;
 552                 bfa_fcs_rport_fcs_offline_action(rport);
 553                 break;
 554
 555         case RPSM_EVENT_PLOGI_COMP:
 556         case RPSM_EVENT_LOGO_IMP:
 557         case RPSM_EVENT_ADDRESS_CHANGE:
 558         case RPSM_EVENT_FAB_SCN:
 559         case RPSM_EVENT_SCN_OFFLINE:
 560                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
 561                 bfa_fcs_rport_fcs_offline_action(rport);
 562                 break;
 563
 564         case RPSM_EVENT_LOGO_RCVD:
 565         case RPSM_EVENT_PRLO_RCVD:
 566                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
 567                 bfa_fcs_rport_fcs_offline_action(rport);
 568                 break;
 569
 570         case RPSM_EVENT_DELETE:
 571                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
 572                 bfa_fcs_rport_fcs_offline_action(rport);
 573                 break;
 574
 575         default:
 576                 bfa_sm_fault(rport->fcs, event);
 577                 break;
 578         }
 579 }
 580
 581 /*
 582  *              PLOGI is complete. Awaiting BFA rport online callback. FC-4s
 583  *              are offline.
 584  */
 585 static void
 586 bfa_fcs_rport_sm_hal_online(struct bfa_fcs_rport_s *rport,
 587                         enum rport_event event)
 588 {
 589         bfa_trc(rport->fcs, rport->pwwn);
 590         bfa_trc(rport->fcs, rport->pid);
 591         bfa_trc(rport->fcs, event);
 592
 593         switch (event) {
 594         case RPSM_EVENT_HCB_ONLINE:
 595                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_online);
 596                 bfa_fcs_rport_hal_online_action(rport);
 597                 break;
 598
 599         case RPSM_EVENT_PLOGI_COMP:
 600                 break;
 601
 602         case RPSM_EVENT_PRLO_RCVD:
 603         case RPSM_EVENT_LOGO_RCVD:
 604                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
 605                 bfa_fcs_rport_fcs_offline_action(rport);
 606                 break;
 607
 608         case RPSM_EVENT_FAB_SCN:
 609         case RPSM_EVENT_LOGO_IMP:
 610         case RPSM_EVENT_ADDRESS_CHANGE:
 611         case RPSM_EVENT_SCN_OFFLINE:
 612                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
 613                 bfa_fcs_rport_fcs_offline_action(rport);
 614                 break;
 615
 616         case RPSM_EVENT_PLOGI_RCVD:
 617                 rport->plogi_pending = BFA_TRUE;
 618                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
 619                 bfa_fcs_rport_fcs_offline_action(rport);
 620                 break;
 621
 622         case RPSM_EVENT_DELETE:
 623                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
 624                 bfa_fcs_rport_fcs_offline_action(rport);
 625                 break;
 626
 627         default:
 628                 bfa_sm_fault(rport->fcs, event);
 629         }
 630 }
 631
 632 /*
 633  *              Rport is ONLINE. FC-4s active.
 634  */
 635 static void
 636 bfa_fcs_rport_sm_online(struct bfa_fcs_rport_s *rport, enum rport_event event)
 637 {
 638         bfa_trc(rport->fcs, rport->pwwn);
 639         bfa_trc(rport->fcs, rport->pid);
 640         bfa_trc(rport->fcs, event);
 641
 642         switch (event) {
 643         case RPSM_EVENT_FAB_SCN:
 644                 if (bfa_fcs_fabric_is_switched(rport->port->fabric)) {
 645                         bfa_sm_set_state(rport,
 646                                          bfa_fcs_rport_sm_nsquery_sending);
 647                         rport->ns_retries = 0;
 648                         bfa_fcs_rport_send_nsdisc(rport, NULL);
 649                 } else {
 650                         bfa_sm_set_state(rport,
 651                                 bfa_fcs_rport_sm_adisc_online_sending);
 652                         bfa_fcs_rport_send_adisc(rport, NULL);
 653                 }
 654                 break;
 655
 656         case RPSM_EVENT_PLOGI_RCVD:
 657         case RPSM_EVENT_LOGO_IMP:
 658         case RPSM_EVENT_ADDRESS_CHANGE:
 659         case RPSM_EVENT_SCN_OFFLINE:
 660                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
 661                 bfa_fcs_rport_hal_offline_action(rport);
 662                 break;
 663
 664         case RPSM_EVENT_DELETE:
 665                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
 666                 bfa_fcs_rport_hal_offline_action(rport);
 667                 break;
 668
 669         case RPSM_EVENT_LOGO_RCVD:
 670         case RPSM_EVENT_PRLO_RCVD:
 671                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
 672                 bfa_fcs_rport_hal_offline_action(rport);
 673                 break;
 674
 675         case RPSM_EVENT_SCN_ONLINE:
 676         case RPSM_EVENT_PLOGI_COMP:
 677                 break;
 678
 679         default:
 680                 bfa_sm_fault(rport->fcs, event);
 681         }
 682 }
 683
 684 /*
 685  *              An SCN event is received in ONLINE state. NS query is being sent
 686  *              prior to ADISC authentication with rport. FC-4s are paused.
 687  */
 688 static void
 689 bfa_fcs_rport_sm_nsquery_sending(struct bfa_fcs_rport_s *rport,
 690          enum rport_event event)
 691 {
 692         bfa_trc(rport->fcs, rport->pwwn);
 693         bfa_trc(rport->fcs, rport->pid);
 694         bfa_trc(rport->fcs, event);
 695
 696         switch (event) {
 697         case RPSM_EVENT_FCXP_SENT:
 698                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsquery);
 699                 break;
 700
 701         case RPSM_EVENT_DELETE:
 702                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
 703                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 704                 bfa_fcs_rport_hal_offline_action(rport);
 705                 break;
 706
 707         case RPSM_EVENT_FAB_SCN:
 708                 /*
 709                  * ignore SCN, wait for response to query itself
 710                  */
 711                 break;
 712
 713         case RPSM_EVENT_LOGO_RCVD:
 714         case RPSM_EVENT_PRLO_RCVD:
 715                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
 716                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 717                 bfa_fcs_rport_hal_offline_action(rport);
 718                 break;
 719
 720         case RPSM_EVENT_LOGO_IMP:
 721         case RPSM_EVENT_PLOGI_RCVD:
 722         case RPSM_EVENT_ADDRESS_CHANGE:
 723         case RPSM_EVENT_PLOGI_COMP:
 724                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
 725                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 726                 bfa_fcs_rport_hal_offline_action(rport);
 727                 break;
 728
 729         default:
 730                 bfa_sm_fault(rport->fcs, event);
 731         }
 732 }
 733
 734 /*
 735  *      An SCN event is received in ONLINE state. NS query is sent to rport.
 736  *      FC-4s are paused.
 737  */
 738 static void
 739 bfa_fcs_rport_sm_nsquery(struct bfa_fcs_rport_s *rport, enum rport_event event)
 740 {
 741         bfa_trc(rport->fcs, rport->pwwn);
 742         bfa_trc(rport->fcs, rport->pid);
 743         bfa_trc(rport->fcs, event);
 744
 745         switch (event) {
 746         case RPSM_EVENT_ACCEPTED:
 747                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_adisc_online_sending);
 748                 bfa_fcs_rport_send_adisc(rport, NULL);
 749                 break;
 750
 751         case RPSM_EVENT_FAILED:
 752                 rport->ns_retries++;
 753                 if (rport->ns_retries < BFA_FCS_RPORT_MAX_RETRIES) {
 754                         bfa_sm_set_state(rport,
 755                                          bfa_fcs_rport_sm_nsquery_sending);
 756                         bfa_fcs_rport_send_nsdisc(rport, NULL);
 757                 } else {
 758                         bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
 759                         bfa_fcs_rport_hal_offline_action(rport);
 760                 }
 761                 break;
 762
 763         case RPSM_EVENT_DELETE:
 764                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
 765                 bfa_fcxp_discard(rport->fcxp);
 766                 bfa_fcs_rport_hal_offline_action(rport);
 767                 break;
 768
 769         case RPSM_EVENT_FAB_SCN:
 770                 break;
 771
 772         case RPSM_EVENT_LOGO_RCVD:
 773         case RPSM_EVENT_PRLO_RCVD:
 774                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
 775                 bfa_fcxp_discard(rport->fcxp);
 776                 bfa_fcs_rport_hal_offline_action(rport);
 777                 break;
 778
 779         case RPSM_EVENT_PLOGI_COMP:
 780         case RPSM_EVENT_ADDRESS_CHANGE:
 781         case RPSM_EVENT_PLOGI_RCVD:
 782         case RPSM_EVENT_LOGO_IMP:
 783                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
 784                 bfa_fcxp_discard(rport->fcxp);
 785                 bfa_fcs_rport_hal_offline_action(rport);
 786                 break;
 787
 788         default:
 789                 bfa_sm_fault(rport->fcs, event);
 790         }
 791 }
 792
 793 /*
 794  *      An SCN event is received in ONLINE state. ADISC is being sent for
 795  *      authenticating with rport. FC-4s are paused.
 796  */
 797 static void
 798 bfa_fcs_rport_sm_adisc_online_sending(struct bfa_fcs_rport_s *rport,
 799          enum rport_event event)
 800 {
 801         bfa_trc(rport->fcs, rport->pwwn);
 802         bfa_trc(rport->fcs, rport->pid);
 803         bfa_trc(rport->fcs, event);
 804
 805         switch (event) {
 806         case RPSM_EVENT_FCXP_SENT:
 807                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_adisc_online);
 808                 break;
 809
 810         case RPSM_EVENT_DELETE:
 811                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
 812                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 813                 bfa_fcs_rport_hal_offline_action(rport);
 814                 break;
 815
 816         case RPSM_EVENT_LOGO_IMP:
 817         case RPSM_EVENT_ADDRESS_CHANGE:
 818                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
 819                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 820                 bfa_fcs_rport_hal_offline_action(rport);
 821                 break;
 822
 823         case RPSM_EVENT_LOGO_RCVD:
 824         case RPSM_EVENT_PRLO_RCVD:
 825                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
 826                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 827                 bfa_fcs_rport_hal_offline_action(rport);
 828                 break;
 829
 830         case RPSM_EVENT_FAB_SCN:
 831                 break;
 832
 833         case RPSM_EVENT_PLOGI_RCVD:
 834                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
 835                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 836                 bfa_fcs_rport_hal_offline_action(rport);
 837                 break;
 838
 839         default:
 840                 bfa_sm_fault(rport->fcs, event);
 841         }
 842 }
 843
 844 /*
 845  *              An SCN event is received in ONLINE state. ADISC is to rport.
 846  *              FC-4s are paused.
 847  */
 848 static void
 849 bfa_fcs_rport_sm_adisc_online(struct bfa_fcs_rport_s *rport,
 850                                 enum rport_event event)
 851 {
 852         bfa_trc(rport->fcs, rport->pwwn);
 853         bfa_trc(rport->fcs, rport->pid);
 854         bfa_trc(rport->fcs, event);
 855
 856         switch (event) {
 857         case RPSM_EVENT_ACCEPTED:
 858                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_online);
 859                 break;
 860
 861         case RPSM_EVENT_PLOGI_RCVD:
 862                 /*
 863                  * Too complex to cleanup FC-4 & rport and then acc to PLOGI.
 864                  * At least go offline when a PLOGI is received.
 865                  */
 866                 bfa_fcxp_discard(rport->fcxp);
 867                 /* fall through */
 868
 869         case RPSM_EVENT_FAILED:
 870         case RPSM_EVENT_ADDRESS_CHANGE:
 871                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
 872                 bfa_fcs_rport_hal_offline_action(rport);
 873                 break;
 874
 875         case RPSM_EVENT_DELETE:
 876                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
 877                 bfa_fcxp_discard(rport->fcxp);
 878                 bfa_fcs_rport_hal_offline_action(rport);
 879                 break;
 880
 881         case RPSM_EVENT_FAB_SCN:
 882                 /*
 883                  * already processing RSCN
 884                  */
 885                 break;
 886
 887         case RPSM_EVENT_LOGO_IMP:
 888                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
 889                 bfa_fcxp_discard(rport->fcxp);
 890                 bfa_fcs_rport_hal_offline_action(rport);
 891                 break;
 892
 893         case RPSM_EVENT_LOGO_RCVD:
 894         case RPSM_EVENT_PRLO_RCVD:
 895                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
 896                 bfa_fcxp_discard(rport->fcxp);
 897                 bfa_fcs_rport_hal_offline_action(rport);
 898                 break;
 899
 900         default:
 901                 bfa_sm_fault(rport->fcs, event);
 902         }
 903 }
 904
 905 /*
 906  * ADISC is being sent for authenticating with rport
 907  * Already did offline actions.
 908  */
 909 static void
 910 bfa_fcs_rport_sm_adisc_offline_sending(struct bfa_fcs_rport_s *rport,
 911         enum rport_event event)
 912 {
 913         bfa_trc(rport->fcs, rport->pwwn);
 914         bfa_trc(rport->fcs, rport->pid);
 915         bfa_trc(rport->fcs, event);
 916
 917         switch (event) {
 918         case RPSM_EVENT_FCXP_SENT:
 919                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_adisc_offline);
 920                 break;
 921
 922         case RPSM_EVENT_DELETE:
 923         case RPSM_EVENT_SCN_OFFLINE:
 924         case RPSM_EVENT_LOGO_IMP:
 925         case RPSM_EVENT_LOGO_RCVD:
 926         case RPSM_EVENT_PRLO_RCVD:
 927                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
 928                 bfa_fcxp_walloc_cancel(rport->fcs->bfa,
 929                         &rport->fcxp_wqe);
 930                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
 931                         bfa_fcs_rport_timeout, rport,
 932                         bfa_fcs_rport_del_timeout);
 933                 break;
 934
 935         case RPSM_EVENT_PLOGI_RCVD:
 936                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
 937                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
 938                 bfa_fcs_rport_send_plogiacc(rport, NULL);
 939                 break;
 940
 941         default:
 942                 bfa_sm_fault(rport->fcs, event);
 943         }
 944 }
 945
 946 /*
 947  * ADISC to rport
 948  * Already did offline actions
 949  */
 950 static void
 951 bfa_fcs_rport_sm_adisc_offline(struct bfa_fcs_rport_s *rport,
 952                         enum rport_event event)
 953 {
 954         bfa_trc(rport->fcs, rport->pwwn);
 955         bfa_trc(rport->fcs, rport->pid);
 956         bfa_trc(rport->fcs, event);
 957
 958         switch (event) {
 959         case RPSM_EVENT_ACCEPTED:
 960                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
 961                 bfa_fcs_rport_hal_online(rport);
 962                 break;
 963
 964         case RPSM_EVENT_PLOGI_RCVD:
 965                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
 966                 bfa_fcxp_discard(rport->fcxp);
 967                 bfa_fcs_rport_send_plogiacc(rport, NULL);
 968                 break;
 969
 970         case RPSM_EVENT_FAILED:
 971                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
 972                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
 973                         bfa_fcs_rport_timeout, rport,
 974                         bfa_fcs_rport_del_timeout);
 975                 break;
 976
 977         case RPSM_EVENT_DELETE:
 978         case RPSM_EVENT_SCN_OFFLINE:
 979         case RPSM_EVENT_LOGO_IMP:
 980         case RPSM_EVENT_LOGO_RCVD:
 981         case RPSM_EVENT_PRLO_RCVD:
 982                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
 983                 bfa_fcxp_discard(rport->fcxp);
 984                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
 985                         bfa_fcs_rport_timeout, rport,
 986                         bfa_fcs_rport_del_timeout);
 987                 break;
 988
 989         default:
 990                 bfa_sm_fault(rport->fcs, event);
 991         }
 992 }
 993
 994 /*
 995  * Rport has sent LOGO. Awaiting FC-4 offline completion callback.
 996  */
 997 static void
 998 bfa_fcs_rport_sm_fc4_logorcv(struct bfa_fcs_rport_s *rport,
 999                         enum rport_event event)
1000 {
1001         bfa_trc(rport->fcs, rport->pwwn);
1002         bfa_trc(rport->fcs, rport->pid);
1003         bfa_trc(rport->fcs, event);
1004
1005         switch (event) {
1006         case RPSM_EVENT_FC4_OFFLINE:
1007                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logorcv);
1008                 bfa_fcs_rport_hal_offline(rport);
1009                 break;
1010
1011         case RPSM_EVENT_DELETE:
1012                 if (rport->pid && (rport->prlo == BFA_TRUE))
1013                         bfa_fcs_rport_send_prlo_acc(rport);
1014                 if (rport->pid && (rport->prlo == BFA_FALSE))
1015                         bfa_fcs_rport_send_logo_acc(rport);
1016
1017                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_off_delete);
1018                 break;
1019
1020         case RPSM_EVENT_SCN_ONLINE:
1021         case RPSM_EVENT_SCN_OFFLINE:
1022         case RPSM_EVENT_HCB_ONLINE:
1023         case RPSM_EVENT_LOGO_RCVD:
1024         case RPSM_EVENT_PRLO_RCVD:
1025         case RPSM_EVENT_ADDRESS_CHANGE:
1026                 break;
1027
1028         default:
1029                 bfa_sm_fault(rport->fcs, event);
1030         }
1031 }
1032
1033 /*
1034  *              LOGO needs to be sent to rport. Awaiting FC-4 offline completion
1035  *              callback.
1036  */
1037 static void
1038 bfa_fcs_rport_sm_fc4_logosend(struct bfa_fcs_rport_s *rport,
1039          enum rport_event event)
1040 {
1041         bfa_trc(rport->fcs, rport->pwwn);
1042         bfa_trc(rport->fcs, rport->pid);
1043         bfa_trc(rport->fcs, event);
1044
1045         switch (event) {
1046         case RPSM_EVENT_FC4_OFFLINE:
1047                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logosend);
1048                 bfa_fcs_rport_hal_offline(rport);
1049                 break;
1050
1051         case RPSM_EVENT_LOGO_RCVD:
1052                 bfa_fcs_rport_send_logo_acc(rport);
1053                 /* fall through */
1054         case RPSM_EVENT_PRLO_RCVD:
1055                 if (rport->prlo == BFA_TRUE)
1056                         bfa_fcs_rport_send_prlo_acc(rport);
1057                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_off_delete);
1058                 break;
1059
1060         case RPSM_EVENT_HCB_ONLINE:
1061         case RPSM_EVENT_DELETE:
1062                 /* Rport is being deleted */
1063                 break;
1064
1065         default:
1066                 bfa_sm_fault(rport->fcs, event);
1067         }
1068 }
1069
1070 /*
1071  *      Rport is going offline. Awaiting FC-4 offline completion callback.
1072  */
1073 static void
1074 bfa_fcs_rport_sm_fc4_offline(struct bfa_fcs_rport_s *rport,
1075                         enum rport_event event)
1076 {
1077         bfa_trc(rport->fcs, rport->pwwn);
1078         bfa_trc(rport->fcs, rport->pid);
1079         bfa_trc(rport->fcs, event);
1080
1081         switch (event) {
1082         case RPSM_EVENT_FC4_OFFLINE:
1083                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_offline);
1084                 bfa_fcs_rport_hal_offline(rport);
1085                 break;
1086
1087         case RPSM_EVENT_SCN_ONLINE:
1088                 break;
1089         case RPSM_EVENT_LOGO_RCVD:
1090                 /*
1091                  * Rport is going offline. Just ack the logo
1092                  */
1093                 bfa_fcs_rport_send_logo_acc(rport);
1094                 break;
1095
1096         case RPSM_EVENT_PRLO_RCVD:
1097                 bfa_fcs_rport_send_prlo_acc(rport);
1098                 break;
1099
1100         case RPSM_EVENT_SCN_OFFLINE:
1101         case RPSM_EVENT_HCB_ONLINE:
1102         case RPSM_EVENT_FAB_SCN:
1103         case RPSM_EVENT_LOGO_IMP:
1104         case RPSM_EVENT_ADDRESS_CHANGE:
1105                 /*
1106                  * rport is already going offline.
1107                  * SCN - ignore and wait till transitioning to offline state
1108                  */
1109                 break;
1110
1111         case RPSM_EVENT_DELETE:
1112                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
1113                 break;
1114
1115         default:
1116                 bfa_sm_fault(rport->fcs, event);
1117         }
1118 }
1119
1120 /*
1121  *              Rport is offline. FC-4s are offline. Awaiting BFA rport offline
1122  *              callback.
1123  */
1124 static void
1125 bfa_fcs_rport_sm_hcb_offline(struct bfa_fcs_rport_s *rport,
1126                                 enum rport_event event)
1127 {
1128         bfa_trc(rport->fcs, rport->pwwn);
1129         bfa_trc(rport->fcs, rport->pid);
1130         bfa_trc(rport->fcs, event);
1131
1132         switch (event) {
1133         case RPSM_EVENT_HCB_OFFLINE:
1134                 if (bfa_fcs_lport_is_online(rport->port) &&
1135                     (rport->plogi_pending)) {
1136                         rport->plogi_pending = BFA_FALSE;
1137                         bfa_sm_set_state(rport,
1138                                 bfa_fcs_rport_sm_plogiacc_sending);
1139                         bfa_fcs_rport_send_plogiacc(rport, NULL);
1140                         break;
1141                 }
1142                 /* fall through */
1143
1144         case RPSM_EVENT_ADDRESS_CHANGE:
1145                 if (!bfa_fcs_lport_is_online(rport->port)) {
1146                         rport->pid = 0;
1147                         bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
1148                         bfa_timer_start(rport->fcs->bfa, &rport->timer,
1149                                         bfa_fcs_rport_timeout, rport,
1150                                         bfa_fcs_rport_del_timeout);
1151                         break;
1152                 }
1153                 if (bfa_fcs_fabric_is_switched(rport->port->fabric)) {
1154                         bfa_sm_set_state(rport,
1155                                 bfa_fcs_rport_sm_nsdisc_sending);
1156                         rport->ns_retries = 0;
1157                         bfa_fcs_rport_send_nsdisc(rport, NULL);
1158                 } else if (bfa_fcport_get_topology(rport->port->fcs->bfa) ==
1159                                         BFA_PORT_TOPOLOGY_LOOP) {
1160                         if (rport->scn_online) {
1161                                 bfa_sm_set_state(rport,
1162                                         bfa_fcs_rport_sm_adisc_offline_sending);
1163                                 bfa_fcs_rport_send_adisc(rport, NULL);
1164                         } else {
1165                                 bfa_sm_set_state(rport,
1166                                         bfa_fcs_rport_sm_offline);
1167                                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
1168                                         bfa_fcs_rport_timeout, rport,
1169                                         bfa_fcs_rport_del_timeout);
1170                         }
1171                 } else {
1172                         bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_sending);
1173                         rport->plogi_retries = 0;
1174                         bfa_fcs_rport_send_plogi(rport, NULL);
1175                 }
1176                 break;
1177
1178         case RPSM_EVENT_DELETE:
1179                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
1180                 bfa_fcs_rport_free(rport);
1181                 break;
1182
1183         case RPSM_EVENT_SCN_ONLINE:
1184         case RPSM_EVENT_SCN_OFFLINE:
1185         case RPSM_EVENT_FAB_SCN:
1186         case RPSM_EVENT_LOGO_RCVD:
1187         case RPSM_EVENT_PRLO_RCVD:
1188         case RPSM_EVENT_PLOGI_RCVD:
1189         case RPSM_EVENT_LOGO_IMP:
1190                 /*
1191                  * Ignore, already offline.
1192                  */
1193                 break;
1194
1195         default:
1196                 bfa_sm_fault(rport->fcs, event);
1197         }
1198 }
1199
1200 /*
1201  *              Rport is offline. FC-4s are offline. Awaiting BFA rport offline
1202  *              callback to send LOGO accept.
1203  */
1204 static void
1205 bfa_fcs_rport_sm_hcb_logorcv(struct bfa_fcs_rport_s *rport,
1206                         enum rport_event event)
1207 {
1208         bfa_trc(rport->fcs, rport->pwwn);
1209         bfa_trc(rport->fcs, rport->pid);
1210         bfa_trc(rport->fcs, event);
1211
1212         switch (event) {
1213         case RPSM_EVENT_HCB_OFFLINE:
1214         case RPSM_EVENT_ADDRESS_CHANGE:
1215                 if (rport->pid && (rport->prlo == BFA_TRUE))
1216                         bfa_fcs_rport_send_prlo_acc(rport);
1217                 if (rport->pid && (rport->prlo == BFA_FALSE))
1218                         bfa_fcs_rport_send_logo_acc(rport);
1219                 /*
1220                  * If the lport is online and if the rport is not a well
1221                  * known address port,
1222                  * we try to re-discover the r-port.
1223                  */
1224                 if (bfa_fcs_lport_is_online(rport->port) &&
1225                         (!BFA_FCS_PID_IS_WKA(rport->pid))) {
1226                         if (bfa_fcs_fabric_is_switched(rport->port->fabric)) {
1227                                 bfa_sm_set_state(rport,
1228                                         bfa_fcs_rport_sm_nsdisc_sending);
1229                                 rport->ns_retries = 0;
1230                                 bfa_fcs_rport_send_nsdisc(rport, NULL);
1231                         } else {
1232                                 /* For N2N  Direct Attach, try to re-login */
1233                                 bfa_sm_set_state(rport,
1234                                         bfa_fcs_rport_sm_plogi_sending);
1235                                 rport->plogi_retries = 0;
1236                                 bfa_fcs_rport_send_plogi(rport, NULL);
1237                         }
1238                 } else {
1239                         /*
1240                          * if it is not a well known address, reset the
1241                          * pid to 0.
1242                          */
1243                         if (!BFA_FCS_PID_IS_WKA(rport->pid))
1244                                 rport->pid = 0;
1245                         bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
1246                         bfa_timer_start(rport->fcs->bfa, &rport->timer,
1247                                         bfa_fcs_rport_timeout, rport,
1248                                         bfa_fcs_rport_del_timeout);
1249                 }
1250                 break;
1251
1252         case RPSM_EVENT_DELETE:
1253                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_delete_pending);
1254                 if (rport->pid && (rport->prlo == BFA_TRUE))
1255                         bfa_fcs_rport_send_prlo_acc(rport);
1256                 if (rport->pid && (rport->prlo == BFA_FALSE))
1257                         bfa_fcs_rport_send_logo_acc(rport);
1258                 break;
1259
1260         case RPSM_EVENT_LOGO_IMP:
1261                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_offline);
1262                 break;
1263
1264         case RPSM_EVENT_SCN_ONLINE:
1265         case RPSM_EVENT_SCN_OFFLINE:
1266         case RPSM_EVENT_LOGO_RCVD:
1267         case RPSM_EVENT_PRLO_RCVD:
1268                 /*
1269                  * Ignore - already processing a LOGO.
1270                  */
1271                 break;
1272
1273         default:
1274                 bfa_sm_fault(rport->fcs, event);
1275         }
1276 }
1277
1278 /*
1279  *              Rport is being deleted. FC-4s are offline.
1280  *  Awaiting BFA rport offline
1281  *              callback to send LOGO.
1282  */
1283 static void
1284 bfa_fcs_rport_sm_hcb_logosend(struct bfa_fcs_rport_s *rport,
1285                  enum rport_event event)
1286 {
1287         bfa_trc(rport->fcs, rport->pwwn);
1288         bfa_trc(rport->fcs, rport->pid);
1289         bfa_trc(rport->fcs, event);
1290
1291         switch (event) {
1292         case RPSM_EVENT_HCB_OFFLINE:
1293                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_logo_sending);
1294                 bfa_fcs_rport_send_logo(rport, NULL);
1295                 break;
1296
1297         case RPSM_EVENT_LOGO_RCVD:
1298                 bfa_fcs_rport_send_logo_acc(rport);
1299                 /* fall through */
1300         case RPSM_EVENT_PRLO_RCVD:
1301                 if (rport->prlo == BFA_TRUE)
1302                         bfa_fcs_rport_send_prlo_acc(rport);
1303
1304                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_delete_pending);
1305                 break;
1306
1307         case RPSM_EVENT_SCN_ONLINE:
1308         case RPSM_EVENT_SCN_OFFLINE:
1309         case RPSM_EVENT_ADDRESS_CHANGE:
1310                 break;
1311
1312         default:
1313                 bfa_sm_fault(rport->fcs, event);
1314         }
1315 }
1316
1317 /*
1318  *              Rport is being deleted. FC-4s are offline. LOGO is being sent.
1319  */
1320 static void
1321 bfa_fcs_rport_sm_logo_sending(struct bfa_fcs_rport_s *rport,
1322          enum rport_event event)
1323 {
1324         bfa_trc(rport->fcs, rport->pwwn);
1325         bfa_trc(rport->fcs, rport->pid);
1326         bfa_trc(rport->fcs, event);
1327
1328         switch (event) {
1329         case RPSM_EVENT_FCXP_SENT:
1330                 /* Once LOGO is sent, we donot wait for the response */
1331                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
1332                 bfa_fcs_rport_free(rport);
1333                 break;
1334
1335         case RPSM_EVENT_SCN_ONLINE:
1336         case RPSM_EVENT_SCN_OFFLINE:
1337         case RPSM_EVENT_FAB_SCN:
1338         case RPSM_EVENT_ADDRESS_CHANGE:
1339                 break;
1340
1341         case RPSM_EVENT_LOGO_RCVD:
1342                 bfa_fcs_rport_send_logo_acc(rport);
1343                 /* fall through */
1344         case RPSM_EVENT_PRLO_RCVD:
1345                 if (rport->prlo == BFA_TRUE)
1346                         bfa_fcs_rport_send_prlo_acc(rport);
1347
1348                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
1349                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
1350                 bfa_fcs_rport_free(rport);
1351                 break;
1352
1353         default:
1354                 bfa_sm_fault(rport->fcs, event);
1355         }
1356 }
1357
1358 /*
1359  *              Rport is offline. FC-4s are offline. BFA rport is offline.
1360  *              Timer active to delete stale rport.
1361  */
1362 static void
1363 bfa_fcs_rport_sm_offline(struct bfa_fcs_rport_s *rport, enum rport_event event)
1364 {
1365         bfa_trc(rport->fcs, rport->pwwn);
1366         bfa_trc(rport->fcs, rport->pid);
1367         bfa_trc(rport->fcs, event);
1368
1369         switch (event) {
1370         case RPSM_EVENT_TIMEOUT:
1371                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
1372                 bfa_fcs_rport_free(rport);
1373                 break;
1374
1375         case RPSM_EVENT_FAB_SCN:
1376         case RPSM_EVENT_ADDRESS_CHANGE:
1377                 bfa_timer_stop(&rport->timer);
1378                 WARN_ON(!(bfa_fcport_get_topology(rport->port->fcs->bfa) !=
1379                                         BFA_PORT_TOPOLOGY_LOOP));
1380                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
1381                 rport->ns_retries = 0;
1382                 bfa_fcs_rport_send_nsdisc(rport, NULL);
1383                 break;
1384
1385         case RPSM_EVENT_DELETE:
1386                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
1387                 bfa_timer_stop(&rport->timer);
1388                 bfa_fcs_rport_free(rport);
1389                 break;
1390
1391         case RPSM_EVENT_PLOGI_RCVD:
1392                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
1393                 bfa_timer_stop(&rport->timer);
1394                 bfa_fcs_rport_send_plogiacc(rport, NULL);
1395                 break;
1396
1397         case RPSM_EVENT_LOGO_RCVD:
1398         case RPSM_EVENT_PRLO_RCVD:
1399         case RPSM_EVENT_LOGO_IMP:
1400         case RPSM_EVENT_SCN_OFFLINE:
1401                 break;
1402
1403         case RPSM_EVENT_PLOGI_COMP:
1404                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
1405                 bfa_timer_stop(&rport->timer);
1406                 bfa_fcs_rport_fcs_online_action(rport);
1407                 break;
1408
1409         case RPSM_EVENT_SCN_ONLINE:
1410                 bfa_timer_stop(&rport->timer);
1411                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_sending);
1412                 bfa_fcs_rport_send_plogi(rport, NULL);
1413                 break;
1414
1415         case RPSM_EVENT_PLOGI_SEND:
1416                 bfa_timer_stop(&rport->timer);
1417                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_sending);
1418                 rport->plogi_retries = 0;
1419                 bfa_fcs_rport_send_plogi(rport, NULL);
1420                 break;
1421
1422         default:
1423                 bfa_sm_fault(rport->fcs, event);
1424         }
1425 }
1426
1427 /*
1428  *      Rport address has changed. Nameserver discovery request is being sent.
1429  */
1430 static void
1431 bfa_fcs_rport_sm_nsdisc_sending(struct bfa_fcs_rport_s *rport,
1432          enum rport_event event)
1433 {
1434         bfa_trc(rport->fcs, rport->pwwn);
1435         bfa_trc(rport->fcs, rport->pid);
1436         bfa_trc(rport->fcs, event);
1437
1438         switch (event) {
1439         case RPSM_EVENT_FCXP_SENT:
1440                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sent);
1441                 break;
1442
1443         case RPSM_EVENT_DELETE:
1444                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
1445                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
1446                 bfa_fcs_rport_free(rport);
1447                 break;
1448
1449         case RPSM_EVENT_PLOGI_RCVD:
1450                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
1451                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
1452                 bfa_fcs_rport_send_plogiacc(rport, NULL);
1453                 break;
1454
1455         case RPSM_EVENT_FAB_SCN:
1456         case RPSM_EVENT_LOGO_RCVD:
1457         case RPSM_EVENT_PRLO_RCVD:
1458         case RPSM_EVENT_PLOGI_SEND:
1459                 break;
1460
1461         case RPSM_EVENT_ADDRESS_CHANGE:
1462                 rport->ns_retries = 0; /* reset the retry count */
1463                 break;
1464
1465         case RPSM_EVENT_LOGO_IMP:
1466                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
1467                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
1468                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
1469                                 bfa_fcs_rport_timeout, rport,
1470                                 bfa_fcs_rport_del_timeout);
1471                 break;
1472
1473         case RPSM_EVENT_PLOGI_COMP:
1474                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
1475                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
1476                 bfa_fcs_rport_fcs_online_action(rport);
1477                 break;
1478
1479         default:
1480                 bfa_sm_fault(rport->fcs, event);
1481         }
1482 }
1483
1484 /*
1485  *              Nameserver discovery failed. Waiting for timeout to retry.
1486  */
1487 static void
1488 bfa_fcs_rport_sm_nsdisc_retry(struct bfa_fcs_rport_s *rport,
1489          enum rport_event event)
1490 {
1491         bfa_trc(rport->fcs, rport->pwwn);
1492         bfa_trc(rport->fcs, rport->pid);
1493         bfa_trc(rport->fcs, event);
1494
1495         switch (event) {
1496         case RPSM_EVENT_TIMEOUT:
1497                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
1498                 bfa_fcs_rport_send_nsdisc(rport, NULL);
1499                 break;
1500
1501         case RPSM_EVENT_FAB_SCN:
1502         case RPSM_EVENT_ADDRESS_CHANGE:
1503                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
1504                 bfa_timer_stop(&rport->timer);
1505                 rport->ns_retries = 0;
1506                 bfa_fcs_rport_send_nsdisc(rport, NULL);
1507                 break;
1508
1509         case RPSM_EVENT_DELETE:
1510                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
1511                 bfa_timer_stop(&rport->timer);
1512                 bfa_fcs_rport_free(rport);
1513                 break;
1514
1515         case RPSM_EVENT_PLOGI_RCVD:
1516                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
1517                 bfa_timer_stop(&rport->timer);
1518                 bfa_fcs_rport_send_plogiacc(rport, NULL);
1519                 break;
1520
1521         case RPSM_EVENT_LOGO_IMP:
1522                 rport->pid = 0;
1523                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
1524                 bfa_timer_stop(&rport->timer);
1525                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
1526                                 bfa_fcs_rport_timeout, rport,
1527                                 bfa_fcs_rport_del_timeout);
1528                 break;
1529
1530         case RPSM_EVENT_LOGO_RCVD:
1531                 bfa_fcs_rport_send_logo_acc(rport);
1532                 break;
1533         case RPSM_EVENT_PRLO_RCVD:
1534                 bfa_fcs_rport_send_prlo_acc(rport);
1535                 break;
1536
1537         case RPSM_EVENT_PLOGI_COMP:
1538                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
1539                 bfa_timer_stop(&rport->timer);
1540                 bfa_fcs_rport_fcs_online_action(rport);
1541                 break;
1542
1543         default:
1544                 bfa_sm_fault(rport->fcs, event);
1545         }
1546 }
1547
1548 /*
1549  *              Rport address has changed. Nameserver discovery request is sent.
1550  */
1551 static void
1552 bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport,
1553                         enum rport_event event)
1554 {
1555         bfa_trc(rport->fcs, rport->pwwn);
1556         bfa_trc(rport->fcs, rport->pid);
1557         bfa_trc(rport->fcs, event);
1558
1559         switch (event) {
1560         case RPSM_EVENT_ACCEPTED:
1561         case RPSM_EVENT_ADDRESS_CHANGE:
1562                 if (rport->pid) {
1563                         bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_sending);
1564                         bfa_fcs_rport_send_plogi(rport, NULL);
1565                 } else {
1566                         bfa_sm_set_state(rport,
1567                                  bfa_fcs_rport_sm_nsdisc_sending);
1568                         rport->ns_retries = 0;
1569                         bfa_fcs_rport_send_nsdisc(rport, NULL);
1570                 }
1571                 break;
1572
1573         case RPSM_EVENT_FAILED:
1574                 rport->ns_retries++;
1575                 if (rport->ns_retries < BFA_FCS_RPORT_MAX_RETRIES) {
1576                         bfa_sm_set_state(rport,
1577                                  bfa_fcs_rport_sm_nsdisc_sending);
1578                         bfa_fcs_rport_send_nsdisc(rport, NULL);
1579                 } else {
1580                         rport->old_pid = rport->pid;
1581                         rport->pid = 0;
1582                         bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
1583                         bfa_timer_start(rport->fcs->bfa, &rport->timer,
1584                                         bfa_fcs_rport_timeout, rport,
1585                                         bfa_fcs_rport_del_timeout);
1586                 };
1587                 break;
1588
1589         case RPSM_EVENT_DELETE:
1590                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
1591                 bfa_fcxp_discard(rport->fcxp);
1592                 bfa_fcs_rport_free(rport);
1593                 break;
1594
1595         case RPSM_EVENT_PLOGI_RCVD:
1596                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
1597                 bfa_fcxp_discard(rport->fcxp);
1598                 bfa_fcs_rport_send_plogiacc(rport, NULL);
1599                 break;
1600
1601         case RPSM_EVENT_LOGO_IMP:
1602                 rport->pid = 0;
1603                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
1604                 bfa_fcxp_discard(rport->fcxp);
1605                 bfa_timer_start(rport->fcs->bfa, &rport->timer,
1606                                 bfa_fcs_rport_timeout, rport,
1607                                 bfa_fcs_rport_del_timeout);
1608                 break;
1609
1610
1611         case RPSM_EVENT_PRLO_RCVD:
1612                 bfa_fcs_rport_send_prlo_acc(rport);
1613                 break;
1614         case RPSM_EVENT_FAB_SCN:
1615                 /*
1616                  * ignore, wait for NS query response
1617                  */
1618                 break;
1619
1620         case RPSM_EVENT_LOGO_RCVD:
1621                 /*
1622                  * Not logged-in yet. Accept LOGO.
1623                  */
1624                 bfa_fcs_rport_send_logo_acc(rport);
1625                 break;
1626
1627         case RPSM_EVENT_PLOGI_COMP:
1628                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
1629                 bfa_fcxp_discard(rport->fcxp);
1630                 bfa_fcs_rport_fcs_online_action(rport);
1631                 break;
1632
1633         default:
1634                 bfa_sm_fault(rport->fcs, event);
1635         }
1636 }
1637
1638 /*
1639  * Rport needs to be deleted
1640  * waiting for ITNIM clean up to finish
1641  */
1642 static void
1643 bfa_fcs_rport_sm_fc4_off_delete(struct bfa_fcs_rport_s *rport,
1644                                 enum rport_event event)
1645 {
1646         bfa_trc(rport->fcs, rport->pwwn);
1647         bfa_trc(rport->fcs, rport->pid);
1648         bfa_trc(rport->fcs, event);
1649
1650         switch (event) {
1651         case RPSM_EVENT_FC4_OFFLINE:
1652                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_delete_pending);
1653                 bfa_fcs_rport_hal_offline(rport);
1654                 break;
1655
1656         case RPSM_EVENT_DELETE:
1657         case RPSM_EVENT_PLOGI_RCVD:
1658                 /* Ignore these events */
1659                 break;
1660
1661         default:
1662                 bfa_sm_fault(rport->fcs, event);
1663                 break;
1664         }
1665 }
1666
1667 /*
1668  * RPort needs to be deleted
1669  * waiting for BFA/FW to finish current processing
1670  */
1671 static void
1672 bfa_fcs_rport_sm_delete_pending(struct bfa_fcs_rport_s *rport,
1673                                 enum rport_event event)
1674 {
1675         bfa_trc(rport->fcs, rport->pwwn);
1676         bfa_trc(rport->fcs, rport->pid);
1677         bfa_trc(rport->fcs, event);
1678
1679         switch (event) {
1680         case RPSM_EVENT_HCB_OFFLINE:
1681                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
1682                 bfa_fcs_rport_free(rport);
1683                 break;
1684
1685         case RPSM_EVENT_DELETE:
1686         case RPSM_EVENT_LOGO_IMP:
1687         case RPSM_EVENT_PLOGI_RCVD:
1688                 /* Ignore these events */
1689                 break;
1690
1691         default:
1692                 bfa_sm_fault(rport->fcs, event);
1693         }
1694 }
1695
1696 /*
1697  *  fcs_rport_private FCS RPORT provate functions
1698  */
1699
1700 static void
1701 bfa_fcs_rport_send_plogi(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
1702 {
1703         struct bfa_fcs_rport_s *rport = rport_cbarg;
1704         struct bfa_fcs_lport_s *port = rport->port;
1705         struct fchs_s   fchs;
1706         int             len;
1707         struct bfa_fcxp_s *fcxp;
1708
1709         bfa_trc(rport->fcs, rport->pwwn);
1710
1711         fcxp = fcxp_alloced ? fcxp_alloced :
1712                bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
1713         if (!fcxp) {
1714                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
1715                                 bfa_fcs_rport_send_plogi, rport, BFA_TRUE);
1716                 return;
1717         }
1718         rport->fcxp = fcxp;
1719
1720         len = fc_plogi_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), rport->pid,
1721                                 bfa_fcs_lport_get_fcid(port), 0,
1722                                 port->port_cfg.pwwn, port->port_cfg.nwwn,
1723                                 bfa_fcport_get_maxfrsize(port->fcs->bfa),
1724                                 bfa_fcport_get_rx_bbcredit(port->fcs->bfa));
1725
1726         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
1727                         FC_CLASS_3, len, &fchs, bfa_fcs_rport_plogi_response,
1728                         (void *)rport, FC_MAX_PDUSZ, FC_ELS_TOV);
1729
1730         rport->stats.plogis++;
1731         bfa_sm_send_event(rport, RPSM_EVENT_FCXP_SENT);
1732 }
1733
1734 static void
1735 bfa_fcs_rport_plogi_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,
1736                                 bfa_status_t req_status, u32 rsp_len,
1737                                 u32 resid_len, struct fchs_s *rsp_fchs)
1738 {
1739         struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;
1740         struct fc_logi_s        *plogi_rsp;
1741         struct fc_ls_rjt_s      *ls_rjt;
1742         struct bfa_fcs_rport_s *twin;
1743         struct list_head        *qe;
1744
1745         bfa_trc(rport->fcs, rport->pwwn);
1746
1747         /*
1748          * Sanity Checks
1749          */
1750         if (req_status != BFA_STATUS_OK) {
1751                 bfa_trc(rport->fcs, req_status);
1752                 rport->stats.plogi_failed++;
1753                 bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
1754                 return;
1755         }
1756
1757         plogi_rsp = (struct fc_logi_s *) BFA_FCXP_RSP_PLD(fcxp);
1758
1759         /*
1760          * Check for failure first.
1761          */
1762         if (plogi_rsp->els_cmd.els_code != FC_ELS_ACC) {
1763                 ls_rjt = (struct fc_ls_rjt_s *) BFA_FCXP_RSP_PLD(fcxp);
1764
1765                 bfa_trc(rport->fcs, ls_rjt->reason_code);
1766                 bfa_trc(rport->fcs, ls_rjt->reason_code_expl);
1767
1768                 if ((ls_rjt->reason_code == FC_LS_RJT_RSN_UNABLE_TO_PERF_CMD) &&
1769                  (ls_rjt->reason_code_expl == FC_LS_RJT_EXP_INSUFF_RES)) {
1770                         rport->stats.rjt_insuff_res++;
1771                         bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_RETRY);
1772                         return;
1773                 }
1774
1775                 rport->stats.plogi_rejects++;
1776                 bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
1777                 return;
1778         }
1779
1780         /*
1781          * PLOGI is complete. Make sure this device is not one of the known
1782          * device with a new FC port address.
1783          */
1784         list_for_each(qe, &rport->port->rport_q) {
1785                 twin = (struct bfa_fcs_rport_s *) qe;
1786                 if (twin == rport)
1787                         continue;
1788                 if (!rport->pwwn && (plogi_rsp->port_name == twin->pwwn)) {
1789                         bfa_trc(rport->fcs, twin->pid);
1790                         bfa_trc(rport->fcs, rport->pid);
1791
1792                         /* Update plogi stats in twin */
1793                         twin->stats.plogis  += rport->stats.plogis;
1794                         twin->stats.plogi_rejects  +=
1795                                  rport->stats.plogi_rejects;
1796                         twin->stats.plogi_timeouts  +=
1797                                  rport->stats.plogi_timeouts;
1798                         twin->stats.plogi_failed +=
1799                                  rport->stats.plogi_failed;
1800                         twin->stats.plogi_rcvd    += rport->stats.plogi_rcvd;
1801                         twin->stats.plogi_accs++;
1802
1803                         bfa_sm_send_event(rport, RPSM_EVENT_DELETE);
1804
1805                         bfa_fcs_rport_update(twin, plogi_rsp);
1806                         twin->pid = rsp_fchs->s_id;
1807                         bfa_sm_send_event(twin, RPSM_EVENT_PLOGI_COMP);
1808                         return;
1809                 }
1810         }
1811
1812         /*
1813          * Normal login path -- no evil twins.
1814          */
1815         rport->stats.plogi_accs++;
1816         bfa_fcs_rport_update(rport, plogi_rsp);
1817         bfa_sm_send_event(rport, RPSM_EVENT_ACCEPTED);
1818 }
1819
1820 static void
1821 bfa_fcs_rport_send_plogiacc(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
1822 {
1823         struct bfa_fcs_rport_s *rport = rport_cbarg;
1824         struct bfa_fcs_lport_s *port = rport->port;
1825         struct fchs_s           fchs;
1826         int             len;
1827         struct bfa_fcxp_s *fcxp;
1828
1829         bfa_trc(rport->fcs, rport->pwwn);
1830         bfa_trc(rport->fcs, rport->reply_oxid);
1831
1832         fcxp = fcxp_alloced ? fcxp_alloced :
1833                bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
1834         if (!fcxp) {
1835                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
1836                                 bfa_fcs_rport_send_plogiacc, rport, BFA_FALSE);
1837                 return;
1838         }
1839         rport->fcxp = fcxp;
1840
1841         len = fc_plogi_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
1842                                  rport->pid, bfa_fcs_lport_get_fcid(port),
1843                                  rport->reply_oxid, port->port_cfg.pwwn,
1844                                  port->port_cfg.nwwn,
1845                                  bfa_fcport_get_maxfrsize(port->fcs->bfa),
1846                                  bfa_fcport_get_rx_bbcredit(port->fcs->bfa));
1847
1848         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
1849                         FC_CLASS_3, len, &fchs, NULL, NULL, FC_MAX_PDUSZ, 0);
1850
1851         bfa_sm_send_event(rport, RPSM_EVENT_FCXP_SENT);
1852 }
1853
1854 static void
1855 bfa_fcs_rport_send_adisc(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
1856 {
1857         struct bfa_fcs_rport_s *rport = rport_cbarg;
1858         struct bfa_fcs_lport_s *port = rport->port;
1859         struct fchs_s           fchs;
1860         int             len;
1861         struct bfa_fcxp_s *fcxp;
1862
1863         bfa_trc(rport->fcs, rport->pwwn);
1864
1865         fcxp = fcxp_alloced ? fcxp_alloced :
1866                bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
1867         if (!fcxp) {
1868                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
1869                                 bfa_fcs_rport_send_adisc, rport, BFA_TRUE);
1870                 return;
1871         }
1872         rport->fcxp = fcxp;
1873
1874         len = fc_adisc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), rport->pid,
1875                                 bfa_fcs_lport_get_fcid(port), 0,
1876                                 port->port_cfg.pwwn, port->port_cfg.nwwn);
1877
1878         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
1879                         FC_CLASS_3, len, &fchs, bfa_fcs_rport_adisc_response,
1880                         rport, FC_MAX_PDUSZ, FC_ELS_TOV);
1881
1882         rport->stats.adisc_sent++;
1883         bfa_sm_send_event(rport, RPSM_EVENT_FCXP_SENT);
1884 }
1885
1886 static void
1887 bfa_fcs_rport_adisc_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,
1888                                 bfa_status_t req_status, u32 rsp_len,
1889                                 u32 resid_len, struct fchs_s *rsp_fchs)
1890 {
1891         struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;
1892         void            *pld = bfa_fcxp_get_rspbuf(fcxp);
1893         struct fc_ls_rjt_s      *ls_rjt;
1894
1895         if (req_status != BFA_STATUS_OK) {
1896                 bfa_trc(rport->fcs, req_status);
1897                 rport->stats.adisc_failed++;
1898                 bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
1899                 return;
1900         }
1901
1902         if (fc_adisc_rsp_parse((struct fc_adisc_s *)pld, rsp_len, rport->pwwn,
1903                                 rport->nwwn)  == FC_PARSE_OK) {
1904                 rport->stats.adisc_accs++;
1905                 bfa_sm_send_event(rport, RPSM_EVENT_ACCEPTED);
1906                 return;
1907         }
1908
1909         rport->stats.adisc_rejects++;
1910         ls_rjt = pld;
1911         bfa_trc(rport->fcs, ls_rjt->els_cmd.els_code);
1912         bfa_trc(rport->fcs, ls_rjt->reason_code);
1913         bfa_trc(rport->fcs, ls_rjt->reason_code_expl);
1914         bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
1915 }
1916
1917 static void
1918 bfa_fcs_rport_send_nsdisc(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
1919 {
1920         struct bfa_fcs_rport_s *rport = rport_cbarg;
1921         struct bfa_fcs_lport_s *port = rport->port;
1922         struct fchs_s   fchs;
1923         struct bfa_fcxp_s *fcxp;
1924         int             len;
1925         bfa_cb_fcxp_send_t cbfn;
1926
1927         bfa_trc(rport->fcs, rport->pid);
1928
1929         fcxp = fcxp_alloced ? fcxp_alloced :
1930                bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
1931         if (!fcxp) {
1932                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
1933                                 bfa_fcs_rport_send_nsdisc, rport, BFA_TRUE);
1934                 return;
1935         }
1936         rport->fcxp = fcxp;
1937
1938         if (rport->pwwn) {
1939                 len = fc_gidpn_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
1940                                 bfa_fcs_lport_get_fcid(port), 0, rport->pwwn);
1941                 cbfn = bfa_fcs_rport_gidpn_response;
1942         } else {
1943                 len = fc_gpnid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
1944                                 bfa_fcs_lport_get_fcid(port), 0, rport->pid);
1945                 cbfn = bfa_fcs_rport_gpnid_response;
1946         }
1947
1948         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
1949                         FC_CLASS_3, len, &fchs, cbfn,
1950                         (void *)rport, FC_MAX_PDUSZ, FC_FCCT_TOV);
1951
1952         bfa_sm_send_event(rport, RPSM_EVENT_FCXP_SENT);
1953 }
1954
1955 static void
1956 bfa_fcs_rport_gidpn_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,
1957                                 bfa_status_t req_status, u32 rsp_len,
1958                                 u32 resid_len, struct fchs_s *rsp_fchs)
1959 {
1960         struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;
1961         struct ct_hdr_s *cthdr;
1962         struct fcgs_gidpn_resp_s        *gidpn_rsp;
1963         struct bfa_fcs_rport_s  *twin;
1964         struct list_head        *qe;
1965
1966         bfa_trc(rport->fcs, rport->pwwn);
1967
1968         cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
1969         cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
1970
1971         if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
1972                 /* Check if the pid is the same as before. */
1973                 gidpn_rsp = (struct fcgs_gidpn_resp_s *) (cthdr + 1);
1974
1975                 if (gidpn_rsp->dap == rport->pid) {
1976                         /* Device is online  */
1977                         bfa_sm_send_event(rport, RPSM_EVENT_ACCEPTED);
1978                 } else {
1979                         /*
1980                          * Device's PID has changed. We need to cleanup
1981                          * and re-login. If there is another device with
1982                          * the the newly discovered pid, send an scn notice
1983                          * so that its new pid can be discovered.
1984                          */
1985                         list_for_each(qe, &rport->port->rport_q) {
1986                                 twin = (struct bfa_fcs_rport_s *) qe;
1987                                 if (twin == rport)
1988                                         continue;
1989                                 if (gidpn_rsp->dap == twin->pid) {
1990                                         bfa_trc(rport->fcs, twin->pid);
1991                                         bfa_trc(rport->fcs, rport->pid);
1992
1993                                         twin->pid = 0;
1994                                         bfa_sm_send_event(twin,
1995                                          RPSM_EVENT_ADDRESS_CHANGE);
1996                                 }
1997                         }
1998                         rport->pid = gidpn_rsp->dap;
1999                         bfa_sm_send_event(rport, RPSM_EVENT_ADDRESS_CHANGE);
2000                 }
2001                 return;
2002         }
2003
2004         /*
2005          * Reject Response
2006          */
2007         switch (cthdr->reason_code) {
2008         case CT_RSN_LOGICAL_BUSY:
2009                 /*
2010                  * Need to retry
2011                  */
2012                 bfa_sm_send_event(rport, RPSM_EVENT_TIMEOUT);
2013                 break;
2014
2015         case CT_RSN_UNABLE_TO_PERF:
2016                 /*
2017                  * device doesn't exist : Start timer to cleanup this later.
2018                  */
2019                 bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
2020                 break;
2021
2022         default:
2023                 bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
2024                 break;
2025         }
2026 }
2027
2028 static void
2029 bfa_fcs_rport_gpnid_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,
2030                                 bfa_status_t req_status, u32 rsp_len,
2031                                 u32 resid_len, struct fchs_s *rsp_fchs)
2032 {
2033         struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;
2034         struct ct_hdr_s *cthdr;
2035
2036         bfa_trc(rport->fcs, rport->pwwn);
2037
2038         cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
2039         cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
2040
2041         if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
2042                 bfa_sm_send_event(rport, RPSM_EVENT_ACCEPTED);
2043                 return;
2044         }
2045
2046         /*
2047          * Reject Response
2048          */
2049         switch (cthdr->reason_code) {
2050         case CT_RSN_LOGICAL_BUSY:
2051                 /*
2052                  * Need to retry
2053                  */
2054                 bfa_sm_send_event(rport, RPSM_EVENT_TIMEOUT);
2055                 break;
2056
2057         case CT_RSN_UNABLE_TO_PERF:
2058                 /*
2059                  * device doesn't exist : Start timer to cleanup this later.
2060                  */
2061                 bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
2062                 break;
2063
2064         default:
2065                 bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
2066                 break;
2067         }
2068 }
2069
2070 /*
2071  *      Called to send a logout to the rport.
2072  */
2073 static void
2074 bfa_fcs_rport_send_logo(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
2075 {
2076         struct bfa_fcs_rport_s *rport = rport_cbarg;
2077         struct bfa_fcs_lport_s *port;
2078         struct fchs_s   fchs;
2079         struct bfa_fcxp_s *fcxp;
2080         u16     len;
2081
2082         bfa_trc(rport->fcs, rport->pid);
2083
2084         port = rport->port;
2085
2086         fcxp = fcxp_alloced ? fcxp_alloced :
2087                bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
2088         if (!fcxp) {
2089                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
2090                                 bfa_fcs_rport_send_logo, rport, BFA_FALSE);
2091                 return;
2092         }
2093         rport->fcxp = fcxp;
2094
2095         len = fc_logo_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), rport->pid,
2096                                 bfa_fcs_lport_get_fcid(port), 0,
2097                                 bfa_fcs_lport_get_pwwn(port));
2098
2099         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
2100                         FC_CLASS_3, len, &fchs, NULL,
2101                         rport, FC_MAX_PDUSZ, FC_ELS_TOV);
2102
2103         rport->stats.logos++;
2104         bfa_fcxp_discard(rport->fcxp);
2105         bfa_sm_send_event(rport, RPSM_EVENT_FCXP_SENT);
2106 }
2107
2108 /*
2109  *      Send ACC for a LOGO received.
2110  */
2111 static void
2112 bfa_fcs_rport_send_logo_acc(void *rport_cbarg)
2113 {
2114         struct bfa_fcs_rport_s *rport = rport_cbarg;
2115         struct bfa_fcs_lport_s *port;
2116         struct fchs_s   fchs;
2117         struct bfa_fcxp_s *fcxp;
2118         u16     len;
2119
2120         bfa_trc(rport->fcs, rport->pid);
2121
2122         port = rport->port;
2123
2124         fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
2125         if (!fcxp)
2126                 return;
2127
2128         rport->stats.logo_rcvd++;
2129         len = fc_logo_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
2130                                 rport->pid, bfa_fcs_lport_get_fcid(port),
2131                                 rport->reply_oxid);
2132
2133         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
2134                         FC_CLASS_3, len, &fchs, NULL, NULL, FC_MAX_PDUSZ, 0);
2135 }
2136
2137 /*
2138  *      brief
2139  *      This routine will be called by bfa_timer on timer timeouts.
2140  *
2141  *      param[in]       rport                   - pointer to bfa_fcs_lport_ns_t.
2142  *      param[out]      rport_status    - pointer to return vport status in
2143  *
2144  *      return
2145  *              void
2146  *
2147  *      Special Considerations:
2148  *
2149  *      note
2150  */
2151 static void
2152 bfa_fcs_rport_timeout(void *arg)
2153 {
2154         struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) arg;
2155
2156         rport->stats.plogi_timeouts++;
2157         bfa_stats(rport->port, rport_plogi_timeouts);
2158         bfa_sm_send_event(rport, RPSM_EVENT_TIMEOUT);
2159 }
2160
2161 static void
2162 bfa_fcs_rport_process_prli(struct bfa_fcs_rport_s *rport,
2163                         struct fchs_s *rx_fchs, u16 len)
2164 {
2165         struct bfa_fcxp_s *fcxp;
2166         struct fchs_s   fchs;
2167         struct bfa_fcs_lport_s *port = rport->port;
2168         struct fc_prli_s        *prli;
2169
2170         bfa_trc(port->fcs, rx_fchs->s_id);
2171         bfa_trc(port->fcs, rx_fchs->d_id);
2172
2173         rport->stats.prli_rcvd++;
2174
2175         /*
2176          * We are in Initiator Mode
2177          */
2178         prli = (struct fc_prli_s *) (rx_fchs + 1);
2179
2180         if (prli->parampage.servparams.target) {
2181                 /*
2182                  * PRLI from a target ?
2183                  * Send the Acc.
2184                  * PRLI sent by us will be used to transition the IT nexus,
2185                  * once the response is received from the target.
2186                  */
2187                 bfa_trc(port->fcs, rx_fchs->s_id);
2188                 rport->scsi_function = BFA_RPORT_TARGET;
2189         } else {
2190                 bfa_trc(rport->fcs, prli->parampage.type);
2191                 rport->scsi_function = BFA_RPORT_INITIATOR;
2192                 bfa_fcs_itnim_is_initiator(rport->itnim);
2193         }
2194
2195         fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
2196         if (!fcxp)
2197                 return;
2198
2199         len = fc_prli_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
2200                                 rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
2201                                 rx_fchs->ox_id, port->port_cfg.roles);
2202
2203         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
2204                         FC_CLASS_3, len, &fchs, NULL, NULL, FC_MAX_PDUSZ, 0);
2205 }
2206
2207 static void
2208 bfa_fcs_rport_process_rpsc(struct bfa_fcs_rport_s *rport,
2209                         struct fchs_s *rx_fchs, u16 len)
2210 {
2211         struct bfa_fcxp_s *fcxp;
2212         struct fchs_s   fchs;
2213         struct bfa_fcs_lport_s *port = rport->port;
2214         struct fc_rpsc_speed_info_s speeds;
2215         struct bfa_port_attr_s pport_attr;
2216
2217         bfa_trc(port->fcs, rx_fchs->s_id);
2218         bfa_trc(port->fcs, rx_fchs->d_id);
2219
2220         rport->stats.rpsc_rcvd++;
2221         speeds.port_speed_cap =
2222                 RPSC_SPEED_CAP_1G | RPSC_SPEED_CAP_2G | RPSC_SPEED_CAP_4G |
2223                 RPSC_SPEED_CAP_8G;
2224
2225         /*
2226          * get curent speed from pport attributes from BFA
2227          */
2228         bfa_fcport_get_attr(port->fcs->bfa, &pport_attr);
2229
2230         speeds.port_op_speed = fc_bfa_speed_to_rpsc_operspeed(pport_attr.speed);
2231
2232         fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
2233         if (!fcxp)
2234                 return;
2235
2236         len = fc_rpsc_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
2237                                 rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
2238                                 rx_fchs->ox_id, &speeds);
2239
2240         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
2241                         FC_CLASS_3, len, &fchs, NULL, NULL, FC_MAX_PDUSZ, 0);
2242 }
2243
2244 static void
2245 bfa_fcs_rport_process_adisc(struct bfa_fcs_rport_s *rport,
2246                         struct fchs_s *rx_fchs, u16 len)
2247 {
2248         struct bfa_fcxp_s *fcxp;
2249         struct fchs_s   fchs;
2250         struct bfa_fcs_lport_s *port = rport->port;
2251         struct fc_adisc_s       *adisc;
2252
2253         bfa_trc(port->fcs, rx_fchs->s_id);
2254         bfa_trc(port->fcs, rx_fchs->d_id);
2255
2256         rport->stats.adisc_rcvd++;
2257
2258         adisc = (struct fc_adisc_s *) (rx_fchs + 1);
2259
2260         /*
2261          * Accept if the itnim for this rport is online.
2262          * Else reject the ADISC.
2263          */
2264         if (bfa_fcs_itnim_get_online_state(rport->itnim) == BFA_STATUS_OK) {
2265
2266                 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
2267                 if (!fcxp)
2268                         return;
2269
2270                 len = fc_adisc_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
2271                          rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
2272                          rx_fchs->ox_id, port->port_cfg.pwwn,
2273                          port->port_cfg.nwwn);
2274
2275                 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag,
2276                                 BFA_FALSE, FC_CLASS_3, len, &fchs, NULL, NULL,
2277                                 FC_MAX_PDUSZ, 0);
2278         } else {
2279                 rport->stats.adisc_rejected++;
2280                 bfa_fcs_rport_send_ls_rjt(rport, rx_fchs,
2281                                           FC_LS_RJT_RSN_UNABLE_TO_PERF_CMD,
2282                                           FC_LS_RJT_EXP_LOGIN_REQUIRED);
2283         }
2284 }
2285
2286 static void
2287 bfa_fcs_rport_hal_online(struct bfa_fcs_rport_s *rport)
2288 {
2289         struct bfa_fcs_lport_s *port = rport->port;
2290         struct bfa_rport_info_s rport_info;
2291
2292         rport_info.pid = rport->pid;
2293         rport_info.local_pid = port->pid;
2294         rport_info.lp_tag = port->lp_tag;
2295         rport_info.vf_id = port->fabric->vf_id;
2296         rport_info.vf_en = port->fabric->is_vf;
2297         rport_info.fc_class = rport->fc_cos;
2298         rport_info.cisc = rport->cisc;
2299         rport_info.max_frmsz = rport->maxfrsize;
2300         bfa_rport_online(rport->bfa_rport, &rport_info);
2301 }
2302
2303 static void
2304 bfa_fcs_rport_hal_offline(struct bfa_fcs_rport_s *rport)
2305 {
2306         if (rport->bfa_rport)
2307                 bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
2308         else
2309                 bfa_cb_rport_offline(rport);
2310 }
2311
2312 static struct bfa_fcs_rport_s *
2313 bfa_fcs_rport_alloc(struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid)
2314 {
2315         struct bfa_fcs_s        *fcs = port->fcs;
2316         struct bfa_fcs_rport_s *rport;
2317         struct bfad_rport_s     *rport_drv;
2318
2319         /*
2320          * allocate rport
2321          */
2322         if (fcs->num_rport_logins >= bfa_fcs_rport_max_logins) {
2323                 bfa_trc(fcs, rpid);
2324                 return NULL;
2325         }
2326
2327         if (bfa_fcb_rport_alloc(fcs->bfad, &rport, &rport_drv)
2328                 != BFA_STATUS_OK) {
2329                 bfa_trc(fcs, rpid);
2330                 return NULL;
2331         }
2332
2333         /*
2334          * Initialize r-port
2335          */
2336         rport->port = port;
2337         rport->fcs = fcs;
2338         rport->rp_drv = rport_drv;
2339         rport->pid = rpid;
2340         rport->pwwn = pwwn;
2341         rport->old_pid = 0;
2342
2343         rport->bfa_rport = NULL;
2344
2345         /*
2346          * allocate FC-4s
2347          */
2348         WARN_ON(!bfa_fcs_lport_is_initiator(port));
2349
2350         if (bfa_fcs_lport_is_initiator(port)) {
2351                 rport->itnim = bfa_fcs_itnim_create(rport);
2352                 if (!rport->itnim) {
2353                         bfa_trc(fcs, rpid);
2354                         kfree(rport_drv);
2355                         return NULL;
2356                 }
2357         }
2358
2359         bfa_fcs_lport_add_rport(port, rport);
2360         fcs->num_rport_logins++;
2361
2362         bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
2363
2364         /* Initialize the Rport Features(RPF) Sub Module  */
2365         if (!BFA_FCS_PID_IS_WKA(rport->pid))
2366                 bfa_fcs_rpf_init(rport);
2367
2368         return rport;
2369 }
2370
2371
2372 static void
2373 bfa_fcs_rport_free(struct bfa_fcs_rport_s *rport)
2374 {
2375         struct bfa_fcs_lport_s *port = rport->port;
2376         struct bfa_fcs_s *fcs = port->fcs;
2377
2378         /*
2379          * - delete FC-4s
2380          * - delete BFA rport
2381          * - remove from queue of rports
2382          */
2383         rport->plogi_pending = BFA_FALSE;
2384
2385         if (bfa_fcs_lport_is_initiator(port)) {
2386                 bfa_fcs_itnim_delete(rport->itnim);
2387                 if (rport->pid != 0 && !BFA_FCS_PID_IS_WKA(rport->pid))
2388                         bfa_fcs_rpf_rport_offline(rport);
2389         }
2390
2391         if (rport->bfa_rport) {
2392                 bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_DELETE);
2393                 rport->bfa_rport = NULL;
2394         }
2395
2396         bfa_fcs_lport_del_rport(port, rport);
2397         fcs->num_rport_logins--;
2398         kfree(rport->rp_drv);
2399 }
2400
2401 static void
2402 bfa_fcs_rport_aen_post(struct bfa_fcs_rport_s *rport,
2403                         enum bfa_rport_aen_event event,
2404                         struct bfa_rport_aen_data_s *data)
2405 {
2406         struct bfa_fcs_lport_s *port = rport->port;
2407         struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad;
2408         struct bfa_aen_entry_s  *aen_entry;
2409
2410         bfad_get_aen_entry(bfad, aen_entry);
2411         if (!aen_entry)
2412                 return;
2413
2414         if (event == BFA_RPORT_AEN_QOS_PRIO)
2415                 aen_entry->aen_data.rport.priv.qos = data->priv.qos;
2416         else if (event == BFA_RPORT_AEN_QOS_FLOWID)
2417                 aen_entry->aen_data.rport.priv.qos = data->priv.qos;
2418
2419         aen_entry->aen_data.rport.vf_id = rport->port->fabric->vf_id;
2420         aen_entry->aen_data.rport.ppwwn = bfa_fcs_lport_get_pwwn(
2421                                         bfa_fcs_get_base_port(rport->fcs));
2422         aen_entry->aen_data.rport.lpwwn = bfa_fcs_lport_get_pwwn(rport->port);
2423         aen_entry->aen_data.rport.rpwwn = rport->pwwn;
2424
2425         /* Send the AEN notification */
2426         bfad_im_post_vendor_event(aen_entry, bfad, ++rport->fcs->fcs_aen_seq,
2427                                   BFA_AEN_CAT_RPORT, event);
2428 }
2429
2430 static void
2431 bfa_fcs_rport_fcs_online_action(struct bfa_fcs_rport_s *rport)
2432 {
2433         if ((!rport->pid) || (!rport->pwwn)) {
2434                 bfa_trc(rport->fcs, rport->pid);
2435                 bfa_sm_fault(rport->fcs, rport->pid);
2436         }
2437
2438         bfa_sm_send_event(rport->itnim, BFA_FCS_ITNIM_SM_FCS_ONLINE);
2439 }
2440
2441 static void
2442 bfa_fcs_rport_hal_online_action(struct bfa_fcs_rport_s *rport)
2443 {
2444         struct bfa_fcs_lport_s *port = rport->port;
2445         struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad;
2446         char    lpwwn_buf[BFA_STRING_32];
2447         char    rpwwn_buf[BFA_STRING_32];
2448
2449         rport->stats.onlines++;
2450
2451         if ((!rport->pid) || (!rport->pwwn)) {
2452                 bfa_trc(rport->fcs, rport->pid);
2453                 bfa_sm_fault(rport->fcs, rport->pid);
2454         }
2455
2456         if (bfa_fcs_lport_is_initiator(port)) {
2457                 bfa_fcs_itnim_brp_online(rport->itnim);
2458                 if (!BFA_FCS_PID_IS_WKA(rport->pid))
2459                         bfa_fcs_rpf_rport_online(rport);
2460         };
2461
2462         wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
2463         wwn2str(rpwwn_buf, rport->pwwn);
2464         if (!BFA_FCS_PID_IS_WKA(rport->pid)) {
2465                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2466                 "Remote port (WWN = %s) online for logical port (WWN = %s)\n",
2467                 rpwwn_buf, lpwwn_buf);
2468                 bfa_fcs_rport_aen_post(rport, BFA_RPORT_AEN_ONLINE, NULL);
2469         }
2470 }
2471
2472 static void
2473 bfa_fcs_rport_fcs_offline_action(struct bfa_fcs_rport_s *rport)
2474 {
2475         if (!BFA_FCS_PID_IS_WKA(rport->pid))
2476                 bfa_fcs_rpf_rport_offline(rport);
2477
2478         bfa_fcs_itnim_rport_offline(rport->itnim);
2479 }
2480
2481 static void
2482 bfa_fcs_rport_hal_offline_action(struct bfa_fcs_rport_s *rport)
2483 {
2484         struct bfa_fcs_lport_s *port = rport->port;
2485         struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad;
2486         char    lpwwn_buf[BFA_STRING_32];
2487         char    rpwwn_buf[BFA_STRING_32];
2488
2489         if (!rport->bfa_rport) {
2490                 bfa_fcs_rport_fcs_offline_action(rport);
2491                 return;
2492         }
2493
2494         rport->stats.offlines++;
2495
2496         wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
2497         wwn2str(rpwwn_buf, rport->pwwn);
2498         if (!BFA_FCS_PID_IS_WKA(rport->pid)) {
2499                 if (bfa_fcs_lport_is_online(rport->port) == BFA_TRUE) {
2500                         BFA_LOG(KERN_ERR, bfad, bfa_log_level,
2501                                 "Remote port (WWN = %s) connectivity lost for "
2502                                 "logical port (WWN = %s)\n",
2503                                 rpwwn_buf, lpwwn_buf);
2504                         bfa_fcs_rport_aen_post(rport,
2505                                 BFA_RPORT_AEN_DISCONNECT, NULL);
2506                 } else {
2507                         BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2508                                 "Remote port (WWN = %s) offlined by "
2509                                 "logical port (WWN = %s)\n",
2510                                 rpwwn_buf, lpwwn_buf);
2511                         bfa_fcs_rport_aen_post(rport,
2512                                 BFA_RPORT_AEN_OFFLINE, NULL);
2513                 }
2514         }
2515
2516         if (bfa_fcs_lport_is_initiator(port)) {
2517                 bfa_fcs_itnim_rport_offline(rport->itnim);
2518                 if (!BFA_FCS_PID_IS_WKA(rport->pid))
2519                         bfa_fcs_rpf_rport_offline(rport);
2520         }
2521 }
2522
2523 /*
2524  * Update rport parameters from PLOGI or PLOGI accept.
2525  */
2526 static void
2527 bfa_fcs_rport_update(struct bfa_fcs_rport_s *rport, struct fc_logi_s *plogi)
2528 {
2529         bfa_fcs_lport_t *port = rport->port;
2530
2531         /*
2532          * - port name
2533          * - node name
2534          */
2535         rport->pwwn = plogi->port_name;
2536         rport->nwwn = plogi->node_name;
2537
2538         /*
2539          * - class of service
2540          */
2541         rport->fc_cos = 0;
2542         if (plogi->class3.class_valid)
2543                 rport->fc_cos = FC_CLASS_3;
2544
2545         if (plogi->class2.class_valid)
2546                 rport->fc_cos |= FC_CLASS_2;
2547
2548         /*
2549          * - CISC
2550          * - MAX receive frame size
2551          */
2552         rport->cisc = plogi->csp.cisc;
2553         if (be16_to_cpu(plogi->class3.rxsz) < be16_to_cpu(plogi->csp.rxsz))
2554                 rport->maxfrsize = be16_to_cpu(plogi->class3.rxsz);
2555         else
2556                 rport->maxfrsize = be16_to_cpu(plogi->csp.rxsz);
2557
2558         bfa_trc(port->fcs, be16_to_cpu(plogi->csp.bbcred));
2559         bfa_trc(port->fcs, port->fabric->bb_credit);
2560         /*
2561          * Direct Attach P2P mode :
2562          * This is to handle a bug (233476) in IBM targets in Direct Attach
2563          *  Mode. Basically, in FLOGI Accept the target would have
2564          * erroneously set the BB Credit to the value used in the FLOGI
2565          * sent by the HBA. It uses the correct value (its own BB credit)
2566          * in PLOGI.
2567          */
2568         if ((!bfa_fcs_fabric_is_switched(port->fabric))  &&
2569                 (be16_to_cpu(plogi->csp.bbcred) < port->fabric->bb_credit)) {
2570
2571                 bfa_trc(port->fcs, be16_to_cpu(plogi->csp.bbcred));
2572                 bfa_trc(port->fcs, port->fabric->bb_credit);
2573
2574                 port->fabric->bb_credit = be16_to_cpu(plogi->csp.bbcred);
2575                 bfa_fcport_set_tx_bbcredit(port->fcs->bfa,
2576                                           port->fabric->bb_credit);
2577         }
2578
2579 }
2580
2581 /*
2582  *      Called to handle LOGO received from an existing remote port.
2583  */
2584 static void
2585 bfa_fcs_rport_process_logo(struct bfa_fcs_rport_s *rport, struct fchs_s *fchs)
2586 {
2587         rport->reply_oxid = fchs->ox_id;
2588         bfa_trc(rport->fcs, rport->reply_oxid);
2589
2590         rport->prlo = BFA_FALSE;
2591         rport->stats.logo_rcvd++;
2592         bfa_sm_send_event(rport, RPSM_EVENT_LOGO_RCVD);
2593 }
2594
2595
2596
2597 /*
2598  *  fcs_rport_public FCS rport public interfaces
2599  */
2600
2601 /*
2602  *      Called by bport/vport to create a remote port instance for a discovered
2603  *      remote device.
2604  *
2605  * @param[in] port      - base port or vport
2606  * @param[in] rpid      - remote port ID
2607  *
2608  * @return None
2609  */
2610 struct bfa_fcs_rport_s *
2611 bfa_fcs_rport_create(struct bfa_fcs_lport_s *port, u32 rpid)
2612 {
2613         struct bfa_fcs_rport_s *rport;
2614
2615         bfa_trc(port->fcs, rpid);
2616         rport = bfa_fcs_rport_alloc(port, WWN_NULL, rpid);
2617         if (!rport)
2618                 return NULL;
2619
2620         bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_SEND);
2621         return rport;
2622 }
2623
2624 /*
2625  * Called to create a rport for which only the wwn is known.
2626  *
2627  * @param[in] port      - base port
2628  * @param[in] rpwwn     - remote port wwn
2629  *
2630  * @return None
2631  */
2632 struct bfa_fcs_rport_s *
2633 bfa_fcs_rport_create_by_wwn(struct bfa_fcs_lport_s *port, wwn_t rpwwn)
2634 {
2635         struct bfa_fcs_rport_s *rport;
2636         bfa_trc(port->fcs, rpwwn);
2637         rport = bfa_fcs_rport_alloc(port, rpwwn, 0);
2638         if (!rport)
2639                 return NULL;
2640
2641         bfa_sm_send_event(rport, RPSM_EVENT_ADDRESS_DISC);
2642         return rport;
2643 }
2644 /*
2645  * Called by bport in private loop topology to indicate that a
2646  * rport has been discovered and plogi has been completed.
2647  *
2648  * @param[in] port      - base port or vport
2649  * @param[in] rpid      - remote port ID
2650  */
2651 void
2652 bfa_fcs_rport_start(struct bfa_fcs_lport_s *port, struct fchs_s *fchs,
2653          struct fc_logi_s *plogi)
2654 {
2655         struct bfa_fcs_rport_s *rport;
2656
2657         rport = bfa_fcs_rport_alloc(port, WWN_NULL, fchs->s_id);
2658         if (!rport)
2659                 return;
2660
2661         bfa_fcs_rport_update(rport, plogi);
2662
2663         bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_COMP);
2664 }
2665
2666 /*
2667  *      Called by bport/vport to handle PLOGI received from a new remote port.
2668  *      If an existing rport does a plogi, it will be handled separately.
2669  */
2670 void
2671 bfa_fcs_rport_plogi_create(struct bfa_fcs_lport_s *port, struct fchs_s *fchs,
2672                                 struct fc_logi_s *plogi)
2673 {
2674         struct bfa_fcs_rport_s *rport;
2675
2676         rport = bfa_fcs_rport_alloc(port, plogi->port_name, fchs->s_id);
2677         if (!rport)
2678                 return;
2679
2680         bfa_fcs_rport_update(rport, plogi);
2681
2682         rport->reply_oxid = fchs->ox_id;
2683         bfa_trc(rport->fcs, rport->reply_oxid);
2684
2685         rport->stats.plogi_rcvd++;
2686         bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_RCVD);
2687 }
2688
2689 /*
2690  *      Called by bport/vport to handle PLOGI received from an existing
2691  *       remote port.
2692  */
2693 void
2694 bfa_fcs_rport_plogi(struct bfa_fcs_rport_s *rport, struct fchs_s *rx_fchs,
2695                         struct fc_logi_s *plogi)
2696 {
2697         /*
2698          * @todo Handle P2P and initiator-initiator.
2699          */
2700
2701         bfa_fcs_rport_update(rport, plogi);
2702
2703         rport->reply_oxid = rx_fchs->ox_id;
2704         bfa_trc(rport->fcs, rport->reply_oxid);
2705
2706         rport->pid = rx_fchs->s_id;
2707         bfa_trc(rport->fcs, rport->pid);
2708
2709         rport->stats.plogi_rcvd++;
2710         bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_RCVD);
2711 }
2712
2713
2714 /*
2715  *      Called by bport/vport to notify SCN for the remote port
2716  */
2717 void
2718 bfa_fcs_rport_scn(struct bfa_fcs_rport_s *rport)
2719 {
2720         rport->stats.rscns++;
2721         bfa_sm_send_event(rport, RPSM_EVENT_FAB_SCN);
2722 }
2723
2724 /*
2725  *      brief
2726  *      This routine BFA callback for bfa_rport_online() call.
2727  *
2728  *      param[in]       cb_arg  -  rport struct.
2729  *
2730  *      return
2731  *              void
2732  *
2733  *      Special Considerations:
2734  *
2735  *      note
2736  */
2737 void
2738 bfa_cb_rport_online(void *cbarg)
2739 {
2740
2741         struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;
2742
2743         bfa_trc(rport->fcs, rport->pwwn);
2744         bfa_sm_send_event(rport, RPSM_EVENT_HCB_ONLINE);
2745 }
2746
2747 /*
2748  *      brief
2749  *      This routine BFA callback for bfa_rport_offline() call.
2750  *
2751  *      param[in]       rport   -
2752  *
2753  *      return
2754  *              void
2755  *
2756  *      Special Considerations:
2757  *
2758  *      note
2759  */
2760 void
2761 bfa_cb_rport_offline(void *cbarg)
2762 {
2763         struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;
2764
2765         bfa_trc(rport->fcs, rport->pwwn);
2766         bfa_sm_send_event(rport, RPSM_EVENT_HCB_OFFLINE);
2767 }
2768
2769 /*
2770  *      brief
2771  *      This routine is a static BFA callback when there is a QoS flow_id
2772  *      change notification
2773  *
2774  *      param[in]       rport   -
2775  *
2776  *      return
2777  *              void
2778  *
2779  *      Special Considerations:
2780  *
2781  *      note
2782  */
2783 void
2784 bfa_cb_rport_qos_scn_flowid(void *cbarg,
2785                 struct bfa_rport_qos_attr_s old_qos_attr,
2786                 struct bfa_rport_qos_attr_s new_qos_attr)
2787 {
2788         struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;
2789         struct bfa_rport_aen_data_s aen_data;
2790
2791         bfa_trc(rport->fcs, rport->pwwn);
2792         aen_data.priv.qos = new_qos_attr;
2793         bfa_fcs_rport_aen_post(rport, BFA_RPORT_AEN_QOS_FLOWID, &aen_data);
2794 }
2795
2796 void
2797 bfa_cb_rport_scn_online(struct bfa_s *bfa)
2798 {
2799         struct bfa_fcs_s *fcs = &((struct bfad_s *)bfa->bfad)->bfa_fcs;
2800         struct bfa_fcs_lport_s *port = bfa_fcs_get_base_port(fcs);
2801         struct bfa_fcs_rport_s *rp;
2802         struct list_head *qe;
2803
2804         list_for_each(qe, &port->rport_q) {
2805                 rp = (struct bfa_fcs_rport_s *) qe;
2806                 bfa_sm_send_event(rp, RPSM_EVENT_SCN_ONLINE);
2807                 rp->scn_online = BFA_TRUE;
2808         }
2809
2810         if (bfa_fcs_lport_is_online(port))
2811                 bfa_fcs_lport_lip_scn_online(port);
2812 }
2813
2814 void
2815 bfa_cb_rport_scn_no_dev(void *rport)
2816 {
2817         struct bfa_fcs_rport_s *rp = rport;
2818
2819         bfa_sm_send_event(rp, RPSM_EVENT_SCN_OFFLINE);
2820         rp->scn_online = BFA_FALSE;
2821 }
2822
2823 void
2824 bfa_cb_rport_scn_offline(struct bfa_s *bfa)
2825 {
2826         struct bfa_fcs_s *fcs = &((struct bfad_s *)bfa->bfad)->bfa_fcs;
2827         struct bfa_fcs_lport_s *port = bfa_fcs_get_base_port(fcs);
2828         struct bfa_fcs_rport_s *rp;
2829         struct list_head *qe;
2830
2831         list_for_each(qe, &port->rport_q) {
2832                 rp = (struct bfa_fcs_rport_s *) qe;
2833                 bfa_sm_send_event(rp, RPSM_EVENT_SCN_OFFLINE);
2834                 rp->scn_online = BFA_FALSE;
2835         }
2836 }
2837
2838 /*
2839  *      brief
2840  *      This routine is a static BFA callback when there is a QoS priority
2841  *      change notification
2842  *
2843  *      param[in]       rport   -
2844  *
2845  *      return
2846  *              void
2847  *
2848  *      Special Considerations:
2849  *
2850  *      note
2851  */
2852 void
2853 bfa_cb_rport_qos_scn_prio(void *cbarg,
2854                 struct bfa_rport_qos_attr_s old_qos_attr,
2855                 struct bfa_rport_qos_attr_s new_qos_attr)
2856 {
2857         struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;
2858         struct bfa_rport_aen_data_s aen_data;
2859
2860         bfa_trc(rport->fcs, rport->pwwn);
2861         aen_data.priv.qos = new_qos_attr;
2862         bfa_fcs_rport_aen_post(rport, BFA_RPORT_AEN_QOS_PRIO, &aen_data);
2863 }
2864
2865 /*
2866  *              Called to process any unsolicted frames from this remote port
2867  */
2868 void
2869 bfa_fcs_rport_uf_recv(struct bfa_fcs_rport_s *rport,
2870                         struct fchs_s *fchs, u16 len)
2871 {
2872         struct bfa_fcs_lport_s *port = rport->port;
2873         struct fc_els_cmd_s     *els_cmd;
2874
2875         bfa_trc(rport->fcs, fchs->s_id);
2876         bfa_trc(rport->fcs, fchs->d_id);
2877         bfa_trc(rport->fcs, fchs->type);
2878
2879         if (fchs->type != FC_TYPE_ELS)
2880                 return;
2881
2882         els_cmd = (struct fc_els_cmd_s *) (fchs + 1);
2883
2884         bfa_trc(rport->fcs, els_cmd->els_code);
2885
2886         switch (els_cmd->els_code) {
2887         case FC_ELS_LOGO:
2888                 bfa_stats(port, plogi_rcvd);
2889                 bfa_fcs_rport_process_logo(rport, fchs);
2890                 break;
2891
2892         case FC_ELS_ADISC:
2893                 bfa_stats(port, adisc_rcvd);
2894                 bfa_fcs_rport_process_adisc(rport, fchs, len);
2895                 break;
2896
2897         case FC_ELS_PRLO:
2898                 bfa_stats(port, prlo_rcvd);
2899                 if (bfa_fcs_lport_is_initiator(port))
2900                         bfa_fcs_fcpim_uf_recv(rport->itnim, fchs, len);
2901                 break;
2902
2903         case FC_ELS_PRLI:
2904                 bfa_stats(port, prli_rcvd);
2905                 bfa_fcs_rport_process_prli(rport, fchs, len);
2906                 break;
2907
2908         case FC_ELS_RPSC:
2909                 bfa_stats(port, rpsc_rcvd);
2910                 bfa_fcs_rport_process_rpsc(rport, fchs, len);
2911                 break;
2912
2913         default:
2914                 bfa_stats(port, un_handled_els_rcvd);
2915                 bfa_fcs_rport_send_ls_rjt(rport, fchs,
2916                                           FC_LS_RJT_RSN_CMD_NOT_SUPP,
2917                                           FC_LS_RJT_EXP_NO_ADDL_INFO);
2918                 break;
2919         }
2920 }
2921
2922 /* send best case  acc to prlo */
2923 static void
2924 bfa_fcs_rport_send_prlo_acc(struct bfa_fcs_rport_s *rport)
2925 {
2926         struct bfa_fcs_lport_s *port = rport->port;
2927         struct fchs_s   fchs;
2928         struct bfa_fcxp_s *fcxp;
2929         int             len;
2930
2931         bfa_trc(rport->fcs, rport->pid);
2932
2933         fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
2934         if (!fcxp)
2935                 return;
2936         len = fc_prlo_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
2937                         rport->pid, bfa_fcs_lport_get_fcid(port),
2938                         rport->reply_oxid, 0);
2939
2940         bfa_fcxp_send(fcxp, rport->bfa_rport, port->fabric->vf_id,
2941                 port->lp_tag, BFA_FALSE, FC_CLASS_3, len, &fchs,
2942                 NULL, NULL, FC_MAX_PDUSZ, 0);
2943 }
2944
2945 /*
2946  * Send a LS reject
2947  */
2948 static void
2949 bfa_fcs_rport_send_ls_rjt(struct bfa_fcs_rport_s *rport, struct fchs_s *rx_fchs,
2950                           u8 reason_code, u8 reason_code_expl)
2951 {
2952         struct bfa_fcs_lport_s *port = rport->port;
2953         struct fchs_s   fchs;
2954         struct bfa_fcxp_s *fcxp;
2955         int             len;
2956
2957         bfa_trc(rport->fcs, rx_fchs->s_id);
2958
2959         fcxp = bfa_fcs_fcxp_alloc(rport->fcs, BFA_FALSE);
2960         if (!fcxp)
2961                 return;
2962
2963         len = fc_ls_rjt_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
2964                                 rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
2965                                 rx_fchs->ox_id, reason_code, reason_code_expl);
2966
2967         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag,
2968                         BFA_FALSE, FC_CLASS_3, len, &fchs, NULL, NULL,
2969                         FC_MAX_PDUSZ, 0);
2970 }
2971
2972 /*
2973  * Return state of rport.
2974  */
2975 int
2976 bfa_fcs_rport_get_state(struct bfa_fcs_rport_s *rport)
2977 {
2978         return bfa_sm_to_state(rport_sm_table, rport->sm);
2979 }
2980
2981
2982 /*
2983  *      brief
2984  *               Called by the Driver to set rport delete/ageout timeout
2985  *
2986  *      param[in]               rport timeout value in seconds.
2987  *
2988  *      return None
2989  */
2990 void
2991 bfa_fcs_rport_set_del_timeout(u8 rport_tmo)
2992 {
2993         /* convert to Millisecs */
2994         if (rport_tmo > 0)
2995                 bfa_fcs_rport_del_timeout = rport_tmo * 1000;
2996 }
2997 void
2998 bfa_fcs_rport_prlo(struct bfa_fcs_rport_s *rport, __be16 ox_id)
2999 {
3000         bfa_trc(rport->fcs, rport->pid);
3001
3002         rport->prlo = BFA_TRUE;
3003         rport->reply_oxid = ox_id;
3004         bfa_sm_send_event(rport, RPSM_EVENT_PRLO_RCVD);
3005 }
3006
3007 /*
3008  * Called by BFAD to set the max limit on number of bfa_fcs_rport allocation
3009  * which limits number of concurrent logins to remote ports
3010  */
3011 void
3012 bfa_fcs_rport_set_max_logins(u32 max_logins)
3013 {
3014         if (max_logins > 0)
3015                 bfa_fcs_rport_max_logins = max_logins;
3016 }
3017
3018 void
3019 bfa_fcs_rport_get_attr(struct bfa_fcs_rport_s *rport,
3020                 struct bfa_rport_attr_s *rport_attr)
3021 {
3022         struct bfa_rport_qos_attr_s qos_attr;
3023         struct bfa_fcs_lport_s *port = rport->port;
3024         bfa_port_speed_t rport_speed = rport->rpf.rpsc_speed;
3025         struct bfa_port_attr_s port_attr;
3026
3027         bfa_fcport_get_attr(rport->fcs->bfa, &port_attr);
3028
3029         memset(rport_attr, 0, sizeof(struct bfa_rport_attr_s));
3030         memset(&qos_attr, 0, sizeof(struct bfa_rport_qos_attr_s));
3031
3032         rport_attr->pid = rport->pid;
3033         rport_attr->pwwn = rport->pwwn;
3034         rport_attr->nwwn = rport->nwwn;
3035         rport_attr->cos_supported = rport->fc_cos;
3036         rport_attr->df_sz = rport->maxfrsize;
3037         rport_attr->state = bfa_fcs_rport_get_state(rport);
3038         rport_attr->fc_cos = rport->fc_cos;
3039         rport_attr->cisc = rport->cisc;
3040         rport_attr->scsi_function = rport->scsi_function;
3041         rport_attr->curr_speed  = rport->rpf.rpsc_speed;
3042         rport_attr->assigned_speed  = rport->rpf.assigned_speed;
3043
3044         if (rport->bfa_rport) {
3045                 qos_attr.qos_priority = rport->bfa_rport->qos_attr.qos_priority;
3046                 qos_attr.qos_flow_id =
3047                         cpu_to_be32(rport->bfa_rport->qos_attr.qos_flow_id);
3048         }
3049         rport_attr->qos_attr = qos_attr;
3050
3051         rport_attr->trl_enforced = BFA_FALSE;
3052         if (bfa_fcport_is_ratelim(port->fcs->bfa) &&
3053             (rport->scsi_function == BFA_RPORT_TARGET)) {
3054                 if (rport_speed == BFA_PORT_SPEED_UNKNOWN)
3055                         rport_speed =
3056                                 bfa_fcport_get_ratelim_speed(rport->fcs->bfa);
3057
3058                 if ((bfa_fcs_lport_get_rport_max_speed(port) !=
3059                     BFA_PORT_SPEED_UNKNOWN) && (rport_speed < port_attr.speed))
3060                         rport_attr->trl_enforced = BFA_TRUE;
3061         }
3062 }
3063
3064 /*
3065  * Remote port implementation.
3066  */
3067
3068 /*
3069  *  fcs_rport_api FCS rport API.
3070  */
3071
3072 struct bfa_fcs_rport_s *
3073 bfa_fcs_rport_lookup(struct bfa_fcs_lport_s *port, wwn_t rpwwn)
3074 {
3075         struct bfa_fcs_rport_s *rport;
3076
3077         rport = bfa_fcs_lport_get_rport_by_pwwn(port, rpwwn);
3078         if (rport == NULL) {
3079                 /*
3080                  * TBD Error handling
3081                  */
3082         }
3083
3084         return rport;
3085 }
3086
3087 struct bfa_fcs_rport_s *
3088 bfa_fcs_rport_lookup_by_nwwn(struct bfa_fcs_lport_s *port, wwn_t rnwwn)
3089 {
3090         struct bfa_fcs_rport_s *rport;
3091
3092         rport = bfa_fcs_lport_get_rport_by_nwwn(port, rnwwn);
3093         if (rport == NULL) {
3094                 /*
3095                  * TBD Error handling
3096                  */
3097         }
3098
3099         return rport;
3100 }
3101
3102 /*
3103  * Remote port features (RPF) implementation.
3104  */
3105
3106 #define BFA_FCS_RPF_RETRIES     (3)
3107 #define BFA_FCS_RPF_RETRY_TIMEOUT  (1000) /* 1 sec (In millisecs) */
3108
3109 static void     bfa_fcs_rpf_send_rpsc2(void *rport_cbarg,
3110                                 struct bfa_fcxp_s *fcxp_alloced);
3111 static void     bfa_fcs_rpf_rpsc2_response(void *fcsarg,
3112                         struct bfa_fcxp_s *fcxp,
3113                         void *cbarg,
3114                         bfa_status_t req_status,
3115                         u32 rsp_len,
3116                         u32 resid_len,
3117                         struct fchs_s *rsp_fchs);
3118
3119 static void     bfa_fcs_rpf_timeout(void *arg);
3120
3121 /*
3122  *  fcs_rport_ftrs_sm FCS rport state machine events
3123  */
3124
3125 enum rpf_event {
3126         RPFSM_EVENT_RPORT_OFFLINE  = 1, /* Rport offline                */
3127         RPFSM_EVENT_RPORT_ONLINE   = 2, /* Rport online                 */
3128         RPFSM_EVENT_FCXP_SENT      = 3, /* Frame from has been sent     */
3129         RPFSM_EVENT_TIMEOUT        = 4, /* Rport SM timeout event       */
3130         RPFSM_EVENT_RPSC_COMP      = 5,
3131         RPFSM_EVENT_RPSC_FAIL      = 6,
3132         RPFSM_EVENT_RPSC_ERROR     = 7,
3133 };
3134
3135 static void     bfa_fcs_rpf_sm_uninit(struct bfa_fcs_rpf_s *rpf,
3136                                         enum rpf_event event);
3137 static void     bfa_fcs_rpf_sm_rpsc_sending(struct bfa_fcs_rpf_s *rpf,
3138                                        enum rpf_event event);
3139 static void     bfa_fcs_rpf_sm_rpsc(struct bfa_fcs_rpf_s *rpf,
3140                                        enum rpf_event event);
3141 static void     bfa_fcs_rpf_sm_rpsc_retry(struct bfa_fcs_rpf_s *rpf,
3142                                         enum rpf_event event);
3143 static void     bfa_fcs_rpf_sm_offline(struct bfa_fcs_rpf_s *rpf,
3144                                         enum rpf_event event);
3145 static void     bfa_fcs_rpf_sm_online(struct bfa_fcs_rpf_s *rpf,
3146                                         enum rpf_event event);
3147
3148 static void
3149 bfa_fcs_rpf_sm_uninit(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
3150 {
3151         struct bfa_fcs_rport_s *rport = rpf->rport;
3152         struct bfa_fcs_fabric_s *fabric = &rport->fcs->fabric;
3153
3154         bfa_trc(rport->fcs, rport->pwwn);
3155         bfa_trc(rport->fcs, rport->pid);
3156         bfa_trc(rport->fcs, event);
3157
3158         switch (event) {
3159         case RPFSM_EVENT_RPORT_ONLINE:
3160                 /* Send RPSC2 to a Brocade fabric only. */
3161                 if ((!BFA_FCS_PID_IS_WKA(rport->pid)) &&
3162                         ((rport->port->fabric->lps->brcd_switch) ||
3163                         (bfa_fcs_fabric_get_switch_oui(fabric) ==
3164                                                 BFA_FCS_BRCD_SWITCH_OUI))) {
3165                         bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_rpsc_sending);
3166                         rpf->rpsc_retries = 0;
3167                         bfa_fcs_rpf_send_rpsc2(rpf, NULL);
3168                 }
3169                 break;
3170
3171         case RPFSM_EVENT_RPORT_OFFLINE:
3172                 break;
3173
3174         default:
3175                 bfa_sm_fault(rport->fcs, event);
3176         }
3177 }
3178
3179 static void
3180 bfa_fcs_rpf_sm_rpsc_sending(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
3181 {
3182         struct bfa_fcs_rport_s *rport = rpf->rport;
3183
3184         bfa_trc(rport->fcs, event);
3185
3186         switch (event) {
3187         case RPFSM_EVENT_FCXP_SENT:
3188                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_rpsc);
3189                 break;
3190
3191         case RPFSM_EVENT_RPORT_OFFLINE:
3192                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_offline);
3193                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rpf->fcxp_wqe);
3194                 rpf->rpsc_retries = 0;
3195                 break;
3196
3197         default:
3198                 bfa_sm_fault(rport->fcs, event);
3199         }
3200 }
3201
3202 static void
3203 bfa_fcs_rpf_sm_rpsc(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
3204 {
3205         struct bfa_fcs_rport_s *rport = rpf->rport;
3206
3207         bfa_trc(rport->fcs, rport->pid);
3208         bfa_trc(rport->fcs, event);
3209
3210         switch (event) {
3211         case RPFSM_EVENT_RPSC_COMP:
3212                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_online);
3213                 /* Update speed info in f/w via BFA */
3214                 if (rpf->rpsc_speed != BFA_PORT_SPEED_UNKNOWN)
3215                         bfa_rport_speed(rport->bfa_rport, rpf->rpsc_speed);
3216                 else if (rpf->assigned_speed != BFA_PORT_SPEED_UNKNOWN)
3217                         bfa_rport_speed(rport->bfa_rport, rpf->assigned_speed);
3218                 break;
3219
3220         case RPFSM_EVENT_RPSC_FAIL:
3221                 /* RPSC not supported by rport */
3222                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_online);
3223                 break;
3224
3225         case RPFSM_EVENT_RPSC_ERROR:
3226                 /* need to retry...delayed a bit. */
3227                 if (rpf->rpsc_retries++ < BFA_FCS_RPF_RETRIES) {
3228                         bfa_timer_start(rport->fcs->bfa, &rpf->timer,
3229                                     bfa_fcs_rpf_timeout, rpf,
3230                                     BFA_FCS_RPF_RETRY_TIMEOUT);
3231                         bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_rpsc_retry);
3232                 } else {
3233                         bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_online);
3234                 }
3235                 break;
3236
3237         case RPFSM_EVENT_RPORT_OFFLINE:
3238                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_offline);
3239                 bfa_fcxp_discard(rpf->fcxp);
3240                 rpf->rpsc_retries = 0;
3241                 break;
3242
3243         default:
3244                 bfa_sm_fault(rport->fcs, event);
3245         }
3246 }
3247
3248 static void
3249 bfa_fcs_rpf_sm_rpsc_retry(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
3250 {
3251         struct bfa_fcs_rport_s *rport = rpf->rport;
3252
3253         bfa_trc(rport->fcs, rport->pid);
3254         bfa_trc(rport->fcs, event);
3255
3256         switch (event) {
3257         case RPFSM_EVENT_TIMEOUT:
3258                 /* re-send the RPSC */
3259                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_rpsc_sending);
3260                 bfa_fcs_rpf_send_rpsc2(rpf, NULL);
3261                 break;
3262
3263         case RPFSM_EVENT_RPORT_OFFLINE:
3264                 bfa_timer_stop(&rpf->timer);
3265                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_offline);
3266                 rpf->rpsc_retries = 0;
3267                 break;
3268
3269         default:
3270                 bfa_sm_fault(rport->fcs, event);
3271         }
3272 }
3273
3274 static void
3275 bfa_fcs_rpf_sm_online(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
3276 {
3277         struct bfa_fcs_rport_s *rport = rpf->rport;
3278
3279         bfa_trc(rport->fcs, rport->pwwn);
3280         bfa_trc(rport->fcs, rport->pid);
3281         bfa_trc(rport->fcs, event);
3282
3283         switch (event) {
3284         case RPFSM_EVENT_RPORT_OFFLINE:
3285                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_offline);
3286                 rpf->rpsc_retries = 0;
3287                 break;
3288
3289         default:
3290                 bfa_sm_fault(rport->fcs, event);
3291         }
3292 }
3293
3294 static void
3295 bfa_fcs_rpf_sm_offline(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
3296 {
3297         struct bfa_fcs_rport_s *rport = rpf->rport;
3298
3299         bfa_trc(rport->fcs, rport->pwwn);
3300         bfa_trc(rport->fcs, rport->pid);
3301         bfa_trc(rport->fcs, event);
3302
3303         switch (event) {
3304         case RPFSM_EVENT_RPORT_ONLINE:
3305                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_rpsc_sending);
3306                 bfa_fcs_rpf_send_rpsc2(rpf, NULL);
3307                 break;
3308
3309         case RPFSM_EVENT_RPORT_OFFLINE:
3310                 break;
3311
3312         default:
3313                 bfa_sm_fault(rport->fcs, event);
3314         }
3315 }
3316 /*
3317  * Called when Rport is created.
3318  */
3319 void
3320 bfa_fcs_rpf_init(struct bfa_fcs_rport_s *rport)
3321 {
3322         struct bfa_fcs_rpf_s *rpf = &rport->rpf;
3323
3324         bfa_trc(rport->fcs, rport->pid);
3325         rpf->rport = rport;
3326
3327         bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_uninit);
3328 }
3329
3330 /*
3331  * Called when Rport becomes online
3332  */
3333 void
3334 bfa_fcs_rpf_rport_online(struct bfa_fcs_rport_s *rport)
3335 {
3336         bfa_trc(rport->fcs, rport->pid);
3337
3338         if (__fcs_min_cfg(rport->port->fcs))
3339                 return;
3340
3341         if (bfa_fcs_fabric_is_switched(rport->port->fabric))
3342                 bfa_sm_send_event(&rport->rpf, RPFSM_EVENT_RPORT_ONLINE);
3343 }
3344
3345 /*
3346  * Called when Rport becomes offline
3347  */
3348 void
3349 bfa_fcs_rpf_rport_offline(struct bfa_fcs_rport_s *rport)
3350 {
3351         bfa_trc(rport->fcs, rport->pid);
3352
3353         if (__fcs_min_cfg(rport->port->fcs))
3354                 return;
3355
3356         rport->rpf.rpsc_speed = 0;
3357         bfa_sm_send_event(&rport->rpf, RPFSM_EVENT_RPORT_OFFLINE);
3358 }
3359
3360 static void
3361 bfa_fcs_rpf_timeout(void *arg)
3362 {
3363         struct bfa_fcs_rpf_s *rpf = (struct bfa_fcs_rpf_s *) arg;
3364         struct bfa_fcs_rport_s *rport = rpf->rport;
3365
3366         bfa_trc(rport->fcs, rport->pid);
3367         bfa_sm_send_event(rpf, RPFSM_EVENT_TIMEOUT);
3368 }
3369
3370 static void
3371 bfa_fcs_rpf_send_rpsc2(void *rpf_cbarg, struct bfa_fcxp_s *fcxp_alloced)
3372 {
3373         struct bfa_fcs_rpf_s *rpf = (struct bfa_fcs_rpf_s *)rpf_cbarg;
3374         struct bfa_fcs_rport_s *rport = rpf->rport;
3375         struct bfa_fcs_lport_s *port = rport->port;
3376         struct fchs_s   fchs;
3377         int             len;
3378         struct bfa_fcxp_s *fcxp;
3379
3380         bfa_trc(rport->fcs, rport->pwwn);
3381
3382         fcxp = fcxp_alloced ? fcxp_alloced :
3383                bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
3384         if (!fcxp) {
3385                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rpf->fcxp_wqe,
3386                                 bfa_fcs_rpf_send_rpsc2, rpf, BFA_TRUE);
3387                 return;
3388         }
3389         rpf->fcxp = fcxp;
3390
3391         len = fc_rpsc2_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), rport->pid,
3392                             bfa_fcs_lport_get_fcid(port), &rport->pid, 1);
3393
3394         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
3395                           FC_CLASS_3, len, &fchs, bfa_fcs_rpf_rpsc2_response,
3396                           rpf, FC_MAX_PDUSZ, FC_ELS_TOV);
3397         rport->stats.rpsc_sent++;
3398         bfa_sm_send_event(rpf, RPFSM_EVENT_FCXP_SENT);
3399
3400 }
3401
3402 static void
3403 bfa_fcs_rpf_rpsc2_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,
3404                             bfa_status_t req_status, u32 rsp_len,
3405                             u32 resid_len, struct fchs_s *rsp_fchs)
3406 {
3407         struct bfa_fcs_rpf_s *rpf = (struct bfa_fcs_rpf_s *) cbarg;
3408         struct bfa_fcs_rport_s *rport = rpf->rport;
3409         struct fc_ls_rjt_s *ls_rjt;
3410         struct fc_rpsc2_acc_s *rpsc2_acc;
3411         u16     num_ents;
3412
3413         bfa_trc(rport->fcs, req_status);
3414
3415         if (req_status != BFA_STATUS_OK) {
3416                 bfa_trc(rport->fcs, req_status);
3417                 if (req_status == BFA_STATUS_ETIMER)
3418                         rport->stats.rpsc_failed++;
3419                 bfa_sm_send_event(rpf, RPFSM_EVENT_RPSC_ERROR);
3420                 return;
3421         }
3422
3423         rpsc2_acc = (struct fc_rpsc2_acc_s *) BFA_FCXP_RSP_PLD(fcxp);
3424         if (rpsc2_acc->els_cmd == FC_ELS_ACC) {
3425                 rport->stats.rpsc_accs++;
3426                 num_ents = be16_to_cpu(rpsc2_acc->num_pids);
3427                 bfa_trc(rport->fcs, num_ents);
3428                 if (num_ents > 0) {
3429                         WARN_ON(be32_to_cpu(rpsc2_acc->port_info[0].pid) !=
3430                                                 bfa_ntoh3b(rport->pid));
3431                         bfa_trc(rport->fcs,
3432                                 be32_to_cpu(rpsc2_acc->port_info[0].pid));
3433                         bfa_trc(rport->fcs,
3434                                 be16_to_cpu(rpsc2_acc->port_info[0].speed));
3435                         bfa_trc(rport->fcs,
3436                                 be16_to_cpu(rpsc2_acc->port_info[0].index));
3437                         bfa_trc(rport->fcs,
3438                                 rpsc2_acc->port_info[0].type);
3439
3440                         if (rpsc2_acc->port_info[0].speed == 0) {
3441                                 bfa_sm_send_event(rpf, RPFSM_EVENT_RPSC_ERROR);
3442                                 return;
3443                         }
3444
3445                         rpf->rpsc_speed = fc_rpsc_operspeed_to_bfa_speed(
3446                                 be16_to_cpu(rpsc2_acc->port_info[0].speed));
3447
3448                         bfa_sm_send_event(rpf, RPFSM_EVENT_RPSC_COMP);
3449                 }
3450         } else {
3451                 ls_rjt = (struct fc_ls_rjt_s *) BFA_FCXP_RSP_PLD(fcxp);
3452                 bfa_trc(rport->fcs, ls_rjt->reason_code);
3453                 bfa_trc(rport->fcs, ls_rjt->reason_code_expl);
3454                 rport->stats.rpsc_rejects++;
3455                 if (ls_rjt->reason_code == FC_LS_RJT_RSN_CMD_NOT_SUPP)
3456                         bfa_sm_send_event(rpf, RPFSM_EVENT_RPSC_FAIL);
3457                 else
3458                         bfa_sm_send_event(rpf, RPFSM_EVENT_RPSC_ERROR);
3459         }
3460 }