kernel/drivers/scsi/bfa/bfa_fcs_rport.c

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