1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Copyright (c) 2005-2014 Brocade Communications Systems, Inc. 4 * Copyright (c) 2014- QLogic Corporation. 5 * All rights reserved 6 * www.qlogic.com 7 * 8 * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter. 9 */ 10 11#include "bfad_drv.h" 12#include "bfad_im.h" 13#include "bfa_fcs.h" 14#include "bfa_fcbuild.h" 15#include "bfa_fc.h" 16 17BFA_TRC_FILE(FCS, PORT); 18 19/* 20 * ALPA to LIXA bitmap mapping 21 * 22 * ALPA 0x00 (Word 0, Bit 30) is invalid for N_Ports. Also Word 0 Bit 31 23 * is for L_bit (login required) and is filled as ALPA 0x00 here. 24 */ 25static const u8 loop_alpa_map[] = { 26 0x00, 0x00, 0x01, 0x02, 0x04, 0x08, 0x0F, 0x10, /* Word 0 Bits 31..24 */ 27 0x17, 0x18, 0x1B, 0x1D, 0x1E, 0x1F, 0x23, 0x25, /* Word 0 Bits 23..16 */ 28 0x26, 0x27, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, /* Word 0 Bits 15..08 */ 29 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x39, 0x3A, /* Word 0 Bits 07..00 */ 30 31 0x3C, 0x43, 0x45, 0x46, 0x47, 0x49, 0x4A, 0x4B, /* Word 1 Bits 31..24 */ 32 0x4C, 0x4D, 0x4E, 0x51, 0x52, 0x53, 0x54, 0x55, /* Word 1 Bits 23..16 */ 33 0x56, 0x59, 0x5A, 0x5C, 0x63, 0x65, 0x66, 0x67, /* Word 1 Bits 15..08 */ 34 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x71, 0x72, /* Word 1 Bits 07..00 */ 35 36 0x73, 0x74, 0x75, 0x76, 0x79, 0x7A, 0x7C, 0x80, /* Word 2 Bits 31..24 */ 37 0x81, 0x82, 0x84, 0x88, 0x8F, 0x90, 0x97, 0x98, /* Word 2 Bits 23..16 */ 38 0x9B, 0x9D, 0x9E, 0x9F, 0xA3, 0xA5, 0xA6, 0xA7, /* Word 2 Bits 15..08 */ 39 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xB1, 0xB2, /* Word 2 Bits 07..00 */ 40 41 0xB3, 0xB4, 0xB5, 0xB6, 0xB9, 0xBA, 0xBC, 0xC3, /* Word 3 Bits 31..24 */ 42 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, /* Word 3 Bits 23..16 */ 43 0xCE, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD9, /* Word 3 Bits 15..08 */ 44 0xDA, 0xDC, 0xE0, 0xE1, 0xE2, 0xE4, 0xE8, 0xEF, /* Word 3 Bits 07..00 */ 45}; 46 47static void bfa_fcs_lport_send_ls_rjt(struct bfa_fcs_lport_s *port, 48 struct fchs_s *rx_fchs, u8 reason_code, 49 u8 reason_code_expl); 50static void bfa_fcs_lport_plogi(struct bfa_fcs_lport_s *port, 51 struct fchs_s *rx_fchs, struct fc_logi_s *plogi); 52static void bfa_fcs_lport_online_actions(struct bfa_fcs_lport_s *port); 53static void bfa_fcs_lport_offline_actions(struct bfa_fcs_lport_s *port); 54static void bfa_fcs_lport_unknown_init(struct bfa_fcs_lport_s *port); 55static void bfa_fcs_lport_unknown_online(struct bfa_fcs_lport_s *port); 56static void bfa_fcs_lport_unknown_offline(struct bfa_fcs_lport_s *port); 57static void bfa_fcs_lport_deleted(struct bfa_fcs_lport_s *port); 58static void bfa_fcs_lport_echo(struct bfa_fcs_lport_s *port, 59 struct fchs_s *rx_fchs, 60 struct fc_echo_s *echo, u16 len); 61static void bfa_fcs_lport_rnid(struct bfa_fcs_lport_s *port, 62 struct fchs_s *rx_fchs, 63 struct fc_rnid_cmd_s *rnid, u16 len); 64static void bfa_fs_port_get_gen_topo_data(struct bfa_fcs_lport_s *port, 65 struct fc_rnid_general_topology_data_s *gen_topo_data); 66 67static void bfa_fcs_lport_fab_init(struct bfa_fcs_lport_s *port); 68static void bfa_fcs_lport_fab_online(struct bfa_fcs_lport_s *port); 69static void bfa_fcs_lport_fab_offline(struct bfa_fcs_lport_s *port); 70 71static void bfa_fcs_lport_n2n_init(struct bfa_fcs_lport_s *port); 72static void bfa_fcs_lport_n2n_online(struct bfa_fcs_lport_s *port); 73static void bfa_fcs_lport_n2n_offline(struct bfa_fcs_lport_s *port); 74 75static void bfa_fcs_lport_loop_init(struct bfa_fcs_lport_s *port); 76static void bfa_fcs_lport_loop_online(struct bfa_fcs_lport_s *port); 77static void bfa_fcs_lport_loop_offline(struct bfa_fcs_lport_s *port); 78 79static struct { 80 void (*init) (struct bfa_fcs_lport_s *port); 81 void (*online) (struct bfa_fcs_lport_s *port); 82 void (*offline) (struct bfa_fcs_lport_s *port); 83} __port_action[] = { 84 [BFA_FCS_FABRIC_UNKNOWN] = { 85 .init = bfa_fcs_lport_unknown_init, 86 .online = bfa_fcs_lport_unknown_online, 87 .offline = bfa_fcs_lport_unknown_offline 88 }, 89 [BFA_FCS_FABRIC_SWITCHED] = { 90 .init = bfa_fcs_lport_fab_init, 91 .online = bfa_fcs_lport_fab_online, 92 .offline = bfa_fcs_lport_fab_offline 93 }, 94 [BFA_FCS_FABRIC_N2N] = { 95 .init = bfa_fcs_lport_n2n_init, 96 .online = bfa_fcs_lport_n2n_online, 97 .offline = bfa_fcs_lport_n2n_offline 98 }, 99 [BFA_FCS_FABRIC_LOOP] = { 100 .init = bfa_fcs_lport_loop_init, 101 .online = bfa_fcs_lport_loop_online, 102 .offline = bfa_fcs_lport_loop_offline 103 }, 104}; 105 106static void bfa_fcs_lport_sm_uninit(struct bfa_fcs_lport_s *port, 107 enum bfa_fcs_lport_event event); 108static void bfa_fcs_lport_sm_init(struct bfa_fcs_lport_s *port, 109 enum bfa_fcs_lport_event event); 110static void bfa_fcs_lport_sm_online(struct bfa_fcs_lport_s *port, 111 enum bfa_fcs_lport_event event); 112static void bfa_fcs_lport_sm_offline(struct bfa_fcs_lport_s *port, 113 enum bfa_fcs_lport_event event); 114static void bfa_fcs_lport_sm_deleting(struct bfa_fcs_lport_s *port, 115 enum bfa_fcs_lport_event event); 116static void bfa_fcs_lport_sm_stopping(struct bfa_fcs_lport_s *port, 117 enum bfa_fcs_lport_event event); 118 119static void 120bfa_fcs_lport_sm_uninit( 121 struct bfa_fcs_lport_s *port, 122 enum bfa_fcs_lport_event event) 123{ 124 bfa_trc(port->fcs, port->port_cfg.pwwn); 125 bfa_trc(port->fcs, event); 126 127 switch (event) { 128 case BFA_FCS_PORT_SM_CREATE: 129 bfa_sm_set_state(port, bfa_fcs_lport_sm_init); 130 break; 131 132 default: 133 bfa_sm_fault(port->fcs, event); 134 } 135} 136 137static void 138bfa_fcs_lport_sm_init(struct bfa_fcs_lport_s *port, 139 enum bfa_fcs_lport_event event) 140{ 141 bfa_trc(port->fcs, port->port_cfg.pwwn); 142 bfa_trc(port->fcs, event); 143 144 switch (event) { 145 case BFA_FCS_PORT_SM_ONLINE: 146 bfa_sm_set_state(port, bfa_fcs_lport_sm_online); 147 bfa_fcs_lport_online_actions(port); 148 break; 149 150 case BFA_FCS_PORT_SM_DELETE: 151 bfa_sm_set_state(port, bfa_fcs_lport_sm_uninit); 152 bfa_fcs_lport_deleted(port); 153 break; 154 155 case BFA_FCS_PORT_SM_STOP: 156 /* If vport - send completion call back */ 157 if (port->vport) 158 bfa_fcs_vport_stop_comp(port->vport); 159 else 160 bfa_wc_down(&(port->fabric->stop_wc)); 161 break; 162 163 case BFA_FCS_PORT_SM_OFFLINE: 164 break; 165 166 default: 167 bfa_sm_fault(port->fcs, event); 168 } 169} 170 171static void 172bfa_fcs_lport_sm_online( 173 struct bfa_fcs_lport_s *port, 174 enum bfa_fcs_lport_event event) 175{ 176 struct bfa_fcs_rport_s *rport; 177 struct list_head *qe, *qen; 178 179 bfa_trc(port->fcs, port->port_cfg.pwwn); 180 bfa_trc(port->fcs, event); 181 182 switch (event) { 183 case BFA_FCS_PORT_SM_OFFLINE: 184 bfa_sm_set_state(port, bfa_fcs_lport_sm_offline); 185 bfa_fcs_lport_offline_actions(port); 186 break; 187 188 case BFA_FCS_PORT_SM_STOP: 189 __port_action[port->fabric->fab_type].offline(port); 190 191 if (port->num_rports == 0) { 192 bfa_sm_set_state(port, bfa_fcs_lport_sm_init); 193 /* If vport - send completion call back */ 194 if (port->vport) 195 bfa_fcs_vport_stop_comp(port->vport); 196 else 197 bfa_wc_down(&(port->fabric->stop_wc)); 198 } else { 199 bfa_sm_set_state(port, bfa_fcs_lport_sm_stopping); 200 list_for_each_safe(qe, qen, &port->rport_q) { 201 rport = (struct bfa_fcs_rport_s *) qe; 202 bfa_sm_send_event(rport, RPSM_EVENT_DELETE); 203 } 204 } 205 break; 206 207 case BFA_FCS_PORT_SM_DELETE: 208 209 __port_action[port->fabric->fab_type].offline(port); 210 211 if (port->num_rports == 0) { 212 bfa_sm_set_state(port, bfa_fcs_lport_sm_uninit); 213 bfa_fcs_lport_deleted(port); 214 } else { 215 bfa_sm_set_state(port, bfa_fcs_lport_sm_deleting); 216 list_for_each_safe(qe, qen, &port->rport_q) { 217 rport = (struct bfa_fcs_rport_s *) qe; 218 bfa_sm_send_event(rport, RPSM_EVENT_DELETE); 219 } 220 } 221 break; 222 223 case BFA_FCS_PORT_SM_DELRPORT: 224 break; 225 226 default: 227 bfa_sm_fault(port->fcs, event); 228 } 229} 230 231static void 232bfa_fcs_lport_sm_offline( 233 struct bfa_fcs_lport_s *port, 234 enum bfa_fcs_lport_event event) 235{ 236 struct bfa_fcs_rport_s *rport; 237 struct list_head *qe, *qen; 238 239 bfa_trc(port->fcs, port->port_cfg.pwwn); 240 bfa_trc(port->fcs, event); 241 242 switch (event) { 243 case BFA_FCS_PORT_SM_ONLINE: 244 bfa_sm_set_state(port, bfa_fcs_lport_sm_online); 245 bfa_fcs_lport_online_actions(port); 246 break; 247 248 case BFA_FCS_PORT_SM_STOP: 249 if (port->num_rports == 0) { 250 bfa_sm_set_state(port, bfa_fcs_lport_sm_init); 251 /* If vport - send completion call back */ 252 if (port->vport) 253 bfa_fcs_vport_stop_comp(port->vport); 254 else 255 bfa_wc_down(&(port->fabric->stop_wc)); 256 } else { 257 bfa_sm_set_state(port, bfa_fcs_lport_sm_stopping); 258 list_for_each_safe(qe, qen, &port->rport_q) { 259 rport = (struct bfa_fcs_rport_s *) qe; 260 bfa_sm_send_event(rport, RPSM_EVENT_DELETE); 261 } 262 } 263 break; 264 265 case BFA_FCS_PORT_SM_DELETE: 266 if (port->num_rports == 0) { 267 bfa_sm_set_state(port, bfa_fcs_lport_sm_uninit); 268 bfa_fcs_lport_deleted(port); 269 } else { 270 bfa_sm_set_state(port, bfa_fcs_lport_sm_deleting); 271 list_for_each_safe(qe, qen, &port->rport_q) { 272 rport = (struct bfa_fcs_rport_s *) qe; 273 bfa_sm_send_event(rport, RPSM_EVENT_DELETE); 274 } 275 } 276 break; 277 278 case BFA_FCS_PORT_SM_DELRPORT: 279 case BFA_FCS_PORT_SM_OFFLINE: 280 break; 281 282 default: 283 bfa_sm_fault(port->fcs, event); 284 } 285} 286 287static void 288bfa_fcs_lport_sm_stopping(struct bfa_fcs_lport_s *port, 289 enum bfa_fcs_lport_event event) 290{ 291 bfa_trc(port->fcs, port->port_cfg.pwwn); 292 bfa_trc(port->fcs, event); 293 294 switch (event) { 295 case BFA_FCS_PORT_SM_DELRPORT: 296 if (port->num_rports == 0) { 297 bfa_sm_set_state(port, bfa_fcs_lport_sm_init); 298 /* If vport - send completion call back */ 299 if (port->vport) 300 bfa_fcs_vport_stop_comp(port->vport); 301 else 302 bfa_wc_down(&(port->fabric->stop_wc)); 303 } 304 break; 305 306 default: 307 bfa_sm_fault(port->fcs, event); 308 } 309} 310 311static void 312bfa_fcs_lport_sm_deleting( 313 struct bfa_fcs_lport_s *port, 314 enum bfa_fcs_lport_event event) 315{ 316 bfa_trc(port->fcs, port->port_cfg.pwwn); 317 bfa_trc(port->fcs, event); 318 319 switch (event) { 320 case BFA_FCS_PORT_SM_DELRPORT: 321 if (port->num_rports == 0) { 322 bfa_sm_set_state(port, bfa_fcs_lport_sm_uninit); 323 bfa_fcs_lport_deleted(port); 324 } 325 break; 326 327 default: 328 bfa_sm_fault(port->fcs, event); 329 } 330} 331 332/* 333 * fcs_port_pvt 334 */ 335 336/* 337 * Send AEN notification 338 */ 339static void 340bfa_fcs_lport_aen_post(struct bfa_fcs_lport_s *port, 341 enum bfa_lport_aen_event event) 342{ 343 struct bfad_s *bfad = (struct bfad_s *)port->fabric->fcs->bfad; 344 struct bfa_aen_entry_s *aen_entry; 345 346 bfad_get_aen_entry(bfad, aen_entry); 347 if (!aen_entry) 348 return; 349 350 aen_entry->aen_data.lport.vf_id = port->fabric->vf_id; 351 aen_entry->aen_data.lport.roles = port->port_cfg.roles; 352 aen_entry->aen_data.lport.ppwwn = bfa_fcs_lport_get_pwwn( 353 bfa_fcs_get_base_port(port->fcs)); 354 aen_entry->aen_data.lport.lpwwn = bfa_fcs_lport_get_pwwn(port); 355 356 /* Send the AEN notification */ 357 bfad_im_post_vendor_event(aen_entry, bfad, ++port->fcs->fcs_aen_seq, 358 BFA_AEN_CAT_LPORT, event); 359} 360 361/* 362 * Send a LS reject 363 */ 364static void 365bfa_fcs_lport_send_ls_rjt(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs, 366 u8 reason_code, u8 reason_code_expl) 367{ 368 struct fchs_s fchs; 369 struct bfa_fcxp_s *fcxp; 370 struct bfa_rport_s *bfa_rport = NULL; 371 int len; 372 373 bfa_trc(port->fcs, rx_fchs->d_id); 374 bfa_trc(port->fcs, rx_fchs->s_id); 375 376 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 377 if (!fcxp) 378 return; 379 380 len = fc_ls_rjt_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 381 rx_fchs->s_id, bfa_fcs_lport_get_fcid(port), 382 rx_fchs->ox_id, reason_code, reason_code_expl); 383 384 bfa_fcxp_send(fcxp, bfa_rport, port->fabric->vf_id, port->lp_tag, 385 BFA_FALSE, FC_CLASS_3, len, &fchs, NULL, NULL, 386 FC_MAX_PDUSZ, 0); 387} 388 389/* 390 * Send a FCCT Reject 391 */ 392static void 393bfa_fcs_lport_send_fcgs_rjt(struct bfa_fcs_lport_s *port, 394 struct fchs_s *rx_fchs, u8 reason_code, u8 reason_code_expl) 395{ 396 struct fchs_s fchs; 397 struct bfa_fcxp_s *fcxp; 398 struct bfa_rport_s *bfa_rport = NULL; 399 int len; 400 struct ct_hdr_s *rx_cthdr = (struct ct_hdr_s *)(rx_fchs + 1); 401 struct ct_hdr_s *ct_hdr; 402 403 bfa_trc(port->fcs, rx_fchs->d_id); 404 bfa_trc(port->fcs, rx_fchs->s_id); 405 406 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 407 if (!fcxp) 408 return; 409 410 ct_hdr = bfa_fcxp_get_reqbuf(fcxp); 411 ct_hdr->gs_type = rx_cthdr->gs_type; 412 ct_hdr->gs_sub_type = rx_cthdr->gs_sub_type; 413 414 len = fc_gs_rjt_build(&fchs, ct_hdr, rx_fchs->s_id, 415 bfa_fcs_lport_get_fcid(port), 416 rx_fchs->ox_id, reason_code, reason_code_expl); 417 418 bfa_fcxp_send(fcxp, bfa_rport, port->fabric->vf_id, port->lp_tag, 419 BFA_FALSE, FC_CLASS_3, len, &fchs, NULL, NULL, 420 FC_MAX_PDUSZ, 0); 421} 422 423/* 424 * Process incoming plogi from a remote port. 425 */ 426static void 427bfa_fcs_lport_plogi(struct bfa_fcs_lport_s *port, 428 struct fchs_s *rx_fchs, struct fc_logi_s *plogi) 429{ 430 struct bfa_fcs_rport_s *rport; 431 432 bfa_trc(port->fcs, rx_fchs->d_id); 433 bfa_trc(port->fcs, rx_fchs->s_id); 434 435 /* 436 * If min cfg mode is enabled, drop any incoming PLOGIs 437 */ 438 if (__fcs_min_cfg(port->fcs)) { 439 bfa_trc(port->fcs, rx_fchs->s_id); 440 return; 441 } 442 443 if (fc_plogi_parse(rx_fchs) != FC_PARSE_OK) { 444 bfa_trc(port->fcs, rx_fchs->s_id); 445 /* 446 * send a LS reject 447 */ 448 bfa_fcs_lport_send_ls_rjt(port, rx_fchs, 449 FC_LS_RJT_RSN_PROTOCOL_ERROR, 450 FC_LS_RJT_EXP_SPARMS_ERR_OPTIONS); 451 return; 452 } 453 454 /* 455 * Direct Attach P2P mode : verify address assigned by the r-port. 456 */ 457 if ((!bfa_fcs_fabric_is_switched(port->fabric)) && 458 (memcmp((void *)&bfa_fcs_lport_get_pwwn(port), 459 (void *)&plogi->port_name, sizeof(wwn_t)) < 0)) { 460 if (BFA_FCS_PID_IS_WKA(rx_fchs->d_id)) { 461 /* Address assigned to us cannot be a WKA */ 462 bfa_fcs_lport_send_ls_rjt(port, rx_fchs, 463 FC_LS_RJT_RSN_PROTOCOL_ERROR, 464 FC_LS_RJT_EXP_INVALID_NPORT_ID); 465 return; 466 } 467 port->pid = rx_fchs->d_id; 468 bfa_lps_set_n2n_pid(port->fabric->lps, rx_fchs->d_id); 469 } 470 471 /* 472 * First, check if we know the device by pwwn. 473 */ 474 rport = bfa_fcs_lport_get_rport_by_pwwn(port, plogi->port_name); 475 if (rport) { 476 /* 477 * Direct Attach P2P mode : handle address assigned by r-port. 478 */ 479 if ((!bfa_fcs_fabric_is_switched(port->fabric)) && 480 (memcmp((void *)&bfa_fcs_lport_get_pwwn(port), 481 (void *)&plogi->port_name, sizeof(wwn_t)) < 0)) { 482 port->pid = rx_fchs->d_id; 483 bfa_lps_set_n2n_pid(port->fabric->lps, rx_fchs->d_id); 484 rport->pid = rx_fchs->s_id; 485 } 486 bfa_fcs_rport_plogi(rport, rx_fchs, plogi); 487 return; 488 } 489 490 /* 491 * Next, lookup rport by PID. 492 */ 493 rport = bfa_fcs_lport_get_rport_by_pid(port, rx_fchs->s_id); 494 if (!rport) { 495 /* 496 * Inbound PLOGI from a new device. 497 */ 498 bfa_fcs_rport_plogi_create(port, rx_fchs, plogi); 499 return; 500 } 501 502 /* 503 * Rport is known only by PID. 504 */ 505 if (rport->pwwn) { 506 /* 507 * This is a different device with the same pid. Old device 508 * disappeared. Send implicit LOGO to old device. 509 */ 510 WARN_ON(rport->pwwn == plogi->port_name); 511 bfa_sm_send_event(rport, RPSM_EVENT_LOGO_IMP); 512 513 /* 514 * Inbound PLOGI from a new device (with old PID). 515 */ 516 bfa_fcs_rport_plogi_create(port, rx_fchs, plogi); 517 return; 518 } 519 520 /* 521 * PLOGI crossing each other. 522 */ 523 WARN_ON(rport->pwwn != WWN_NULL); 524 bfa_fcs_rport_plogi(rport, rx_fchs, plogi); 525} 526 527/* 528 * Process incoming ECHO. 529 * Since it does not require a login, it is processed here. 530 */ 531static void 532bfa_fcs_lport_echo(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs, 533 struct fc_echo_s *echo, u16 rx_len) 534{ 535 struct fchs_s fchs; 536 struct bfa_fcxp_s *fcxp; 537 struct bfa_rport_s *bfa_rport = NULL; 538 int len, pyld_len; 539 540 bfa_trc(port->fcs, rx_fchs->s_id); 541 bfa_trc(port->fcs, rx_fchs->d_id); 542 543 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 544 if (!fcxp) 545 return; 546 547 len = fc_ls_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 548 rx_fchs->s_id, bfa_fcs_lport_get_fcid(port), 549 rx_fchs->ox_id); 550 551 /* 552 * Copy the payload (if any) from the echo frame 553 */ 554 pyld_len = rx_len - sizeof(struct fchs_s); 555 bfa_trc(port->fcs, rx_len); 556 bfa_trc(port->fcs, pyld_len); 557 558 if (pyld_len > len) 559 memcpy(((u8 *) bfa_fcxp_get_reqbuf(fcxp)) + 560 sizeof(struct fc_echo_s), (echo + 1), 561 (pyld_len - sizeof(struct fc_echo_s))); 562 563 bfa_fcxp_send(fcxp, bfa_rport, port->fabric->vf_id, port->lp_tag, 564 BFA_FALSE, FC_CLASS_3, pyld_len, &fchs, NULL, NULL, 565 FC_MAX_PDUSZ, 0); 566} 567 568/* 569 * Process incoming RNID. 570 * Since it does not require a login, it is processed here. 571 */ 572static void 573bfa_fcs_lport_rnid(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs, 574 struct fc_rnid_cmd_s *rnid, u16 rx_len) 575{ 576 struct fc_rnid_common_id_data_s common_id_data; 577 struct fc_rnid_general_topology_data_s gen_topo_data; 578 struct fchs_s fchs; 579 struct bfa_fcxp_s *fcxp; 580 struct bfa_rport_s *bfa_rport = NULL; 581 u16 len; 582 u32 data_format; 583 584 bfa_trc(port->fcs, rx_fchs->s_id); 585 bfa_trc(port->fcs, rx_fchs->d_id); 586 bfa_trc(port->fcs, rx_len); 587 588 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 589 if (!fcxp) 590 return; 591 592 /* 593 * Check Node Indentification Data Format 594 * We only support General Topology Discovery Format. 595 * For any other requested Data Formats, we return Common Node Id Data 596 * only, as per FC-LS. 597 */ 598 bfa_trc(port->fcs, rnid->node_id_data_format); 599 if (rnid->node_id_data_format == RNID_NODEID_DATA_FORMAT_DISCOVERY) { 600 data_format = RNID_NODEID_DATA_FORMAT_DISCOVERY; 601 /* 602 * Get General topology data for this port 603 */ 604 bfa_fs_port_get_gen_topo_data(port, &gen_topo_data); 605 } else { 606 data_format = RNID_NODEID_DATA_FORMAT_COMMON; 607 } 608 609 /* 610 * Copy the Node Id Info 611 */ 612 common_id_data.port_name = bfa_fcs_lport_get_pwwn(port); 613 common_id_data.node_name = bfa_fcs_lport_get_nwwn(port); 614 615 len = fc_rnid_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 616 rx_fchs->s_id, bfa_fcs_lport_get_fcid(port), 617 rx_fchs->ox_id, data_format, &common_id_data, 618 &gen_topo_data); 619 620 bfa_fcxp_send(fcxp, bfa_rport, port->fabric->vf_id, port->lp_tag, 621 BFA_FALSE, FC_CLASS_3, len, &fchs, NULL, NULL, 622 FC_MAX_PDUSZ, 0); 623} 624 625/* 626 * Fill out General Topolpgy Discovery Data for RNID ELS. 627 */ 628static void 629bfa_fs_port_get_gen_topo_data(struct bfa_fcs_lport_s *port, 630 struct fc_rnid_general_topology_data_s *gen_topo_data) 631{ 632 memset(gen_topo_data, 0, 633 sizeof(struct fc_rnid_general_topology_data_s)); 634 635 gen_topo_data->asso_type = cpu_to_be32(RNID_ASSOCIATED_TYPE_HOST); 636 gen_topo_data->phy_port_num = 0; /* @todo */ 637 gen_topo_data->num_attached_nodes = cpu_to_be32(1); 638} 639 640static void 641bfa_fcs_lport_online_actions(struct bfa_fcs_lport_s *port) 642{ 643 struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad; 644 char lpwwn_buf[BFA_STRING_32]; 645 646 bfa_trc(port->fcs, port->fabric->oper_type); 647 648 __port_action[port->fabric->fab_type].init(port); 649 __port_action[port->fabric->fab_type].online(port); 650 651 wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port)); 652 BFA_LOG(KERN_WARNING, bfad, bfa_log_level, 653 "Logical port online: WWN = %s Role = %s\n", 654 lpwwn_buf, "Initiator"); 655 bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_ONLINE); 656 657 bfad->bfad_flags |= BFAD_PORT_ONLINE; 658} 659 660static void 661bfa_fcs_lport_offline_actions(struct bfa_fcs_lport_s *port) 662{ 663 struct list_head *qe, *qen; 664 struct bfa_fcs_rport_s *rport; 665 struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad; 666 char lpwwn_buf[BFA_STRING_32]; 667 668 bfa_trc(port->fcs, port->fabric->oper_type); 669 670 __port_action[port->fabric->fab_type].offline(port); 671 672 wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port)); 673 if (bfa_sm_cmp_state(port->fabric, 674 bfa_fcs_fabric_sm_online) == BFA_TRUE) { 675 BFA_LOG(KERN_WARNING, bfad, bfa_log_level, 676 "Logical port lost fabric connectivity: WWN = %s Role = %s\n", 677 lpwwn_buf, "Initiator"); 678 bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_DISCONNECT); 679 } else { 680 BFA_LOG(KERN_WARNING, bfad, bfa_log_level, 681 "Logical port taken offline: WWN = %s Role = %s\n", 682 lpwwn_buf, "Initiator"); 683 bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_OFFLINE); 684 } 685 686 list_for_each_safe(qe, qen, &port->rport_q) { 687 rport = (struct bfa_fcs_rport_s *) qe; 688 bfa_sm_send_event(rport, RPSM_EVENT_LOGO_IMP); 689 } 690} 691 692static void 693bfa_fcs_lport_unknown_init(struct bfa_fcs_lport_s *port) 694{ 695 WARN_ON(1); 696} 697 698static void 699bfa_fcs_lport_unknown_online(struct bfa_fcs_lport_s *port) 700{ 701 WARN_ON(1); 702} 703 704static void 705bfa_fcs_lport_unknown_offline(struct bfa_fcs_lport_s *port) 706{ 707 WARN_ON(1); 708} 709 710static void 711bfa_fcs_lport_abts_acc(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs) 712{ 713 struct fchs_s fchs; 714 struct bfa_fcxp_s *fcxp; 715 int len; 716 717 bfa_trc(port->fcs, rx_fchs->d_id); 718 bfa_trc(port->fcs, rx_fchs->s_id); 719 720 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 721 if (!fcxp) 722 return; 723 724 len = fc_ba_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 725 rx_fchs->s_id, bfa_fcs_lport_get_fcid(port), 726 rx_fchs->ox_id, 0); 727 728 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, 729 BFA_FALSE, FC_CLASS_3, len, &fchs, NULL, NULL, 730 FC_MAX_PDUSZ, 0); 731} 732static void 733bfa_fcs_lport_deleted(struct bfa_fcs_lport_s *port) 734{ 735 struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad; 736 char lpwwn_buf[BFA_STRING_32]; 737 738 wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port)); 739 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 740 "Logical port deleted: WWN = %s Role = %s\n", 741 lpwwn_buf, "Initiator"); 742 bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_DELETE); 743 744 /* Base port will be deleted by the OS driver */ 745 if (port->vport) 746 bfa_fcs_vport_delete_comp(port->vport); 747 else 748 bfa_wc_down(&port->fabric->wc); 749} 750 751 752/* 753 * Unsolicited frame receive handling. 754 */ 755void 756bfa_fcs_lport_uf_recv(struct bfa_fcs_lport_s *lport, 757 struct fchs_s *fchs, u16 len) 758{ 759 u32 pid = fchs->s_id; 760 struct bfa_fcs_rport_s *rport = NULL; 761 struct fc_els_cmd_s *els_cmd = (struct fc_els_cmd_s *) (fchs + 1); 762 763 bfa_stats(lport, uf_recvs); 764 bfa_trc(lport->fcs, fchs->type); 765 766 if (!bfa_fcs_lport_is_online(lport)) { 767 /* 768 * In direct attach topology, it is possible to get a PLOGI 769 * before the lport is online due to port feature 770 * (QoS/Trunk/FEC/CR), so send a rjt 771 */ 772 if ((fchs->type == FC_TYPE_ELS) && 773 (els_cmd->els_code == FC_ELS_PLOGI)) { 774 bfa_fcs_lport_send_ls_rjt(lport, fchs, 775 FC_LS_RJT_RSN_UNABLE_TO_PERF_CMD, 776 FC_LS_RJT_EXP_NO_ADDL_INFO); 777 bfa_stats(lport, plogi_rcvd); 778 } else 779 bfa_stats(lport, uf_recv_drops); 780 781 return; 782 } 783 784 /* 785 * First, handle ELSs that donot require a login. 786 */ 787 /* 788 * Handle PLOGI first 789 */ 790 if ((fchs->type == FC_TYPE_ELS) && 791 (els_cmd->els_code == FC_ELS_PLOGI)) { 792 bfa_fcs_lport_plogi(lport, fchs, (struct fc_logi_s *) els_cmd); 793 return; 794 } 795 796 /* 797 * Handle ECHO separately. 798 */ 799 if ((fchs->type == FC_TYPE_ELS) && (els_cmd->els_code == FC_ELS_ECHO)) { 800 bfa_fcs_lport_echo(lport, fchs, 801 (struct fc_echo_s *)els_cmd, len); 802 return; 803 } 804 805 /* 806 * Handle RNID separately. 807 */ 808 if ((fchs->type == FC_TYPE_ELS) && (els_cmd->els_code == FC_ELS_RNID)) { 809 bfa_fcs_lport_rnid(lport, fchs, 810 (struct fc_rnid_cmd_s *) els_cmd, len); 811 return; 812 } 813 814 if (fchs->type == FC_TYPE_BLS) { 815 if ((fchs->routing == FC_RTG_BASIC_LINK) && 816 (fchs->cat_info == FC_CAT_ABTS)) 817 bfa_fcs_lport_abts_acc(lport, fchs); 818 return; 819 } 820 821 if (fchs->type == FC_TYPE_SERVICES) { 822 /* 823 * Unhandled FC-GS frames. Send a FC-CT Reject 824 */ 825 bfa_fcs_lport_send_fcgs_rjt(lport, fchs, CT_RSN_NOT_SUPP, 826 CT_NS_EXP_NOADDITIONAL); 827 return; 828 } 829 830 /* 831 * look for a matching remote port ID 832 */ 833 rport = bfa_fcs_lport_get_rport_by_pid(lport, pid); 834 if (rport) { 835 bfa_trc(rport->fcs, fchs->s_id); 836 bfa_trc(rport->fcs, fchs->d_id); 837 bfa_trc(rport->fcs, fchs->type); 838 839 bfa_fcs_rport_uf_recv(rport, fchs, len); 840 return; 841 } 842 843 /* 844 * Only handles ELS frames for now. 845 */ 846 if (fchs->type != FC_TYPE_ELS) { 847 bfa_trc(lport->fcs, fchs->s_id); 848 bfa_trc(lport->fcs, fchs->d_id); 849 /* ignore type FC_TYPE_FC_FSS */ 850 if (fchs->type != FC_TYPE_FC_FSS) 851 bfa_sm_fault(lport->fcs, fchs->type); 852 return; 853 } 854 855 bfa_trc(lport->fcs, els_cmd->els_code); 856 if (els_cmd->els_code == FC_ELS_RSCN) { 857 bfa_fcs_lport_scn_process_rscn(lport, fchs, len); 858 return; 859 } 860 861 if (els_cmd->els_code == FC_ELS_LOGO) { 862 /* 863 * @todo Handle LOGO frames received. 864 */ 865 return; 866 } 867 868 if (els_cmd->els_code == FC_ELS_PRLI) { 869 /* 870 * @todo Handle PRLI frames received. 871 */ 872 return; 873 } 874 875 /* 876 * Unhandled ELS frames. Send a LS_RJT. 877 */ 878 bfa_fcs_lport_send_ls_rjt(lport, fchs, FC_LS_RJT_RSN_CMD_NOT_SUPP, 879 FC_LS_RJT_EXP_NO_ADDL_INFO); 880 881} 882 883/* 884 * PID based Lookup for a R-Port in the Port R-Port Queue 885 */ 886struct bfa_fcs_rport_s * 887bfa_fcs_lport_get_rport_by_pid(struct bfa_fcs_lport_s *port, u32 pid) 888{ 889 struct bfa_fcs_rport_s *rport; 890 struct list_head *qe; 891 892 list_for_each(qe, &port->rport_q) { 893 rport = (struct bfa_fcs_rport_s *) qe; 894 if (rport->pid == pid) 895 return rport; 896 } 897 898 bfa_trc(port->fcs, pid); 899 return NULL; 900} 901 902/* 903 * OLD_PID based Lookup for a R-Port in the Port R-Port Queue 904 */ 905struct bfa_fcs_rport_s * 906bfa_fcs_lport_get_rport_by_old_pid(struct bfa_fcs_lport_s *port, u32 pid) 907{ 908 struct bfa_fcs_rport_s *rport; 909 struct list_head *qe; 910 911 list_for_each(qe, &port->rport_q) { 912 rport = (struct bfa_fcs_rport_s *) qe; 913 if (rport->old_pid == pid) 914 return rport; 915 } 916 917 bfa_trc(port->fcs, pid); 918 return NULL; 919} 920 921/* 922 * PWWN based Lookup for a R-Port in the Port R-Port Queue 923 */ 924struct bfa_fcs_rport_s * 925bfa_fcs_lport_get_rport_by_pwwn(struct bfa_fcs_lport_s *port, wwn_t pwwn) 926{ 927 struct bfa_fcs_rport_s *rport; 928 struct list_head *qe; 929 930 list_for_each(qe, &port->rport_q) { 931 rport = (struct bfa_fcs_rport_s *) qe; 932 if (wwn_is_equal(rport->pwwn, pwwn)) 933 return rport; 934 } 935 936 bfa_trc(port->fcs, pwwn); 937 return NULL; 938} 939 940/* 941 * NWWN based Lookup for a R-Port in the Port R-Port Queue 942 */ 943struct bfa_fcs_rport_s * 944bfa_fcs_lport_get_rport_by_nwwn(struct bfa_fcs_lport_s *port, wwn_t nwwn) 945{ 946 struct bfa_fcs_rport_s *rport; 947 struct list_head *qe; 948 949 list_for_each(qe, &port->rport_q) { 950 rport = (struct bfa_fcs_rport_s *) qe; 951 if (wwn_is_equal(rport->nwwn, nwwn)) 952 return rport; 953 } 954 955 bfa_trc(port->fcs, nwwn); 956 return NULL; 957} 958 959/* 960 * PWWN & PID based Lookup for a R-Port in the Port R-Port Queue 961 */ 962struct bfa_fcs_rport_s * 963bfa_fcs_lport_get_rport_by_qualifier(struct bfa_fcs_lport_s *port, 964 wwn_t pwwn, u32 pid) 965{ 966 struct bfa_fcs_rport_s *rport; 967 struct list_head *qe; 968 969 list_for_each(qe, &port->rport_q) { 970 rport = (struct bfa_fcs_rport_s *) qe; 971 if (wwn_is_equal(rport->pwwn, pwwn) && rport->pid == pid) 972 return rport; 973 } 974 975 bfa_trc(port->fcs, pwwn); 976 return NULL; 977} 978 979/* 980 * Called by rport module when new rports are discovered. 981 */ 982void 983bfa_fcs_lport_add_rport( 984 struct bfa_fcs_lport_s *port, 985 struct bfa_fcs_rport_s *rport) 986{ 987 list_add_tail(&rport->qe, &port->rport_q); 988 port->num_rports++; 989} 990 991/* 992 * Called by rport module to when rports are deleted. 993 */ 994void 995bfa_fcs_lport_del_rport( 996 struct bfa_fcs_lport_s *port, 997 struct bfa_fcs_rport_s *rport) 998{ 999 WARN_ON(!bfa_q_is_on_q(&port->rport_q, rport)); 1000 list_del(&rport->qe); 1001 port->num_rports--; 1002 1003 bfa_sm_send_event(port, BFA_FCS_PORT_SM_DELRPORT); 1004} 1005 1006/* 1007 * Called by fabric for base port when fabric login is complete. 1008 * Called by vport for virtual ports when FDISC is complete. 1009 */ 1010void 1011bfa_fcs_lport_online(struct bfa_fcs_lport_s *port) 1012{ 1013 bfa_sm_send_event(port, BFA_FCS_PORT_SM_ONLINE); 1014} 1015 1016/* 1017 * Called by fabric for base port when fabric goes offline. 1018 * Called by vport for virtual ports when virtual port becomes offline. 1019 */ 1020void 1021bfa_fcs_lport_offline(struct bfa_fcs_lport_s *port) 1022{ 1023 bfa_sm_send_event(port, BFA_FCS_PORT_SM_OFFLINE); 1024} 1025 1026/* 1027 * Called by fabric for base port and by vport for virtual ports 1028 * when target mode driver is unloaded. 1029 */ 1030void 1031bfa_fcs_lport_stop(struct bfa_fcs_lport_s *port) 1032{ 1033 bfa_sm_send_event(port, BFA_FCS_PORT_SM_STOP); 1034} 1035 1036/* 1037 * Called by fabric to delete base lport and associated resources. 1038 * 1039 * Called by vport to delete lport and associated resources. Should call 1040 * bfa_fcs_vport_delete_comp() for vports on completion. 1041 */ 1042void 1043bfa_fcs_lport_delete(struct bfa_fcs_lport_s *port) 1044{ 1045 bfa_sm_send_event(port, BFA_FCS_PORT_SM_DELETE); 1046} 1047 1048/* 1049 * Return TRUE if port is online, else return FALSE 1050 */ 1051bfa_boolean_t 1052bfa_fcs_lport_is_online(struct bfa_fcs_lport_s *port) 1053{ 1054 return bfa_sm_cmp_state(port, bfa_fcs_lport_sm_online); 1055} 1056 1057/* 1058 * Attach time initialization of logical ports. 1059 */ 1060void 1061bfa_fcs_lport_attach(struct bfa_fcs_lport_s *lport, struct bfa_fcs_s *fcs, 1062 u16 vf_id, struct bfa_fcs_vport_s *vport) 1063{ 1064 lport->fcs = fcs; 1065 lport->fabric = bfa_fcs_vf_lookup(fcs, vf_id); 1066 lport->vport = vport; 1067 lport->lp_tag = (vport) ? vport->lps->bfa_tag : 1068 lport->fabric->lps->bfa_tag; 1069 1070 INIT_LIST_HEAD(&lport->rport_q); 1071 lport->num_rports = 0; 1072} 1073 1074/* 1075 * Logical port initialization of base or virtual port. 1076 * Called by fabric for base port or by vport for virtual ports. 1077 */ 1078 1079void 1080bfa_fcs_lport_init(struct bfa_fcs_lport_s *lport, 1081 struct bfa_lport_cfg_s *port_cfg) 1082{ 1083 struct bfa_fcs_vport_s *vport = lport->vport; 1084 struct bfad_s *bfad = (struct bfad_s *)lport->fcs->bfad; 1085 char lpwwn_buf[BFA_STRING_32]; 1086 1087 lport->port_cfg = *port_cfg; 1088 1089 lport->bfad_port = bfa_fcb_lport_new(lport->fcs->bfad, lport, 1090 lport->port_cfg.roles, 1091 lport->fabric->vf_drv, 1092 vport ? vport->vport_drv : NULL); 1093 1094 wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(lport)); 1095 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 1096 "New logical port created: WWN = %s Role = %s\n", 1097 lpwwn_buf, "Initiator"); 1098 bfa_fcs_lport_aen_post(lport, BFA_LPORT_AEN_NEW); 1099 1100 bfa_sm_set_state(lport, bfa_fcs_lport_sm_uninit); 1101 bfa_sm_send_event(lport, BFA_FCS_PORT_SM_CREATE); 1102} 1103 1104void 1105bfa_fcs_lport_set_symname(struct bfa_fcs_lport_s *port, 1106 char *symname) 1107{ 1108 strcpy(port->port_cfg.sym_name.symname, symname); 1109 1110 if (bfa_sm_cmp_state(port, bfa_fcs_lport_sm_online)) 1111 bfa_fcs_lport_ns_util_send_rspn_id( 1112 BFA_FCS_GET_NS_FROM_PORT(port), NULL); 1113} 1114 1115/* 1116 * fcs_lport_api 1117 */ 1118 1119void 1120bfa_fcs_lport_get_attr( 1121 struct bfa_fcs_lport_s *port, 1122 struct bfa_lport_attr_s *port_attr) 1123{ 1124 if (bfa_sm_cmp_state(port, bfa_fcs_lport_sm_online)) 1125 port_attr->pid = port->pid; 1126 else 1127 port_attr->pid = 0; 1128 1129 port_attr->port_cfg = port->port_cfg; 1130 1131 if (port->fabric) { 1132 port_attr->port_type = port->fabric->oper_type; 1133 port_attr->loopback = bfa_sm_cmp_state(port->fabric, 1134 bfa_fcs_fabric_sm_loopback); 1135 port_attr->authfail = 1136 bfa_sm_cmp_state(port->fabric, 1137 bfa_fcs_fabric_sm_auth_failed); 1138 port_attr->fabric_name = bfa_fcs_lport_get_fabric_name(port); 1139 memcpy(port_attr->fabric_ip_addr, 1140 bfa_fcs_lport_get_fabric_ipaddr(port), 1141 BFA_FCS_FABRIC_IPADDR_SZ); 1142 1143 if (port->vport != NULL) { 1144 port_attr->port_type = BFA_PORT_TYPE_VPORT; 1145 port_attr->fpma_mac = 1146 port->vport->lps->lp_mac; 1147 } else { 1148 port_attr->fpma_mac = 1149 port->fabric->lps->lp_mac; 1150 } 1151 } else { 1152 port_attr->port_type = BFA_PORT_TYPE_UNKNOWN; 1153 port_attr->state = BFA_LPORT_UNINIT; 1154 } 1155} 1156 1157/* 1158 * bfa_fcs_lport_fab port fab functions 1159 */ 1160 1161/* 1162 * Called by port to initialize fabric services of the base port. 1163 */ 1164static void 1165bfa_fcs_lport_fab_init(struct bfa_fcs_lport_s *port) 1166{ 1167 bfa_fcs_lport_ns_init(port); 1168 bfa_fcs_lport_scn_init(port); 1169 bfa_fcs_lport_ms_init(port); 1170} 1171 1172/* 1173 * Called by port to notify transition to online state. 1174 */ 1175static void 1176bfa_fcs_lport_fab_online(struct bfa_fcs_lport_s *port) 1177{ 1178 bfa_fcs_lport_ns_online(port); 1179 bfa_fcs_lport_fab_scn_online(port); 1180} 1181 1182/* 1183 * Called by port to notify transition to offline state. 1184 */ 1185static void 1186bfa_fcs_lport_fab_offline(struct bfa_fcs_lport_s *port) 1187{ 1188 bfa_fcs_lport_ns_offline(port); 1189 bfa_fcs_lport_scn_offline(port); 1190 bfa_fcs_lport_ms_offline(port); 1191} 1192 1193/* 1194 * bfa_fcs_lport_n2n functions 1195 */ 1196 1197/* 1198 * Called by fcs/port to initialize N2N topology. 1199 */ 1200static void 1201bfa_fcs_lport_n2n_init(struct bfa_fcs_lport_s *port) 1202{ 1203} 1204 1205/* 1206 * Called by fcs/port to notify transition to online state. 1207 */ 1208static void 1209bfa_fcs_lport_n2n_online(struct bfa_fcs_lport_s *port) 1210{ 1211 struct bfa_fcs_lport_n2n_s *n2n_port = &port->port_topo.pn2n; 1212 struct bfa_lport_cfg_s *pcfg = &port->port_cfg; 1213 struct bfa_fcs_rport_s *rport; 1214 1215 bfa_trc(port->fcs, pcfg->pwwn); 1216 1217 /* 1218 * If our PWWN is > than that of the r-port, we have to initiate PLOGI 1219 * and assign an Address. if not, we need to wait for its PLOGI. 1220 * 1221 * If our PWWN is < than that of the remote port, it will send a PLOGI 1222 * with the PIDs assigned. The rport state machine take care of this 1223 * incoming PLOGI. 1224 */ 1225 if (memcmp 1226 ((void *)&pcfg->pwwn, (void *)&n2n_port->rem_port_wwn, 1227 sizeof(wwn_t)) > 0) { 1228 port->pid = N2N_LOCAL_PID; 1229 bfa_lps_set_n2n_pid(port->fabric->lps, N2N_LOCAL_PID); 1230 /* 1231 * First, check if we know the device by pwwn. 1232 */ 1233 rport = bfa_fcs_lport_get_rport_by_pwwn(port, 1234 n2n_port->rem_port_wwn); 1235 if (rport) { 1236 bfa_trc(port->fcs, rport->pid); 1237 bfa_trc(port->fcs, rport->pwwn); 1238 rport->pid = N2N_REMOTE_PID; 1239 bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_SEND); 1240 return; 1241 } 1242 1243 /* 1244 * In n2n there can be only one rport. Delete the old one 1245 * whose pid should be zero, because it is offline. 1246 */ 1247 if (port->num_rports > 0) { 1248 rport = bfa_fcs_lport_get_rport_by_pid(port, 0); 1249 WARN_ON(rport == NULL); 1250 if (rport) { 1251 bfa_trc(port->fcs, rport->pwwn); 1252 bfa_sm_send_event(rport, RPSM_EVENT_DELETE); 1253 } 1254 } 1255 bfa_fcs_rport_create(port, N2N_REMOTE_PID); 1256 } 1257} 1258 1259/* 1260 * Called by fcs/port to notify transition to offline state. 1261 */ 1262static void 1263bfa_fcs_lport_n2n_offline(struct bfa_fcs_lport_s *port) 1264{ 1265 struct bfa_fcs_lport_n2n_s *n2n_port = &port->port_topo.pn2n; 1266 1267 bfa_trc(port->fcs, port->pid); 1268 port->pid = 0; 1269 n2n_port->rem_port_wwn = 0; 1270 n2n_port->reply_oxid = 0; 1271} 1272 1273static void 1274bfa_fcport_get_loop_attr(struct bfa_fcs_lport_s *port) 1275{ 1276 int i = 0, j = 0, bit = 0, alpa_bit = 0; 1277 u8 k = 0; 1278 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(port->fcs->bfa); 1279 1280 port->port_topo.ploop.alpabm_valid = fcport->alpabm_valid; 1281 port->pid = fcport->myalpa; 1282 port->pid = bfa_hton3b(port->pid); 1283 1284 for (i = 0; i < (FC_ALPA_MAX / 8); i++) { 1285 for (j = 0, alpa_bit = 0; j < 8; j++, alpa_bit++) { 1286 bfa_trc(port->fcs->bfa, fcport->alpabm.alpa_bm[i]); 1287 bit = (fcport->alpabm.alpa_bm[i] & (1 << (7 - j))); 1288 if (bit) { 1289 port->port_topo.ploop.alpa_pos_map[k] = 1290 loop_alpa_map[(i * 8) + alpa_bit]; 1291 k++; 1292 bfa_trc(port->fcs->bfa, k); 1293 bfa_trc(port->fcs->bfa, 1294 port->port_topo.ploop.alpa_pos_map[k]); 1295 } 1296 } 1297 } 1298 port->port_topo.ploop.num_alpa = k; 1299} 1300 1301/* 1302 * Called by fcs/port to initialize Loop topology. 1303 */ 1304static void 1305bfa_fcs_lport_loop_init(struct bfa_fcs_lport_s *port) 1306{ 1307} 1308 1309/* 1310 * Called by fcs/port to notify transition to online state. 1311 */ 1312static void 1313bfa_fcs_lport_loop_online(struct bfa_fcs_lport_s *port) 1314{ 1315 u8 num_alpa = 0, alpabm_valid = 0; 1316 struct bfa_fcs_rport_s *rport; 1317 u8 *alpa_map = NULL; 1318 int i = 0; 1319 u32 pid; 1320 1321 bfa_fcport_get_loop_attr(port); 1322 1323 num_alpa = port->port_topo.ploop.num_alpa; 1324 alpabm_valid = port->port_topo.ploop.alpabm_valid; 1325 alpa_map = port->port_topo.ploop.alpa_pos_map; 1326 1327 bfa_trc(port->fcs->bfa, port->pid); 1328 bfa_trc(port->fcs->bfa, num_alpa); 1329 if (alpabm_valid == 1) { 1330 for (i = 0; i < num_alpa; i++) { 1331 bfa_trc(port->fcs->bfa, alpa_map[i]); 1332 if (alpa_map[i] != bfa_hton3b(port->pid)) { 1333 pid = alpa_map[i]; 1334 bfa_trc(port->fcs->bfa, pid); 1335 rport = bfa_fcs_lport_get_rport_by_pid(port, 1336 bfa_hton3b(pid)); 1337 if (!rport) 1338 rport = bfa_fcs_rport_create(port, 1339 bfa_hton3b(pid)); 1340 } 1341 } 1342 } else { 1343 for (i = 0; i < MAX_ALPA_COUNT; i++) { 1344 if (alpa_map[i] != port->pid) { 1345 pid = loop_alpa_map[i]; 1346 bfa_trc(port->fcs->bfa, pid); 1347 rport = bfa_fcs_lport_get_rport_by_pid(port, 1348 bfa_hton3b(pid)); 1349 if (!rport) 1350 rport = bfa_fcs_rport_create(port, 1351 bfa_hton3b(pid)); 1352 } 1353 } 1354 } 1355} 1356 1357/* 1358 * Called by fcs/port to notify transition to offline state. 1359 */ 1360static void 1361bfa_fcs_lport_loop_offline(struct bfa_fcs_lport_s *port) 1362{ 1363} 1364 1365#define BFA_FCS_FDMI_CMD_MAX_RETRIES 2 1366 1367/* 1368 * forward declarations 1369 */ 1370static void bfa_fcs_lport_fdmi_send_rhba(void *fdmi_cbarg, 1371 struct bfa_fcxp_s *fcxp_alloced); 1372static void bfa_fcs_lport_fdmi_send_rprt(void *fdmi_cbarg, 1373 struct bfa_fcxp_s *fcxp_alloced); 1374static void bfa_fcs_lport_fdmi_send_rpa(void *fdmi_cbarg, 1375 struct bfa_fcxp_s *fcxp_alloced); 1376static void bfa_fcs_lport_fdmi_rhba_response(void *fcsarg, 1377 struct bfa_fcxp_s *fcxp, 1378 void *cbarg, 1379 bfa_status_t req_status, 1380 u32 rsp_len, 1381 u32 resid_len, 1382 struct fchs_s *rsp_fchs); 1383static void bfa_fcs_lport_fdmi_rprt_response(void *fcsarg, 1384 struct bfa_fcxp_s *fcxp, 1385 void *cbarg, 1386 bfa_status_t req_status, 1387 u32 rsp_len, 1388 u32 resid_len, 1389 struct fchs_s *rsp_fchs); 1390static void bfa_fcs_lport_fdmi_rpa_response(void *fcsarg, 1391 struct bfa_fcxp_s *fcxp, 1392 void *cbarg, 1393 bfa_status_t req_status, 1394 u32 rsp_len, 1395 u32 resid_len, 1396 struct fchs_s *rsp_fchs); 1397static void bfa_fcs_lport_fdmi_timeout(void *arg); 1398static int bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, 1399 u8 *pyld); 1400static u16 bfa_fcs_lport_fdmi_build_rprt_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, 1401 u8 *pyld); 1402static u16 bfa_fcs_lport_fdmi_build_rpa_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, 1403 u8 *pyld); 1404static u16 bfa_fcs_lport_fdmi_build_portattr_block(struct bfa_fcs_lport_fdmi_s * 1405 fdmi, u8 *pyld); 1406static void bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_lport_fdmi_s *fdmi, 1407 struct bfa_fcs_fdmi_hba_attr_s *hba_attr); 1408static void bfa_fcs_fdmi_get_portattr(struct bfa_fcs_lport_fdmi_s *fdmi, 1409 struct bfa_fcs_fdmi_port_attr_s *port_attr); 1410u32 bfa_fcs_fdmi_convert_speed(enum bfa_port_speed pport_speed); 1411 1412/* 1413 * fcs_fdmi_sm FCS FDMI state machine 1414 */ 1415 1416static void bfa_fcs_lport_fdmi_sm_offline(struct bfa_fcs_lport_fdmi_s *fdmi, 1417 enum port_fdmi_event event); 1418static void bfa_fcs_lport_fdmi_sm_sending_rhba( 1419 struct bfa_fcs_lport_fdmi_s *fdmi, 1420 enum port_fdmi_event event); 1421static void bfa_fcs_lport_fdmi_sm_rhba(struct bfa_fcs_lport_fdmi_s *fdmi, 1422 enum port_fdmi_event event); 1423static void bfa_fcs_lport_fdmi_sm_rhba_retry( 1424 struct bfa_fcs_lport_fdmi_s *fdmi, 1425 enum port_fdmi_event event); 1426static void bfa_fcs_lport_fdmi_sm_sending_rprt( 1427 struct bfa_fcs_lport_fdmi_s *fdmi, 1428 enum port_fdmi_event event); 1429static void bfa_fcs_lport_fdmi_sm_rprt(struct bfa_fcs_lport_fdmi_s *fdmi, 1430 enum port_fdmi_event event); 1431static void bfa_fcs_lport_fdmi_sm_rprt_retry( 1432 struct bfa_fcs_lport_fdmi_s *fdmi, 1433 enum port_fdmi_event event); 1434static void bfa_fcs_lport_fdmi_sm_sending_rpa( 1435 struct bfa_fcs_lport_fdmi_s *fdmi, 1436 enum port_fdmi_event event); 1437static void bfa_fcs_lport_fdmi_sm_rpa(struct bfa_fcs_lport_fdmi_s *fdmi, 1438 enum port_fdmi_event event); 1439static void bfa_fcs_lport_fdmi_sm_rpa_retry( 1440 struct bfa_fcs_lport_fdmi_s *fdmi, 1441 enum port_fdmi_event event); 1442static void bfa_fcs_lport_fdmi_sm_online(struct bfa_fcs_lport_fdmi_s *fdmi, 1443 enum port_fdmi_event event); 1444static void bfa_fcs_lport_fdmi_sm_disabled( 1445 struct bfa_fcs_lport_fdmi_s *fdmi, 1446 enum port_fdmi_event event); 1447/* 1448 * Start in offline state - awaiting MS to send start. 1449 */ 1450static void 1451bfa_fcs_lport_fdmi_sm_offline(struct bfa_fcs_lport_fdmi_s *fdmi, 1452 enum port_fdmi_event event) 1453{ 1454 struct bfa_fcs_lport_s *port = fdmi->ms->port; 1455 1456 bfa_trc(port->fcs, port->port_cfg.pwwn); 1457 bfa_trc(port->fcs, event); 1458 1459 fdmi->retry_cnt = 0; 1460 1461 switch (event) { 1462 case FDMISM_EVENT_PORT_ONLINE: 1463 if (port->vport) { 1464 /* 1465 * For Vports, register a new port. 1466 */ 1467 bfa_sm_set_state(fdmi, 1468 bfa_fcs_lport_fdmi_sm_sending_rprt); 1469 bfa_fcs_lport_fdmi_send_rprt(fdmi, NULL); 1470 } else { 1471 /* 1472 * For a base port, we should first register the HBA 1473 * attribute. The HBA attribute also contains the base 1474 * port registration. 1475 */ 1476 bfa_sm_set_state(fdmi, 1477 bfa_fcs_lport_fdmi_sm_sending_rhba); 1478 bfa_fcs_lport_fdmi_send_rhba(fdmi, NULL); 1479 } 1480 break; 1481 1482 case FDMISM_EVENT_PORT_OFFLINE: 1483 break; 1484 1485 default: 1486 bfa_sm_fault(port->fcs, event); 1487 } 1488} 1489 1490static void 1491bfa_fcs_lport_fdmi_sm_sending_rhba(struct bfa_fcs_lport_fdmi_s *fdmi, 1492 enum port_fdmi_event event) 1493{ 1494 struct bfa_fcs_lport_s *port = fdmi->ms->port; 1495 1496 bfa_trc(port->fcs, port->port_cfg.pwwn); 1497 bfa_trc(port->fcs, event); 1498 1499 switch (event) { 1500 case FDMISM_EVENT_RHBA_SENT: 1501 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_rhba); 1502 break; 1503 1504 case FDMISM_EVENT_PORT_OFFLINE: 1505 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline); 1506 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(port), 1507 &fdmi->fcxp_wqe); 1508 break; 1509 1510 default: 1511 bfa_sm_fault(port->fcs, event); 1512 } 1513} 1514 1515static void 1516bfa_fcs_lport_fdmi_sm_rhba(struct bfa_fcs_lport_fdmi_s *fdmi, 1517 enum port_fdmi_event event) 1518{ 1519 struct bfa_fcs_lport_s *port = fdmi->ms->port; 1520 1521 bfa_trc(port->fcs, port->port_cfg.pwwn); 1522 bfa_trc(port->fcs, event); 1523 1524 switch (event) { 1525 case FDMISM_EVENT_RSP_ERROR: 1526 /* 1527 * if max retries have not been reached, start timer for a 1528 * delayed retry 1529 */ 1530 if (fdmi->retry_cnt++ < BFA_FCS_FDMI_CMD_MAX_RETRIES) { 1531 bfa_sm_set_state(fdmi, 1532 bfa_fcs_lport_fdmi_sm_rhba_retry); 1533 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(port), 1534 &fdmi->timer, 1535 bfa_fcs_lport_fdmi_timeout, fdmi, 1536 BFA_FCS_RETRY_TIMEOUT); 1537 } else { 1538 /* 1539 * set state to offline 1540 */ 1541 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline); 1542 } 1543 break; 1544 1545 case FDMISM_EVENT_RSP_OK: 1546 /* 1547 * Initiate Register Port Attributes 1548 */ 1549 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_sending_rpa); 1550 fdmi->retry_cnt = 0; 1551 bfa_fcs_lport_fdmi_send_rpa(fdmi, NULL); 1552 break; 1553 1554 case FDMISM_EVENT_PORT_OFFLINE: 1555 bfa_fcxp_discard(fdmi->fcxp); 1556 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline); 1557 break; 1558 1559 default: 1560 bfa_sm_fault(port->fcs, event); 1561 } 1562} 1563 1564static void 1565bfa_fcs_lport_fdmi_sm_rhba_retry(struct bfa_fcs_lport_fdmi_s *fdmi, 1566 enum port_fdmi_event event) 1567{ 1568 struct bfa_fcs_lport_s *port = fdmi->ms->port; 1569 1570 bfa_trc(port->fcs, port->port_cfg.pwwn); 1571 bfa_trc(port->fcs, event); 1572 1573 switch (event) { 1574 case FDMISM_EVENT_TIMEOUT: 1575 /* 1576 * Retry Timer Expired. Re-send 1577 */ 1578 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_sending_rhba); 1579 bfa_fcs_lport_fdmi_send_rhba(fdmi, NULL); 1580 break; 1581 1582 case FDMISM_EVENT_PORT_OFFLINE: 1583 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline); 1584 bfa_timer_stop(&fdmi->timer); 1585 break; 1586 1587 default: 1588 bfa_sm_fault(port->fcs, event); 1589 } 1590} 1591 1592/* 1593* RPRT : Register Port 1594 */ 1595static void 1596bfa_fcs_lport_fdmi_sm_sending_rprt(struct bfa_fcs_lport_fdmi_s *fdmi, 1597 enum port_fdmi_event event) 1598{ 1599 struct bfa_fcs_lport_s *port = fdmi->ms->port; 1600 1601 bfa_trc(port->fcs, port->port_cfg.pwwn); 1602 bfa_trc(port->fcs, event); 1603 1604 switch (event) { 1605 case FDMISM_EVENT_RPRT_SENT: 1606 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_rprt); 1607 break; 1608 1609 case FDMISM_EVENT_PORT_OFFLINE: 1610 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline); 1611 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(port), 1612 &fdmi->fcxp_wqe); 1613 break; 1614 1615 default: 1616 bfa_sm_fault(port->fcs, event); 1617 } 1618} 1619 1620static void 1621bfa_fcs_lport_fdmi_sm_rprt(struct bfa_fcs_lport_fdmi_s *fdmi, 1622 enum port_fdmi_event event) 1623{ 1624 struct bfa_fcs_lport_s *port = fdmi->ms->port; 1625 1626 bfa_trc(port->fcs, port->port_cfg.pwwn); 1627 bfa_trc(port->fcs, event); 1628 1629 switch (event) { 1630 case FDMISM_EVENT_RSP_ERROR: 1631 /* 1632 * if max retries have not been reached, start timer for a 1633 * delayed retry 1634 */ 1635 if (fdmi->retry_cnt++ < BFA_FCS_FDMI_CMD_MAX_RETRIES) { 1636 bfa_sm_set_state(fdmi, 1637 bfa_fcs_lport_fdmi_sm_rprt_retry); 1638 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(port), 1639 &fdmi->timer, 1640 bfa_fcs_lport_fdmi_timeout, fdmi, 1641 BFA_FCS_RETRY_TIMEOUT); 1642 1643 } else { 1644 /* 1645 * set state to offline 1646 */ 1647 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline); 1648 fdmi->retry_cnt = 0; 1649 } 1650 break; 1651 1652 case FDMISM_EVENT_RSP_OK: 1653 fdmi->retry_cnt = 0; 1654 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_online); 1655 break; 1656 1657 case FDMISM_EVENT_PORT_OFFLINE: 1658 bfa_fcxp_discard(fdmi->fcxp); 1659 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline); 1660 break; 1661 1662 default: 1663 bfa_sm_fault(port->fcs, event); 1664 } 1665} 1666 1667static void 1668bfa_fcs_lport_fdmi_sm_rprt_retry(struct bfa_fcs_lport_fdmi_s *fdmi, 1669 enum port_fdmi_event event) 1670{ 1671 struct bfa_fcs_lport_s *port = fdmi->ms->port; 1672 1673 bfa_trc(port->fcs, port->port_cfg.pwwn); 1674 bfa_trc(port->fcs, event); 1675 1676 switch (event) { 1677 case FDMISM_EVENT_TIMEOUT: 1678 /* 1679 * Retry Timer Expired. Re-send 1680 */ 1681 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_sending_rprt); 1682 bfa_fcs_lport_fdmi_send_rprt(fdmi, NULL); 1683 break; 1684 1685 case FDMISM_EVENT_PORT_OFFLINE: 1686 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline); 1687 bfa_timer_stop(&fdmi->timer); 1688 break; 1689 1690 default: 1691 bfa_sm_fault(port->fcs, event); 1692 } 1693} 1694 1695/* 1696 * Register Port Attributes 1697 */ 1698static void 1699bfa_fcs_lport_fdmi_sm_sending_rpa(struct bfa_fcs_lport_fdmi_s *fdmi, 1700 enum port_fdmi_event event) 1701{ 1702 struct bfa_fcs_lport_s *port = fdmi->ms->port; 1703 1704 bfa_trc(port->fcs, port->port_cfg.pwwn); 1705 bfa_trc(port->fcs, event); 1706 1707 switch (event) { 1708 case FDMISM_EVENT_RPA_SENT: 1709 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_rpa); 1710 break; 1711 1712 case FDMISM_EVENT_PORT_OFFLINE: 1713 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline); 1714 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(port), 1715 &fdmi->fcxp_wqe); 1716 break; 1717 1718 default: 1719 bfa_sm_fault(port->fcs, event); 1720 } 1721} 1722 1723static void 1724bfa_fcs_lport_fdmi_sm_rpa(struct bfa_fcs_lport_fdmi_s *fdmi, 1725 enum port_fdmi_event event) 1726{ 1727 struct bfa_fcs_lport_s *port = fdmi->ms->port; 1728 1729 bfa_trc(port->fcs, port->port_cfg.pwwn); 1730 bfa_trc(port->fcs, event); 1731 1732 switch (event) { 1733 case FDMISM_EVENT_RSP_ERROR: 1734 /* 1735 * if max retries have not been reached, start timer for a 1736 * delayed retry 1737 */ 1738 if (fdmi->retry_cnt++ < BFA_FCS_FDMI_CMD_MAX_RETRIES) { 1739 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_rpa_retry); 1740 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(port), 1741 &fdmi->timer, 1742 bfa_fcs_lport_fdmi_timeout, fdmi, 1743 BFA_FCS_RETRY_TIMEOUT); 1744 } else { 1745 /* 1746 * set state to offline 1747 */ 1748 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline); 1749 fdmi->retry_cnt = 0; 1750 } 1751 break; 1752 1753 case FDMISM_EVENT_RSP_OK: 1754 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_online); 1755 fdmi->retry_cnt = 0; 1756 break; 1757 1758 case FDMISM_EVENT_PORT_OFFLINE: 1759 bfa_fcxp_discard(fdmi->fcxp); 1760 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline); 1761 break; 1762 1763 default: 1764 bfa_sm_fault(port->fcs, event); 1765 } 1766} 1767 1768static void 1769bfa_fcs_lport_fdmi_sm_rpa_retry(struct bfa_fcs_lport_fdmi_s *fdmi, 1770 enum port_fdmi_event event) 1771{ 1772 struct bfa_fcs_lport_s *port = fdmi->ms->port; 1773 1774 bfa_trc(port->fcs, port->port_cfg.pwwn); 1775 bfa_trc(port->fcs, event); 1776 1777 switch (event) { 1778 case FDMISM_EVENT_TIMEOUT: 1779 /* 1780 * Retry Timer Expired. Re-send 1781 */ 1782 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_sending_rpa); 1783 bfa_fcs_lport_fdmi_send_rpa(fdmi, NULL); 1784 break; 1785 1786 case FDMISM_EVENT_PORT_OFFLINE: 1787 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline); 1788 bfa_timer_stop(&fdmi->timer); 1789 break; 1790 1791 default: 1792 bfa_sm_fault(port->fcs, event); 1793 } 1794} 1795 1796static void 1797bfa_fcs_lport_fdmi_sm_online(struct bfa_fcs_lport_fdmi_s *fdmi, 1798 enum port_fdmi_event event) 1799{ 1800 struct bfa_fcs_lport_s *port = fdmi->ms->port; 1801 1802 bfa_trc(port->fcs, port->port_cfg.pwwn); 1803 bfa_trc(port->fcs, event); 1804 1805 switch (event) { 1806 case FDMISM_EVENT_PORT_OFFLINE: 1807 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline); 1808 break; 1809 1810 default: 1811 bfa_sm_fault(port->fcs, event); 1812 } 1813} 1814/* 1815 * FDMI is disabled state. 1816 */ 1817static void 1818bfa_fcs_lport_fdmi_sm_disabled(struct bfa_fcs_lport_fdmi_s *fdmi, 1819 enum port_fdmi_event event) 1820{ 1821 struct bfa_fcs_lport_s *port = fdmi->ms->port; 1822 1823 bfa_trc(port->fcs, port->port_cfg.pwwn); 1824 bfa_trc(port->fcs, event); 1825 1826 /* No op State. It can only be enabled at Driver Init. */ 1827} 1828 1829/* 1830* RHBA : Register HBA Attributes. 1831 */ 1832static void 1833bfa_fcs_lport_fdmi_send_rhba(void *fdmi_cbarg, struct bfa_fcxp_s *fcxp_alloced) 1834{ 1835 struct bfa_fcs_lport_fdmi_s *fdmi = fdmi_cbarg; 1836 struct bfa_fcs_lport_s *port = fdmi->ms->port; 1837 struct fchs_s fchs; 1838 int len, attr_len; 1839 struct bfa_fcxp_s *fcxp; 1840 u8 *pyld; 1841 1842 bfa_trc(port->fcs, port->port_cfg.pwwn); 1843 1844 fcxp = fcxp_alloced ? fcxp_alloced : 1845 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE); 1846 if (!fcxp) { 1847 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe, 1848 bfa_fcs_lport_fdmi_send_rhba, fdmi, BFA_TRUE); 1849 return; 1850 } 1851 fdmi->fcxp = fcxp; 1852 1853 pyld = bfa_fcxp_get_reqbuf(fcxp); 1854 memset(pyld, 0, FC_MAX_PDUSZ); 1855 1856 len = fc_fdmi_reqhdr_build(&fchs, pyld, bfa_fcs_lport_get_fcid(port), 1857 FDMI_RHBA); 1858 1859 attr_len = 1860 bfa_fcs_lport_fdmi_build_rhba_pyld(fdmi, 1861 (u8 *) ((struct ct_hdr_s *) pyld 1862 + 1)); 1863 if (attr_len < 0) 1864 return; 1865 1866 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 1867 FC_CLASS_3, (len + attr_len), &fchs, 1868 bfa_fcs_lport_fdmi_rhba_response, (void *)fdmi, 1869 FC_MAX_PDUSZ, FC_FCCT_TOV); 1870 1871 bfa_sm_send_event(fdmi, FDMISM_EVENT_RHBA_SENT); 1872} 1873 1874static int 1875bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld) 1876{ 1877 struct bfa_fcs_lport_s *port = fdmi->ms->port; 1878 struct bfa_fcs_fdmi_hba_attr_s *fcs_hba_attr; 1879 struct fdmi_rhba_s *rhba = (struct fdmi_rhba_s *) pyld; 1880 struct fdmi_attr_s *attr; 1881 int len; 1882 u8 *curr_ptr; 1883 u16 templen, count; 1884 1885 fcs_hba_attr = kzalloc(sizeof(*fcs_hba_attr), GFP_KERNEL); 1886 if (!fcs_hba_attr) 1887 return -ENOMEM; 1888 1889 /* 1890 * get hba attributes 1891 */ 1892 bfa_fcs_fdmi_get_hbaattr(fdmi, fcs_hba_attr); 1893 1894 rhba->hba_id = bfa_fcs_lport_get_pwwn(port); 1895 rhba->port_list.num_ports = cpu_to_be32(1); 1896 rhba->port_list.port_entry = bfa_fcs_lport_get_pwwn(port); 1897 1898 len = sizeof(rhba->hba_id) + sizeof(rhba->port_list); 1899 1900 count = 0; 1901 len += sizeof(rhba->hba_attr_blk.attr_count); 1902 1903 /* 1904 * fill out the invididual entries of the HBA attrib Block 1905 */ 1906 curr_ptr = (u8 *) &rhba->hba_attr_blk.hba_attr; 1907 1908 /* 1909 * Node Name 1910 */ 1911 attr = (struct fdmi_attr_s *) curr_ptr; 1912 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_NODENAME); 1913 templen = sizeof(wwn_t); 1914 memcpy(attr->value, &bfa_fcs_lport_get_nwwn(port), templen); 1915 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 1916 len += templen; 1917 count++; 1918 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 1919 sizeof(templen)); 1920 1921 /* 1922 * Manufacturer 1923 */ 1924 attr = (struct fdmi_attr_s *) curr_ptr; 1925 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MANUFACTURER); 1926 templen = (u16) strlen(fcs_hba_attr->manufacturer); 1927 memcpy(attr->value, fcs_hba_attr->manufacturer, templen); 1928 templen = fc_roundup(templen, sizeof(u32)); 1929 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 1930 len += templen; 1931 count++; 1932 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 1933 sizeof(templen)); 1934 1935 /* 1936 * Serial Number 1937 */ 1938 attr = (struct fdmi_attr_s *) curr_ptr; 1939 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_SERIALNUM); 1940 templen = (u16) strlen(fcs_hba_attr->serial_num); 1941 memcpy(attr->value, fcs_hba_attr->serial_num, templen); 1942 templen = fc_roundup(templen, sizeof(u32)); 1943 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 1944 len += templen; 1945 count++; 1946 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 1947 sizeof(templen)); 1948 1949 /* 1950 * Model 1951 */ 1952 attr = (struct fdmi_attr_s *) curr_ptr; 1953 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MODEL); 1954 templen = (u16) strlen(fcs_hba_attr->model); 1955 memcpy(attr->value, fcs_hba_attr->model, templen); 1956 templen = fc_roundup(templen, sizeof(u32)); 1957 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 1958 len += templen; 1959 count++; 1960 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 1961 sizeof(templen)); 1962 1963 /* 1964 * Model Desc 1965 */ 1966 attr = (struct fdmi_attr_s *) curr_ptr; 1967 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MODEL_DESC); 1968 templen = (u16) strlen(fcs_hba_attr->model_desc); 1969 memcpy(attr->value, fcs_hba_attr->model_desc, templen); 1970 templen = fc_roundup(templen, sizeof(u32)); 1971 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 1972 len += templen; 1973 count++; 1974 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 1975 sizeof(templen)); 1976 1977 /* 1978 * H/W Version 1979 */ 1980 if (fcs_hba_attr->hw_version[0] != '\0') { 1981 attr = (struct fdmi_attr_s *) curr_ptr; 1982 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_HW_VERSION); 1983 templen = (u16) strlen(fcs_hba_attr->hw_version); 1984 memcpy(attr->value, fcs_hba_attr->hw_version, templen); 1985 templen = fc_roundup(templen, sizeof(u32)); 1986 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 1987 len += templen; 1988 count++; 1989 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 1990 sizeof(templen)); 1991 } 1992 1993 /* 1994 * Driver Version 1995 */ 1996 attr = (struct fdmi_attr_s *) curr_ptr; 1997 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_DRIVER_VERSION); 1998 templen = (u16) strlen(fcs_hba_attr->driver_version); 1999 memcpy(attr->value, fcs_hba_attr->driver_version, templen); 2000 templen = fc_roundup(templen, sizeof(u32)); 2001 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2002 len += templen; 2003 count++; 2004 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2005 sizeof(templen)); 2006 2007 /* 2008 * Option Rom Version 2009 */ 2010 if (fcs_hba_attr->option_rom_ver[0] != '\0') { 2011 attr = (struct fdmi_attr_s *) curr_ptr; 2012 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_ROM_VERSION); 2013 templen = (u16) strlen(fcs_hba_attr->option_rom_ver); 2014 memcpy(attr->value, fcs_hba_attr->option_rom_ver, templen); 2015 templen = fc_roundup(templen, sizeof(u32)); 2016 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2017 len += templen; 2018 count++; 2019 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2020 sizeof(templen)); 2021 } 2022 2023 attr = (struct fdmi_attr_s *) curr_ptr; 2024 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_FW_VERSION); 2025 templen = (u16) strlen(fcs_hba_attr->fw_version); 2026 memcpy(attr->value, fcs_hba_attr->fw_version, templen); 2027 templen = fc_roundup(templen, sizeof(u32)); 2028 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2029 len += templen; 2030 count++; 2031 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2032 sizeof(templen)); 2033 2034 /* 2035 * OS Name 2036 */ 2037 if (fcs_hba_attr->os_name[0] != '\0') { 2038 attr = (struct fdmi_attr_s *) curr_ptr; 2039 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_OS_NAME); 2040 templen = (u16) strlen(fcs_hba_attr->os_name); 2041 memcpy(attr->value, fcs_hba_attr->os_name, templen); 2042 templen = fc_roundup(templen, sizeof(u32)); 2043 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2044 len += templen; 2045 count++; 2046 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2047 sizeof(templen)); 2048 } 2049 2050 /* 2051 * MAX_CT_PAYLOAD 2052 */ 2053 attr = (struct fdmi_attr_s *) curr_ptr; 2054 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MAX_CT); 2055 templen = sizeof(fcs_hba_attr->max_ct_pyld); 2056 memcpy(attr->value, &fcs_hba_attr->max_ct_pyld, templen); 2057 templen = fc_roundup(templen, sizeof(u32)); 2058 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2059 len += templen; 2060 count++; 2061 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2062 sizeof(templen)); 2063 /* 2064 * Send extended attributes ( FOS 7.1 support ) 2065 */ 2066 if (fdmi->retry_cnt == 0) { 2067 attr = (struct fdmi_attr_s *) curr_ptr; 2068 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_NODE_SYM_NAME); 2069 templen = sizeof(fcs_hba_attr->node_sym_name); 2070 memcpy(attr->value, &fcs_hba_attr->node_sym_name, templen); 2071 templen = fc_roundup(templen, sizeof(u32)); 2072 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2073 len += templen; 2074 count++; 2075 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2076 sizeof(templen)); 2077 2078 attr = (struct fdmi_attr_s *) curr_ptr; 2079 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_VENDOR_ID); 2080 templen = sizeof(fcs_hba_attr->vendor_info); 2081 memcpy(attr->value, &fcs_hba_attr->vendor_info, templen); 2082 templen = fc_roundup(templen, sizeof(u32)); 2083 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2084 len += templen; 2085 count++; 2086 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2087 sizeof(templen)); 2088 2089 attr = (struct fdmi_attr_s *) curr_ptr; 2090 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_NUM_PORTS); 2091 templen = sizeof(fcs_hba_attr->num_ports); 2092 memcpy(attr->value, &fcs_hba_attr->num_ports, templen); 2093 templen = fc_roundup(templen, sizeof(u32)); 2094 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2095 len += templen; 2096 count++; 2097 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2098 sizeof(templen)); 2099 2100 attr = (struct fdmi_attr_s *) curr_ptr; 2101 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_FABRIC_NAME); 2102 templen = sizeof(fcs_hba_attr->fabric_name); 2103 memcpy(attr->value, &fcs_hba_attr->fabric_name, templen); 2104 templen = fc_roundup(templen, sizeof(u32)); 2105 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2106 len += templen; 2107 count++; 2108 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2109 sizeof(templen)); 2110 2111 attr = (struct fdmi_attr_s *) curr_ptr; 2112 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_BIOS_VER); 2113 templen = sizeof(fcs_hba_attr->bios_ver); 2114 memcpy(attr->value, &fcs_hba_attr->bios_ver, templen); 2115 templen = fc_roundup(attr->len, sizeof(u32)); 2116 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2117 len += templen; 2118 count++; 2119 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2120 sizeof(templen)); 2121 } 2122 2123 /* 2124 * Update size of payload 2125 */ 2126 len += ((sizeof(attr->type) + sizeof(attr->len)) * count); 2127 2128 rhba->hba_attr_blk.attr_count = cpu_to_be32(count); 2129 2130 kfree(fcs_hba_attr); 2131 2132 return len; 2133} 2134 2135static void 2136bfa_fcs_lport_fdmi_rhba_response(void *fcsarg, struct bfa_fcxp_s *fcxp, 2137 void *cbarg, bfa_status_t req_status, 2138 u32 rsp_len, u32 resid_len, 2139 struct fchs_s *rsp_fchs) 2140{ 2141 struct bfa_fcs_lport_fdmi_s *fdmi = 2142 (struct bfa_fcs_lport_fdmi_s *) cbarg; 2143 struct bfa_fcs_lport_s *port = fdmi->ms->port; 2144 struct ct_hdr_s *cthdr = NULL; 2145 2146 bfa_trc(port->fcs, port->port_cfg.pwwn); 2147 2148 /* 2149 * Sanity Checks 2150 */ 2151 if (req_status != BFA_STATUS_OK) { 2152 bfa_trc(port->fcs, req_status); 2153 bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR); 2154 return; 2155 } 2156 2157 cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp); 2158 cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code); 2159 2160 if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) { 2161 bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_OK); 2162 return; 2163 } 2164 2165 bfa_trc(port->fcs, cthdr->reason_code); 2166 bfa_trc(port->fcs, cthdr->exp_code); 2167 bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR); 2168} 2169 2170/* 2171* RPRT : Register Port 2172 */ 2173static void 2174bfa_fcs_lport_fdmi_send_rprt(void *fdmi_cbarg, struct bfa_fcxp_s *fcxp_alloced) 2175{ 2176 struct bfa_fcs_lport_fdmi_s *fdmi = fdmi_cbarg; 2177 struct bfa_fcs_lport_s *port = fdmi->ms->port; 2178 struct fchs_s fchs; 2179 u16 len, attr_len; 2180 struct bfa_fcxp_s *fcxp; 2181 u8 *pyld; 2182 2183 bfa_trc(port->fcs, port->port_cfg.pwwn); 2184 2185 fcxp = fcxp_alloced ? fcxp_alloced : 2186 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE); 2187 if (!fcxp) { 2188 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe, 2189 bfa_fcs_lport_fdmi_send_rprt, fdmi, BFA_TRUE); 2190 return; 2191 } 2192 fdmi->fcxp = fcxp; 2193 2194 pyld = bfa_fcxp_get_reqbuf(fcxp); 2195 memset(pyld, 0, FC_MAX_PDUSZ); 2196 2197 len = fc_fdmi_reqhdr_build(&fchs, pyld, bfa_fcs_lport_get_fcid(port), 2198 FDMI_RPRT); 2199 2200 attr_len = 2201 bfa_fcs_lport_fdmi_build_rprt_pyld(fdmi, 2202 (u8 *) ((struct ct_hdr_s *) pyld 2203 + 1)); 2204 2205 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 2206 FC_CLASS_3, len + attr_len, &fchs, 2207 bfa_fcs_lport_fdmi_rprt_response, (void *)fdmi, 2208 FC_MAX_PDUSZ, FC_FCCT_TOV); 2209 2210 bfa_sm_send_event(fdmi, FDMISM_EVENT_RPRT_SENT); 2211} 2212 2213/* 2214 * This routine builds Port Attribute Block that used in RPA, RPRT commands. 2215 */ 2216static u16 2217bfa_fcs_lport_fdmi_build_portattr_block(struct bfa_fcs_lport_fdmi_s *fdmi, 2218 u8 *pyld) 2219{ 2220 struct bfa_fcs_fdmi_port_attr_s fcs_port_attr; 2221 struct fdmi_port_attr_s *port_attrib = (struct fdmi_port_attr_s *) pyld; 2222 struct fdmi_attr_s *attr; 2223 u8 *curr_ptr; 2224 u16 len; 2225 u8 count = 0; 2226 u16 templen; 2227 2228 /* 2229 * get port attributes 2230 */ 2231 bfa_fcs_fdmi_get_portattr(fdmi, &fcs_port_attr); 2232 2233 len = sizeof(port_attrib->attr_count); 2234 2235 /* 2236 * fill out the invididual entries 2237 */ 2238 curr_ptr = (u8 *) &port_attrib->port_attr; 2239 2240 /* 2241 * FC4 Types 2242 */ 2243 attr = (struct fdmi_attr_s *) curr_ptr; 2244 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_FC4_TYPES); 2245 templen = sizeof(fcs_port_attr.supp_fc4_types); 2246 memcpy(attr->value, fcs_port_attr.supp_fc4_types, templen); 2247 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2248 len += templen; 2249 ++count; 2250 attr->len = 2251 cpu_to_be16(templen + sizeof(attr->type) + 2252 sizeof(templen)); 2253 2254 /* 2255 * Supported Speed 2256 */ 2257 attr = (struct fdmi_attr_s *) curr_ptr; 2258 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_SUPP_SPEED); 2259 templen = sizeof(fcs_port_attr.supp_speed); 2260 memcpy(attr->value, &fcs_port_attr.supp_speed, templen); 2261 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2262 len += templen; 2263 ++count; 2264 attr->len = 2265 cpu_to_be16(templen + sizeof(attr->type) + 2266 sizeof(templen)); 2267 2268 /* 2269 * current Port Speed 2270 */ 2271 attr = (struct fdmi_attr_s *) curr_ptr; 2272 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_SPEED); 2273 templen = sizeof(fcs_port_attr.curr_speed); 2274 memcpy(attr->value, &fcs_port_attr.curr_speed, templen); 2275 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2276 len += templen; 2277 ++count; 2278 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2279 sizeof(templen)); 2280 2281 /* 2282 * max frame size 2283 */ 2284 attr = (struct fdmi_attr_s *) curr_ptr; 2285 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_FRAME_SIZE); 2286 templen = sizeof(fcs_port_attr.max_frm_size); 2287 memcpy(attr->value, &fcs_port_attr.max_frm_size, templen); 2288 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2289 len += templen; 2290 ++count; 2291 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2292 sizeof(templen)); 2293 2294 /* 2295 * OS Device Name 2296 */ 2297 if (fcs_port_attr.os_device_name[0] != '\0') { 2298 attr = (struct fdmi_attr_s *) curr_ptr; 2299 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_DEV_NAME); 2300 templen = (u16) strlen(fcs_port_attr.os_device_name); 2301 memcpy(attr->value, fcs_port_attr.os_device_name, templen); 2302 templen = fc_roundup(templen, sizeof(u32)); 2303 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2304 len += templen; 2305 ++count; 2306 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2307 sizeof(templen)); 2308 } 2309 /* 2310 * Host Name 2311 */ 2312 if (fcs_port_attr.host_name[0] != '\0') { 2313 attr = (struct fdmi_attr_s *) curr_ptr; 2314 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_HOST_NAME); 2315 templen = (u16) strlen(fcs_port_attr.host_name); 2316 memcpy(attr->value, fcs_port_attr.host_name, templen); 2317 templen = fc_roundup(templen, sizeof(u32)); 2318 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2319 len += templen; 2320 ++count; 2321 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2322 sizeof(templen)); 2323 } 2324 2325 if (fdmi->retry_cnt == 0) { 2326 attr = (struct fdmi_attr_s *) curr_ptr; 2327 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_NODE_NAME); 2328 templen = sizeof(fcs_port_attr.node_name); 2329 memcpy(attr->value, &fcs_port_attr.node_name, templen); 2330 templen = fc_roundup(templen, sizeof(u32)); 2331 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2332 len += templen; 2333 ++count; 2334 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2335 sizeof(templen)); 2336 2337 attr = (struct fdmi_attr_s *) curr_ptr; 2338 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_NAME); 2339 templen = sizeof(fcs_port_attr.port_name); 2340 memcpy(attr->value, &fcs_port_attr.port_name, templen); 2341 templen = fc_roundup(templen, sizeof(u32)); 2342 curr_ptr += sizeof(attr->type) + sizeof(attr->len) + templen; 2343 len += templen; 2344 ++count; 2345 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2346 sizeof(templen)); 2347 2348 if (fcs_port_attr.port_sym_name.symname[0] != '\0') { 2349 attr = (struct fdmi_attr_s *) curr_ptr; 2350 attr->type = 2351 cpu_to_be16(FDMI_PORT_ATTRIB_PORT_SYM_NAME); 2352 templen = sizeof(fcs_port_attr.port_sym_name); 2353 memcpy(attr->value, 2354 &fcs_port_attr.port_sym_name, templen); 2355 templen = fc_roundup(templen, sizeof(u32)); 2356 curr_ptr += sizeof(attr->type) + 2357 sizeof(templen) + templen; 2358 len += templen; 2359 ++count; 2360 attr->len = cpu_to_be16(templen + 2361 sizeof(attr->type) + sizeof(templen)); 2362 } 2363 2364 attr = (struct fdmi_attr_s *) curr_ptr; 2365 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_TYPE); 2366 templen = sizeof(fcs_port_attr.port_type); 2367 memcpy(attr->value, &fcs_port_attr.port_type, templen); 2368 templen = fc_roundup(templen, sizeof(u32)); 2369 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2370 len += templen; 2371 ++count; 2372 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2373 sizeof(templen)); 2374 2375 attr = (struct fdmi_attr_s *) curr_ptr; 2376 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_SUPP_COS); 2377 templen = sizeof(fcs_port_attr.scos); 2378 memcpy(attr->value, &fcs_port_attr.scos, templen); 2379 templen = fc_roundup(templen, sizeof(u32)); 2380 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2381 len += templen; 2382 ++count; 2383 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2384 sizeof(templen)); 2385 2386 attr = (struct fdmi_attr_s *) curr_ptr; 2387 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_FAB_NAME); 2388 templen = sizeof(fcs_port_attr.port_fabric_name); 2389 memcpy(attr->value, &fcs_port_attr.port_fabric_name, templen); 2390 templen = fc_roundup(templen, sizeof(u32)); 2391 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2392 len += templen; 2393 ++count; 2394 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2395 sizeof(templen)); 2396 2397 attr = (struct fdmi_attr_s *) curr_ptr; 2398 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_FC4_TYPE); 2399 templen = sizeof(fcs_port_attr.port_act_fc4_type); 2400 memcpy(attr->value, fcs_port_attr.port_act_fc4_type, 2401 templen); 2402 templen = fc_roundup(templen, sizeof(u32)); 2403 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2404 len += templen; 2405 ++count; 2406 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2407 sizeof(templen)); 2408 2409 attr = (struct fdmi_attr_s *) curr_ptr; 2410 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_STATE); 2411 templen = sizeof(fcs_port_attr.port_state); 2412 memcpy(attr->value, &fcs_port_attr.port_state, templen); 2413 templen = fc_roundup(templen, sizeof(u32)); 2414 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2415 len += templen; 2416 ++count; 2417 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2418 sizeof(templen)); 2419 2420 attr = (struct fdmi_attr_s *) curr_ptr; 2421 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_NUM_RPRT); 2422 templen = sizeof(fcs_port_attr.num_ports); 2423 memcpy(attr->value, &fcs_port_attr.num_ports, templen); 2424 templen = fc_roundup(templen, sizeof(u32)); 2425 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 2426 len += templen; 2427 ++count; 2428 attr->len = cpu_to_be16(templen + sizeof(attr->type) + 2429 sizeof(templen)); 2430 } 2431 2432 /* 2433 * Update size of payload 2434 */ 2435 port_attrib->attr_count = cpu_to_be32(count); 2436 len += ((sizeof(attr->type) + sizeof(attr->len)) * count); 2437 return len; 2438} 2439 2440static u16 2441bfa_fcs_lport_fdmi_build_rprt_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld) 2442{ 2443 struct bfa_fcs_lport_s *port = fdmi->ms->port; 2444 struct fdmi_rprt_s *rprt = (struct fdmi_rprt_s *) pyld; 2445 u16 len; 2446 2447 rprt->hba_id = bfa_fcs_lport_get_pwwn(bfa_fcs_get_base_port(port->fcs)); 2448 rprt->port_name = bfa_fcs_lport_get_pwwn(port); 2449 2450 len = bfa_fcs_lport_fdmi_build_portattr_block(fdmi, 2451 (u8 *) &rprt->port_attr_blk); 2452 2453 len += sizeof(rprt->hba_id) + sizeof(rprt->port_name); 2454 2455 return len; 2456} 2457 2458static void 2459bfa_fcs_lport_fdmi_rprt_response(void *fcsarg, struct bfa_fcxp_s *fcxp, 2460 void *cbarg, bfa_status_t req_status, 2461 u32 rsp_len, u32 resid_len, 2462 struct fchs_s *rsp_fchs) 2463{ 2464 struct bfa_fcs_lport_fdmi_s *fdmi = 2465 (struct bfa_fcs_lport_fdmi_s *) cbarg; 2466 struct bfa_fcs_lport_s *port = fdmi->ms->port; 2467 struct ct_hdr_s *cthdr = NULL; 2468 2469 bfa_trc(port->fcs, port->port_cfg.pwwn); 2470 2471 /* 2472 * Sanity Checks 2473 */ 2474 if (req_status != BFA_STATUS_OK) { 2475 bfa_trc(port->fcs, req_status); 2476 bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR); 2477 return; 2478 } 2479 2480 cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp); 2481 cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code); 2482 2483 if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) { 2484 bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_OK); 2485 return; 2486 } 2487 2488 bfa_trc(port->fcs, cthdr->reason_code); 2489 bfa_trc(port->fcs, cthdr->exp_code); 2490 bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR); 2491} 2492 2493/* 2494* RPA : Register Port Attributes. 2495 */ 2496static void 2497bfa_fcs_lport_fdmi_send_rpa(void *fdmi_cbarg, struct bfa_fcxp_s *fcxp_alloced) 2498{ 2499 struct bfa_fcs_lport_fdmi_s *fdmi = fdmi_cbarg; 2500 struct bfa_fcs_lport_s *port = fdmi->ms->port; 2501 struct fchs_s fchs; 2502 u16 len, attr_len; 2503 struct bfa_fcxp_s *fcxp; 2504 u8 *pyld; 2505 2506 bfa_trc(port->fcs, port->port_cfg.pwwn); 2507 2508 fcxp = fcxp_alloced ? fcxp_alloced : 2509 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE); 2510 if (!fcxp) { 2511 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe, 2512 bfa_fcs_lport_fdmi_send_rpa, fdmi, BFA_TRUE); 2513 return; 2514 } 2515 fdmi->fcxp = fcxp; 2516 2517 pyld = bfa_fcxp_get_reqbuf(fcxp); 2518 memset(pyld, 0, FC_MAX_PDUSZ); 2519 2520 len = fc_fdmi_reqhdr_build(&fchs, pyld, bfa_fcs_lport_get_fcid(port), 2521 FDMI_RPA); 2522 2523 attr_len = bfa_fcs_lport_fdmi_build_rpa_pyld(fdmi, 2524 (u8 *) ((struct ct_hdr_s *) pyld + 1)); 2525 2526 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 2527 FC_CLASS_3, len + attr_len, &fchs, 2528 bfa_fcs_lport_fdmi_rpa_response, (void *)fdmi, 2529 FC_MAX_PDUSZ, FC_FCCT_TOV); 2530 2531 bfa_sm_send_event(fdmi, FDMISM_EVENT_RPA_SENT); 2532} 2533 2534static u16 2535bfa_fcs_lport_fdmi_build_rpa_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld) 2536{ 2537 struct bfa_fcs_lport_s *port = fdmi->ms->port; 2538 struct fdmi_rpa_s *rpa = (struct fdmi_rpa_s *) pyld; 2539 u16 len; 2540 2541 rpa->port_name = bfa_fcs_lport_get_pwwn(port); 2542 2543 len = bfa_fcs_lport_fdmi_build_portattr_block(fdmi, 2544 (u8 *) &rpa->port_attr_blk); 2545 2546 len += sizeof(rpa->port_name); 2547 2548 return len; 2549} 2550 2551static void 2552bfa_fcs_lport_fdmi_rpa_response(void *fcsarg, struct bfa_fcxp_s *fcxp, 2553 void *cbarg, bfa_status_t req_status, u32 rsp_len, 2554 u32 resid_len, struct fchs_s *rsp_fchs) 2555{ 2556 struct bfa_fcs_lport_fdmi_s *fdmi = 2557 (struct bfa_fcs_lport_fdmi_s *) cbarg; 2558 struct bfa_fcs_lport_s *port = fdmi->ms->port; 2559 struct ct_hdr_s *cthdr = NULL; 2560 2561 bfa_trc(port->fcs, port->port_cfg.pwwn); 2562 2563 /* 2564 * Sanity Checks 2565 */ 2566 if (req_status != BFA_STATUS_OK) { 2567 bfa_trc(port->fcs, req_status); 2568 bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR); 2569 return; 2570 } 2571 2572 cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp); 2573 cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code); 2574 2575 if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) { 2576 bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_OK); 2577 return; 2578 } 2579 2580 bfa_trc(port->fcs, cthdr->reason_code); 2581 bfa_trc(port->fcs, cthdr->exp_code); 2582 bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR); 2583} 2584 2585static void 2586bfa_fcs_lport_fdmi_timeout(void *arg) 2587{ 2588 struct bfa_fcs_lport_fdmi_s *fdmi = (struct bfa_fcs_lport_fdmi_s *) arg; 2589 2590 bfa_sm_send_event(fdmi, FDMISM_EVENT_TIMEOUT); 2591} 2592 2593static void 2594bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_lport_fdmi_s *fdmi, 2595 struct bfa_fcs_fdmi_hba_attr_s *hba_attr) 2596{ 2597 struct bfa_fcs_lport_s *port = fdmi->ms->port; 2598 struct bfa_fcs_driver_info_s *driver_info = &port->fcs->driver_info; 2599 struct bfa_fcs_fdmi_port_attr_s fcs_port_attr; 2600 2601 memset(hba_attr, 0, sizeof(struct bfa_fcs_fdmi_hba_attr_s)); 2602 2603 bfa_ioc_get_adapter_manufacturer(&port->fcs->bfa->ioc, 2604 hba_attr->manufacturer); 2605 bfa_ioc_get_adapter_serial_num(&port->fcs->bfa->ioc, 2606 hba_attr->serial_num); 2607 bfa_ioc_get_adapter_model(&port->fcs->bfa->ioc, 2608 hba_attr->model); 2609 bfa_ioc_get_adapter_model(&port->fcs->bfa->ioc, 2610 hba_attr->model_desc); 2611 bfa_ioc_get_pci_chip_rev(&port->fcs->bfa->ioc, 2612 hba_attr->hw_version); 2613 bfa_ioc_get_adapter_optrom_ver(&port->fcs->bfa->ioc, 2614 hba_attr->option_rom_ver); 2615 bfa_ioc_get_adapter_fw_ver(&port->fcs->bfa->ioc, 2616 hba_attr->fw_version); 2617 2618 strscpy(hba_attr->driver_version, (char *)driver_info->version, 2619 sizeof(hba_attr->driver_version)); 2620 2621 strscpy(hba_attr->os_name, driver_info->host_os_name, 2622 sizeof(hba_attr->os_name)); 2623 2624 /* 2625 * If there is a patch level, append it 2626 * to the os name along with a separator 2627 */ 2628 if (driver_info->host_os_patch[0] != '\0') { 2629 strlcat(hba_attr->os_name, BFA_FCS_PORT_SYMBNAME_SEPARATOR, 2630 sizeof(hba_attr->os_name)); 2631 strlcat(hba_attr->os_name, driver_info->host_os_patch, 2632 sizeof(hba_attr->os_name)); 2633 } 2634 2635 /* Retrieve the max frame size from the port attr */ 2636 bfa_fcs_fdmi_get_portattr(fdmi, &fcs_port_attr); 2637 hba_attr->max_ct_pyld = fcs_port_attr.max_frm_size; 2638 2639 strscpy(hba_attr->node_sym_name.symname, 2640 port->port_cfg.node_sym_name.symname, BFA_SYMNAME_MAXLEN); 2641 strcpy(hba_attr->vendor_info, "QLogic"); 2642 hba_attr->num_ports = 2643 cpu_to_be32(bfa_ioc_get_nports(&port->fcs->bfa->ioc)); 2644 hba_attr->fabric_name = port->fabric->lps->pr_nwwn; 2645 strscpy(hba_attr->bios_ver, hba_attr->option_rom_ver, BFA_VERSION_LEN); 2646 2647} 2648 2649static void 2650bfa_fcs_fdmi_get_portattr(struct bfa_fcs_lport_fdmi_s *fdmi, 2651 struct bfa_fcs_fdmi_port_attr_s *port_attr) 2652{ 2653 struct bfa_fcs_lport_s *port = fdmi->ms->port; 2654 struct bfa_fcs_driver_info_s *driver_info = &port->fcs->driver_info; 2655 struct bfa_port_attr_s pport_attr; 2656 struct bfa_lport_attr_s lport_attr; 2657 2658 memset(port_attr, 0, sizeof(struct bfa_fcs_fdmi_port_attr_s)); 2659 2660 /* 2661 * get pport attributes from hal 2662 */ 2663 bfa_fcport_get_attr(port->fcs->bfa, &pport_attr); 2664 2665 /* 2666 * get FC4 type Bitmask 2667 */ 2668 fc_get_fc4type_bitmask(FC_TYPE_FCP, port_attr->supp_fc4_types); 2669 2670 /* 2671 * Supported Speeds 2672 */ 2673 switch (pport_attr.speed_supported) { 2674 case BFA_PORT_SPEED_16GBPS: 2675 port_attr->supp_speed = 2676 cpu_to_be32(BFA_FCS_FDMI_SUPP_SPEEDS_16G); 2677 break; 2678 2679 case BFA_PORT_SPEED_10GBPS: 2680 port_attr->supp_speed = 2681 cpu_to_be32(BFA_FCS_FDMI_SUPP_SPEEDS_10G); 2682 break; 2683 2684 case BFA_PORT_SPEED_8GBPS: 2685 port_attr->supp_speed = 2686 cpu_to_be32(BFA_FCS_FDMI_SUPP_SPEEDS_8G); 2687 break; 2688 2689 case BFA_PORT_SPEED_4GBPS: 2690 port_attr->supp_speed = 2691 cpu_to_be32(BFA_FCS_FDMI_SUPP_SPEEDS_4G); 2692 break; 2693 2694 default: 2695 bfa_sm_fault(port->fcs, pport_attr.speed_supported); 2696 } 2697 2698 /* 2699 * Current Speed 2700 */ 2701 port_attr->curr_speed = cpu_to_be32( 2702 bfa_fcs_fdmi_convert_speed(pport_attr.speed)); 2703 2704 /* 2705 * Max PDU Size. 2706 */ 2707 port_attr->max_frm_size = cpu_to_be32(pport_attr.pport_cfg.maxfrsize); 2708 2709 /* 2710 * OS device Name 2711 */ 2712 strscpy(port_attr->os_device_name, driver_info->os_device_name, 2713 sizeof(port_attr->os_device_name)); 2714 2715 /* 2716 * Host name 2717 */ 2718 strscpy(port_attr->host_name, driver_info->host_machine_name, 2719 sizeof(port_attr->host_name)); 2720 2721 port_attr->node_name = bfa_fcs_lport_get_nwwn(port); 2722 port_attr->port_name = bfa_fcs_lport_get_pwwn(port); 2723 2724 strscpy(port_attr->port_sym_name.symname, 2725 bfa_fcs_lport_get_psym_name(port).symname, BFA_SYMNAME_MAXLEN); 2726 bfa_fcs_lport_get_attr(port, &lport_attr); 2727 port_attr->port_type = cpu_to_be32(lport_attr.port_type); 2728 port_attr->scos = pport_attr.cos_supported; 2729 port_attr->port_fabric_name = port->fabric->lps->pr_nwwn; 2730 fc_get_fc4type_bitmask(FC_TYPE_FCP, port_attr->port_act_fc4_type); 2731 port_attr->port_state = cpu_to_be32(pport_attr.port_state); 2732 port_attr->num_ports = cpu_to_be32(port->num_rports); 2733} 2734 2735/* 2736 * Convert BFA speed to FDMI format. 2737 */ 2738u32 2739bfa_fcs_fdmi_convert_speed(bfa_port_speed_t pport_speed) 2740{ 2741 u32 ret; 2742 2743 switch (pport_speed) { 2744 case BFA_PORT_SPEED_1GBPS: 2745 case BFA_PORT_SPEED_2GBPS: 2746 ret = pport_speed; 2747 break; 2748 2749 case BFA_PORT_SPEED_4GBPS: 2750 ret = FDMI_TRANS_SPEED_4G; 2751 break; 2752 2753 case BFA_PORT_SPEED_8GBPS: 2754 ret = FDMI_TRANS_SPEED_8G; 2755 break; 2756 2757 case BFA_PORT_SPEED_10GBPS: 2758 ret = FDMI_TRANS_SPEED_10G; 2759 break; 2760 2761 case BFA_PORT_SPEED_16GBPS: 2762 ret = FDMI_TRANS_SPEED_16G; 2763 break; 2764 2765 default: 2766 ret = FDMI_TRANS_SPEED_UNKNOWN; 2767 } 2768 return ret; 2769} 2770 2771void 2772bfa_fcs_lport_fdmi_init(struct bfa_fcs_lport_ms_s *ms) 2773{ 2774 struct bfa_fcs_lport_fdmi_s *fdmi = &ms->fdmi; 2775 2776 fdmi->ms = ms; 2777 if (ms->port->fcs->fdmi_enabled) 2778 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline); 2779 else 2780 bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_disabled); 2781} 2782 2783void 2784bfa_fcs_lport_fdmi_offline(struct bfa_fcs_lport_ms_s *ms) 2785{ 2786 struct bfa_fcs_lport_fdmi_s *fdmi = &ms->fdmi; 2787 2788 fdmi->ms = ms; 2789 bfa_sm_send_event(fdmi, FDMISM_EVENT_PORT_OFFLINE); 2790} 2791 2792void 2793bfa_fcs_lport_fdmi_online(struct bfa_fcs_lport_ms_s *ms) 2794{ 2795 struct bfa_fcs_lport_fdmi_s *fdmi = &ms->fdmi; 2796 2797 fdmi->ms = ms; 2798 bfa_sm_send_event(fdmi, FDMISM_EVENT_PORT_ONLINE); 2799} 2800 2801#define BFA_FCS_MS_CMD_MAX_RETRIES 2 2802 2803/* 2804 * forward declarations 2805 */ 2806static void bfa_fcs_lport_ms_send_plogi(void *ms_cbarg, 2807 struct bfa_fcxp_s *fcxp_alloced); 2808static void bfa_fcs_lport_ms_timeout(void *arg); 2809static void bfa_fcs_lport_ms_plogi_response(void *fcsarg, 2810 struct bfa_fcxp_s *fcxp, 2811 void *cbarg, 2812 bfa_status_t req_status, 2813 u32 rsp_len, 2814 u32 resid_len, 2815 struct fchs_s *rsp_fchs); 2816 2817static void bfa_fcs_lport_ms_send_gmal(void *ms_cbarg, 2818 struct bfa_fcxp_s *fcxp_alloced); 2819static void bfa_fcs_lport_ms_gmal_response(void *fcsarg, 2820 struct bfa_fcxp_s *fcxp, 2821 void *cbarg, 2822 bfa_status_t req_status, 2823 u32 rsp_len, 2824 u32 resid_len, 2825 struct fchs_s *rsp_fchs); 2826static void bfa_fcs_lport_ms_send_gfn(void *ms_cbarg, 2827 struct bfa_fcxp_s *fcxp_alloced); 2828static void bfa_fcs_lport_ms_gfn_response(void *fcsarg, 2829 struct bfa_fcxp_s *fcxp, 2830 void *cbarg, 2831 bfa_status_t req_status, 2832 u32 rsp_len, 2833 u32 resid_len, 2834 struct fchs_s *rsp_fchs); 2835/* 2836 * fcs_ms_sm FCS MS state machine 2837 */ 2838 2839static void bfa_fcs_lport_ms_sm_offline(struct bfa_fcs_lport_ms_s *ms, 2840 enum port_ms_event event); 2841static void bfa_fcs_lport_ms_sm_plogi_sending(struct bfa_fcs_lport_ms_s *ms, 2842 enum port_ms_event event); 2843static void bfa_fcs_lport_ms_sm_plogi(struct bfa_fcs_lport_ms_s *ms, 2844 enum port_ms_event event); 2845static void bfa_fcs_lport_ms_sm_plogi_retry(struct bfa_fcs_lport_ms_s *ms, 2846 enum port_ms_event event); 2847static void bfa_fcs_lport_ms_sm_gmal_sending(struct bfa_fcs_lport_ms_s *ms, 2848 enum port_ms_event event); 2849static void bfa_fcs_lport_ms_sm_gmal(struct bfa_fcs_lport_ms_s *ms, 2850 enum port_ms_event event); 2851static void bfa_fcs_lport_ms_sm_gmal_retry(struct bfa_fcs_lport_ms_s *ms, 2852 enum port_ms_event event); 2853static void bfa_fcs_lport_ms_sm_gfn_sending(struct bfa_fcs_lport_ms_s *ms, 2854 enum port_ms_event event); 2855static void bfa_fcs_lport_ms_sm_gfn(struct bfa_fcs_lport_ms_s *ms, 2856 enum port_ms_event event); 2857static void bfa_fcs_lport_ms_sm_gfn_retry(struct bfa_fcs_lport_ms_s *ms, 2858 enum port_ms_event event); 2859static void bfa_fcs_lport_ms_sm_online(struct bfa_fcs_lport_ms_s *ms, 2860 enum port_ms_event event); 2861/* 2862 * Start in offline state - awaiting NS to send start. 2863 */ 2864static void 2865bfa_fcs_lport_ms_sm_offline(struct bfa_fcs_lport_ms_s *ms, 2866 enum port_ms_event event) 2867{ 2868 bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn); 2869 bfa_trc(ms->port->fcs, event); 2870 2871 switch (event) { 2872 case MSSM_EVENT_PORT_ONLINE: 2873 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_plogi_sending); 2874 bfa_fcs_lport_ms_send_plogi(ms, NULL); 2875 break; 2876 2877 case MSSM_EVENT_PORT_OFFLINE: 2878 break; 2879 2880 default: 2881 bfa_sm_fault(ms->port->fcs, event); 2882 } 2883} 2884 2885static void 2886bfa_fcs_lport_ms_sm_plogi_sending(struct bfa_fcs_lport_ms_s *ms, 2887 enum port_ms_event event) 2888{ 2889 bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn); 2890 bfa_trc(ms->port->fcs, event); 2891 2892 switch (event) { 2893 case MSSM_EVENT_FCXP_SENT: 2894 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_plogi); 2895 break; 2896 2897 case MSSM_EVENT_PORT_OFFLINE: 2898 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline); 2899 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ms->port), 2900 &ms->fcxp_wqe); 2901 break; 2902 2903 default: 2904 bfa_sm_fault(ms->port->fcs, event); 2905 } 2906} 2907 2908static void 2909bfa_fcs_lport_ms_sm_plogi(struct bfa_fcs_lport_ms_s *ms, 2910 enum port_ms_event event) 2911{ 2912 bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn); 2913 bfa_trc(ms->port->fcs, event); 2914 2915 switch (event) { 2916 case MSSM_EVENT_RSP_ERROR: 2917 /* 2918 * Start timer for a delayed retry 2919 */ 2920 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_plogi_retry); 2921 ms->port->stats.ms_retries++; 2922 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ms->port), 2923 &ms->timer, bfa_fcs_lport_ms_timeout, ms, 2924 BFA_FCS_RETRY_TIMEOUT); 2925 break; 2926 2927 case MSSM_EVENT_RSP_OK: 2928 /* 2929 * since plogi is done, now invoke MS related sub-modules 2930 */ 2931 bfa_fcs_lport_fdmi_online(ms); 2932 2933 /* 2934 * if this is a Vport, go to online state. 2935 */ 2936 if (ms->port->vport) { 2937 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_online); 2938 break; 2939 } 2940 2941 /* 2942 * For a base port we need to get the 2943 * switch's IP address. 2944 */ 2945 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gmal_sending); 2946 bfa_fcs_lport_ms_send_gmal(ms, NULL); 2947 break; 2948 2949 case MSSM_EVENT_PORT_OFFLINE: 2950 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline); 2951 bfa_fcxp_discard(ms->fcxp); 2952 break; 2953 2954 default: 2955 bfa_sm_fault(ms->port->fcs, event); 2956 } 2957} 2958 2959static void 2960bfa_fcs_lport_ms_sm_plogi_retry(struct bfa_fcs_lport_ms_s *ms, 2961 enum port_ms_event event) 2962{ 2963 bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn); 2964 bfa_trc(ms->port->fcs, event); 2965 2966 switch (event) { 2967 case MSSM_EVENT_TIMEOUT: 2968 /* 2969 * Retry Timer Expired. Re-send 2970 */ 2971 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_plogi_sending); 2972 bfa_fcs_lport_ms_send_plogi(ms, NULL); 2973 break; 2974 2975 case MSSM_EVENT_PORT_OFFLINE: 2976 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline); 2977 bfa_timer_stop(&ms->timer); 2978 break; 2979 2980 default: 2981 bfa_sm_fault(ms->port->fcs, event); 2982 } 2983} 2984 2985static void 2986bfa_fcs_lport_ms_sm_online(struct bfa_fcs_lport_ms_s *ms, 2987 enum port_ms_event event) 2988{ 2989 bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn); 2990 bfa_trc(ms->port->fcs, event); 2991 2992 switch (event) { 2993 case MSSM_EVENT_PORT_OFFLINE: 2994 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline); 2995 break; 2996 2997 case MSSM_EVENT_PORT_FABRIC_RSCN: 2998 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn_sending); 2999 ms->retry_cnt = 0; 3000 bfa_fcs_lport_ms_send_gfn(ms, NULL); 3001 break; 3002 3003 default: 3004 bfa_sm_fault(ms->port->fcs, event); 3005 } 3006} 3007 3008static void 3009bfa_fcs_lport_ms_sm_gmal_sending(struct bfa_fcs_lport_ms_s *ms, 3010 enum port_ms_event event) 3011{ 3012 bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn); 3013 bfa_trc(ms->port->fcs, event); 3014 3015 switch (event) { 3016 case MSSM_EVENT_FCXP_SENT: 3017 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gmal); 3018 break; 3019 3020 case MSSM_EVENT_PORT_OFFLINE: 3021 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline); 3022 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ms->port), 3023 &ms->fcxp_wqe); 3024 break; 3025 3026 default: 3027 bfa_sm_fault(ms->port->fcs, event); 3028 } 3029} 3030 3031static void 3032bfa_fcs_lport_ms_sm_gmal(struct bfa_fcs_lport_ms_s *ms, 3033 enum port_ms_event event) 3034{ 3035 bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn); 3036 bfa_trc(ms->port->fcs, event); 3037 3038 switch (event) { 3039 case MSSM_EVENT_RSP_ERROR: 3040 /* 3041 * Start timer for a delayed retry 3042 */ 3043 if (ms->retry_cnt++ < BFA_FCS_MS_CMD_MAX_RETRIES) { 3044 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gmal_retry); 3045 ms->port->stats.ms_retries++; 3046 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ms->port), 3047 &ms->timer, bfa_fcs_lport_ms_timeout, ms, 3048 BFA_FCS_RETRY_TIMEOUT); 3049 } else { 3050 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn_sending); 3051 bfa_fcs_lport_ms_send_gfn(ms, NULL); 3052 ms->retry_cnt = 0; 3053 } 3054 break; 3055 3056 case MSSM_EVENT_RSP_OK: 3057 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn_sending); 3058 bfa_fcs_lport_ms_send_gfn(ms, NULL); 3059 break; 3060 3061 case MSSM_EVENT_PORT_OFFLINE: 3062 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline); 3063 bfa_fcxp_discard(ms->fcxp); 3064 break; 3065 3066 default: 3067 bfa_sm_fault(ms->port->fcs, event); 3068 } 3069} 3070 3071static void 3072bfa_fcs_lport_ms_sm_gmal_retry(struct bfa_fcs_lport_ms_s *ms, 3073 enum port_ms_event event) 3074{ 3075 bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn); 3076 bfa_trc(ms->port->fcs, event); 3077 3078 switch (event) { 3079 case MSSM_EVENT_TIMEOUT: 3080 /* 3081 * Retry Timer Expired. Re-send 3082 */ 3083 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gmal_sending); 3084 bfa_fcs_lport_ms_send_gmal(ms, NULL); 3085 break; 3086 3087 case MSSM_EVENT_PORT_OFFLINE: 3088 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline); 3089 bfa_timer_stop(&ms->timer); 3090 break; 3091 3092 default: 3093 bfa_sm_fault(ms->port->fcs, event); 3094 } 3095} 3096/* 3097 * ms_pvt MS local functions 3098 */ 3099 3100static void 3101bfa_fcs_lport_ms_send_gmal(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced) 3102{ 3103 struct bfa_fcs_lport_ms_s *ms = ms_cbarg; 3104 bfa_fcs_lport_t *port = ms->port; 3105 struct fchs_s fchs; 3106 int len; 3107 struct bfa_fcxp_s *fcxp; 3108 3109 bfa_trc(port->fcs, port->pid); 3110 3111 fcxp = fcxp_alloced ? fcxp_alloced : 3112 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE); 3113 if (!fcxp) { 3114 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe, 3115 bfa_fcs_lport_ms_send_gmal, ms, BFA_TRUE); 3116 return; 3117 } 3118 ms->fcxp = fcxp; 3119 3120 len = fc_gmal_req_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 3121 bfa_fcs_lport_get_fcid(port), 3122 port->fabric->lps->pr_nwwn); 3123 3124 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 3125 FC_CLASS_3, len, &fchs, 3126 bfa_fcs_lport_ms_gmal_response, (void *)ms, 3127 FC_MAX_PDUSZ, FC_FCCT_TOV); 3128 3129 bfa_sm_send_event(ms, MSSM_EVENT_FCXP_SENT); 3130} 3131 3132static void 3133bfa_fcs_lport_ms_gmal_response(void *fcsarg, struct bfa_fcxp_s *fcxp, 3134 void *cbarg, bfa_status_t req_status, 3135 u32 rsp_len, u32 resid_len, 3136 struct fchs_s *rsp_fchs) 3137{ 3138 struct bfa_fcs_lport_ms_s *ms = (struct bfa_fcs_lport_ms_s *) cbarg; 3139 bfa_fcs_lport_t *port = ms->port; 3140 struct ct_hdr_s *cthdr = NULL; 3141 struct fcgs_gmal_resp_s *gmal_resp; 3142 struct fcgs_gmal_entry_s *gmal_entry; 3143 u32 num_entries; 3144 u8 *rsp_str; 3145 3146 bfa_trc(port->fcs, req_status); 3147 bfa_trc(port->fcs, port->port_cfg.pwwn); 3148 3149 /* 3150 * Sanity Checks 3151 */ 3152 if (req_status != BFA_STATUS_OK) { 3153 bfa_trc(port->fcs, req_status); 3154 bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR); 3155 return; 3156 } 3157 3158 cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp); 3159 cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code); 3160 3161 if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) { 3162 gmal_resp = (struct fcgs_gmal_resp_s *)(cthdr + 1); 3163 3164 num_entries = be32_to_cpu(gmal_resp->ms_len); 3165 if (num_entries == 0) { 3166 bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR); 3167 return; 3168 } 3169 /* 3170 * The response could contain multiple Entries. 3171 * Entries for SNMP interface, etc. 3172 * We look for the entry with a telnet prefix. 3173 * First "http://" entry refers to IP addr 3174 */ 3175 3176 gmal_entry = (struct fcgs_gmal_entry_s *)gmal_resp->ms_ma; 3177 while (num_entries > 0) { 3178 if (strncmp(gmal_entry->prefix, 3179 CT_GMAL_RESP_PREFIX_HTTP, 3180 sizeof(gmal_entry->prefix)) == 0) { 3181 3182 /* 3183 * if the IP address is terminating with a '/', 3184 * remove it. 3185 * Byte 0 consists of the length of the string. 3186 */ 3187 rsp_str = &(gmal_entry->prefix[0]); 3188 if (rsp_str[gmal_entry->len-1] == '/') 3189 rsp_str[gmal_entry->len-1] = 0; 3190 3191 /* copy IP Address to fabric */ 3192 strscpy(bfa_fcs_lport_get_fabric_ipaddr(port), 3193 gmal_entry->ip_addr, 3194 BFA_FCS_FABRIC_IPADDR_SZ); 3195 break; 3196 } else { 3197 --num_entries; 3198 ++gmal_entry; 3199 } 3200 } 3201 3202 bfa_sm_send_event(ms, MSSM_EVENT_RSP_OK); 3203 return; 3204 } 3205 3206 bfa_trc(port->fcs, cthdr->reason_code); 3207 bfa_trc(port->fcs, cthdr->exp_code); 3208 bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR); 3209} 3210 3211static void 3212bfa_fcs_lport_ms_sm_gfn_sending(struct bfa_fcs_lport_ms_s *ms, 3213 enum port_ms_event event) 3214{ 3215 bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn); 3216 bfa_trc(ms->port->fcs, event); 3217 3218 switch (event) { 3219 case MSSM_EVENT_FCXP_SENT: 3220 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn); 3221 break; 3222 3223 case MSSM_EVENT_PORT_OFFLINE: 3224 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline); 3225 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ms->port), 3226 &ms->fcxp_wqe); 3227 break; 3228 3229 default: 3230 bfa_sm_fault(ms->port->fcs, event); 3231 } 3232} 3233 3234static void 3235bfa_fcs_lport_ms_sm_gfn(struct bfa_fcs_lport_ms_s *ms, 3236 enum port_ms_event event) 3237{ 3238 bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn); 3239 bfa_trc(ms->port->fcs, event); 3240 3241 switch (event) { 3242 case MSSM_EVENT_RSP_ERROR: 3243 /* 3244 * Start timer for a delayed retry 3245 */ 3246 if (ms->retry_cnt++ < BFA_FCS_MS_CMD_MAX_RETRIES) { 3247 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn_retry); 3248 ms->port->stats.ms_retries++; 3249 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ms->port), 3250 &ms->timer, bfa_fcs_lport_ms_timeout, ms, 3251 BFA_FCS_RETRY_TIMEOUT); 3252 } else { 3253 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_online); 3254 ms->retry_cnt = 0; 3255 } 3256 break; 3257 3258 case MSSM_EVENT_RSP_OK: 3259 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_online); 3260 break; 3261 3262 case MSSM_EVENT_PORT_OFFLINE: 3263 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline); 3264 bfa_fcxp_discard(ms->fcxp); 3265 break; 3266 3267 default: 3268 bfa_sm_fault(ms->port->fcs, event); 3269 } 3270} 3271 3272static void 3273bfa_fcs_lport_ms_sm_gfn_retry(struct bfa_fcs_lport_ms_s *ms, 3274 enum port_ms_event event) 3275{ 3276 bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn); 3277 bfa_trc(ms->port->fcs, event); 3278 3279 switch (event) { 3280 case MSSM_EVENT_TIMEOUT: 3281 /* 3282 * Retry Timer Expired. Re-send 3283 */ 3284 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn_sending); 3285 bfa_fcs_lport_ms_send_gfn(ms, NULL); 3286 break; 3287 3288 case MSSM_EVENT_PORT_OFFLINE: 3289 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline); 3290 bfa_timer_stop(&ms->timer); 3291 break; 3292 3293 default: 3294 bfa_sm_fault(ms->port->fcs, event); 3295 } 3296} 3297/* 3298 * ms_pvt MS local functions 3299 */ 3300 3301static void 3302bfa_fcs_lport_ms_send_gfn(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced) 3303{ 3304 struct bfa_fcs_lport_ms_s *ms = ms_cbarg; 3305 bfa_fcs_lport_t *port = ms->port; 3306 struct fchs_s fchs; 3307 int len; 3308 struct bfa_fcxp_s *fcxp; 3309 3310 bfa_trc(port->fcs, port->pid); 3311 3312 fcxp = fcxp_alloced ? fcxp_alloced : 3313 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE); 3314 if (!fcxp) { 3315 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe, 3316 bfa_fcs_lport_ms_send_gfn, ms, BFA_TRUE); 3317 return; 3318 } 3319 ms->fcxp = fcxp; 3320 3321 len = fc_gfn_req_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 3322 bfa_fcs_lport_get_fcid(port), 3323 port->fabric->lps->pr_nwwn); 3324 3325 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 3326 FC_CLASS_3, len, &fchs, 3327 bfa_fcs_lport_ms_gfn_response, (void *)ms, 3328 FC_MAX_PDUSZ, FC_FCCT_TOV); 3329 3330 bfa_sm_send_event(ms, MSSM_EVENT_FCXP_SENT); 3331} 3332 3333static void 3334bfa_fcs_lport_ms_gfn_response(void *fcsarg, struct bfa_fcxp_s *fcxp, 3335 void *cbarg, bfa_status_t req_status, u32 rsp_len, 3336 u32 resid_len, struct fchs_s *rsp_fchs) 3337{ 3338 struct bfa_fcs_lport_ms_s *ms = (struct bfa_fcs_lport_ms_s *) cbarg; 3339 bfa_fcs_lport_t *port = ms->port; 3340 struct ct_hdr_s *cthdr = NULL; 3341 wwn_t *gfn_resp; 3342 3343 bfa_trc(port->fcs, req_status); 3344 bfa_trc(port->fcs, port->port_cfg.pwwn); 3345 3346 /* 3347 * Sanity Checks 3348 */ 3349 if (req_status != BFA_STATUS_OK) { 3350 bfa_trc(port->fcs, req_status); 3351 bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR); 3352 return; 3353 } 3354 3355 cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp); 3356 cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code); 3357 3358 if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) { 3359 gfn_resp = (wwn_t *)(cthdr + 1); 3360 /* check if it has actually changed */ 3361 if ((memcmp((void *)&bfa_fcs_lport_get_fabric_name(port), 3362 gfn_resp, sizeof(wwn_t)) != 0)) { 3363 bfa_fcs_fabric_set_fabric_name(port->fabric, *gfn_resp); 3364 } 3365 bfa_sm_send_event(ms, MSSM_EVENT_RSP_OK); 3366 return; 3367 } 3368 3369 bfa_trc(port->fcs, cthdr->reason_code); 3370 bfa_trc(port->fcs, cthdr->exp_code); 3371 bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR); 3372} 3373 3374/* 3375 * ms_pvt MS local functions 3376 */ 3377 3378static void 3379bfa_fcs_lport_ms_send_plogi(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced) 3380{ 3381 struct bfa_fcs_lport_ms_s *ms = ms_cbarg; 3382 struct bfa_fcs_lport_s *port = ms->port; 3383 struct fchs_s fchs; 3384 int len; 3385 struct bfa_fcxp_s *fcxp; 3386 3387 bfa_trc(port->fcs, port->pid); 3388 3389 fcxp = fcxp_alloced ? fcxp_alloced : 3390 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE); 3391 if (!fcxp) { 3392 port->stats.ms_plogi_alloc_wait++; 3393 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe, 3394 bfa_fcs_lport_ms_send_plogi, ms, BFA_TRUE); 3395 return; 3396 } 3397 ms->fcxp = fcxp; 3398 3399 len = fc_plogi_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 3400 bfa_hton3b(FC_MGMT_SERVER), 3401 bfa_fcs_lport_get_fcid(port), 0, 3402 port->port_cfg.pwwn, port->port_cfg.nwwn, 3403 bfa_fcport_get_maxfrsize(port->fcs->bfa), 3404 bfa_fcport_get_rx_bbcredit(port->fcs->bfa)); 3405 3406 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 3407 FC_CLASS_3, len, &fchs, 3408 bfa_fcs_lport_ms_plogi_response, (void *)ms, 3409 FC_MAX_PDUSZ, FC_ELS_TOV); 3410 3411 port->stats.ms_plogi_sent++; 3412 bfa_sm_send_event(ms, MSSM_EVENT_FCXP_SENT); 3413} 3414 3415static void 3416bfa_fcs_lport_ms_plogi_response(void *fcsarg, struct bfa_fcxp_s *fcxp, 3417 void *cbarg, bfa_status_t req_status, 3418 u32 rsp_len, u32 resid_len, struct fchs_s *rsp_fchs) 3419{ 3420 struct bfa_fcs_lport_ms_s *ms = (struct bfa_fcs_lport_ms_s *) cbarg; 3421 struct bfa_fcs_lport_s *port = ms->port; 3422 struct fc_els_cmd_s *els_cmd; 3423 struct fc_ls_rjt_s *ls_rjt; 3424 3425 bfa_trc(port->fcs, req_status); 3426 bfa_trc(port->fcs, port->port_cfg.pwwn); 3427 3428 /* 3429 * Sanity Checks 3430 */ 3431 if (req_status != BFA_STATUS_OK) { 3432 port->stats.ms_plogi_rsp_err++; 3433 bfa_trc(port->fcs, req_status); 3434 bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR); 3435 return; 3436 } 3437 3438 els_cmd = (struct fc_els_cmd_s *) BFA_FCXP_RSP_PLD(fcxp); 3439 3440 switch (els_cmd->els_code) { 3441 3442 case FC_ELS_ACC: 3443 if (rsp_len < sizeof(struct fc_logi_s)) { 3444 bfa_trc(port->fcs, rsp_len); 3445 port->stats.ms_plogi_acc_err++; 3446 bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR); 3447 break; 3448 } 3449 port->stats.ms_plogi_accepts++; 3450 bfa_sm_send_event(ms, MSSM_EVENT_RSP_OK); 3451 break; 3452 3453 case FC_ELS_LS_RJT: 3454 ls_rjt = (struct fc_ls_rjt_s *) BFA_FCXP_RSP_PLD(fcxp); 3455 3456 bfa_trc(port->fcs, ls_rjt->reason_code); 3457 bfa_trc(port->fcs, ls_rjt->reason_code_expl); 3458 3459 port->stats.ms_rejects++; 3460 bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR); 3461 break; 3462 3463 default: 3464 port->stats.ms_plogi_unknown_rsp++; 3465 bfa_trc(port->fcs, els_cmd->els_code); 3466 bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR); 3467 } 3468} 3469 3470static void 3471bfa_fcs_lport_ms_timeout(void *arg) 3472{ 3473 struct bfa_fcs_lport_ms_s *ms = (struct bfa_fcs_lport_ms_s *) arg; 3474 3475 ms->port->stats.ms_timeouts++; 3476 bfa_sm_send_event(ms, MSSM_EVENT_TIMEOUT); 3477} 3478 3479 3480void 3481bfa_fcs_lport_ms_init(struct bfa_fcs_lport_s *port) 3482{ 3483 struct bfa_fcs_lport_ms_s *ms = BFA_FCS_GET_MS_FROM_PORT(port); 3484 3485 ms->port = port; 3486 bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline); 3487 3488 /* 3489 * Invoke init routines of sub modules. 3490 */ 3491 bfa_fcs_lport_fdmi_init(ms); 3492} 3493 3494void 3495bfa_fcs_lport_ms_offline(struct bfa_fcs_lport_s *port) 3496{ 3497 struct bfa_fcs_lport_ms_s *ms = BFA_FCS_GET_MS_FROM_PORT(port); 3498 3499 ms->port = port; 3500 bfa_sm_send_event(ms, MSSM_EVENT_PORT_OFFLINE); 3501 bfa_fcs_lport_fdmi_offline(ms); 3502} 3503 3504void 3505bfa_fcs_lport_ms_online(struct bfa_fcs_lport_s *port) 3506{ 3507 struct bfa_fcs_lport_ms_s *ms = BFA_FCS_GET_MS_FROM_PORT(port); 3508 3509 ms->port = port; 3510 bfa_sm_send_event(ms, MSSM_EVENT_PORT_ONLINE); 3511} 3512void 3513bfa_fcs_lport_ms_fabric_rscn(struct bfa_fcs_lport_s *port) 3514{ 3515 struct bfa_fcs_lport_ms_s *ms = BFA_FCS_GET_MS_FROM_PORT(port); 3516 3517 /* todo. Handle this only when in Online state */ 3518 if (bfa_sm_cmp_state(ms, bfa_fcs_lport_ms_sm_online)) 3519 bfa_sm_send_event(ms, MSSM_EVENT_PORT_FABRIC_RSCN); 3520} 3521 3522/* 3523 * @page ns_sm_info VPORT NS State Machine 3524 * 3525 * @section ns_sm_interactions VPORT NS State Machine Interactions 3526 * 3527 * @section ns_sm VPORT NS State Machine 3528 * img ns_sm.jpg 3529 */ 3530 3531/* 3532 * forward declarations 3533 */ 3534static void bfa_fcs_lport_ns_send_plogi(void *ns_cbarg, 3535 struct bfa_fcxp_s *fcxp_alloced); 3536static void bfa_fcs_lport_ns_send_rspn_id(void *ns_cbarg, 3537 struct bfa_fcxp_s *fcxp_alloced); 3538static void bfa_fcs_lport_ns_send_rft_id(void *ns_cbarg, 3539 struct bfa_fcxp_s *fcxp_alloced); 3540static void bfa_fcs_lport_ns_send_rff_id(void *ns_cbarg, 3541 struct bfa_fcxp_s *fcxp_alloced); 3542static void bfa_fcs_lport_ns_send_gid_ft(void *ns_cbarg, 3543 struct bfa_fcxp_s *fcxp_alloced); 3544static void bfa_fcs_lport_ns_send_rnn_id(void *ns_cbarg, 3545 struct bfa_fcxp_s *fcxp_alloced); 3546static void bfa_fcs_lport_ns_send_rsnn_nn(void *ns_cbarg, 3547 struct bfa_fcxp_s *fcxp_alloced); 3548static void bfa_fcs_lport_ns_timeout(void *arg); 3549static void bfa_fcs_lport_ns_plogi_response(void *fcsarg, 3550 struct bfa_fcxp_s *fcxp, 3551 void *cbarg, 3552 bfa_status_t req_status, 3553 u32 rsp_len, 3554 u32 resid_len, 3555 struct fchs_s *rsp_fchs); 3556static void bfa_fcs_lport_ns_rspn_id_response(void *fcsarg, 3557 struct bfa_fcxp_s *fcxp, 3558 void *cbarg, 3559 bfa_status_t req_status, 3560 u32 rsp_len, 3561 u32 resid_len, 3562 struct fchs_s *rsp_fchs); 3563static void bfa_fcs_lport_ns_rft_id_response(void *fcsarg, 3564 struct bfa_fcxp_s *fcxp, 3565 void *cbarg, 3566 bfa_status_t req_status, 3567 u32 rsp_len, 3568 u32 resid_len, 3569 struct fchs_s *rsp_fchs); 3570static void bfa_fcs_lport_ns_rff_id_response(void *fcsarg, 3571 struct bfa_fcxp_s *fcxp, 3572 void *cbarg, 3573 bfa_status_t req_status, 3574 u32 rsp_len, 3575 u32 resid_len, 3576 struct fchs_s *rsp_fchs); 3577static void bfa_fcs_lport_ns_gid_ft_response(void *fcsarg, 3578 struct bfa_fcxp_s *fcxp, 3579 void *cbarg, 3580 bfa_status_t req_status, 3581 u32 rsp_len, 3582 u32 resid_len, 3583 struct fchs_s *rsp_fchs); 3584static void bfa_fcs_lport_ns_rnn_id_response(void *fcsarg, 3585 struct bfa_fcxp_s *fcxp, 3586 void *cbarg, 3587 bfa_status_t req_status, 3588 u32 rsp_len, 3589 u32 resid_len, 3590 struct fchs_s *rsp_fchs); 3591static void bfa_fcs_lport_ns_rsnn_nn_response(void *fcsarg, 3592 struct bfa_fcxp_s *fcxp, 3593 void *cbarg, 3594 bfa_status_t req_status, 3595 u32 rsp_len, 3596 u32 resid_len, 3597 struct fchs_s *rsp_fchs); 3598static void bfa_fcs_lport_ns_process_gidft_pids( 3599 struct bfa_fcs_lport_s *port, 3600 u32 *pid_buf, u32 n_pids); 3601 3602static void bfa_fcs_lport_ns_boot_target_disc(bfa_fcs_lport_t *port); 3603/* 3604 * fcs_ns_sm FCS nameserver interface state machine 3605 */ 3606 3607static void bfa_fcs_lport_ns_sm_offline(struct bfa_fcs_lport_ns_s *ns, 3608 enum vport_ns_event event); 3609static void bfa_fcs_lport_ns_sm_plogi_sending(struct bfa_fcs_lport_ns_s *ns, 3610 enum vport_ns_event event); 3611static void bfa_fcs_lport_ns_sm_plogi(struct bfa_fcs_lport_ns_s *ns, 3612 enum vport_ns_event event); 3613static void bfa_fcs_lport_ns_sm_plogi_retry(struct bfa_fcs_lport_ns_s *ns, 3614 enum vport_ns_event event); 3615static void bfa_fcs_lport_ns_sm_sending_rspn_id( 3616 struct bfa_fcs_lport_ns_s *ns, 3617 enum vport_ns_event event); 3618static void bfa_fcs_lport_ns_sm_rspn_id(struct bfa_fcs_lport_ns_s *ns, 3619 enum vport_ns_event event); 3620static void bfa_fcs_lport_ns_sm_rspn_id_retry(struct bfa_fcs_lport_ns_s *ns, 3621 enum vport_ns_event event); 3622static void bfa_fcs_lport_ns_sm_sending_rft_id( 3623 struct bfa_fcs_lport_ns_s *ns, 3624 enum vport_ns_event event); 3625static void bfa_fcs_lport_ns_sm_rft_id_retry(struct bfa_fcs_lport_ns_s *ns, 3626 enum vport_ns_event event); 3627static void bfa_fcs_lport_ns_sm_rft_id(struct bfa_fcs_lport_ns_s *ns, 3628 enum vport_ns_event event); 3629static void bfa_fcs_lport_ns_sm_sending_rff_id( 3630 struct bfa_fcs_lport_ns_s *ns, 3631 enum vport_ns_event event); 3632static void bfa_fcs_lport_ns_sm_rff_id_retry(struct bfa_fcs_lport_ns_s *ns, 3633 enum vport_ns_event event); 3634static void bfa_fcs_lport_ns_sm_rff_id(struct bfa_fcs_lport_ns_s *ns, 3635 enum vport_ns_event event); 3636static void bfa_fcs_lport_ns_sm_sending_gid_ft( 3637 struct bfa_fcs_lport_ns_s *ns, 3638 enum vport_ns_event event); 3639static void bfa_fcs_lport_ns_sm_gid_ft(struct bfa_fcs_lport_ns_s *ns, 3640 enum vport_ns_event event); 3641static void bfa_fcs_lport_ns_sm_gid_ft_retry(struct bfa_fcs_lport_ns_s *ns, 3642 enum vport_ns_event event); 3643static void bfa_fcs_lport_ns_sm_online(struct bfa_fcs_lport_ns_s *ns, 3644 enum vport_ns_event event); 3645static void bfa_fcs_lport_ns_sm_sending_rnn_id( 3646 struct bfa_fcs_lport_ns_s *ns, 3647 enum vport_ns_event event); 3648static void bfa_fcs_lport_ns_sm_rnn_id(struct bfa_fcs_lport_ns_s *ns, 3649 enum vport_ns_event event); 3650static void bfa_fcs_lport_ns_sm_rnn_id_retry(struct bfa_fcs_lport_ns_s *ns, 3651 enum vport_ns_event event); 3652static void bfa_fcs_lport_ns_sm_sending_rsnn_nn( 3653 struct bfa_fcs_lport_ns_s *ns, 3654 enum vport_ns_event event); 3655static void bfa_fcs_lport_ns_sm_rsnn_nn(struct bfa_fcs_lport_ns_s *ns, 3656 enum vport_ns_event event); 3657static void bfa_fcs_lport_ns_sm_rsnn_nn_retry( 3658 struct bfa_fcs_lport_ns_s *ns, 3659 enum vport_ns_event event); 3660/* 3661 * Start in offline state - awaiting linkup 3662 */ 3663static void 3664bfa_fcs_lport_ns_sm_offline(struct bfa_fcs_lport_ns_s *ns, 3665 enum vport_ns_event event) 3666{ 3667 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 3668 bfa_trc(ns->port->fcs, event); 3669 3670 switch (event) { 3671 case NSSM_EVENT_PORT_ONLINE: 3672 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_plogi_sending); 3673 bfa_fcs_lport_ns_send_plogi(ns, NULL); 3674 break; 3675 3676 case NSSM_EVENT_PORT_OFFLINE: 3677 break; 3678 3679 default: 3680 bfa_sm_fault(ns->port->fcs, event); 3681 } 3682} 3683 3684static void 3685bfa_fcs_lport_ns_sm_plogi_sending(struct bfa_fcs_lport_ns_s *ns, 3686 enum vport_ns_event event) 3687{ 3688 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 3689 bfa_trc(ns->port->fcs, event); 3690 3691 switch (event) { 3692 case NSSM_EVENT_PLOGI_SENT: 3693 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_plogi); 3694 break; 3695 3696 case NSSM_EVENT_PORT_OFFLINE: 3697 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 3698 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port), 3699 &ns->fcxp_wqe); 3700 break; 3701 3702 default: 3703 bfa_sm_fault(ns->port->fcs, event); 3704 } 3705} 3706 3707static void 3708bfa_fcs_lport_ns_sm_plogi(struct bfa_fcs_lport_ns_s *ns, 3709 enum vport_ns_event event) 3710{ 3711 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 3712 bfa_trc(ns->port->fcs, event); 3713 3714 switch (event) { 3715 case NSSM_EVENT_RSP_ERROR: 3716 /* 3717 * Start timer for a delayed retry 3718 */ 3719 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_plogi_retry); 3720 ns->port->stats.ns_retries++; 3721 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port), 3722 &ns->timer, bfa_fcs_lport_ns_timeout, ns, 3723 BFA_FCS_RETRY_TIMEOUT); 3724 break; 3725 3726 case NSSM_EVENT_RSP_OK: 3727 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rnn_id); 3728 ns->num_rnnid_retries = 0; 3729 bfa_fcs_lport_ns_send_rnn_id(ns, NULL); 3730 break; 3731 3732 case NSSM_EVENT_PORT_OFFLINE: 3733 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 3734 bfa_fcxp_discard(ns->fcxp); 3735 break; 3736 3737 default: 3738 bfa_sm_fault(ns->port->fcs, event); 3739 } 3740} 3741 3742static void 3743bfa_fcs_lport_ns_sm_plogi_retry(struct bfa_fcs_lport_ns_s *ns, 3744 enum vport_ns_event event) 3745{ 3746 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 3747 bfa_trc(ns->port->fcs, event); 3748 3749 switch (event) { 3750 case NSSM_EVENT_TIMEOUT: 3751 /* 3752 * Retry Timer Expired. Re-send 3753 */ 3754 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_plogi_sending); 3755 bfa_fcs_lport_ns_send_plogi(ns, NULL); 3756 break; 3757 3758 case NSSM_EVENT_PORT_OFFLINE: 3759 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 3760 bfa_timer_stop(&ns->timer); 3761 break; 3762 3763 default: 3764 bfa_sm_fault(ns->port->fcs, event); 3765 } 3766} 3767 3768static void 3769bfa_fcs_lport_ns_sm_sending_rnn_id(struct bfa_fcs_lport_ns_s *ns, 3770 enum vport_ns_event event) 3771{ 3772 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 3773 bfa_trc(ns->port->fcs, event); 3774 3775 switch (event) { 3776 case NSSM_EVENT_RNNID_SENT: 3777 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rnn_id); 3778 break; 3779 3780 case NSSM_EVENT_PORT_OFFLINE: 3781 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 3782 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port), 3783 &ns->fcxp_wqe); 3784 break; 3785 default: 3786 bfa_sm_fault(ns->port->fcs, event); 3787 } 3788} 3789 3790static void 3791bfa_fcs_lport_ns_sm_rnn_id(struct bfa_fcs_lport_ns_s *ns, 3792 enum vport_ns_event event) 3793{ 3794 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 3795 bfa_trc(ns->port->fcs, event); 3796 3797 switch (event) { 3798 case NSSM_EVENT_RSP_OK: 3799 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rsnn_nn); 3800 ns->num_rnnid_retries = 0; 3801 ns->num_rsnn_nn_retries = 0; 3802 bfa_fcs_lport_ns_send_rsnn_nn(ns, NULL); 3803 break; 3804 3805 case NSSM_EVENT_RSP_ERROR: 3806 if (ns->num_rnnid_retries < BFA_FCS_MAX_NS_RETRIES) { 3807 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rnn_id_retry); 3808 ns->port->stats.ns_retries++; 3809 ns->num_rnnid_retries++; 3810 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port), 3811 &ns->timer, bfa_fcs_lport_ns_timeout, ns, 3812 BFA_FCS_RETRY_TIMEOUT); 3813 } else { 3814 bfa_sm_set_state(ns, 3815 bfa_fcs_lport_ns_sm_sending_rspn_id); 3816 bfa_fcs_lport_ns_send_rspn_id(ns, NULL); 3817 } 3818 break; 3819 3820 case NSSM_EVENT_PORT_OFFLINE: 3821 bfa_fcxp_discard(ns->fcxp); 3822 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 3823 break; 3824 3825 default: 3826 bfa_sm_fault(ns->port->fcs, event); 3827 } 3828} 3829 3830static void 3831bfa_fcs_lport_ns_sm_rnn_id_retry(struct bfa_fcs_lport_ns_s *ns, 3832 enum vport_ns_event event) 3833{ 3834 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 3835 bfa_trc(ns->port->fcs, event); 3836 3837 switch (event) { 3838 case NSSM_EVENT_TIMEOUT: 3839 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rnn_id); 3840 bfa_fcs_lport_ns_send_rnn_id(ns, NULL); 3841 break; 3842 3843 case NSSM_EVENT_PORT_OFFLINE: 3844 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 3845 bfa_timer_stop(&ns->timer); 3846 break; 3847 3848 default: 3849 bfa_sm_fault(ns->port->fcs, event); 3850 } 3851} 3852 3853static void 3854bfa_fcs_lport_ns_sm_sending_rsnn_nn(struct bfa_fcs_lport_ns_s *ns, 3855 enum vport_ns_event event) 3856{ 3857 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 3858 bfa_trc(ns->port->fcs, event); 3859 3860 switch (event) { 3861 case NSSM_EVENT_RSNN_NN_SENT: 3862 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rsnn_nn); 3863 break; 3864 3865 case NSSM_EVENT_PORT_OFFLINE: 3866 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 3867 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port), 3868 &ns->fcxp_wqe); 3869 break; 3870 3871 default: 3872 bfa_sm_fault(ns->port->fcs, event); 3873 } 3874} 3875 3876static void 3877bfa_fcs_lport_ns_sm_rsnn_nn(struct bfa_fcs_lport_ns_s *ns, 3878 enum vport_ns_event event) 3879{ 3880 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 3881 bfa_trc(ns->port->fcs, event); 3882 3883 switch (event) { 3884 case NSSM_EVENT_RSP_OK: 3885 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rspn_id); 3886 ns->num_rsnn_nn_retries = 0; 3887 bfa_fcs_lport_ns_send_rspn_id(ns, NULL); 3888 break; 3889 3890 case NSSM_EVENT_RSP_ERROR: 3891 if (ns->num_rsnn_nn_retries < BFA_FCS_MAX_NS_RETRIES) { 3892 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rsnn_nn_retry); 3893 ns->port->stats.ns_retries++; 3894 ns->num_rsnn_nn_retries++; 3895 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port), 3896 &ns->timer, bfa_fcs_lport_ns_timeout, 3897 ns, BFA_FCS_RETRY_TIMEOUT); 3898 } else { 3899 bfa_sm_set_state(ns, 3900 bfa_fcs_lport_ns_sm_sending_rspn_id); 3901 bfa_fcs_lport_ns_send_rspn_id(ns, NULL); 3902 } 3903 break; 3904 3905 case NSSM_EVENT_PORT_OFFLINE: 3906 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 3907 bfa_fcxp_discard(ns->fcxp); 3908 break; 3909 3910 default: 3911 bfa_sm_fault(ns->port->fcs, event); 3912 } 3913} 3914 3915static void 3916bfa_fcs_lport_ns_sm_rsnn_nn_retry(struct bfa_fcs_lport_ns_s *ns, 3917 enum vport_ns_event event) 3918{ 3919 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 3920 bfa_trc(ns->port->fcs, event); 3921 3922 switch (event) { 3923 case NSSM_EVENT_TIMEOUT: 3924 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rsnn_nn); 3925 bfa_fcs_lport_ns_send_rsnn_nn(ns, NULL); 3926 break; 3927 3928 case NSSM_EVENT_PORT_OFFLINE: 3929 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 3930 bfa_timer_stop(&ns->timer); 3931 break; 3932 3933 default: 3934 bfa_sm_fault(ns->port->fcs, event); 3935 } 3936} 3937 3938static void 3939bfa_fcs_lport_ns_sm_sending_rspn_id(struct bfa_fcs_lport_ns_s *ns, 3940 enum vport_ns_event event) 3941{ 3942 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 3943 bfa_trc(ns->port->fcs, event); 3944 3945 switch (event) { 3946 case NSSM_EVENT_RSPNID_SENT: 3947 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rspn_id); 3948 break; 3949 3950 case NSSM_EVENT_PORT_OFFLINE: 3951 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 3952 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port), 3953 &ns->fcxp_wqe); 3954 break; 3955 3956 default: 3957 bfa_sm_fault(ns->port->fcs, event); 3958 } 3959} 3960 3961static void 3962bfa_fcs_lport_ns_sm_rspn_id(struct bfa_fcs_lport_ns_s *ns, 3963 enum vport_ns_event event) 3964{ 3965 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 3966 bfa_trc(ns->port->fcs, event); 3967 3968 switch (event) { 3969 case NSSM_EVENT_RSP_ERROR: 3970 /* 3971 * Start timer for a delayed retry 3972 */ 3973 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rspn_id_retry); 3974 ns->port->stats.ns_retries++; 3975 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port), 3976 &ns->timer, bfa_fcs_lport_ns_timeout, ns, 3977 BFA_FCS_RETRY_TIMEOUT); 3978 break; 3979 3980 case NSSM_EVENT_RSP_OK: 3981 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rft_id); 3982 bfa_fcs_lport_ns_send_rft_id(ns, NULL); 3983 break; 3984 3985 case NSSM_EVENT_PORT_OFFLINE: 3986 bfa_fcxp_discard(ns->fcxp); 3987 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 3988 break; 3989 3990 default: 3991 bfa_sm_fault(ns->port->fcs, event); 3992 } 3993} 3994 3995static void 3996bfa_fcs_lport_ns_sm_rspn_id_retry(struct bfa_fcs_lport_ns_s *ns, 3997 enum vport_ns_event event) 3998{ 3999 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 4000 bfa_trc(ns->port->fcs, event); 4001 4002 switch (event) { 4003 case NSSM_EVENT_TIMEOUT: 4004 /* 4005 * Retry Timer Expired. Re-send 4006 */ 4007 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rspn_id); 4008 bfa_fcs_lport_ns_send_rspn_id(ns, NULL); 4009 break; 4010 4011 case NSSM_EVENT_PORT_OFFLINE: 4012 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 4013 bfa_timer_stop(&ns->timer); 4014 break; 4015 4016 default: 4017 bfa_sm_fault(ns->port->fcs, event); 4018 } 4019} 4020 4021static void 4022bfa_fcs_lport_ns_sm_sending_rft_id(struct bfa_fcs_lport_ns_s *ns, 4023 enum vport_ns_event event) 4024{ 4025 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 4026 bfa_trc(ns->port->fcs, event); 4027 4028 switch (event) { 4029 case NSSM_EVENT_RFTID_SENT: 4030 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rft_id); 4031 break; 4032 4033 case NSSM_EVENT_PORT_OFFLINE: 4034 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 4035 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port), 4036 &ns->fcxp_wqe); 4037 break; 4038 4039 default: 4040 bfa_sm_fault(ns->port->fcs, event); 4041 } 4042} 4043 4044static void 4045bfa_fcs_lport_ns_sm_rft_id(struct bfa_fcs_lport_ns_s *ns, 4046 enum vport_ns_event event) 4047{ 4048 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 4049 bfa_trc(ns->port->fcs, event); 4050 4051 switch (event) { 4052 case NSSM_EVENT_RSP_OK: 4053 /* Now move to register FC4 Features */ 4054 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rff_id); 4055 bfa_fcs_lport_ns_send_rff_id(ns, NULL); 4056 break; 4057 4058 case NSSM_EVENT_RSP_ERROR: 4059 /* 4060 * Start timer for a delayed retry 4061 */ 4062 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rft_id_retry); 4063 ns->port->stats.ns_retries++; 4064 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port), 4065 &ns->timer, bfa_fcs_lport_ns_timeout, ns, 4066 BFA_FCS_RETRY_TIMEOUT); 4067 break; 4068 4069 case NSSM_EVENT_PORT_OFFLINE: 4070 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 4071 bfa_fcxp_discard(ns->fcxp); 4072 break; 4073 4074 default: 4075 bfa_sm_fault(ns->port->fcs, event); 4076 } 4077} 4078 4079static void 4080bfa_fcs_lport_ns_sm_rft_id_retry(struct bfa_fcs_lport_ns_s *ns, 4081 enum vport_ns_event event) 4082{ 4083 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 4084 bfa_trc(ns->port->fcs, event); 4085 4086 switch (event) { 4087 case NSSM_EVENT_TIMEOUT: 4088 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rft_id); 4089 bfa_fcs_lport_ns_send_rft_id(ns, NULL); 4090 break; 4091 4092 case NSSM_EVENT_PORT_OFFLINE: 4093 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 4094 bfa_timer_stop(&ns->timer); 4095 break; 4096 4097 default: 4098 bfa_sm_fault(ns->port->fcs, event); 4099 } 4100} 4101 4102static void 4103bfa_fcs_lport_ns_sm_sending_rff_id(struct bfa_fcs_lport_ns_s *ns, 4104 enum vport_ns_event event) 4105{ 4106 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 4107 bfa_trc(ns->port->fcs, event); 4108 4109 switch (event) { 4110 case NSSM_EVENT_RFFID_SENT: 4111 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rff_id); 4112 break; 4113 4114 case NSSM_EVENT_PORT_OFFLINE: 4115 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 4116 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port), 4117 &ns->fcxp_wqe); 4118 break; 4119 4120 default: 4121 bfa_sm_fault(ns->port->fcs, event); 4122 } 4123} 4124 4125static void 4126bfa_fcs_lport_ns_sm_rff_id(struct bfa_fcs_lport_ns_s *ns, 4127 enum vport_ns_event event) 4128{ 4129 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 4130 bfa_trc(ns->port->fcs, event); 4131 4132 switch (event) { 4133 case NSSM_EVENT_RSP_OK: 4134 4135 /* 4136 * If min cfg mode is enabled, we donot initiate rport 4137 * discovery with the fabric. Instead, we will retrieve the 4138 * boot targets from HAL/FW. 4139 */ 4140 if (__fcs_min_cfg(ns->port->fcs)) { 4141 bfa_fcs_lport_ns_boot_target_disc(ns->port); 4142 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_online); 4143 return; 4144 } 4145 4146 /* 4147 * If the port role is Initiator Mode issue NS query. 4148 * If it is Target Mode, skip this and go to online. 4149 */ 4150 if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns->port)) { 4151 bfa_sm_set_state(ns, 4152 bfa_fcs_lport_ns_sm_sending_gid_ft); 4153 bfa_fcs_lport_ns_send_gid_ft(ns, NULL); 4154 } 4155 /* 4156 * kick off mgmt srvr state machine 4157 */ 4158 bfa_fcs_lport_ms_online(ns->port); 4159 break; 4160 4161 case NSSM_EVENT_RSP_ERROR: 4162 /* 4163 * Start timer for a delayed retry 4164 */ 4165 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rff_id_retry); 4166 ns->port->stats.ns_retries++; 4167 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port), 4168 &ns->timer, bfa_fcs_lport_ns_timeout, ns, 4169 BFA_FCS_RETRY_TIMEOUT); 4170 break; 4171 4172 case NSSM_EVENT_PORT_OFFLINE: 4173 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 4174 bfa_fcxp_discard(ns->fcxp); 4175 break; 4176 4177 default: 4178 bfa_sm_fault(ns->port->fcs, event); 4179 } 4180} 4181 4182static void 4183bfa_fcs_lport_ns_sm_rff_id_retry(struct bfa_fcs_lport_ns_s *ns, 4184 enum vport_ns_event event) 4185{ 4186 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 4187 bfa_trc(ns->port->fcs, event); 4188 4189 switch (event) { 4190 case NSSM_EVENT_TIMEOUT: 4191 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rff_id); 4192 bfa_fcs_lport_ns_send_rff_id(ns, NULL); 4193 break; 4194 4195 case NSSM_EVENT_PORT_OFFLINE: 4196 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 4197 bfa_timer_stop(&ns->timer); 4198 break; 4199 4200 default: 4201 bfa_sm_fault(ns->port->fcs, event); 4202 } 4203} 4204static void 4205bfa_fcs_lport_ns_sm_sending_gid_ft(struct bfa_fcs_lport_ns_s *ns, 4206 enum vport_ns_event event) 4207{ 4208 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 4209 bfa_trc(ns->port->fcs, event); 4210 4211 switch (event) { 4212 case NSSM_EVENT_GIDFT_SENT: 4213 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_gid_ft); 4214 break; 4215 4216 case NSSM_EVENT_PORT_OFFLINE: 4217 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 4218 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port), 4219 &ns->fcxp_wqe); 4220 break; 4221 4222 default: 4223 bfa_sm_fault(ns->port->fcs, event); 4224 } 4225} 4226 4227static void 4228bfa_fcs_lport_ns_sm_gid_ft(struct bfa_fcs_lport_ns_s *ns, 4229 enum vport_ns_event event) 4230{ 4231 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 4232 bfa_trc(ns->port->fcs, event); 4233 4234 switch (event) { 4235 case NSSM_EVENT_RSP_OK: 4236 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_online); 4237 break; 4238 4239 case NSSM_EVENT_RSP_ERROR: 4240 /* 4241 * TBD: for certain reject codes, we don't need to retry 4242 */ 4243 /* 4244 * Start timer for a delayed retry 4245 */ 4246 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_gid_ft_retry); 4247 ns->port->stats.ns_retries++; 4248 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port), 4249 &ns->timer, bfa_fcs_lport_ns_timeout, ns, 4250 BFA_FCS_RETRY_TIMEOUT); 4251 break; 4252 4253 case NSSM_EVENT_PORT_OFFLINE: 4254 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 4255 bfa_fcxp_discard(ns->fcxp); 4256 break; 4257 4258 case NSSM_EVENT_NS_QUERY: 4259 break; 4260 4261 default: 4262 bfa_sm_fault(ns->port->fcs, event); 4263 } 4264} 4265 4266static void 4267bfa_fcs_lport_ns_sm_gid_ft_retry(struct bfa_fcs_lport_ns_s *ns, 4268 enum vport_ns_event event) 4269{ 4270 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 4271 bfa_trc(ns->port->fcs, event); 4272 4273 switch (event) { 4274 case NSSM_EVENT_TIMEOUT: 4275 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_gid_ft); 4276 bfa_fcs_lport_ns_send_gid_ft(ns, NULL); 4277 break; 4278 4279 case NSSM_EVENT_PORT_OFFLINE: 4280 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 4281 bfa_timer_stop(&ns->timer); 4282 break; 4283 4284 default: 4285 bfa_sm_fault(ns->port->fcs, event); 4286 } 4287} 4288 4289static void 4290bfa_fcs_lport_ns_sm_online(struct bfa_fcs_lport_ns_s *ns, 4291 enum vport_ns_event event) 4292{ 4293 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn); 4294 bfa_trc(ns->port->fcs, event); 4295 4296 switch (event) { 4297 case NSSM_EVENT_PORT_OFFLINE: 4298 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 4299 break; 4300 4301 case NSSM_EVENT_NS_QUERY: 4302 /* 4303 * If the port role is Initiator Mode issue NS query. 4304 * If it is Target Mode, skip this and go to online. 4305 */ 4306 if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns->port)) { 4307 bfa_sm_set_state(ns, 4308 bfa_fcs_lport_ns_sm_sending_gid_ft); 4309 bfa_fcs_lport_ns_send_gid_ft(ns, NULL); 4310 } 4311 break; 4312 4313 default: 4314 bfa_sm_fault(ns->port->fcs, event); 4315 } 4316} 4317 4318 4319 4320/* 4321 * ns_pvt Nameserver local functions 4322 */ 4323 4324static void 4325bfa_fcs_lport_ns_send_plogi(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced) 4326{ 4327 struct bfa_fcs_lport_ns_s *ns = ns_cbarg; 4328 struct bfa_fcs_lport_s *port = ns->port; 4329 struct fchs_s fchs; 4330 int len; 4331 struct bfa_fcxp_s *fcxp; 4332 4333 bfa_trc(port->fcs, port->pid); 4334 4335 fcxp = fcxp_alloced ? fcxp_alloced : 4336 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE); 4337 if (!fcxp) { 4338 port->stats.ns_plogi_alloc_wait++; 4339 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe, 4340 bfa_fcs_lport_ns_send_plogi, ns, BFA_TRUE); 4341 return; 4342 } 4343 ns->fcxp = fcxp; 4344 4345 len = fc_plogi_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 4346 bfa_hton3b(FC_NAME_SERVER), 4347 bfa_fcs_lport_get_fcid(port), 0, 4348 port->port_cfg.pwwn, port->port_cfg.nwwn, 4349 bfa_fcport_get_maxfrsize(port->fcs->bfa), 4350 bfa_fcport_get_rx_bbcredit(port->fcs->bfa)); 4351 4352 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 4353 FC_CLASS_3, len, &fchs, 4354 bfa_fcs_lport_ns_plogi_response, (void *)ns, 4355 FC_MAX_PDUSZ, FC_ELS_TOV); 4356 port->stats.ns_plogi_sent++; 4357 4358 bfa_sm_send_event(ns, NSSM_EVENT_PLOGI_SENT); 4359} 4360 4361static void 4362bfa_fcs_lport_ns_plogi_response(void *fcsarg, struct bfa_fcxp_s *fcxp, 4363 void *cbarg, bfa_status_t req_status, u32 rsp_len, 4364 u32 resid_len, struct fchs_s *rsp_fchs) 4365{ 4366 struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg; 4367 struct bfa_fcs_lport_s *port = ns->port; 4368 /* struct fc_logi_s *plogi_resp; */ 4369 struct fc_els_cmd_s *els_cmd; 4370 struct fc_ls_rjt_s *ls_rjt; 4371 4372 bfa_trc(port->fcs, req_status); 4373 bfa_trc(port->fcs, port->port_cfg.pwwn); 4374 4375 /* 4376 * Sanity Checks 4377 */ 4378 if (req_status != BFA_STATUS_OK) { 4379 bfa_trc(port->fcs, req_status); 4380 port->stats.ns_plogi_rsp_err++; 4381 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4382 return; 4383 } 4384 4385 els_cmd = (struct fc_els_cmd_s *) BFA_FCXP_RSP_PLD(fcxp); 4386 4387 switch (els_cmd->els_code) { 4388 4389 case FC_ELS_ACC: 4390 if (rsp_len < sizeof(struct fc_logi_s)) { 4391 bfa_trc(port->fcs, rsp_len); 4392 port->stats.ns_plogi_acc_err++; 4393 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4394 break; 4395 } 4396 port->stats.ns_plogi_accepts++; 4397 bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK); 4398 break; 4399 4400 case FC_ELS_LS_RJT: 4401 ls_rjt = (struct fc_ls_rjt_s *) BFA_FCXP_RSP_PLD(fcxp); 4402 4403 bfa_trc(port->fcs, ls_rjt->reason_code); 4404 bfa_trc(port->fcs, ls_rjt->reason_code_expl); 4405 4406 port->stats.ns_rejects++; 4407 4408 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4409 break; 4410 4411 default: 4412 port->stats.ns_plogi_unknown_rsp++; 4413 bfa_trc(port->fcs, els_cmd->els_code); 4414 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4415 } 4416} 4417 4418/* 4419 * Register node name for port_id 4420 */ 4421static void 4422bfa_fcs_lport_ns_send_rnn_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced) 4423{ 4424 struct bfa_fcs_lport_ns_s *ns = ns_cbarg; 4425 struct bfa_fcs_lport_s *port = ns->port; 4426 struct fchs_s fchs; 4427 int len; 4428 struct bfa_fcxp_s *fcxp; 4429 4430 bfa_trc(port->fcs, port->port_cfg.pwwn); 4431 4432 fcxp = fcxp_alloced ? fcxp_alloced : 4433 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE); 4434 if (!fcxp) { 4435 port->stats.ns_rnnid_alloc_wait++; 4436 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe, 4437 bfa_fcs_lport_ns_send_rnn_id, ns, BFA_TRUE); 4438 return; 4439 } 4440 4441 ns->fcxp = fcxp; 4442 4443 len = fc_rnnid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 4444 bfa_fcs_lport_get_fcid(port), 4445 bfa_fcs_lport_get_fcid(port), 4446 bfa_fcs_lport_get_nwwn(port)); 4447 4448 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 4449 FC_CLASS_3, len, &fchs, 4450 bfa_fcs_lport_ns_rnn_id_response, (void *)ns, 4451 FC_MAX_PDUSZ, FC_FCCT_TOV); 4452 4453 port->stats.ns_rnnid_sent++; 4454 bfa_sm_send_event(ns, NSSM_EVENT_RNNID_SENT); 4455} 4456 4457static void 4458bfa_fcs_lport_ns_rnn_id_response(void *fcsarg, struct bfa_fcxp_s *fcxp, 4459 void *cbarg, bfa_status_t req_status, 4460 u32 rsp_len, u32 resid_len, 4461 struct fchs_s *rsp_fchs) 4462 4463{ 4464 struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg; 4465 struct bfa_fcs_lport_s *port = ns->port; 4466 struct ct_hdr_s *cthdr = NULL; 4467 4468 bfa_trc(port->fcs, port->port_cfg.pwwn); 4469 4470 /* 4471 * Sanity Checks 4472 */ 4473 if (req_status != BFA_STATUS_OK) { 4474 bfa_trc(port->fcs, req_status); 4475 port->stats.ns_rnnid_rsp_err++; 4476 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4477 return; 4478 } 4479 4480 cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp); 4481 cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code); 4482 4483 if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) { 4484 port->stats.ns_rnnid_accepts++; 4485 bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK); 4486 return; 4487 } 4488 4489 port->stats.ns_rnnid_rejects++; 4490 bfa_trc(port->fcs, cthdr->reason_code); 4491 bfa_trc(port->fcs, cthdr->exp_code); 4492 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4493} 4494 4495/* 4496 * Register the symbolic node name for a given node name. 4497 */ 4498static void 4499bfa_fcs_lport_ns_send_rsnn_nn(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced) 4500{ 4501 struct bfa_fcs_lport_ns_s *ns = ns_cbarg; 4502 struct bfa_fcs_lport_s *port = ns->port; 4503 struct fchs_s fchs; 4504 int len; 4505 struct bfa_fcxp_s *fcxp; 4506 u8 *nsymbl; 4507 4508 bfa_trc(port->fcs, port->port_cfg.pwwn); 4509 4510 fcxp = fcxp_alloced ? fcxp_alloced : 4511 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE); 4512 if (!fcxp) { 4513 port->stats.ns_rsnn_nn_alloc_wait++; 4514 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe, 4515 bfa_fcs_lport_ns_send_rsnn_nn, ns, BFA_TRUE); 4516 return; 4517 } 4518 ns->fcxp = fcxp; 4519 4520 nsymbl = (u8 *) &(bfa_fcs_lport_get_nsym_name( 4521 bfa_fcs_get_base_port(port->fcs))); 4522 4523 len = fc_rsnn_nn_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 4524 bfa_fcs_lport_get_fcid(port), 4525 bfa_fcs_lport_get_nwwn(port), nsymbl); 4526 4527 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 4528 FC_CLASS_3, len, &fchs, 4529 bfa_fcs_lport_ns_rsnn_nn_response, (void *)ns, 4530 FC_MAX_PDUSZ, FC_FCCT_TOV); 4531 4532 port->stats.ns_rsnn_nn_sent++; 4533 4534 bfa_sm_send_event(ns, NSSM_EVENT_RSNN_NN_SENT); 4535} 4536 4537static void 4538bfa_fcs_lport_ns_rsnn_nn_response(void *fcsarg, struct bfa_fcxp_s *fcxp, 4539 void *cbarg, bfa_status_t req_status, 4540 u32 rsp_len, u32 resid_len, 4541 struct fchs_s *rsp_fchs) 4542{ 4543 struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg; 4544 struct bfa_fcs_lport_s *port = ns->port; 4545 struct ct_hdr_s *cthdr = NULL; 4546 4547 bfa_trc(port->fcs, port->port_cfg.pwwn); 4548 4549 /* 4550 * Sanity Checks 4551 */ 4552 if (req_status != BFA_STATUS_OK) { 4553 bfa_trc(port->fcs, req_status); 4554 port->stats.ns_rsnn_nn_rsp_err++; 4555 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4556 return; 4557 } 4558 4559 cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp); 4560 cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code); 4561 4562 if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) { 4563 port->stats.ns_rsnn_nn_accepts++; 4564 bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK); 4565 return; 4566 } 4567 4568 port->stats.ns_rsnn_nn_rejects++; 4569 bfa_trc(port->fcs, cthdr->reason_code); 4570 bfa_trc(port->fcs, cthdr->exp_code); 4571 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4572} 4573 4574/* 4575 * Register the symbolic port name. 4576 */ 4577static void 4578bfa_fcs_lport_ns_send_rspn_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced) 4579{ 4580 struct bfa_fcs_lport_ns_s *ns = ns_cbarg; 4581 struct bfa_fcs_lport_s *port = ns->port; 4582 struct fchs_s fchs; 4583 int len; 4584 struct bfa_fcxp_s *fcxp; 4585 u8 symbl[256]; 4586 u8 *psymbl = &symbl[0]; 4587 4588 memset(symbl, 0, sizeof(symbl)); 4589 4590 bfa_trc(port->fcs, port->port_cfg.pwwn); 4591 4592 fcxp = fcxp_alloced ? fcxp_alloced : 4593 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE); 4594 if (!fcxp) { 4595 port->stats.ns_rspnid_alloc_wait++; 4596 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe, 4597 bfa_fcs_lport_ns_send_rspn_id, ns, BFA_TRUE); 4598 return; 4599 } 4600 ns->fcxp = fcxp; 4601 4602 /* 4603 * for V-Port, form a Port Symbolic Name 4604 */ 4605 if (port->vport) { 4606 /* 4607 * For Vports, we append the vport's port symbolic name 4608 * to that of the base port. 4609 */ 4610 4611 strscpy(symbl, 4612 (char *)&(bfa_fcs_lport_get_psym_name 4613 (bfa_fcs_get_base_port(port->fcs))), 4614 sizeof(symbl)); 4615 4616 strlcat(symbl, (char *)&(bfa_fcs_lport_get_psym_name(port)), 4617 sizeof(symbl)); 4618 } else { 4619 psymbl = (u8 *) &(bfa_fcs_lport_get_psym_name(port)); 4620 } 4621 4622 len = fc_rspnid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 4623 bfa_fcs_lport_get_fcid(port), 0, psymbl); 4624 4625 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 4626 FC_CLASS_3, len, &fchs, 4627 bfa_fcs_lport_ns_rspn_id_response, (void *)ns, 4628 FC_MAX_PDUSZ, FC_FCCT_TOV); 4629 4630 port->stats.ns_rspnid_sent++; 4631 4632 bfa_sm_send_event(ns, NSSM_EVENT_RSPNID_SENT); 4633} 4634 4635static void 4636bfa_fcs_lport_ns_rspn_id_response(void *fcsarg, struct bfa_fcxp_s *fcxp, 4637 void *cbarg, bfa_status_t req_status, 4638 u32 rsp_len, u32 resid_len, 4639 struct fchs_s *rsp_fchs) 4640{ 4641 struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg; 4642 struct bfa_fcs_lport_s *port = ns->port; 4643 struct ct_hdr_s *cthdr = NULL; 4644 4645 bfa_trc(port->fcs, port->port_cfg.pwwn); 4646 4647 /* 4648 * Sanity Checks 4649 */ 4650 if (req_status != BFA_STATUS_OK) { 4651 bfa_trc(port->fcs, req_status); 4652 port->stats.ns_rspnid_rsp_err++; 4653 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4654 return; 4655 } 4656 4657 cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp); 4658 cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code); 4659 4660 if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) { 4661 port->stats.ns_rspnid_accepts++; 4662 bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK); 4663 return; 4664 } 4665 4666 port->stats.ns_rspnid_rejects++; 4667 bfa_trc(port->fcs, cthdr->reason_code); 4668 bfa_trc(port->fcs, cthdr->exp_code); 4669 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4670} 4671 4672/* 4673 * Register FC4-Types 4674 */ 4675static void 4676bfa_fcs_lport_ns_send_rft_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced) 4677{ 4678 struct bfa_fcs_lport_ns_s *ns = ns_cbarg; 4679 struct bfa_fcs_lport_s *port = ns->port; 4680 struct fchs_s fchs; 4681 int len; 4682 struct bfa_fcxp_s *fcxp; 4683 4684 bfa_trc(port->fcs, port->port_cfg.pwwn); 4685 4686 fcxp = fcxp_alloced ? fcxp_alloced : 4687 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE); 4688 if (!fcxp) { 4689 port->stats.ns_rftid_alloc_wait++; 4690 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe, 4691 bfa_fcs_lport_ns_send_rft_id, ns, BFA_TRUE); 4692 return; 4693 } 4694 ns->fcxp = fcxp; 4695 4696 len = fc_rftid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 4697 bfa_fcs_lport_get_fcid(port), 0, port->port_cfg.roles); 4698 4699 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 4700 FC_CLASS_3, len, &fchs, 4701 bfa_fcs_lport_ns_rft_id_response, (void *)ns, 4702 FC_MAX_PDUSZ, FC_FCCT_TOV); 4703 4704 port->stats.ns_rftid_sent++; 4705 bfa_sm_send_event(ns, NSSM_EVENT_RFTID_SENT); 4706} 4707 4708static void 4709bfa_fcs_lport_ns_rft_id_response(void *fcsarg, struct bfa_fcxp_s *fcxp, 4710 void *cbarg, bfa_status_t req_status, 4711 u32 rsp_len, u32 resid_len, 4712 struct fchs_s *rsp_fchs) 4713{ 4714 struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg; 4715 struct bfa_fcs_lport_s *port = ns->port; 4716 struct ct_hdr_s *cthdr = NULL; 4717 4718 bfa_trc(port->fcs, port->port_cfg.pwwn); 4719 4720 /* 4721 * Sanity Checks 4722 */ 4723 if (req_status != BFA_STATUS_OK) { 4724 bfa_trc(port->fcs, req_status); 4725 port->stats.ns_rftid_rsp_err++; 4726 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4727 return; 4728 } 4729 4730 cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp); 4731 cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code); 4732 4733 if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) { 4734 port->stats.ns_rftid_accepts++; 4735 bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK); 4736 return; 4737 } 4738 4739 port->stats.ns_rftid_rejects++; 4740 bfa_trc(port->fcs, cthdr->reason_code); 4741 bfa_trc(port->fcs, cthdr->exp_code); 4742 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4743} 4744 4745/* 4746 * Register FC4-Features : Should be done after RFT_ID 4747 */ 4748static void 4749bfa_fcs_lport_ns_send_rff_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced) 4750{ 4751 struct bfa_fcs_lport_ns_s *ns = ns_cbarg; 4752 struct bfa_fcs_lport_s *port = ns->port; 4753 struct fchs_s fchs; 4754 int len; 4755 struct bfa_fcxp_s *fcxp; 4756 u8 fc4_ftrs = 0; 4757 4758 bfa_trc(port->fcs, port->port_cfg.pwwn); 4759 4760 fcxp = fcxp_alloced ? fcxp_alloced : 4761 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE); 4762 if (!fcxp) { 4763 port->stats.ns_rffid_alloc_wait++; 4764 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe, 4765 bfa_fcs_lport_ns_send_rff_id, ns, BFA_TRUE); 4766 return; 4767 } 4768 ns->fcxp = fcxp; 4769 4770 if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns->port)) 4771 fc4_ftrs = FC_GS_FCP_FC4_FEATURE_INITIATOR; 4772 4773 len = fc_rffid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 4774 bfa_fcs_lport_get_fcid(port), 0, 4775 FC_TYPE_FCP, fc4_ftrs); 4776 4777 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 4778 FC_CLASS_3, len, &fchs, 4779 bfa_fcs_lport_ns_rff_id_response, (void *)ns, 4780 FC_MAX_PDUSZ, FC_FCCT_TOV); 4781 4782 port->stats.ns_rffid_sent++; 4783 bfa_sm_send_event(ns, NSSM_EVENT_RFFID_SENT); 4784} 4785 4786static void 4787bfa_fcs_lport_ns_rff_id_response(void *fcsarg, struct bfa_fcxp_s *fcxp, 4788 void *cbarg, bfa_status_t req_status, 4789 u32 rsp_len, u32 resid_len, 4790 struct fchs_s *rsp_fchs) 4791{ 4792 struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg; 4793 struct bfa_fcs_lport_s *port = ns->port; 4794 struct ct_hdr_s *cthdr = NULL; 4795 4796 bfa_trc(port->fcs, port->port_cfg.pwwn); 4797 4798 /* 4799 * Sanity Checks 4800 */ 4801 if (req_status != BFA_STATUS_OK) { 4802 bfa_trc(port->fcs, req_status); 4803 port->stats.ns_rffid_rsp_err++; 4804 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4805 return; 4806 } 4807 4808 cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp); 4809 cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code); 4810 4811 if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) { 4812 port->stats.ns_rffid_accepts++; 4813 bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK); 4814 return; 4815 } 4816 4817 port->stats.ns_rffid_rejects++; 4818 bfa_trc(port->fcs, cthdr->reason_code); 4819 bfa_trc(port->fcs, cthdr->exp_code); 4820 4821 if (cthdr->reason_code == CT_RSN_NOT_SUPP) { 4822 /* if this command is not supported, we don't retry */ 4823 bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK); 4824 } else 4825 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4826} 4827/* 4828 * Query Fabric for FC4-Types Devices. 4829 * 4830* TBD : Need to use a local (FCS private) response buffer, since the response 4831 * can be larger than 2K. 4832 */ 4833static void 4834bfa_fcs_lport_ns_send_gid_ft(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced) 4835{ 4836 struct bfa_fcs_lport_ns_s *ns = ns_cbarg; 4837 struct bfa_fcs_lport_s *port = ns->port; 4838 struct fchs_s fchs; 4839 int len; 4840 struct bfa_fcxp_s *fcxp; 4841 4842 bfa_trc(port->fcs, port->pid); 4843 4844 fcxp = fcxp_alloced ? fcxp_alloced : 4845 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE); 4846 if (!fcxp) { 4847 port->stats.ns_gidft_alloc_wait++; 4848 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe, 4849 bfa_fcs_lport_ns_send_gid_ft, ns, BFA_TRUE); 4850 return; 4851 } 4852 ns->fcxp = fcxp; 4853 4854 /* 4855 * This query is only initiated for FCP initiator mode. 4856 */ 4857 len = fc_gid_ft_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 4858 ns->port->pid, FC_TYPE_FCP); 4859 4860 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 4861 FC_CLASS_3, len, &fchs, 4862 bfa_fcs_lport_ns_gid_ft_response, (void *)ns, 4863 bfa_fcxp_get_maxrsp(port->fcs->bfa), FC_FCCT_TOV); 4864 4865 port->stats.ns_gidft_sent++; 4866 4867 bfa_sm_send_event(ns, NSSM_EVENT_GIDFT_SENT); 4868} 4869 4870static void 4871bfa_fcs_lport_ns_gid_ft_response(void *fcsarg, struct bfa_fcxp_s *fcxp, 4872 void *cbarg, bfa_status_t req_status, 4873 u32 rsp_len, u32 resid_len, 4874 struct fchs_s *rsp_fchs) 4875{ 4876 struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg; 4877 struct bfa_fcs_lport_s *port = ns->port; 4878 struct ct_hdr_s *cthdr = NULL; 4879 u32 n_pids; 4880 4881 bfa_trc(port->fcs, port->port_cfg.pwwn); 4882 4883 /* 4884 * Sanity Checks 4885 */ 4886 if (req_status != BFA_STATUS_OK) { 4887 bfa_trc(port->fcs, req_status); 4888 port->stats.ns_gidft_rsp_err++; 4889 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4890 return; 4891 } 4892 4893 if (resid_len != 0) { 4894 /* 4895 * TBD : we will need to allocate a larger buffer & retry the 4896 * command 4897 */ 4898 bfa_trc(port->fcs, rsp_len); 4899 bfa_trc(port->fcs, resid_len); 4900 return; 4901 } 4902 4903 cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp); 4904 cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code); 4905 4906 switch (cthdr->cmd_rsp_code) { 4907 4908 case CT_RSP_ACCEPT: 4909 4910 port->stats.ns_gidft_accepts++; 4911 n_pids = (fc_get_ctresp_pyld_len(rsp_len) / sizeof(u32)); 4912 bfa_trc(port->fcs, n_pids); 4913 bfa_fcs_lport_ns_process_gidft_pids(port, 4914 (u32 *) (cthdr + 1), 4915 n_pids); 4916 bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK); 4917 break; 4918 4919 case CT_RSP_REJECT: 4920 4921 /* 4922 * Check the reason code & explanation. 4923 * There may not have been any FC4 devices in the fabric 4924 */ 4925 port->stats.ns_gidft_rejects++; 4926 bfa_trc(port->fcs, cthdr->reason_code); 4927 bfa_trc(port->fcs, cthdr->exp_code); 4928 4929 if ((cthdr->reason_code == CT_RSN_UNABLE_TO_PERF) 4930 && (cthdr->exp_code == CT_NS_EXP_FT_NOT_REG)) { 4931 4932 bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK); 4933 } else { 4934 /* 4935 * for all other errors, retry 4936 */ 4937 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4938 } 4939 break; 4940 4941 default: 4942 port->stats.ns_gidft_unknown_rsp++; 4943 bfa_trc(port->fcs, cthdr->cmd_rsp_code); 4944 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR); 4945 } 4946} 4947 4948/* 4949 * This routine will be called by bfa_timer on timer timeouts. 4950 * 4951 * param[in] port - pointer to bfa_fcs_lport_t. 4952 * 4953 * return 4954 * void 4955 * 4956 * Special Considerations: 4957 * 4958 * note 4959 */ 4960static void 4961bfa_fcs_lport_ns_timeout(void *arg) 4962{ 4963 struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) arg; 4964 4965 ns->port->stats.ns_timeouts++; 4966 bfa_sm_send_event(ns, NSSM_EVENT_TIMEOUT); 4967} 4968 4969/* 4970 * Process the PID list in GID_FT response 4971 */ 4972static void 4973bfa_fcs_lport_ns_process_gidft_pids(struct bfa_fcs_lport_s *port, u32 *pid_buf, 4974 u32 n_pids) 4975{ 4976 struct fcgs_gidft_resp_s *gidft_entry; 4977 struct bfa_fcs_rport_s *rport; 4978 u32 ii; 4979 struct bfa_fcs_fabric_s *fabric = port->fabric; 4980 struct bfa_fcs_vport_s *vport; 4981 struct list_head *qe; 4982 u8 found = 0; 4983 4984 for (ii = 0; ii < n_pids; ii++) { 4985 gidft_entry = (struct fcgs_gidft_resp_s *) &pid_buf[ii]; 4986 4987 if (gidft_entry->pid == port->pid) 4988 continue; 4989 4990 /* 4991 * Ignore PID if it is of base port 4992 * (Avoid vports discovering base port as remote port) 4993 */ 4994 if (gidft_entry->pid == fabric->bport.pid) 4995 continue; 4996 4997 /* 4998 * Ignore PID if it is of vport created on the same base port 4999 * (Avoid vport discovering every other vport created on the 5000 * same port as remote port) 5001 */ 5002 list_for_each(qe, &fabric->vport_q) { 5003 vport = (struct bfa_fcs_vport_s *) qe; 5004 if (vport->lport.pid == gidft_entry->pid) 5005 found = 1; 5006 } 5007 5008 if (found) { 5009 found = 0; 5010 continue; 5011 } 5012 5013 /* 5014 * Check if this rport already exists 5015 */ 5016 rport = bfa_fcs_lport_get_rport_by_pid(port, gidft_entry->pid); 5017 if (rport == NULL) { 5018 /* 5019 * this is a new device. create rport 5020 */ 5021 rport = bfa_fcs_rport_create(port, gidft_entry->pid); 5022 } else { 5023 /* 5024 * this rport already exists 5025 */ 5026 bfa_fcs_rport_scn(rport); 5027 } 5028 5029 bfa_trc(port->fcs, gidft_entry->pid); 5030 5031 /* 5032 * if the last entry bit is set, bail out. 5033 */ 5034 if (gidft_entry->last) 5035 return; 5036 } 5037} 5038 5039/* 5040 * fcs_ns_public FCS nameserver public interfaces 5041 */ 5042 5043/* 5044 * Functions called by port/fab. 5045 * These will send relevant Events to the ns state machine. 5046 */ 5047void 5048bfa_fcs_lport_ns_init(struct bfa_fcs_lport_s *port) 5049{ 5050 struct bfa_fcs_lport_ns_s *ns = BFA_FCS_GET_NS_FROM_PORT(port); 5051 5052 ns->port = port; 5053 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline); 5054} 5055 5056void 5057bfa_fcs_lport_ns_offline(struct bfa_fcs_lport_s *port) 5058{ 5059 struct bfa_fcs_lport_ns_s *ns = BFA_FCS_GET_NS_FROM_PORT(port); 5060 5061 ns->port = port; 5062 bfa_sm_send_event(ns, NSSM_EVENT_PORT_OFFLINE); 5063} 5064 5065void 5066bfa_fcs_lport_ns_online(struct bfa_fcs_lport_s *port) 5067{ 5068 struct bfa_fcs_lport_ns_s *ns = BFA_FCS_GET_NS_FROM_PORT(port); 5069 5070 ns->port = port; 5071 bfa_sm_send_event(ns, NSSM_EVENT_PORT_ONLINE); 5072} 5073 5074void 5075bfa_fcs_lport_ns_query(struct bfa_fcs_lport_s *port) 5076{ 5077 struct bfa_fcs_lport_ns_s *ns = BFA_FCS_GET_NS_FROM_PORT(port); 5078 5079 bfa_trc(port->fcs, port->pid); 5080 if (bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_online)) 5081 bfa_sm_send_event(ns, NSSM_EVENT_NS_QUERY); 5082} 5083 5084static void 5085bfa_fcs_lport_ns_boot_target_disc(bfa_fcs_lport_t *port) 5086{ 5087 5088 struct bfa_fcs_rport_s *rport; 5089 u8 nwwns; 5090 wwn_t wwns[BFA_PREBOOT_BOOTLUN_MAX]; 5091 int ii; 5092 5093 bfa_iocfc_get_bootwwns(port->fcs->bfa, &nwwns, wwns); 5094 5095 for (ii = 0 ; ii < nwwns; ++ii) { 5096 rport = bfa_fcs_rport_create_by_wwn(port, wwns[ii]); 5097 WARN_ON(!rport); 5098 } 5099} 5100 5101void 5102bfa_fcs_lport_ns_util_send_rspn_id(void *cbarg, struct bfa_fcxp_s *fcxp_alloced) 5103{ 5104 struct bfa_fcs_lport_ns_s *ns = cbarg; 5105 struct bfa_fcs_lport_s *port = ns->port; 5106 struct fchs_s fchs; 5107 struct bfa_fcxp_s *fcxp; 5108 u8 symbl[256]; 5109 int len; 5110 5111 /* Avoid sending RSPN in the following states. */ 5112 if (bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_offline) || 5113 bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_plogi_sending) || 5114 bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_plogi) || 5115 bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_plogi_retry) || 5116 bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_rspn_id_retry)) 5117 return; 5118 5119 memset(symbl, 0, sizeof(symbl)); 5120 bfa_trc(port->fcs, port->port_cfg.pwwn); 5121 5122 fcxp = fcxp_alloced ? fcxp_alloced : 5123 bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 5124 if (!fcxp) { 5125 port->stats.ns_rspnid_alloc_wait++; 5126 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe, 5127 bfa_fcs_lport_ns_util_send_rspn_id, ns, BFA_FALSE); 5128 return; 5129 } 5130 5131 ns->fcxp = fcxp; 5132 5133 if (port->vport) { 5134 /* 5135 * For Vports, we append the vport's port symbolic name 5136 * to that of the base port. 5137 */ 5138 strscpy(symbl, (char *)&(bfa_fcs_lport_get_psym_name 5139 (bfa_fcs_get_base_port(port->fcs))), 5140 sizeof(symbl)); 5141 5142 strlcat(symbl, 5143 (char *)&(bfa_fcs_lport_get_psym_name(port)), 5144 sizeof(symbl)); 5145 } 5146 5147 len = fc_rspnid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 5148 bfa_fcs_lport_get_fcid(port), 0, symbl); 5149 5150 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 5151 FC_CLASS_3, len, &fchs, NULL, NULL, FC_MAX_PDUSZ, 0); 5152 5153 port->stats.ns_rspnid_sent++; 5154} 5155 5156/* 5157 * FCS SCN 5158 */ 5159 5160#define FC_QOS_RSCN_EVENT 0x0c 5161#define FC_FABRIC_NAME_RSCN_EVENT 0x0d 5162 5163/* 5164 * forward declarations 5165 */ 5166static void bfa_fcs_lport_scn_send_scr(void *scn_cbarg, 5167 struct bfa_fcxp_s *fcxp_alloced); 5168static void bfa_fcs_lport_scn_scr_response(void *fcsarg, 5169 struct bfa_fcxp_s *fcxp, 5170 void *cbarg, 5171 bfa_status_t req_status, 5172 u32 rsp_len, 5173 u32 resid_len, 5174 struct fchs_s *rsp_fchs); 5175static void bfa_fcs_lport_scn_send_ls_acc(struct bfa_fcs_lport_s *port, 5176 struct fchs_s *rx_fchs); 5177static void bfa_fcs_lport_scn_timeout(void *arg); 5178 5179/* 5180 * fcs_scm_sm FCS SCN state machine 5181 */ 5182 5183static void bfa_fcs_lport_scn_sm_offline(struct bfa_fcs_lport_scn_s *scn, 5184 enum port_scn_event event); 5185static void bfa_fcs_lport_scn_sm_sending_scr( 5186 struct bfa_fcs_lport_scn_s *scn, 5187 enum port_scn_event event); 5188static void bfa_fcs_lport_scn_sm_scr(struct bfa_fcs_lport_scn_s *scn, 5189 enum port_scn_event event); 5190static void bfa_fcs_lport_scn_sm_scr_retry(struct bfa_fcs_lport_scn_s *scn, 5191 enum port_scn_event event); 5192static void bfa_fcs_lport_scn_sm_online(struct bfa_fcs_lport_scn_s *scn, 5193 enum port_scn_event event); 5194 5195/* 5196 * Starting state - awaiting link up. 5197 */ 5198static void 5199bfa_fcs_lport_scn_sm_offline(struct bfa_fcs_lport_scn_s *scn, 5200 enum port_scn_event event) 5201{ 5202 switch (event) { 5203 case SCNSM_EVENT_PORT_ONLINE: 5204 bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_sending_scr); 5205 bfa_fcs_lport_scn_send_scr(scn, NULL); 5206 break; 5207 5208 case SCNSM_EVENT_PORT_OFFLINE: 5209 break; 5210 5211 default: 5212 bfa_sm_fault(scn->port->fcs, event); 5213 } 5214} 5215 5216static void 5217bfa_fcs_lport_scn_sm_sending_scr(struct bfa_fcs_lport_scn_s *scn, 5218 enum port_scn_event event) 5219{ 5220 switch (event) { 5221 case SCNSM_EVENT_SCR_SENT: 5222 bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_scr); 5223 break; 5224 5225 case SCNSM_EVENT_PORT_OFFLINE: 5226 bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_offline); 5227 bfa_fcxp_walloc_cancel(scn->port->fcs->bfa, &scn->fcxp_wqe); 5228 break; 5229 5230 default: 5231 bfa_sm_fault(scn->port->fcs, event); 5232 } 5233} 5234 5235static void 5236bfa_fcs_lport_scn_sm_scr(struct bfa_fcs_lport_scn_s *scn, 5237 enum port_scn_event event) 5238{ 5239 struct bfa_fcs_lport_s *port = scn->port; 5240 5241 switch (event) { 5242 case SCNSM_EVENT_RSP_OK: 5243 bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_online); 5244 break; 5245 5246 case SCNSM_EVENT_RSP_ERROR: 5247 bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_scr_retry); 5248 bfa_timer_start(port->fcs->bfa, &scn->timer, 5249 bfa_fcs_lport_scn_timeout, scn, 5250 BFA_FCS_RETRY_TIMEOUT); 5251 break; 5252 5253 case SCNSM_EVENT_PORT_OFFLINE: 5254 bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_offline); 5255 bfa_fcxp_discard(scn->fcxp); 5256 break; 5257 5258 default: 5259 bfa_sm_fault(port->fcs, event); 5260 } 5261} 5262 5263static void 5264bfa_fcs_lport_scn_sm_scr_retry(struct bfa_fcs_lport_scn_s *scn, 5265 enum port_scn_event event) 5266{ 5267 switch (event) { 5268 case SCNSM_EVENT_TIMEOUT: 5269 bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_sending_scr); 5270 bfa_fcs_lport_scn_send_scr(scn, NULL); 5271 break; 5272 5273 case SCNSM_EVENT_PORT_OFFLINE: 5274 bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_offline); 5275 bfa_timer_stop(&scn->timer); 5276 break; 5277 5278 default: 5279 bfa_sm_fault(scn->port->fcs, event); 5280 } 5281} 5282 5283static void 5284bfa_fcs_lport_scn_sm_online(struct bfa_fcs_lport_scn_s *scn, 5285 enum port_scn_event event) 5286{ 5287 switch (event) { 5288 case SCNSM_EVENT_PORT_OFFLINE: 5289 bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_offline); 5290 break; 5291 5292 default: 5293 bfa_sm_fault(scn->port->fcs, event); 5294 } 5295} 5296 5297 5298 5299/* 5300 * fcs_scn_private FCS SCN private functions 5301 */ 5302 5303/* 5304 * This routine will be called to send a SCR command. 5305 */ 5306static void 5307bfa_fcs_lport_scn_send_scr(void *scn_cbarg, struct bfa_fcxp_s *fcxp_alloced) 5308{ 5309 struct bfa_fcs_lport_scn_s *scn = scn_cbarg; 5310 struct bfa_fcs_lport_s *port = scn->port; 5311 struct fchs_s fchs; 5312 int len; 5313 struct bfa_fcxp_s *fcxp; 5314 5315 bfa_trc(port->fcs, port->pid); 5316 bfa_trc(port->fcs, port->port_cfg.pwwn); 5317 5318 fcxp = fcxp_alloced ? fcxp_alloced : 5319 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE); 5320 if (!fcxp) { 5321 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &scn->fcxp_wqe, 5322 bfa_fcs_lport_scn_send_scr, scn, BFA_TRUE); 5323 return; 5324 } 5325 scn->fcxp = fcxp; 5326 5327 /* Handle VU registrations for Base port only */ 5328 if ((!port->vport) && bfa_ioc_get_fcmode(&port->fcs->bfa->ioc)) { 5329 len = fc_scr_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 5330 port->fabric->lps->brcd_switch, 5331 port->pid, 0); 5332 } else { 5333 len = fc_scr_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 5334 BFA_FALSE, 5335 port->pid, 0); 5336 } 5337 5338 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE, 5339 FC_CLASS_3, len, &fchs, 5340 bfa_fcs_lport_scn_scr_response, 5341 (void *)scn, FC_MAX_PDUSZ, FC_ELS_TOV); 5342 5343 bfa_sm_send_event(scn, SCNSM_EVENT_SCR_SENT); 5344} 5345 5346static void 5347bfa_fcs_lport_scn_scr_response(void *fcsarg, struct bfa_fcxp_s *fcxp, 5348 void *cbarg, bfa_status_t req_status, u32 rsp_len, 5349 u32 resid_len, struct fchs_s *rsp_fchs) 5350{ 5351 struct bfa_fcs_lport_scn_s *scn = (struct bfa_fcs_lport_scn_s *) cbarg; 5352 struct bfa_fcs_lport_s *port = scn->port; 5353 struct fc_els_cmd_s *els_cmd; 5354 struct fc_ls_rjt_s *ls_rjt; 5355 5356 bfa_trc(port->fcs, port->port_cfg.pwwn); 5357 5358 /* 5359 * Sanity Checks 5360 */ 5361 if (req_status != BFA_STATUS_OK) { 5362 bfa_trc(port->fcs, req_status); 5363 bfa_sm_send_event(scn, SCNSM_EVENT_RSP_ERROR); 5364 return; 5365 } 5366 5367 els_cmd = (struct fc_els_cmd_s *) BFA_FCXP_RSP_PLD(fcxp); 5368 5369 switch (els_cmd->els_code) { 5370 5371 case FC_ELS_ACC: 5372 bfa_sm_send_event(scn, SCNSM_EVENT_RSP_OK); 5373 break; 5374 5375 case FC_ELS_LS_RJT: 5376 5377 ls_rjt = (struct fc_ls_rjt_s *) BFA_FCXP_RSP_PLD(fcxp); 5378 5379 bfa_trc(port->fcs, ls_rjt->reason_code); 5380 bfa_trc(port->fcs, ls_rjt->reason_code_expl); 5381 5382 bfa_sm_send_event(scn, SCNSM_EVENT_RSP_ERROR); 5383 break; 5384 5385 default: 5386 bfa_sm_send_event(scn, SCNSM_EVENT_RSP_ERROR); 5387 } 5388} 5389 5390/* 5391 * Send a LS Accept 5392 */ 5393static void 5394bfa_fcs_lport_scn_send_ls_acc(struct bfa_fcs_lport_s *port, 5395 struct fchs_s *rx_fchs) 5396{ 5397 struct fchs_s fchs; 5398 struct bfa_fcxp_s *fcxp; 5399 struct bfa_rport_s *bfa_rport = NULL; 5400 int len; 5401 5402 bfa_trc(port->fcs, rx_fchs->s_id); 5403 5404 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 5405 if (!fcxp) 5406 return; 5407 5408 len = fc_ls_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 5409 rx_fchs->s_id, bfa_fcs_lport_get_fcid(port), 5410 rx_fchs->ox_id); 5411 5412 bfa_fcxp_send(fcxp, bfa_rport, port->fabric->vf_id, port->lp_tag, 5413 BFA_FALSE, FC_CLASS_3, len, &fchs, NULL, NULL, 5414 FC_MAX_PDUSZ, 0); 5415} 5416 5417/* 5418 * This routine will be called by bfa_timer on timer timeouts. 5419 * 5420 * param[in] vport - pointer to bfa_fcs_lport_t. 5421 * param[out] vport_status - pointer to return vport status in 5422 * 5423 * return 5424 * void 5425 * 5426 * Special Considerations: 5427 * 5428 * note 5429 */ 5430static void 5431bfa_fcs_lport_scn_timeout(void *arg) 5432{ 5433 struct bfa_fcs_lport_scn_s *scn = (struct bfa_fcs_lport_scn_s *) arg; 5434 5435 bfa_sm_send_event(scn, SCNSM_EVENT_TIMEOUT); 5436} 5437 5438 5439 5440/* 5441 * fcs_scn_public FCS state change notification public interfaces 5442 */ 5443 5444/* 5445 * Functions called by port/fab 5446 */ 5447void 5448bfa_fcs_lport_scn_init(struct bfa_fcs_lport_s *port) 5449{ 5450 struct bfa_fcs_lport_scn_s *scn = BFA_FCS_GET_SCN_FROM_PORT(port); 5451 5452 scn->port = port; 5453 bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_offline); 5454} 5455 5456void 5457bfa_fcs_lport_scn_offline(struct bfa_fcs_lport_s *port) 5458{ 5459 struct bfa_fcs_lport_scn_s *scn = BFA_FCS_GET_SCN_FROM_PORT(port); 5460 5461 scn->port = port; 5462 bfa_sm_send_event(scn, SCNSM_EVENT_PORT_OFFLINE); 5463} 5464 5465void 5466bfa_fcs_lport_fab_scn_online(struct bfa_fcs_lport_s *port) 5467{ 5468 struct bfa_fcs_lport_scn_s *scn = BFA_FCS_GET_SCN_FROM_PORT(port); 5469 5470 scn->port = port; 5471 bfa_sm_send_event(scn, SCNSM_EVENT_PORT_ONLINE); 5472} 5473 5474static void 5475bfa_fcs_lport_scn_portid_rscn(struct bfa_fcs_lport_s *port, u32 rpid) 5476{ 5477 struct bfa_fcs_rport_s *rport; 5478 struct bfa_fcs_fabric_s *fabric = port->fabric; 5479 struct bfa_fcs_vport_s *vport; 5480 struct list_head *qe; 5481 5482 bfa_trc(port->fcs, rpid); 5483 5484 /* 5485 * Ignore PID if it is of base port or of vports created on the 5486 * same base port. It is to avoid vports discovering base port or 5487 * other vports created on same base port as remote port 5488 */ 5489 if (rpid == fabric->bport.pid) 5490 return; 5491 5492 list_for_each(qe, &fabric->vport_q) { 5493 vport = (struct bfa_fcs_vport_s *) qe; 5494 if (vport->lport.pid == rpid) 5495 return; 5496 } 5497 /* 5498 * If this is an unknown device, then it just came online. 5499 * Otherwise let rport handle the RSCN event. 5500 */ 5501 rport = bfa_fcs_lport_get_rport_by_pid(port, rpid); 5502 if (!rport) 5503 rport = bfa_fcs_lport_get_rport_by_old_pid(port, rpid); 5504 5505 if (rport == NULL) { 5506 /* 5507 * If min cfg mode is enabled, we donot need to 5508 * discover any new rports. 5509 */ 5510 if (!__fcs_min_cfg(port->fcs)) 5511 rport = bfa_fcs_rport_create(port, rpid); 5512 } else 5513 bfa_fcs_rport_scn(rport); 5514} 5515 5516/* 5517 * rscn format based PID comparison 5518 */ 5519#define __fc_pid_match(__c0, __c1, __fmt) \ 5520 (((__fmt) == FC_RSCN_FORMAT_FABRIC) || \ 5521 (((__fmt) == FC_RSCN_FORMAT_DOMAIN) && \ 5522 ((__c0)[0] == (__c1)[0])) || \ 5523 (((__fmt) == FC_RSCN_FORMAT_AREA) && \ 5524 ((__c0)[0] == (__c1)[0]) && \ 5525 ((__c0)[1] == (__c1)[1]))) 5526 5527static void 5528bfa_fcs_lport_scn_multiport_rscn(struct bfa_fcs_lport_s *port, 5529 enum fc_rscn_format format, 5530 u32 rscn_pid) 5531{ 5532 struct bfa_fcs_rport_s *rport; 5533 struct list_head *qe, *qe_next; 5534 u8 *c0, *c1; 5535 5536 bfa_trc(port->fcs, format); 5537 bfa_trc(port->fcs, rscn_pid); 5538 5539 c0 = (u8 *) &rscn_pid; 5540 5541 list_for_each_safe(qe, qe_next, &port->rport_q) { 5542 rport = (struct bfa_fcs_rport_s *) qe; 5543 c1 = (u8 *) &rport->pid; 5544 if (__fc_pid_match(c0, c1, format)) 5545 bfa_fcs_rport_scn(rport); 5546 } 5547} 5548 5549 5550void 5551bfa_fcs_lport_scn_process_rscn(struct bfa_fcs_lport_s *port, 5552 struct fchs_s *fchs, u32 len) 5553{ 5554 struct fc_rscn_pl_s *rscn = (struct fc_rscn_pl_s *) (fchs + 1); 5555 int num_entries; 5556 u32 rscn_pid; 5557 bfa_boolean_t nsquery = BFA_FALSE, found; 5558 int i = 0, j; 5559 5560 num_entries = 5561 (be16_to_cpu(rscn->payldlen) - 5562 sizeof(u32)) / sizeof(rscn->event[0]); 5563 5564 bfa_trc(port->fcs, num_entries); 5565 5566 port->stats.num_rscn++; 5567 5568 bfa_fcs_lport_scn_send_ls_acc(port, fchs); 5569 5570 for (i = 0; i < num_entries; i++) { 5571 rscn_pid = rscn->event[i].portid; 5572 5573 bfa_trc(port->fcs, rscn->event[i].format); 5574 bfa_trc(port->fcs, rscn_pid); 5575 5576 /* check for duplicate entries in the list */ 5577 found = BFA_FALSE; 5578 for (j = 0; j < i; j++) { 5579 if (rscn->event[j].portid == rscn_pid) { 5580 found = BFA_TRUE; 5581 break; 5582 } 5583 } 5584 5585 /* if found in down the list, pid has been already processed */ 5586 if (found) { 5587 bfa_trc(port->fcs, rscn_pid); 5588 continue; 5589 } 5590 5591 switch (rscn->event[i].format) { 5592 case FC_RSCN_FORMAT_PORTID: 5593 if (rscn->event[i].qualifier == FC_QOS_RSCN_EVENT) { 5594 /* 5595 * Ignore this event. 5596 * f/w would have processed it 5597 */ 5598 bfa_trc(port->fcs, rscn_pid); 5599 } else { 5600 port->stats.num_portid_rscn++; 5601 bfa_fcs_lport_scn_portid_rscn(port, rscn_pid); 5602 } 5603 break; 5604 5605 case FC_RSCN_FORMAT_FABRIC: 5606 if (rscn->event[i].qualifier == 5607 FC_FABRIC_NAME_RSCN_EVENT) { 5608 bfa_fcs_lport_ms_fabric_rscn(port); 5609 break; 5610 } 5611 fallthrough; 5612 5613 case FC_RSCN_FORMAT_AREA: 5614 case FC_RSCN_FORMAT_DOMAIN: 5615 nsquery = BFA_TRUE; 5616 bfa_fcs_lport_scn_multiport_rscn(port, 5617 rscn->event[i].format, 5618 rscn_pid); 5619 break; 5620 5621 5622 default: 5623 WARN_ON(1); 5624 nsquery = BFA_TRUE; 5625 } 5626 } 5627 5628 /* 5629 * If any of area, domain or fabric RSCN is received, do a fresh 5630 * discovery to find new devices. 5631 */ 5632 if (nsquery) 5633 bfa_fcs_lport_ns_query(port); 5634} 5635 5636/* 5637 * BFA FCS port 5638 */ 5639/* 5640 * fcs_port_api BFA FCS port API 5641 */ 5642struct bfa_fcs_lport_s * 5643bfa_fcs_get_base_port(struct bfa_fcs_s *fcs) 5644{ 5645 return &fcs->fabric.bport; 5646} 5647 5648wwn_t 5649bfa_fcs_lport_get_rport(struct bfa_fcs_lport_s *port, wwn_t wwn, int index, 5650 int nrports, bfa_boolean_t bwwn) 5651{ 5652 struct list_head *qh, *qe; 5653 struct bfa_fcs_rport_s *rport = NULL; 5654 int i; 5655 struct bfa_fcs_s *fcs; 5656 5657 if (port == NULL || nrports == 0) 5658 return (wwn_t) 0; 5659 5660 fcs = port->fcs; 5661 bfa_trc(fcs, (u32) nrports); 5662 5663 i = 0; 5664 qh = &port->rport_q; 5665 qe = bfa_q_first(qh); 5666 5667 while ((qe != qh) && (i < nrports)) { 5668 rport = (struct bfa_fcs_rport_s *) qe; 5669 if (bfa_ntoh3b(rport->pid) > 0xFFF000) { 5670 qe = bfa_q_next(qe); 5671 bfa_trc(fcs, (u32) rport->pwwn); 5672 bfa_trc(fcs, rport->pid); 5673 bfa_trc(fcs, i); 5674 continue; 5675 } 5676 5677 if (bwwn) { 5678 if (!memcmp(&wwn, &rport->pwwn, 8)) 5679 break; 5680 } else { 5681 if (i == index) 5682 break; 5683 } 5684 5685 i++; 5686 qe = bfa_q_next(qe); 5687 } 5688 5689 bfa_trc(fcs, i); 5690 if (rport) 5691 return rport->pwwn; 5692 else 5693 return (wwn_t) 0; 5694} 5695 5696void 5697bfa_fcs_lport_get_rport_quals(struct bfa_fcs_lport_s *port, 5698 struct bfa_rport_qualifier_s rports[], int *nrports) 5699{ 5700 struct list_head *qh, *qe; 5701 struct bfa_fcs_rport_s *rport = NULL; 5702 int i; 5703 struct bfa_fcs_s *fcs; 5704 5705 if (port == NULL || rports == NULL || *nrports == 0) 5706 return; 5707 5708 fcs = port->fcs; 5709 bfa_trc(fcs, (u32) *nrports); 5710 5711 i = 0; 5712 qh = &port->rport_q; 5713 qe = bfa_q_first(qh); 5714 5715 while ((qe != qh) && (i < *nrports)) { 5716 rport = (struct bfa_fcs_rport_s *) qe; 5717 if (bfa_ntoh3b(rport->pid) > 0xFFF000) { 5718 qe = bfa_q_next(qe); 5719 bfa_trc(fcs, (u32) rport->pwwn); 5720 bfa_trc(fcs, rport->pid); 5721 bfa_trc(fcs, i); 5722 continue; 5723 } 5724 5725 if (!rport->pwwn && !rport->pid) { 5726 qe = bfa_q_next(qe); 5727 continue; 5728 } 5729 5730 rports[i].pwwn = rport->pwwn; 5731 rports[i].pid = rport->pid; 5732 5733 i++; 5734 qe = bfa_q_next(qe); 5735 } 5736 5737 bfa_trc(fcs, i); 5738 *nrports = i; 5739} 5740 5741/* 5742 * Iterate's through all the rport's in the given port to 5743 * determine the maximum operating speed. 5744 * 5745 * !!!! To be used in TRL Functionality only !!!! 5746 */ 5747bfa_port_speed_t 5748bfa_fcs_lport_get_rport_max_speed(bfa_fcs_lport_t *port) 5749{ 5750 struct list_head *qh, *qe; 5751 struct bfa_fcs_rport_s *rport = NULL; 5752 struct bfa_fcs_s *fcs; 5753 bfa_port_speed_t max_speed = 0; 5754 struct bfa_port_attr_s port_attr; 5755 bfa_port_speed_t port_speed, rport_speed; 5756 bfa_boolean_t trl_enabled; 5757 5758 if (port == NULL) 5759 return 0; 5760 5761 fcs = port->fcs; 5762 trl_enabled = bfa_fcport_is_ratelim(port->fcs->bfa); 5763 5764 /* Get Physical port's current speed */ 5765 bfa_fcport_get_attr(port->fcs->bfa, &port_attr); 5766 port_speed = port_attr.speed; 5767 bfa_trc(fcs, port_speed); 5768 5769 qh = &port->rport_q; 5770 qe = bfa_q_first(qh); 5771 5772 while (qe != qh) { 5773 rport = (struct bfa_fcs_rport_s *) qe; 5774 if ((bfa_ntoh3b(rport->pid) > 0xFFF000) || 5775 (bfa_fcs_rport_get_state(rport) == BFA_RPORT_OFFLINE) || 5776 (rport->scsi_function != BFA_RPORT_TARGET)) { 5777 qe = bfa_q_next(qe); 5778 continue; 5779 } 5780 5781 rport_speed = rport->rpf.rpsc_speed; 5782 if ((trl_enabled) && (rport_speed == 5783 BFA_PORT_SPEED_UNKNOWN)) { 5784 /* Use default ratelim speed setting */ 5785 rport_speed = 5786 bfa_fcport_get_ratelim_speed(port->fcs->bfa); 5787 } 5788 5789 if (rport_speed > max_speed) 5790 max_speed = rport_speed; 5791 5792 qe = bfa_q_next(qe); 5793 } 5794 5795 if (max_speed > port_speed) 5796 max_speed = port_speed; 5797 5798 bfa_trc(fcs, max_speed); 5799 return max_speed; 5800} 5801 5802struct bfa_fcs_lport_s * 5803bfa_fcs_lookup_port(struct bfa_fcs_s *fcs, u16 vf_id, wwn_t lpwwn) 5804{ 5805 struct bfa_fcs_vport_s *vport; 5806 bfa_fcs_vf_t *vf; 5807 5808 WARN_ON(fcs == NULL); 5809 5810 vf = bfa_fcs_vf_lookup(fcs, vf_id); 5811 if (vf == NULL) { 5812 bfa_trc(fcs, vf_id); 5813 return NULL; 5814 } 5815 5816 if (!lpwwn || (vf->bport.port_cfg.pwwn == lpwwn)) 5817 return &vf->bport; 5818 5819 vport = bfa_fcs_fabric_vport_lookup(vf, lpwwn); 5820 if (vport) 5821 return &vport->lport; 5822 5823 return NULL; 5824} 5825 5826/* 5827 * API corresponding to NPIV_VPORT_GETINFO. 5828 */ 5829void 5830bfa_fcs_lport_get_info(struct bfa_fcs_lport_s *port, 5831 struct bfa_lport_info_s *port_info) 5832{ 5833 5834 bfa_trc(port->fcs, port->fabric->fabric_name); 5835 5836 if (port->vport == NULL) { 5837 /* 5838 * This is a Physical port 5839 */ 5840 port_info->port_type = BFA_LPORT_TYPE_PHYSICAL; 5841 5842 /* 5843 * @todo : need to fix the state & reason 5844 */ 5845 port_info->port_state = 0; 5846 port_info->offline_reason = 0; 5847 5848 port_info->port_wwn = bfa_fcs_lport_get_pwwn(port); 5849 port_info->node_wwn = bfa_fcs_lport_get_nwwn(port); 5850 5851 port_info->max_vports_supp = 5852 bfa_lps_get_max_vport(port->fcs->bfa); 5853 port_info->num_vports_inuse = 5854 port->fabric->num_vports; 5855 port_info->max_rports_supp = BFA_FCS_MAX_RPORTS_SUPP; 5856 port_info->num_rports_inuse = port->num_rports; 5857 } else { 5858 /* 5859 * This is a virtual port 5860 */ 5861 port_info->port_type = BFA_LPORT_TYPE_VIRTUAL; 5862 5863 /* 5864 * @todo : need to fix the state & reason 5865 */ 5866 port_info->port_state = 0; 5867 port_info->offline_reason = 0; 5868 5869 port_info->port_wwn = bfa_fcs_lport_get_pwwn(port); 5870 port_info->node_wwn = bfa_fcs_lport_get_nwwn(port); 5871 } 5872} 5873 5874void 5875bfa_fcs_lport_get_stats(struct bfa_fcs_lport_s *fcs_port, 5876 struct bfa_lport_stats_s *port_stats) 5877{ 5878 *port_stats = fcs_port->stats; 5879} 5880 5881void 5882bfa_fcs_lport_clear_stats(struct bfa_fcs_lport_s *fcs_port) 5883{ 5884 memset(&fcs_port->stats, 0, sizeof(struct bfa_lport_stats_s)); 5885} 5886 5887/* 5888 * Let new loop map create missing rports 5889 */ 5890void 5891bfa_fcs_lport_lip_scn_online(struct bfa_fcs_lport_s *port) 5892{ 5893 bfa_fcs_lport_loop_online(port); 5894} 5895 5896/* 5897 * FCS virtual port state machine 5898 */ 5899 5900#define __vport_fcs(__vp) ((__vp)->lport.fcs) 5901#define __vport_pwwn(__vp) ((__vp)->lport.port_cfg.pwwn) 5902#define __vport_nwwn(__vp) ((__vp)->lport.port_cfg.nwwn) 5903#define __vport_bfa(__vp) ((__vp)->lport.fcs->bfa) 5904#define __vport_fcid(__vp) ((__vp)->lport.pid) 5905#define __vport_fabric(__vp) ((__vp)->lport.fabric) 5906#define __vport_vfid(__vp) ((__vp)->lport.fabric->vf_id) 5907 5908#define BFA_FCS_VPORT_MAX_RETRIES 5 5909/* 5910 * Forward declarations 5911 */ 5912static void bfa_fcs_vport_do_fdisc(struct bfa_fcs_vport_s *vport); 5913static void bfa_fcs_vport_timeout(void *vport_arg); 5914static void bfa_fcs_vport_do_logo(struct bfa_fcs_vport_s *vport); 5915static void bfa_fcs_vport_free(struct bfa_fcs_vport_s *vport); 5916 5917/* 5918 * fcs_vport_sm FCS virtual port state machine 5919 */ 5920 5921static void bfa_fcs_vport_sm_uninit(struct bfa_fcs_vport_s *vport, 5922 enum bfa_fcs_vport_event event); 5923static void bfa_fcs_vport_sm_created(struct bfa_fcs_vport_s *vport, 5924 enum bfa_fcs_vport_event event); 5925static void bfa_fcs_vport_sm_offline(struct bfa_fcs_vport_s *vport, 5926 enum bfa_fcs_vport_event event); 5927static void bfa_fcs_vport_sm_fdisc(struct bfa_fcs_vport_s *vport, 5928 enum bfa_fcs_vport_event event); 5929static void bfa_fcs_vport_sm_fdisc_retry(struct bfa_fcs_vport_s *vport, 5930 enum bfa_fcs_vport_event event); 5931static void bfa_fcs_vport_sm_fdisc_rsp_wait(struct bfa_fcs_vport_s *vport, 5932 enum bfa_fcs_vport_event event); 5933static void bfa_fcs_vport_sm_online(struct bfa_fcs_vport_s *vport, 5934 enum bfa_fcs_vport_event event); 5935static void bfa_fcs_vport_sm_deleting(struct bfa_fcs_vport_s *vport, 5936 enum bfa_fcs_vport_event event); 5937static void bfa_fcs_vport_sm_cleanup(struct bfa_fcs_vport_s *vport, 5938 enum bfa_fcs_vport_event event); 5939static void bfa_fcs_vport_sm_logo(struct bfa_fcs_vport_s *vport, 5940 enum bfa_fcs_vport_event event); 5941static void bfa_fcs_vport_sm_error(struct bfa_fcs_vport_s *vport, 5942 enum bfa_fcs_vport_event event); 5943static void bfa_fcs_vport_sm_stopping(struct bfa_fcs_vport_s *vport, 5944 enum bfa_fcs_vport_event event); 5945static void bfa_fcs_vport_sm_logo_for_stop(struct bfa_fcs_vport_s *vport, 5946 enum bfa_fcs_vport_event event); 5947 5948struct bfa_fcs_vport_sm_table_s { 5949 bfa_fcs_vport_sm_t sm; /* state machine function */ 5950 enum bfa_vport_state state; /* state machine encoding */ 5951 char *name; /* state name for display */ 5952}; 5953 5954static inline enum bfa_vport_state 5955bfa_vport_sm_to_state(struct bfa_fcs_vport_sm_table_s *smt, bfa_fcs_vport_sm_t sm) 5956{ 5957 int i = 0; 5958 5959 while (smt[i].sm && smt[i].sm != sm) 5960 i++; 5961 return smt[i].state; 5962} 5963 5964static struct bfa_fcs_vport_sm_table_s vport_sm_table[] = { 5965 {BFA_SM(bfa_fcs_vport_sm_uninit), BFA_FCS_VPORT_UNINIT}, 5966 {BFA_SM(bfa_fcs_vport_sm_created), BFA_FCS_VPORT_CREATED}, 5967 {BFA_SM(bfa_fcs_vport_sm_offline), BFA_FCS_VPORT_OFFLINE}, 5968 {BFA_SM(bfa_fcs_vport_sm_fdisc), BFA_FCS_VPORT_FDISC}, 5969 {BFA_SM(bfa_fcs_vport_sm_fdisc_retry), BFA_FCS_VPORT_FDISC_RETRY}, 5970 {BFA_SM(bfa_fcs_vport_sm_fdisc_rsp_wait), BFA_FCS_VPORT_FDISC_RSP_WAIT}, 5971 {BFA_SM(bfa_fcs_vport_sm_online), BFA_FCS_VPORT_ONLINE}, 5972 {BFA_SM(bfa_fcs_vport_sm_deleting), BFA_FCS_VPORT_DELETING}, 5973 {BFA_SM(bfa_fcs_vport_sm_cleanup), BFA_FCS_VPORT_CLEANUP}, 5974 {BFA_SM(bfa_fcs_vport_sm_logo), BFA_FCS_VPORT_LOGO}, 5975 {BFA_SM(bfa_fcs_vport_sm_error), BFA_FCS_VPORT_ERROR} 5976}; 5977 5978/* 5979 * Beginning state. 5980 */ 5981static void 5982bfa_fcs_vport_sm_uninit(struct bfa_fcs_vport_s *vport, 5983 enum bfa_fcs_vport_event event) 5984{ 5985 bfa_trc(__vport_fcs(vport), __vport_pwwn(vport)); 5986 bfa_trc(__vport_fcs(vport), event); 5987 5988 switch (event) { 5989 case BFA_FCS_VPORT_SM_CREATE: 5990 bfa_sm_set_state(vport, bfa_fcs_vport_sm_created); 5991 bfa_fcs_fabric_addvport(__vport_fabric(vport), vport); 5992 break; 5993 5994 default: 5995 bfa_sm_fault(__vport_fcs(vport), event); 5996 } 5997} 5998 5999/* 6000 * Created state - a start event is required to start up the state machine. 6001 */ 6002static void 6003bfa_fcs_vport_sm_created(struct bfa_fcs_vport_s *vport, 6004 enum bfa_fcs_vport_event event) 6005{ 6006 bfa_trc(__vport_fcs(vport), __vport_pwwn(vport)); 6007 bfa_trc(__vport_fcs(vport), event); 6008 6009 switch (event) { 6010 case BFA_FCS_VPORT_SM_START: 6011 if (bfa_sm_cmp_state(__vport_fabric(vport), 6012 bfa_fcs_fabric_sm_online) 6013 && bfa_fcs_fabric_npiv_capable(__vport_fabric(vport))) { 6014 bfa_sm_set_state(vport, bfa_fcs_vport_sm_fdisc); 6015 bfa_fcs_vport_do_fdisc(vport); 6016 } else { 6017 /* 6018 * Fabric is offline or not NPIV capable, stay in 6019 * offline state. 6020 */ 6021 vport->vport_stats.fab_no_npiv++; 6022 bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline); 6023 } 6024 break; 6025 6026 case BFA_FCS_VPORT_SM_DELETE: 6027 bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup); 6028 bfa_fcs_lport_delete(&vport->lport); 6029 break; 6030 6031 case BFA_FCS_VPORT_SM_ONLINE: 6032 case BFA_FCS_VPORT_SM_OFFLINE: 6033 /* 6034 * Ignore ONLINE/OFFLINE events from fabric 6035 * till vport is started. 6036 */ 6037 break; 6038 6039 default: 6040 bfa_sm_fault(__vport_fcs(vport), event); 6041 } 6042} 6043 6044/* 6045 * Offline state - awaiting ONLINE event from fabric SM. 6046 */ 6047static void 6048bfa_fcs_vport_sm_offline(struct bfa_fcs_vport_s *vport, 6049 enum bfa_fcs_vport_event event) 6050{ 6051 bfa_trc(__vport_fcs(vport), __vport_pwwn(vport)); 6052 bfa_trc(__vport_fcs(vport), event); 6053 6054 switch (event) { 6055 case BFA_FCS_VPORT_SM_DELETE: 6056 bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup); 6057 bfa_fcs_lport_delete(&vport->lport); 6058 break; 6059 6060 case BFA_FCS_VPORT_SM_ONLINE: 6061 bfa_sm_set_state(vport, bfa_fcs_vport_sm_fdisc); 6062 vport->fdisc_retries = 0; 6063 bfa_fcs_vport_do_fdisc(vport); 6064 break; 6065 6066 case BFA_FCS_VPORT_SM_STOP: 6067 bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup); 6068 bfa_sm_send_event(&vport->lport, BFA_FCS_PORT_SM_STOP); 6069 break; 6070 6071 case BFA_FCS_VPORT_SM_OFFLINE: 6072 /* 6073 * This can happen if the vport couldn't be initialzied 6074 * due the fact that the npiv was not enabled on the switch. 6075 * In that case we will put the vport in offline state. 6076 * However, the link can go down and cause the this event to 6077 * be sent when we are already offline. Ignore it. 6078 */ 6079 break; 6080 6081 default: 6082 bfa_sm_fault(__vport_fcs(vport), event); 6083 } 6084} 6085 6086 6087/* 6088 * FDISC is sent and awaiting reply from fabric. 6089 */ 6090static void 6091bfa_fcs_vport_sm_fdisc(struct bfa_fcs_vport_s *vport, 6092 enum bfa_fcs_vport_event event) 6093{ 6094 bfa_trc(__vport_fcs(vport), __vport_pwwn(vport)); 6095 bfa_trc(__vport_fcs(vport), event); 6096 6097 switch (event) { 6098 case BFA_FCS_VPORT_SM_DELETE: 6099 bfa_sm_set_state(vport, bfa_fcs_vport_sm_fdisc_rsp_wait); 6100 break; 6101 6102 case BFA_FCS_VPORT_SM_OFFLINE: 6103 bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline); 6104 bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE); 6105 break; 6106 6107 case BFA_FCS_VPORT_SM_RSP_OK: 6108 bfa_sm_set_state(vport, bfa_fcs_vport_sm_online); 6109 bfa_fcs_lport_online(&vport->lport); 6110 break; 6111 6112 case BFA_FCS_VPORT_SM_RSP_ERROR: 6113 bfa_sm_set_state(vport, bfa_fcs_vport_sm_fdisc_retry); 6114 bfa_timer_start(__vport_bfa(vport), &vport->timer, 6115 bfa_fcs_vport_timeout, vport, 6116 BFA_FCS_RETRY_TIMEOUT); 6117 break; 6118 6119 case BFA_FCS_VPORT_SM_RSP_FAILED: 6120 case BFA_FCS_VPORT_SM_FABRIC_MAX: 6121 bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline); 6122 break; 6123 6124 case BFA_FCS_VPORT_SM_RSP_DUP_WWN: 6125 bfa_sm_set_state(vport, bfa_fcs_vport_sm_error); 6126 break; 6127 6128 default: 6129 bfa_sm_fault(__vport_fcs(vport), event); 6130 } 6131} 6132 6133/* 6134 * FDISC attempt failed - a timer is active to retry FDISC. 6135 */ 6136static void 6137bfa_fcs_vport_sm_fdisc_retry(struct bfa_fcs_vport_s *vport, 6138 enum bfa_fcs_vport_event event) 6139{ 6140 bfa_trc(__vport_fcs(vport), __vport_pwwn(vport)); 6141 bfa_trc(__vport_fcs(vport), event); 6142 6143 switch (event) { 6144 case BFA_FCS_VPORT_SM_DELETE: 6145 bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup); 6146 bfa_timer_stop(&vport->timer); 6147 bfa_fcs_lport_delete(&vport->lport); 6148 break; 6149 6150 case BFA_FCS_VPORT_SM_OFFLINE: 6151 bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline); 6152 bfa_timer_stop(&vport->timer); 6153 break; 6154 6155 case BFA_FCS_VPORT_SM_TIMEOUT: 6156 bfa_sm_set_state(vport, bfa_fcs_vport_sm_fdisc); 6157 vport->vport_stats.fdisc_retries++; 6158 vport->fdisc_retries++; 6159 bfa_fcs_vport_do_fdisc(vport); 6160 break; 6161 6162 default: 6163 bfa_sm_fault(__vport_fcs(vport), event); 6164 } 6165} 6166 6167/* 6168 * FDISC is in progress and we got a vport delete request - 6169 * this is a wait state while we wait for fdisc response and 6170 * we will transition to the appropriate state - on rsp status. 6171 */ 6172static void 6173bfa_fcs_vport_sm_fdisc_rsp_wait(struct bfa_fcs_vport_s *vport, 6174 enum bfa_fcs_vport_event event) 6175{ 6176 bfa_trc(__vport_fcs(vport), __vport_pwwn(vport)); 6177 bfa_trc(__vport_fcs(vport), event); 6178 6179 switch (event) { 6180 case BFA_FCS_VPORT_SM_RSP_OK: 6181 bfa_sm_set_state(vport, bfa_fcs_vport_sm_deleting); 6182 bfa_fcs_lport_delete(&vport->lport); 6183 break; 6184 6185 case BFA_FCS_VPORT_SM_DELETE: 6186 break; 6187 6188 case BFA_FCS_VPORT_SM_OFFLINE: 6189 case BFA_FCS_VPORT_SM_RSP_ERROR: 6190 case BFA_FCS_VPORT_SM_RSP_FAILED: 6191 case BFA_FCS_VPORT_SM_FABRIC_MAX: 6192 case BFA_FCS_VPORT_SM_RSP_DUP_WWN: 6193 bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup); 6194 bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE); 6195 bfa_fcs_lport_delete(&vport->lport); 6196 break; 6197 6198 default: 6199 bfa_sm_fault(__vport_fcs(vport), event); 6200 } 6201} 6202 6203/* 6204 * Vport is online (FDISC is complete). 6205 */ 6206static void 6207bfa_fcs_vport_sm_online(struct bfa_fcs_vport_s *vport, 6208 enum bfa_fcs_vport_event event) 6209{ 6210 bfa_trc(__vport_fcs(vport), __vport_pwwn(vport)); 6211 bfa_trc(__vport_fcs(vport), event); 6212 6213 switch (event) { 6214 case BFA_FCS_VPORT_SM_DELETE: 6215 bfa_sm_set_state(vport, bfa_fcs_vport_sm_deleting); 6216 bfa_fcs_lport_delete(&vport->lport); 6217 break; 6218 6219 case BFA_FCS_VPORT_SM_STOP: 6220 bfa_sm_set_state(vport, bfa_fcs_vport_sm_stopping); 6221 bfa_sm_send_event(&vport->lport, BFA_FCS_PORT_SM_STOP); 6222 break; 6223 6224 case BFA_FCS_VPORT_SM_OFFLINE: 6225 bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline); 6226 bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE); 6227 bfa_fcs_lport_offline(&vport->lport); 6228 break; 6229 6230 default: 6231 bfa_sm_fault(__vport_fcs(vport), event); 6232 } 6233} 6234 6235/* 6236 * Vport is being stopped - awaiting lport stop completion to send 6237 * LOGO to fabric. 6238 */ 6239static void 6240bfa_fcs_vport_sm_stopping(struct bfa_fcs_vport_s *vport, 6241 enum bfa_fcs_vport_event event) 6242{ 6243 bfa_trc(__vport_fcs(vport), __vport_pwwn(vport)); 6244 bfa_trc(__vport_fcs(vport), event); 6245 6246 switch (event) { 6247 case BFA_FCS_VPORT_SM_STOPCOMP: 6248 bfa_sm_set_state(vport, bfa_fcs_vport_sm_logo_for_stop); 6249 bfa_fcs_vport_do_logo(vport); 6250 break; 6251 6252 case BFA_FCS_VPORT_SM_OFFLINE: 6253 bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup); 6254 break; 6255 6256 default: 6257 bfa_sm_fault(__vport_fcs(vport), event); 6258 } 6259} 6260 6261/* 6262 * Vport is being deleted - awaiting lport delete completion to send 6263 * LOGO to fabric. 6264 */ 6265static void 6266bfa_fcs_vport_sm_deleting(struct bfa_fcs_vport_s *vport, 6267 enum bfa_fcs_vport_event event) 6268{ 6269 bfa_trc(__vport_fcs(vport), __vport_pwwn(vport)); 6270 bfa_trc(__vport_fcs(vport), event); 6271 6272 switch (event) { 6273 case BFA_FCS_VPORT_SM_DELETE: 6274 break; 6275 6276 case BFA_FCS_VPORT_SM_DELCOMP: 6277 bfa_sm_set_state(vport, bfa_fcs_vport_sm_logo); 6278 bfa_fcs_vport_do_logo(vport); 6279 break; 6280 6281 case BFA_FCS_VPORT_SM_OFFLINE: 6282 bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup); 6283 break; 6284 6285 default: 6286 bfa_sm_fault(__vport_fcs(vport), event); 6287 } 6288} 6289 6290/* 6291 * Error State. 6292 * This state will be set when the Vport Creation fails due 6293 * to errors like Dup WWN. In this state only operation allowed 6294 * is a Vport Delete. 6295 */ 6296static void 6297bfa_fcs_vport_sm_error(struct bfa_fcs_vport_s *vport, 6298 enum bfa_fcs_vport_event event) 6299{ 6300 bfa_trc(__vport_fcs(vport), __vport_pwwn(vport)); 6301 bfa_trc(__vport_fcs(vport), event); 6302 6303 switch (event) { 6304 case BFA_FCS_VPORT_SM_DELETE: 6305 bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup); 6306 bfa_fcs_lport_delete(&vport->lport); 6307 break; 6308 6309 default: 6310 bfa_trc(__vport_fcs(vport), event); 6311 } 6312} 6313 6314/* 6315 * Lport cleanup is in progress since vport is being deleted. Fabric is 6316 * offline, so no LOGO is needed to complete vport deletion. 6317 */ 6318static void 6319bfa_fcs_vport_sm_cleanup(struct bfa_fcs_vport_s *vport, 6320 enum bfa_fcs_vport_event event) 6321{ 6322 bfa_trc(__vport_fcs(vport), __vport_pwwn(vport)); 6323 bfa_trc(__vport_fcs(vport), event); 6324 6325 switch (event) { 6326 case BFA_FCS_VPORT_SM_DELCOMP: 6327 bfa_sm_set_state(vport, bfa_fcs_vport_sm_uninit); 6328 bfa_fcs_vport_free(vport); 6329 break; 6330 6331 case BFA_FCS_VPORT_SM_STOPCOMP: 6332 bfa_sm_set_state(vport, bfa_fcs_vport_sm_created); 6333 break; 6334 6335 case BFA_FCS_VPORT_SM_DELETE: 6336 break; 6337 6338 default: 6339 bfa_sm_fault(__vport_fcs(vport), event); 6340 } 6341} 6342 6343/* 6344 * LOGO is sent to fabric. Vport stop is in progress. Lport stop cleanup 6345 * is done. 6346 */ 6347static void 6348bfa_fcs_vport_sm_logo_for_stop(struct bfa_fcs_vport_s *vport, 6349 enum bfa_fcs_vport_event event) 6350{ 6351 bfa_trc(__vport_fcs(vport), __vport_pwwn(vport)); 6352 bfa_trc(__vport_fcs(vport), event); 6353 6354 switch (event) { 6355 case BFA_FCS_VPORT_SM_OFFLINE: 6356 bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE); 6357 fallthrough; 6358 6359 case BFA_FCS_VPORT_SM_RSP_OK: 6360 case BFA_FCS_VPORT_SM_RSP_ERROR: 6361 bfa_sm_set_state(vport, bfa_fcs_vport_sm_created); 6362 break; 6363 6364 default: 6365 bfa_sm_fault(__vport_fcs(vport), event); 6366 } 6367} 6368 6369/* 6370 * LOGO is sent to fabric. Vport delete is in progress. Lport delete cleanup 6371 * is done. 6372 */ 6373static void 6374bfa_fcs_vport_sm_logo(struct bfa_fcs_vport_s *vport, 6375 enum bfa_fcs_vport_event event) 6376{ 6377 bfa_trc(__vport_fcs(vport), __vport_pwwn(vport)); 6378 bfa_trc(__vport_fcs(vport), event); 6379 6380 switch (event) { 6381 case BFA_FCS_VPORT_SM_OFFLINE: 6382 bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE); 6383 fallthrough; 6384 6385 case BFA_FCS_VPORT_SM_RSP_OK: 6386 case BFA_FCS_VPORT_SM_RSP_ERROR: 6387 bfa_sm_set_state(vport, bfa_fcs_vport_sm_uninit); 6388 bfa_fcs_vport_free(vport); 6389 break; 6390 6391 case BFA_FCS_VPORT_SM_DELETE: 6392 break; 6393 6394 default: 6395 bfa_sm_fault(__vport_fcs(vport), event); 6396 } 6397} 6398 6399 6400 6401/* 6402 * fcs_vport_private FCS virtual port private functions 6403 */ 6404/* 6405 * Send AEN notification 6406 */ 6407static void 6408bfa_fcs_vport_aen_post(struct bfa_fcs_lport_s *port, 6409 enum bfa_lport_aen_event event) 6410{ 6411 struct bfad_s *bfad = (struct bfad_s *)port->fabric->fcs->bfad; 6412 struct bfa_aen_entry_s *aen_entry; 6413 6414 bfad_get_aen_entry(bfad, aen_entry); 6415 if (!aen_entry) 6416 return; 6417 6418 aen_entry->aen_data.lport.vf_id = port->fabric->vf_id; 6419 aen_entry->aen_data.lport.roles = port->port_cfg.roles; 6420 aen_entry->aen_data.lport.ppwwn = bfa_fcs_lport_get_pwwn( 6421 bfa_fcs_get_base_port(port->fcs)); 6422 aen_entry->aen_data.lport.lpwwn = bfa_fcs_lport_get_pwwn(port); 6423 6424 /* Send the AEN notification */ 6425 bfad_im_post_vendor_event(aen_entry, bfad, ++port->fcs->fcs_aen_seq, 6426 BFA_AEN_CAT_LPORT, event); 6427} 6428 6429/* 6430 * This routine will be called to send a FDISC command. 6431 */ 6432static void 6433bfa_fcs_vport_do_fdisc(struct bfa_fcs_vport_s *vport) 6434{ 6435 bfa_lps_fdisc(vport->lps, vport, 6436 bfa_fcport_get_maxfrsize(__vport_bfa(vport)), 6437 __vport_pwwn(vport), __vport_nwwn(vport)); 6438 vport->vport_stats.fdisc_sent++; 6439} 6440 6441static void 6442bfa_fcs_vport_fdisc_rejected(struct bfa_fcs_vport_s *vport) 6443{ 6444 u8 lsrjt_rsn = vport->lps->lsrjt_rsn; 6445 u8 lsrjt_expl = vport->lps->lsrjt_expl; 6446 6447 bfa_trc(__vport_fcs(vport), lsrjt_rsn); 6448 bfa_trc(__vport_fcs(vport), lsrjt_expl); 6449 6450 /* For certain reason codes, we don't want to retry. */ 6451 switch (vport->lps->lsrjt_expl) { 6452 case FC_LS_RJT_EXP_INV_PORT_NAME: /* by brocade */ 6453 case FC_LS_RJT_EXP_INVALID_NPORT_ID: /* by Cisco */ 6454 if (vport->fdisc_retries < BFA_FCS_VPORT_MAX_RETRIES) 6455 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR); 6456 else { 6457 bfa_fcs_vport_aen_post(&vport->lport, 6458 BFA_LPORT_AEN_NPIV_DUP_WWN); 6459 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_DUP_WWN); 6460 } 6461 break; 6462 6463 case FC_LS_RJT_EXP_INSUFF_RES: 6464 /* 6465 * This means max logins per port/switch setting on the 6466 * switch was exceeded. 6467 */ 6468 if (vport->fdisc_retries < BFA_FCS_VPORT_MAX_RETRIES) 6469 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR); 6470 else { 6471 bfa_fcs_vport_aen_post(&vport->lport, 6472 BFA_LPORT_AEN_NPIV_FABRIC_MAX); 6473 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_FABRIC_MAX); 6474 } 6475 break; 6476 6477 default: 6478 if (vport->fdisc_retries == 0) 6479 bfa_fcs_vport_aen_post(&vport->lport, 6480 BFA_LPORT_AEN_NPIV_UNKNOWN); 6481 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR); 6482 } 6483} 6484 6485/* 6486 * Called to send a logout to the fabric. Used when a V-Port is 6487 * deleted/stopped. 6488 */ 6489static void 6490bfa_fcs_vport_do_logo(struct bfa_fcs_vport_s *vport) 6491{ 6492 bfa_trc(__vport_fcs(vport), __vport_pwwn(vport)); 6493 6494 vport->vport_stats.logo_sent++; 6495 bfa_lps_fdisclogo(vport->lps); 6496} 6497 6498 6499/* 6500 * This routine will be called by bfa_timer on timer timeouts. 6501 * 6502 * param[in] vport - pointer to bfa_fcs_vport_t. 6503 * param[out] vport_status - pointer to return vport status in 6504 * 6505 * return 6506 * void 6507 * 6508 * Special Considerations: 6509 * 6510 * note 6511 */ 6512static void 6513bfa_fcs_vport_timeout(void *vport_arg) 6514{ 6515 struct bfa_fcs_vport_s *vport = (struct bfa_fcs_vport_s *) vport_arg; 6516 6517 vport->vport_stats.fdisc_timeouts++; 6518 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_TIMEOUT); 6519} 6520 6521static void 6522bfa_fcs_vport_free(struct bfa_fcs_vport_s *vport) 6523{ 6524 struct bfad_vport_s *vport_drv = 6525 (struct bfad_vport_s *)vport->vport_drv; 6526 6527 bfa_fcs_fabric_delvport(__vport_fabric(vport), vport); 6528 bfa_lps_delete(vport->lps); 6529 6530 if (vport_drv->comp_del) { 6531 complete(vport_drv->comp_del); 6532 return; 6533 } 6534 6535 /* 6536 * We queue the vport delete work to the IM work_q from here. 6537 * The memory for the bfad_vport_s is freed from the FC function 6538 * template vport_delete entry point. 6539 */ 6540 bfad_im_port_delete(vport_drv->drv_port.bfad, &vport_drv->drv_port); 6541} 6542 6543/* 6544 * fcs_vport_public FCS virtual port public interfaces 6545 */ 6546 6547/* 6548 * Online notification from fabric SM. 6549 */ 6550void 6551bfa_fcs_vport_online(struct bfa_fcs_vport_s *vport) 6552{ 6553 vport->vport_stats.fab_online++; 6554 if (bfa_fcs_fabric_npiv_capable(__vport_fabric(vport))) 6555 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_ONLINE); 6556 else 6557 vport->vport_stats.fab_no_npiv++; 6558} 6559 6560/* 6561 * Offline notification from fabric SM. 6562 */ 6563void 6564bfa_fcs_vport_offline(struct bfa_fcs_vport_s *vport) 6565{ 6566 vport->vport_stats.fab_offline++; 6567 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_OFFLINE); 6568} 6569 6570/* 6571 * Cleanup notification from fabric SM on link timer expiry. 6572 */ 6573void 6574bfa_fcs_vport_cleanup(struct bfa_fcs_vport_s *vport) 6575{ 6576 vport->vport_stats.fab_cleanup++; 6577} 6578 6579/* 6580 * Stop notification from fabric SM. To be invoked from within FCS. 6581 */ 6582void 6583bfa_fcs_vport_fcs_stop(struct bfa_fcs_vport_s *vport) 6584{ 6585 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_STOP); 6586} 6587 6588/* 6589 * delete notification from fabric SM. To be invoked from within FCS. 6590 */ 6591void 6592bfa_fcs_vport_fcs_delete(struct bfa_fcs_vport_s *vport) 6593{ 6594 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_DELETE); 6595} 6596 6597/* 6598 * Stop completion callback from associated lport 6599 */ 6600void 6601bfa_fcs_vport_stop_comp(struct bfa_fcs_vport_s *vport) 6602{ 6603 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_STOPCOMP); 6604} 6605 6606/* 6607 * Delete completion callback from associated lport 6608 */ 6609void 6610bfa_fcs_vport_delete_comp(struct bfa_fcs_vport_s *vport) 6611{ 6612 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_DELCOMP); 6613} 6614 6615 6616 6617/* 6618 * fcs_vport_api Virtual port API 6619 */ 6620 6621/* 6622 * Use this function to instantiate a new FCS vport object. This 6623 * function will not trigger any HW initialization process (which will be 6624 * done in vport_start() call) 6625 * 6626 * param[in] vport - pointer to bfa_fcs_vport_t. This space 6627 * needs to be allocated by the driver. 6628 * param[in] fcs - FCS instance 6629 * param[in] vport_cfg - vport configuration 6630 * param[in] vf_id - VF_ID if vport is created within a VF. 6631 * FC_VF_ID_NULL to specify base fabric. 6632 * param[in] vport_drv - Opaque handle back to the driver's vport 6633 * structure 6634 * 6635 * retval BFA_STATUS_OK - on success. 6636 * retval BFA_STATUS_FAILED - on failure. 6637 */ 6638bfa_status_t 6639bfa_fcs_vport_create(struct bfa_fcs_vport_s *vport, struct bfa_fcs_s *fcs, 6640 u16 vf_id, struct bfa_lport_cfg_s *vport_cfg, 6641 struct bfad_vport_s *vport_drv) 6642{ 6643 if (vport_cfg->pwwn == 0) 6644 return BFA_STATUS_INVALID_WWN; 6645 6646 if (bfa_fcs_lport_get_pwwn(&fcs->fabric.bport) == vport_cfg->pwwn) 6647 return BFA_STATUS_VPORT_WWN_BP; 6648 6649 if (bfa_fcs_vport_lookup(fcs, vf_id, vport_cfg->pwwn) != NULL) 6650 return BFA_STATUS_VPORT_EXISTS; 6651 6652 if (fcs->fabric.num_vports == 6653 bfa_lps_get_max_vport(fcs->bfa)) 6654 return BFA_STATUS_VPORT_MAX; 6655 6656 vport->lps = bfa_lps_alloc(fcs->bfa); 6657 if (!vport->lps) 6658 return BFA_STATUS_VPORT_MAX; 6659 6660 vport->vport_drv = vport_drv; 6661 vport_cfg->preboot_vp = BFA_FALSE; 6662 6663 bfa_sm_set_state(vport, bfa_fcs_vport_sm_uninit); 6664 bfa_fcs_lport_attach(&vport->lport, fcs, vf_id, vport); 6665 bfa_fcs_lport_init(&vport->lport, vport_cfg); 6666 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_CREATE); 6667 6668 return BFA_STATUS_OK; 6669} 6670 6671/* 6672 * Use this function to instantiate a new FCS PBC vport object. This 6673 * function will not trigger any HW initialization process (which will be 6674 * done in vport_start() call) 6675 * 6676 * param[in] vport - pointer to bfa_fcs_vport_t. This space 6677 * needs to be allocated by the driver. 6678 * param[in] fcs - FCS instance 6679 * param[in] vport_cfg - vport configuration 6680 * param[in] vf_id - VF_ID if vport is created within a VF. 6681 * FC_VF_ID_NULL to specify base fabric. 6682 * param[in] vport_drv - Opaque handle back to the driver's vport 6683 * structure 6684 * 6685 * retval BFA_STATUS_OK - on success. 6686 * retval BFA_STATUS_FAILED - on failure. 6687 */ 6688bfa_status_t 6689bfa_fcs_pbc_vport_create(struct bfa_fcs_vport_s *vport, struct bfa_fcs_s *fcs, 6690 u16 vf_id, struct bfa_lport_cfg_s *vport_cfg, 6691 struct bfad_vport_s *vport_drv) 6692{ 6693 bfa_status_t rc; 6694 6695 rc = bfa_fcs_vport_create(vport, fcs, vf_id, vport_cfg, vport_drv); 6696 vport->lport.port_cfg.preboot_vp = BFA_TRUE; 6697 6698 return rc; 6699} 6700 6701/* 6702 * Use this function to findout if this is a pbc vport or not. 6703 * 6704 * @param[in] vport - pointer to bfa_fcs_vport_t. 6705 * 6706 * @returns None 6707 */ 6708bfa_boolean_t 6709bfa_fcs_is_pbc_vport(struct bfa_fcs_vport_s *vport) 6710{ 6711 6712 if (vport && (vport->lport.port_cfg.preboot_vp == BFA_TRUE)) 6713 return BFA_TRUE; 6714 else 6715 return BFA_FALSE; 6716 6717} 6718 6719/* 6720 * Use this function initialize the vport. 6721 * 6722 * @param[in] vport - pointer to bfa_fcs_vport_t. 6723 * 6724 * @returns None 6725 */ 6726bfa_status_t 6727bfa_fcs_vport_start(struct bfa_fcs_vport_s *vport) 6728{ 6729 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_START); 6730 6731 return BFA_STATUS_OK; 6732} 6733 6734/* 6735 * Use this function quiese the vport object. This function will return 6736 * immediately, when the vport is actually stopped, the 6737 * bfa_drv_vport_stop_cb() will be called. 6738 * 6739 * param[in] vport - pointer to bfa_fcs_vport_t. 6740 * 6741 * return None 6742 */ 6743bfa_status_t 6744bfa_fcs_vport_stop(struct bfa_fcs_vport_s *vport) 6745{ 6746 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_STOP); 6747 6748 return BFA_STATUS_OK; 6749} 6750 6751/* 6752 * Use this function to delete a vport object. Fabric object should 6753 * be stopped before this function call. 6754 * 6755 * !!!!!!! Donot invoke this from within FCS !!!!!!! 6756 * 6757 * param[in] vport - pointer to bfa_fcs_vport_t. 6758 * 6759 * return None 6760 */ 6761bfa_status_t 6762bfa_fcs_vport_delete(struct bfa_fcs_vport_s *vport) 6763{ 6764 6765 if (vport->lport.port_cfg.preboot_vp) 6766 return BFA_STATUS_PBC; 6767 6768 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_DELETE); 6769 6770 return BFA_STATUS_OK; 6771} 6772 6773/* 6774 * Use this function to get vport's current status info. 6775 * 6776 * param[in] vport pointer to bfa_fcs_vport_t. 6777 * param[out] attr pointer to return vport attributes 6778 * 6779 * return None 6780 */ 6781void 6782bfa_fcs_vport_get_attr(struct bfa_fcs_vport_s *vport, 6783 struct bfa_vport_attr_s *attr) 6784{ 6785 if (vport == NULL || attr == NULL) 6786 return; 6787 6788 memset(attr, 0, sizeof(struct bfa_vport_attr_s)); 6789 6790 bfa_fcs_lport_get_attr(&vport->lport, &attr->port_attr); 6791 attr->vport_state = bfa_vport_sm_to_state(vport_sm_table, vport->sm); 6792} 6793 6794 6795/* 6796 * Lookup a virtual port. Excludes base port from lookup. 6797 */ 6798struct bfa_fcs_vport_s * 6799bfa_fcs_vport_lookup(struct bfa_fcs_s *fcs, u16 vf_id, wwn_t vpwwn) 6800{ 6801 struct bfa_fcs_vport_s *vport; 6802 struct bfa_fcs_fabric_s *fabric; 6803 6804 bfa_trc(fcs, vf_id); 6805 bfa_trc(fcs, vpwwn); 6806 6807 fabric = bfa_fcs_vf_lookup(fcs, vf_id); 6808 if (!fabric) { 6809 bfa_trc(fcs, vf_id); 6810 return NULL; 6811 } 6812 6813 vport = bfa_fcs_fabric_vport_lookup(fabric, vpwwn); 6814 return vport; 6815} 6816 6817/* 6818 * FDISC Response 6819 */ 6820void 6821bfa_cb_lps_fdisc_comp(void *bfad, void *uarg, bfa_status_t status) 6822{ 6823 struct bfa_fcs_vport_s *vport = uarg; 6824 6825 bfa_trc(__vport_fcs(vport), __vport_pwwn(vport)); 6826 bfa_trc(__vport_fcs(vport), status); 6827 6828 switch (status) { 6829 case BFA_STATUS_OK: 6830 /* 6831 * Initialize the V-Port fields 6832 */ 6833 __vport_fcid(vport) = vport->lps->lp_pid; 6834 vport->vport_stats.fdisc_accepts++; 6835 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_OK); 6836 break; 6837 6838 case BFA_STATUS_INVALID_MAC: 6839 /* Only for CNA */ 6840 vport->vport_stats.fdisc_acc_bad++; 6841 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR); 6842 6843 break; 6844 6845 case BFA_STATUS_EPROTOCOL: 6846 switch (vport->lps->ext_status) { 6847 case BFA_EPROTO_BAD_ACCEPT: 6848 vport->vport_stats.fdisc_acc_bad++; 6849 break; 6850 6851 case BFA_EPROTO_UNKNOWN_RSP: 6852 vport->vport_stats.fdisc_unknown_rsp++; 6853 break; 6854 6855 default: 6856 break; 6857 } 6858 6859 if (vport->fdisc_retries < BFA_FCS_VPORT_MAX_RETRIES) 6860 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR); 6861 else 6862 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_FAILED); 6863 6864 break; 6865 6866 case BFA_STATUS_ETIMER: 6867 vport->vport_stats.fdisc_timeouts++; 6868 if (vport->fdisc_retries < BFA_FCS_VPORT_MAX_RETRIES) 6869 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR); 6870 else 6871 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_FAILED); 6872 break; 6873 6874 case BFA_STATUS_FABRIC_RJT: 6875 vport->vport_stats.fdisc_rejects++; 6876 bfa_fcs_vport_fdisc_rejected(vport); 6877 break; 6878 6879 default: 6880 vport->vport_stats.fdisc_rsp_err++; 6881 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR); 6882 } 6883} 6884 6885/* 6886 * LOGO response 6887 */ 6888void 6889bfa_cb_lps_fdisclogo_comp(void *bfad, void *uarg) 6890{ 6891 struct bfa_fcs_vport_s *vport = uarg; 6892 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_OK); 6893} 6894 6895/* 6896 * Received clear virtual link 6897 */ 6898void 6899bfa_cb_lps_cvl_event(void *bfad, void *uarg) 6900{ 6901 struct bfa_fcs_vport_s *vport = uarg; 6902 6903 /* Send an Offline followed by an ONLINE */ 6904 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_OFFLINE); 6905 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_ONLINE); 6906} 6907