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 } 3465