2 * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
6 * Linux driver for Brocade Fibre Channel Host Bus Adapter.
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License (GPL) Version 2 as
10 * published by the Free Software Foundation
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
19 * bfa_fcs_lport.c BFA FCS port
23 #include "bfa_fcbuild.h"
27 BFA_TRC_FILE(FCS
, PORT
);
30 * Forward declarations
33 static void bfa_fcs_lport_send_ls_rjt(struct bfa_fcs_lport_s
*port
,
34 struct fchs_s
*rx_fchs
, u8 reason_code
,
36 static void bfa_fcs_lport_plogi(struct bfa_fcs_lport_s
*port
,
37 struct fchs_s
*rx_fchs
, struct fc_logi_s
*plogi
);
38 static void bfa_fcs_lport_online_actions(struct bfa_fcs_lport_s
*port
);
39 static void bfa_fcs_lport_offline_actions(struct bfa_fcs_lport_s
*port
);
40 static void bfa_fcs_lport_unknown_init(struct bfa_fcs_lport_s
*port
);
41 static void bfa_fcs_lport_unknown_online(struct bfa_fcs_lport_s
*port
);
42 static void bfa_fcs_lport_unknown_offline(struct bfa_fcs_lport_s
*port
);
43 static void bfa_fcs_lport_deleted(struct bfa_fcs_lport_s
*port
);
44 static void bfa_fcs_lport_echo(struct bfa_fcs_lport_s
*port
,
45 struct fchs_s
*rx_fchs
,
46 struct fc_echo_s
*echo
, u16 len
);
47 static void bfa_fcs_lport_rnid(struct bfa_fcs_lport_s
*port
,
48 struct fchs_s
*rx_fchs
,
49 struct fc_rnid_cmd_s
*rnid
, u16 len
);
50 static void bfa_fs_port_get_gen_topo_data(struct bfa_fcs_lport_s
*port
,
51 struct fc_rnid_general_topology_data_s
*gen_topo_data
);
53 static void bfa_fcs_lport_fab_init(struct bfa_fcs_lport_s
*port
);
54 static void bfa_fcs_lport_fab_online(struct bfa_fcs_lport_s
*port
);
55 static void bfa_fcs_lport_fab_offline(struct bfa_fcs_lport_s
*port
);
57 static void bfa_fcs_lport_n2n_init(struct bfa_fcs_lport_s
*port
);
58 static void bfa_fcs_lport_n2n_online(struct bfa_fcs_lport_s
*port
);
59 static void bfa_fcs_lport_n2n_offline(struct bfa_fcs_lport_s
*port
);
62 void (*init
) (struct bfa_fcs_lport_s
*port
);
63 void (*online
) (struct bfa_fcs_lport_s
*port
);
64 void (*offline
) (struct bfa_fcs_lport_s
*port
);
67 bfa_fcs_lport_unknown_init
, bfa_fcs_lport_unknown_online
,
68 bfa_fcs_lport_unknown_offline
}, {
69 bfa_fcs_lport_fab_init
, bfa_fcs_lport_fab_online
,
70 bfa_fcs_lport_fab_offline
}, {
71 bfa_fcs_lport_n2n_init
, bfa_fcs_lport_n2n_online
,
72 bfa_fcs_lport_n2n_offline
},
76 * fcs_port_sm FCS logical port state machine
79 enum bfa_fcs_lport_event
{
80 BFA_FCS_PORT_SM_CREATE
= 1,
81 BFA_FCS_PORT_SM_ONLINE
= 2,
82 BFA_FCS_PORT_SM_OFFLINE
= 3,
83 BFA_FCS_PORT_SM_DELETE
= 4,
84 BFA_FCS_PORT_SM_DELRPORT
= 5,
87 static void bfa_fcs_lport_sm_uninit(struct bfa_fcs_lport_s
*port
,
88 enum bfa_fcs_lport_event event
);
89 static void bfa_fcs_lport_sm_init(struct bfa_fcs_lport_s
*port
,
90 enum bfa_fcs_lport_event event
);
91 static void bfa_fcs_lport_sm_online(struct bfa_fcs_lport_s
*port
,
92 enum bfa_fcs_lport_event event
);
93 static void bfa_fcs_lport_sm_offline(struct bfa_fcs_lport_s
*port
,
94 enum bfa_fcs_lport_event event
);
95 static void bfa_fcs_lport_sm_deleting(struct bfa_fcs_lport_s
*port
,
96 enum bfa_fcs_lport_event event
);
99 bfa_fcs_lport_sm_uninit(
100 struct bfa_fcs_lport_s
*port
,
101 enum bfa_fcs_lport_event event
)
103 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
104 bfa_trc(port
->fcs
, event
);
107 case BFA_FCS_PORT_SM_CREATE
:
108 bfa_sm_set_state(port
, bfa_fcs_lport_sm_init
);
112 bfa_sm_fault(port
->fcs
, event
);
117 bfa_fcs_lport_sm_init(struct bfa_fcs_lport_s
*port
,
118 enum bfa_fcs_lport_event event
)
120 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
121 bfa_trc(port
->fcs
, event
);
124 case BFA_FCS_PORT_SM_ONLINE
:
125 bfa_sm_set_state(port
, bfa_fcs_lport_sm_online
);
126 bfa_fcs_lport_online_actions(port
);
129 case BFA_FCS_PORT_SM_DELETE
:
130 bfa_sm_set_state(port
, bfa_fcs_lport_sm_uninit
);
131 bfa_fcs_lport_deleted(port
);
134 case BFA_FCS_PORT_SM_OFFLINE
:
138 bfa_sm_fault(port
->fcs
, event
);
143 bfa_fcs_lport_sm_online(
144 struct bfa_fcs_lport_s
*port
,
145 enum bfa_fcs_lport_event event
)
147 struct bfa_fcs_rport_s
*rport
;
148 struct list_head
*qe
, *qen
;
150 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
151 bfa_trc(port
->fcs
, event
);
154 case BFA_FCS_PORT_SM_OFFLINE
:
155 bfa_sm_set_state(port
, bfa_fcs_lport_sm_offline
);
156 bfa_fcs_lport_offline_actions(port
);
159 case BFA_FCS_PORT_SM_DELETE
:
161 __port_action
[port
->fabric
->fab_type
].offline(port
);
163 if (port
->num_rports
== 0) {
164 bfa_sm_set_state(port
, bfa_fcs_lport_sm_uninit
);
165 bfa_fcs_lport_deleted(port
);
167 bfa_sm_set_state(port
, bfa_fcs_lport_sm_deleting
);
168 list_for_each_safe(qe
, qen
, &port
->rport_q
) {
169 rport
= (struct bfa_fcs_rport_s
*) qe
;
170 bfa_fcs_rport_delete(rport
);
175 case BFA_FCS_PORT_SM_DELRPORT
:
179 bfa_sm_fault(port
->fcs
, event
);
184 bfa_fcs_lport_sm_offline(
185 struct bfa_fcs_lport_s
*port
,
186 enum bfa_fcs_lport_event event
)
188 struct bfa_fcs_rport_s
*rport
;
189 struct list_head
*qe
, *qen
;
191 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
192 bfa_trc(port
->fcs
, event
);
195 case BFA_FCS_PORT_SM_ONLINE
:
196 bfa_sm_set_state(port
, bfa_fcs_lport_sm_online
);
197 bfa_fcs_lport_online_actions(port
);
200 case BFA_FCS_PORT_SM_DELETE
:
201 if (port
->num_rports
== 0) {
202 bfa_sm_set_state(port
, bfa_fcs_lport_sm_uninit
);
203 bfa_fcs_lport_deleted(port
);
205 bfa_sm_set_state(port
, bfa_fcs_lport_sm_deleting
);
206 list_for_each_safe(qe
, qen
, &port
->rport_q
) {
207 rport
= (struct bfa_fcs_rport_s
*) qe
;
208 bfa_fcs_rport_delete(rport
);
213 case BFA_FCS_PORT_SM_DELRPORT
:
214 case BFA_FCS_PORT_SM_OFFLINE
:
218 bfa_sm_fault(port
->fcs
, event
);
223 bfa_fcs_lport_sm_deleting(
224 struct bfa_fcs_lport_s
*port
,
225 enum bfa_fcs_lport_event event
)
227 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
228 bfa_trc(port
->fcs
, event
);
231 case BFA_FCS_PORT_SM_DELRPORT
:
232 if (port
->num_rports
== 0) {
233 bfa_sm_set_state(port
, bfa_fcs_lport_sm_uninit
);
234 bfa_fcs_lport_deleted(port
);
239 bfa_sm_fault(port
->fcs
, event
);
251 bfa_fcs_lport_send_ls_rjt(struct bfa_fcs_lport_s
*port
, struct fchs_s
*rx_fchs
,
252 u8 reason_code
, u8 reason_code_expl
)
255 struct bfa_fcxp_s
*fcxp
;
256 struct bfa_rport_s
*bfa_rport
= NULL
;
259 bfa_trc(port
->fcs
, rx_fchs
->d_id
);
260 bfa_trc(port
->fcs
, rx_fchs
->s_id
);
262 fcxp
= bfa_fcs_fcxp_alloc(port
->fcs
);
266 len
= fc_ls_rjt_build(&fchs
, bfa_fcxp_get_reqbuf(fcxp
),
267 rx_fchs
->s_id
, bfa_fcs_lport_get_fcid(port
),
268 rx_fchs
->ox_id
, reason_code
, reason_code_expl
);
270 bfa_fcxp_send(fcxp
, bfa_rport
, port
->fabric
->vf_id
, port
->lp_tag
,
271 BFA_FALSE
, FC_CLASS_3
, len
, &fchs
, NULL
, NULL
,
276 * Process incoming plogi from a remote port.
279 bfa_fcs_lport_plogi(struct bfa_fcs_lport_s
*port
,
280 struct fchs_s
*rx_fchs
, struct fc_logi_s
*plogi
)
282 struct bfa_fcs_rport_s
*rport
;
284 bfa_trc(port
->fcs
, rx_fchs
->d_id
);
285 bfa_trc(port
->fcs
, rx_fchs
->s_id
);
288 * If min cfg mode is enabled, drop any incoming PLOGIs
290 if (__fcs_min_cfg(port
->fcs
)) {
291 bfa_trc(port
->fcs
, rx_fchs
->s_id
);
295 if (fc_plogi_parse(rx_fchs
) != FC_PARSE_OK
) {
296 bfa_trc(port
->fcs
, rx_fchs
->s_id
);
300 bfa_fcs_lport_send_ls_rjt(port
, rx_fchs
,
301 FC_LS_RJT_RSN_PROTOCOL_ERROR
,
302 FC_LS_RJT_EXP_SPARMS_ERR_OPTIONS
);
307 * Direct Attach P2P mode : verify address assigned by the r-port.
309 if ((!bfa_fcs_fabric_is_switched(port
->fabric
)) &&
310 (memcmp((void *)&bfa_fcs_lport_get_pwwn(port
),
311 (void *)&plogi
->port_name
, sizeof(wwn_t
)) < 0)) {
312 if (BFA_FCS_PID_IS_WKA(rx_fchs
->d_id
)) {
313 /* Address assigned to us cannot be a WKA */
314 bfa_fcs_lport_send_ls_rjt(port
, rx_fchs
,
315 FC_LS_RJT_RSN_PROTOCOL_ERROR
,
316 FC_LS_RJT_EXP_INVALID_NPORT_ID
);
319 port
->pid
= rx_fchs
->d_id
;
323 * First, check if we know the device by pwwn.
325 rport
= bfa_fcs_lport_get_rport_by_pwwn(port
, plogi
->port_name
);
328 * Direct Attach P2P mode : handle address assigned by r-port.
330 if ((!bfa_fcs_fabric_is_switched(port
->fabric
)) &&
331 (memcmp((void *)&bfa_fcs_lport_get_pwwn(port
),
332 (void *)&plogi
->port_name
, sizeof(wwn_t
)) < 0)) {
333 port
->pid
= rx_fchs
->d_id
;
334 rport
->pid
= rx_fchs
->s_id
;
336 bfa_fcs_rport_plogi(rport
, rx_fchs
, plogi
);
341 * Next, lookup rport by PID.
343 rport
= bfa_fcs_lport_get_rport_by_pid(port
, rx_fchs
->s_id
);
346 * Inbound PLOGI from a new device.
348 bfa_fcs_rport_plogi_create(port
, rx_fchs
, plogi
);
353 * Rport is known only by PID.
357 * This is a different device with the same pid. Old device
358 * disappeared. Send implicit LOGO to old device.
360 bfa_assert(rport
->pwwn
!= plogi
->port_name
);
361 bfa_fcs_rport_logo_imp(rport
);
364 * Inbound PLOGI from a new device (with old PID).
366 bfa_fcs_rport_plogi_create(port
, rx_fchs
, plogi
);
371 * PLOGI crossing each other.
373 bfa_assert(rport
->pwwn
== WWN_NULL
);
374 bfa_fcs_rport_plogi(rport
, rx_fchs
, plogi
);
378 * Process incoming ECHO.
379 * Since it does not require a login, it is processed here.
382 bfa_fcs_lport_echo(struct bfa_fcs_lport_s
*port
, struct fchs_s
*rx_fchs
,
383 struct fc_echo_s
*echo
, u16 rx_len
)
386 struct bfa_fcxp_s
*fcxp
;
387 struct bfa_rport_s
*bfa_rport
= NULL
;
390 bfa_trc(port
->fcs
, rx_fchs
->s_id
);
391 bfa_trc(port
->fcs
, rx_fchs
->d_id
);
393 fcxp
= bfa_fcs_fcxp_alloc(port
->fcs
);
397 len
= fc_ls_acc_build(&fchs
, bfa_fcxp_get_reqbuf(fcxp
),
398 rx_fchs
->s_id
, bfa_fcs_lport_get_fcid(port
),
402 * Copy the payload (if any) from the echo frame
404 pyld_len
= rx_len
- sizeof(struct fchs_s
);
405 bfa_trc(port
->fcs
, rx_len
);
406 bfa_trc(port
->fcs
, pyld_len
);
409 memcpy(((u8
*) bfa_fcxp_get_reqbuf(fcxp
)) +
410 sizeof(struct fc_echo_s
), (echo
+ 1),
411 (pyld_len
- sizeof(struct fc_echo_s
)));
413 bfa_fcxp_send(fcxp
, bfa_rport
, port
->fabric
->vf_id
, port
->lp_tag
,
414 BFA_FALSE
, FC_CLASS_3
, pyld_len
, &fchs
, NULL
, NULL
,
419 * Process incoming RNID.
420 * Since it does not require a login, it is processed here.
423 bfa_fcs_lport_rnid(struct bfa_fcs_lport_s
*port
, struct fchs_s
*rx_fchs
,
424 struct fc_rnid_cmd_s
*rnid
, u16 rx_len
)
426 struct fc_rnid_common_id_data_s common_id_data
;
427 struct fc_rnid_general_topology_data_s gen_topo_data
;
429 struct bfa_fcxp_s
*fcxp
;
430 struct bfa_rport_s
*bfa_rport
= NULL
;
434 bfa_trc(port
->fcs
, rx_fchs
->s_id
);
435 bfa_trc(port
->fcs
, rx_fchs
->d_id
);
436 bfa_trc(port
->fcs
, rx_len
);
438 fcxp
= bfa_fcs_fcxp_alloc(port
->fcs
);
443 * Check Node Indentification Data Format
444 * We only support General Topology Discovery Format.
445 * For any other requested Data Formats, we return Common Node Id Data
446 * only, as per FC-LS.
448 bfa_trc(port
->fcs
, rnid
->node_id_data_format
);
449 if (rnid
->node_id_data_format
== RNID_NODEID_DATA_FORMAT_DISCOVERY
) {
450 data_format
= RNID_NODEID_DATA_FORMAT_DISCOVERY
;
452 * Get General topology data for this port
454 bfa_fs_port_get_gen_topo_data(port
, &gen_topo_data
);
456 data_format
= RNID_NODEID_DATA_FORMAT_COMMON
;
460 * Copy the Node Id Info
462 common_id_data
.port_name
= bfa_fcs_lport_get_pwwn(port
);
463 common_id_data
.node_name
= bfa_fcs_lport_get_nwwn(port
);
465 len
= fc_rnid_acc_build(&fchs
, bfa_fcxp_get_reqbuf(fcxp
),
466 rx_fchs
->s_id
, bfa_fcs_lport_get_fcid(port
),
467 rx_fchs
->ox_id
, data_format
, &common_id_data
,
470 bfa_fcxp_send(fcxp
, bfa_rport
, port
->fabric
->vf_id
, port
->lp_tag
,
471 BFA_FALSE
, FC_CLASS_3
, len
, &fchs
, NULL
, NULL
,
476 * Fill out General Topolpgy Discovery Data for RNID ELS.
479 bfa_fs_port_get_gen_topo_data(struct bfa_fcs_lport_s
*port
,
480 struct fc_rnid_general_topology_data_s
*gen_topo_data
)
482 bfa_os_memset(gen_topo_data
, 0,
483 sizeof(struct fc_rnid_general_topology_data_s
));
485 gen_topo_data
->asso_type
= bfa_os_htonl(RNID_ASSOCIATED_TYPE_HOST
);
486 gen_topo_data
->phy_port_num
= 0; /* @todo */
487 gen_topo_data
->num_attached_nodes
= bfa_os_htonl(1);
491 bfa_fcs_lport_online_actions(struct bfa_fcs_lport_s
*port
)
493 struct bfad_s
*bfad
= (struct bfad_s
*)port
->fcs
->bfad
;
494 char lpwwn_buf
[BFA_STRING_32
];
496 bfa_trc(port
->fcs
, port
->fabric
->oper_type
);
498 __port_action
[port
->fabric
->fab_type
].init(port
);
499 __port_action
[port
->fabric
->fab_type
].online(port
);
501 wwn2str(lpwwn_buf
, bfa_fcs_lport_get_pwwn(port
));
502 BFA_LOG(KERN_INFO
, bfad
, log_level
,
503 "Logical port online: WWN = %s Role = %s\n",
504 lpwwn_buf
, "Initiator");
506 bfad
->bfad_flags
|= BFAD_PORT_ONLINE
;
510 bfa_fcs_lport_offline_actions(struct bfa_fcs_lport_s
*port
)
512 struct list_head
*qe
, *qen
;
513 struct bfa_fcs_rport_s
*rport
;
514 struct bfad_s
*bfad
= (struct bfad_s
*)port
->fcs
->bfad
;
515 char lpwwn_buf
[BFA_STRING_32
];
517 bfa_trc(port
->fcs
, port
->fabric
->oper_type
);
519 __port_action
[port
->fabric
->fab_type
].offline(port
);
521 wwn2str(lpwwn_buf
, bfa_fcs_lport_get_pwwn(port
));
522 if (bfa_fcs_fabric_is_online(port
->fabric
) == BFA_TRUE
)
523 BFA_LOG(KERN_ERR
, bfad
, log_level
,
524 "Logical port lost fabric connectivity: WWN = %s Role = %s\n",
525 lpwwn_buf
, "Initiator");
527 BFA_LOG(KERN_INFO
, bfad
, log_level
,
528 "Logical port taken offline: WWN = %s Role = %s\n",
529 lpwwn_buf
, "Initiator");
531 list_for_each_safe(qe
, qen
, &port
->rport_q
) {
532 rport
= (struct bfa_fcs_rport_s
*) qe
;
533 bfa_fcs_rport_offline(rport
);
538 bfa_fcs_lport_unknown_init(struct bfa_fcs_lport_s
*port
)
544 bfa_fcs_lport_unknown_online(struct bfa_fcs_lport_s
*port
)
550 bfa_fcs_lport_unknown_offline(struct bfa_fcs_lport_s
*port
)
556 bfa_fcs_lport_abts_acc(struct bfa_fcs_lport_s
*port
, struct fchs_s
*rx_fchs
)
559 struct bfa_fcxp_s
*fcxp
;
562 bfa_trc(port
->fcs
, rx_fchs
->d_id
);
563 bfa_trc(port
->fcs
, rx_fchs
->s_id
);
565 fcxp
= bfa_fcs_fcxp_alloc(port
->fcs
);
569 len
= fc_ba_acc_build(&fchs
, bfa_fcxp_get_reqbuf(fcxp
),
570 rx_fchs
->s_id
, bfa_fcs_lport_get_fcid(port
),
573 bfa_fcxp_send(fcxp
, NULL
, port
->fabric
->vf_id
, port
->lp_tag
,
574 BFA_FALSE
, FC_CLASS_3
, len
, &fchs
, NULL
, NULL
,
578 bfa_fcs_lport_deleted(struct bfa_fcs_lport_s
*port
)
580 struct bfad_s
*bfad
= (struct bfad_s
*)port
->fcs
->bfad
;
581 char lpwwn_buf
[BFA_STRING_32
];
583 wwn2str(lpwwn_buf
, bfa_fcs_lport_get_pwwn(port
));
584 BFA_LOG(KERN_INFO
, bfad
, log_level
,
585 "Logical port deleted: WWN = %s Role = %s\n",
586 lpwwn_buf
, "Initiator");
588 /* Base port will be deleted by the OS driver */
590 bfa_fcb_lport_delete(port
->fcs
->bfad
, port
->port_cfg
.roles
,
591 port
->fabric
->vf_drv
,
592 port
->vport
? port
->vport
->vport_drv
: NULL
);
593 bfa_fcs_vport_delete_comp(port
->vport
);
595 bfa_fcs_fabric_port_delete_comp(port
->fabric
);
602 * fcs_lport_api BFA FCS port API
605 * Module initialization
608 bfa_fcs_lport_modinit(struct bfa_fcs_s
*fcs
)
617 bfa_fcs_lport_modexit(struct bfa_fcs_s
*fcs
)
619 bfa_fcs_modexit_comp(fcs
);
623 * Unsolicited frame receive handling.
626 bfa_fcs_lport_uf_recv(struct bfa_fcs_lport_s
*lport
,
627 struct fchs_s
*fchs
, u16 len
)
629 u32 pid
= fchs
->s_id
;
630 struct bfa_fcs_rport_s
*rport
= NULL
;
631 struct fc_els_cmd_s
*els_cmd
= (struct fc_els_cmd_s
*) (fchs
+ 1);
633 bfa_stats(lport
, uf_recvs
);
635 if (!bfa_fcs_lport_is_online(lport
)) {
636 bfa_stats(lport
, uf_recv_drops
);
641 * First, handle ELSs that donot require a login.
646 if ((fchs
->type
== FC_TYPE_ELS
) &&
647 (els_cmd
->els_code
== FC_ELS_PLOGI
)) {
648 bfa_fcs_lport_plogi(lport
, fchs
, (struct fc_logi_s
*) els_cmd
);
653 * Handle ECHO separately.
655 if ((fchs
->type
== FC_TYPE_ELS
) && (els_cmd
->els_code
== FC_ELS_ECHO
)) {
656 bfa_fcs_lport_echo(lport
, fchs
,
657 (struct fc_echo_s
*)els_cmd
, len
);
662 * Handle RNID separately.
664 if ((fchs
->type
== FC_TYPE_ELS
) && (els_cmd
->els_code
== FC_ELS_RNID
)) {
665 bfa_fcs_lport_rnid(lport
, fchs
,
666 (struct fc_rnid_cmd_s
*) els_cmd
, len
);
670 if (fchs
->type
== FC_TYPE_BLS
) {
671 if ((fchs
->routing
== FC_RTG_BASIC_LINK
) &&
672 (fchs
->cat_info
== FC_CAT_ABTS
))
673 bfa_fcs_lport_abts_acc(lport
, fchs
);
677 * look for a matching remote port ID
679 rport
= bfa_fcs_lport_get_rport_by_pid(lport
, pid
);
681 bfa_trc(rport
->fcs
, fchs
->s_id
);
682 bfa_trc(rport
->fcs
, fchs
->d_id
);
683 bfa_trc(rport
->fcs
, fchs
->type
);
685 bfa_fcs_rport_uf_recv(rport
, fchs
, len
);
690 * Only handles ELS frames for now.
692 if (fchs
->type
!= FC_TYPE_ELS
) {
693 bfa_trc(lport
->fcs
, fchs
->type
);
698 bfa_trc(lport
->fcs
, els_cmd
->els_code
);
699 if (els_cmd
->els_code
== FC_ELS_RSCN
) {
700 bfa_fcs_lport_scn_process_rscn(lport
, fchs
, len
);
704 if (els_cmd
->els_code
== FC_ELS_LOGO
) {
706 * @todo Handle LOGO frames received.
711 if (els_cmd
->els_code
== FC_ELS_PRLI
) {
713 * @todo Handle PRLI frames received.
719 * Unhandled ELS frames. Send a LS_RJT.
721 bfa_fcs_lport_send_ls_rjt(lport
, fchs
, FC_LS_RJT_RSN_CMD_NOT_SUPP
,
722 FC_LS_RJT_EXP_NO_ADDL_INFO
);
727 * PID based Lookup for a R-Port in the Port R-Port Queue
729 struct bfa_fcs_rport_s
*
730 bfa_fcs_lport_get_rport_by_pid(struct bfa_fcs_lport_s
*port
, u32 pid
)
732 struct bfa_fcs_rport_s
*rport
;
733 struct list_head
*qe
;
735 list_for_each(qe
, &port
->rport_q
) {
736 rport
= (struct bfa_fcs_rport_s
*) qe
;
737 if (rport
->pid
== pid
)
741 bfa_trc(port
->fcs
, pid
);
746 * PWWN based Lookup for a R-Port in the Port R-Port Queue
748 struct bfa_fcs_rport_s
*
749 bfa_fcs_lport_get_rport_by_pwwn(struct bfa_fcs_lport_s
*port
, wwn_t pwwn
)
751 struct bfa_fcs_rport_s
*rport
;
752 struct list_head
*qe
;
754 list_for_each(qe
, &port
->rport_q
) {
755 rport
= (struct bfa_fcs_rport_s
*) qe
;
756 if (wwn_is_equal(rport
->pwwn
, pwwn
))
760 bfa_trc(port
->fcs
, pwwn
);
765 * NWWN based Lookup for a R-Port in the Port R-Port Queue
767 struct bfa_fcs_rport_s
*
768 bfa_fcs_lport_get_rport_by_nwwn(struct bfa_fcs_lport_s
*port
, wwn_t nwwn
)
770 struct bfa_fcs_rport_s
*rport
;
771 struct list_head
*qe
;
773 list_for_each(qe
, &port
->rport_q
) {
774 rport
= (struct bfa_fcs_rport_s
*) qe
;
775 if (wwn_is_equal(rport
->nwwn
, nwwn
))
779 bfa_trc(port
->fcs
, nwwn
);
784 * Called by rport module when new rports are discovered.
787 bfa_fcs_lport_add_rport(
788 struct bfa_fcs_lport_s
*port
,
789 struct bfa_fcs_rport_s
*rport
)
791 list_add_tail(&rport
->qe
, &port
->rport_q
);
796 * Called by rport module to when rports are deleted.
799 bfa_fcs_lport_del_rport(
800 struct bfa_fcs_lport_s
*port
,
801 struct bfa_fcs_rport_s
*rport
)
803 bfa_assert(bfa_q_is_on_q(&port
->rport_q
, rport
));
804 list_del(&rport
->qe
);
807 bfa_sm_send_event(port
, BFA_FCS_PORT_SM_DELRPORT
);
811 * Called by fabric for base port when fabric login is complete.
812 * Called by vport for virtual ports when FDISC is complete.
815 bfa_fcs_lport_online(struct bfa_fcs_lport_s
*port
)
817 bfa_sm_send_event(port
, BFA_FCS_PORT_SM_ONLINE
);
821 * Called by fabric for base port when fabric goes offline.
822 * Called by vport for virtual ports when virtual port becomes offline.
825 bfa_fcs_lport_offline(struct bfa_fcs_lport_s
*port
)
827 bfa_sm_send_event(port
, BFA_FCS_PORT_SM_OFFLINE
);
831 * Called by fabric to delete base lport and associated resources.
833 * Called by vport to delete lport and associated resources. Should call
834 * bfa_fcs_vport_delete_comp() for vports on completion.
837 bfa_fcs_lport_delete(struct bfa_fcs_lport_s
*port
)
839 bfa_sm_send_event(port
, BFA_FCS_PORT_SM_DELETE
);
843 * Return TRUE if port is online, else return FALSE
846 bfa_fcs_lport_is_online(struct bfa_fcs_lport_s
*port
)
848 return bfa_sm_cmp_state(port
, bfa_fcs_lport_sm_online
);
852 * Attach time initialization of logical ports.
855 bfa_fcs_lport_attach(struct bfa_fcs_lport_s
*lport
, struct bfa_fcs_s
*fcs
,
856 u16 vf_id
, struct bfa_fcs_vport_s
*vport
)
859 lport
->fabric
= bfa_fcs_vf_lookup(fcs
, vf_id
);
860 lport
->vport
= vport
;
861 lport
->lp_tag
= (vport
) ? bfa_lps_get_tag(vport
->lps
) :
862 bfa_lps_get_tag(lport
->fabric
->lps
);
864 INIT_LIST_HEAD(&lport
->rport_q
);
865 lport
->num_rports
= 0;
869 * Logical port initialization of base or virtual port.
870 * Called by fabric for base port or by vport for virtual ports.
874 bfa_fcs_lport_init(struct bfa_fcs_lport_s
*lport
,
875 struct bfa_lport_cfg_s
*port_cfg
)
877 struct bfa_fcs_vport_s
*vport
= lport
->vport
;
878 struct bfad_s
*bfad
= (struct bfad_s
*)lport
->fcs
->bfad
;
879 char lpwwn_buf
[BFA_STRING_32
];
881 bfa_os_assign(lport
->port_cfg
, *port_cfg
);
883 lport
->bfad_port
= bfa_fcb_lport_new(lport
->fcs
->bfad
, lport
,
884 lport
->port_cfg
.roles
,
885 lport
->fabric
->vf_drv
,
886 vport
? vport
->vport_drv
: NULL
);
888 wwn2str(lpwwn_buf
, bfa_fcs_lport_get_pwwn(lport
));
889 BFA_LOG(KERN_INFO
, bfad
, log_level
,
890 "New logical port created: WWN = %s Role = %s\n",
891 lpwwn_buf
, "Initiator");
893 bfa_sm_set_state(lport
, bfa_fcs_lport_sm_uninit
);
894 bfa_sm_send_event(lport
, BFA_FCS_PORT_SM_CREATE
);
902 bfa_fcs_lport_get_attr(
903 struct bfa_fcs_lport_s
*port
,
904 struct bfa_lport_attr_s
*port_attr
)
906 if (bfa_sm_cmp_state(port
, bfa_fcs_lport_sm_online
))
907 port_attr
->pid
= port
->pid
;
911 port_attr
->port_cfg
= port
->port_cfg
;
914 port_attr
->port_type
= bfa_fcs_fabric_port_type(port
->fabric
);
915 port_attr
->loopback
= bfa_fcs_fabric_is_loopback(port
->fabric
);
916 port_attr
->authfail
=
917 bfa_fcs_fabric_is_auth_failed(port
->fabric
);
918 port_attr
->fabric_name
= bfa_fcs_lport_get_fabric_name(port
);
919 memcpy(port_attr
->fabric_ip_addr
,
920 bfa_fcs_lport_get_fabric_ipaddr(port
),
921 BFA_FCS_FABRIC_IPADDR_SZ
);
923 if (port
->vport
!= NULL
) {
924 port_attr
->port_type
= BFA_PORT_TYPE_VPORT
;
925 port_attr
->fpma_mac
=
926 bfa_lps_get_lp_mac(port
->vport
->lps
);
928 port_attr
->fpma_mac
=
929 bfa_lps_get_lp_mac(port
->fabric
->lps
);
932 port_attr
->port_type
= BFA_PORT_TYPE_UNKNOWN
;
933 port_attr
->state
= BFA_LPORT_UNINIT
;
938 * bfa_fcs_lport_fab port fab functions
942 * Called by port to initialize fabric services of the base port.
945 bfa_fcs_lport_fab_init(struct bfa_fcs_lport_s
*port
)
947 bfa_fcs_lport_ns_init(port
);
948 bfa_fcs_lport_scn_init(port
);
949 bfa_fcs_lport_ms_init(port
);
953 * Called by port to notify transition to online state.
956 bfa_fcs_lport_fab_online(struct bfa_fcs_lport_s
*port
)
958 bfa_fcs_lport_ns_online(port
);
959 bfa_fcs_lport_scn_online(port
);
963 * Called by port to notify transition to offline state.
966 bfa_fcs_lport_fab_offline(struct bfa_fcs_lport_s
*port
)
968 bfa_fcs_lport_ns_offline(port
);
969 bfa_fcs_lport_scn_offline(port
);
970 bfa_fcs_lport_ms_offline(port
);
974 * bfa_fcs_lport_n2n functions
978 * Called by fcs/port to initialize N2N topology.
981 bfa_fcs_lport_n2n_init(struct bfa_fcs_lport_s
*port
)
986 * Called by fcs/port to notify transition to online state.
989 bfa_fcs_lport_n2n_online(struct bfa_fcs_lport_s
*port
)
991 struct bfa_fcs_lport_n2n_s
*n2n_port
= &port
->port_topo
.pn2n
;
992 struct bfa_lport_cfg_s
*pcfg
= &port
->port_cfg
;
993 struct bfa_fcs_rport_s
*rport
;
995 bfa_trc(port
->fcs
, pcfg
->pwwn
);
998 * If our PWWN is > than that of the r-port, we have to initiate PLOGI
999 * and assign an Address. if not, we need to wait for its PLOGI.
1001 * If our PWWN is < than that of the remote port, it will send a PLOGI
1002 * with the PIDs assigned. The rport state machine take care of this
1006 ((void *)&pcfg
->pwwn
, (void *)&n2n_port
->rem_port_wwn
,
1007 sizeof(wwn_t
)) > 0) {
1008 port
->pid
= N2N_LOCAL_PID
;
1010 * First, check if we know the device by pwwn.
1012 rport
= bfa_fcs_lport_get_rport_by_pwwn(port
,
1013 n2n_port
->rem_port_wwn
);
1015 bfa_trc(port
->fcs
, rport
->pid
);
1016 bfa_trc(port
->fcs
, rport
->pwwn
);
1017 rport
->pid
= N2N_REMOTE_PID
;
1018 bfa_fcs_rport_online(rport
);
1023 * In n2n there can be only one rport. Delete the old one
1024 * whose pid should be zero, because it is offline.
1026 if (port
->num_rports
> 0) {
1027 rport
= bfa_fcs_lport_get_rport_by_pid(port
, 0);
1028 bfa_assert(rport
!= NULL
);
1030 bfa_trc(port
->fcs
, rport
->pwwn
);
1031 bfa_fcs_rport_delete(rport
);
1034 bfa_fcs_rport_create(port
, N2N_REMOTE_PID
);
1039 * Called by fcs/port to notify transition to offline state.
1042 bfa_fcs_lport_n2n_offline(struct bfa_fcs_lport_s
*port
)
1044 struct bfa_fcs_lport_n2n_s
*n2n_port
= &port
->port_topo
.pn2n
;
1046 bfa_trc(port
->fcs
, port
->pid
);
1048 n2n_port
->rem_port_wwn
= 0;
1049 n2n_port
->reply_oxid
= 0;
1052 #define BFA_FCS_FDMI_CMD_MAX_RETRIES 2
1055 * forward declarations
1057 static void bfa_fcs_lport_fdmi_send_rhba(void *fdmi_cbarg
,
1058 struct bfa_fcxp_s
*fcxp_alloced
);
1059 static void bfa_fcs_lport_fdmi_send_rprt(void *fdmi_cbarg
,
1060 struct bfa_fcxp_s
*fcxp_alloced
);
1061 static void bfa_fcs_lport_fdmi_send_rpa(void *fdmi_cbarg
,
1062 struct bfa_fcxp_s
*fcxp_alloced
);
1063 static void bfa_fcs_lport_fdmi_rhba_response(void *fcsarg
,
1064 struct bfa_fcxp_s
*fcxp
,
1066 bfa_status_t req_status
,
1069 struct fchs_s
*rsp_fchs
);
1070 static void bfa_fcs_lport_fdmi_rprt_response(void *fcsarg
,
1071 struct bfa_fcxp_s
*fcxp
,
1073 bfa_status_t req_status
,
1076 struct fchs_s
*rsp_fchs
);
1077 static void bfa_fcs_lport_fdmi_rpa_response(void *fcsarg
,
1078 struct bfa_fcxp_s
*fcxp
,
1080 bfa_status_t req_status
,
1083 struct fchs_s
*rsp_fchs
);
1084 static void bfa_fcs_lport_fdmi_timeout(void *arg
);
1085 static u16
bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1087 static u16
bfa_fcs_lport_fdmi_build_rprt_pyld(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1089 static u16
bfa_fcs_lport_fdmi_build_rpa_pyld(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1091 static u16
bfa_fcs_lport_fdmi_build_portattr_block(struct bfa_fcs_lport_fdmi_s
*
1093 static void bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1094 struct bfa_fcs_fdmi_hba_attr_s
*hba_attr
);
1095 static void bfa_fcs_fdmi_get_portattr(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1096 struct bfa_fcs_fdmi_port_attr_s
*port_attr
);
1098 * fcs_fdmi_sm FCS FDMI state machine
1102 * FDMI State Machine events
1104 enum port_fdmi_event
{
1105 FDMISM_EVENT_PORT_ONLINE
= 1,
1106 FDMISM_EVENT_PORT_OFFLINE
= 2,
1107 FDMISM_EVENT_RSP_OK
= 4,
1108 FDMISM_EVENT_RSP_ERROR
= 5,
1109 FDMISM_EVENT_TIMEOUT
= 6,
1110 FDMISM_EVENT_RHBA_SENT
= 7,
1111 FDMISM_EVENT_RPRT_SENT
= 8,
1112 FDMISM_EVENT_RPA_SENT
= 9,
1115 static void bfa_fcs_lport_fdmi_sm_offline(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1116 enum port_fdmi_event event
);
1117 static void bfa_fcs_lport_fdmi_sm_sending_rhba(
1118 struct bfa_fcs_lport_fdmi_s
*fdmi
,
1119 enum port_fdmi_event event
);
1120 static void bfa_fcs_lport_fdmi_sm_rhba(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1121 enum port_fdmi_event event
);
1122 static void bfa_fcs_lport_fdmi_sm_rhba_retry(
1123 struct bfa_fcs_lport_fdmi_s
*fdmi
,
1124 enum port_fdmi_event event
);
1125 static void bfa_fcs_lport_fdmi_sm_sending_rprt(
1126 struct bfa_fcs_lport_fdmi_s
*fdmi
,
1127 enum port_fdmi_event event
);
1128 static void bfa_fcs_lport_fdmi_sm_rprt(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1129 enum port_fdmi_event event
);
1130 static void bfa_fcs_lport_fdmi_sm_rprt_retry(
1131 struct bfa_fcs_lport_fdmi_s
*fdmi
,
1132 enum port_fdmi_event event
);
1133 static void bfa_fcs_lport_fdmi_sm_sending_rpa(
1134 struct bfa_fcs_lport_fdmi_s
*fdmi
,
1135 enum port_fdmi_event event
);
1136 static void bfa_fcs_lport_fdmi_sm_rpa(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1137 enum port_fdmi_event event
);
1138 static void bfa_fcs_lport_fdmi_sm_rpa_retry(
1139 struct bfa_fcs_lport_fdmi_s
*fdmi
,
1140 enum port_fdmi_event event
);
1141 static void bfa_fcs_lport_fdmi_sm_online(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1142 enum port_fdmi_event event
);
1143 static void bfa_fcs_lport_fdmi_sm_disabled(
1144 struct bfa_fcs_lport_fdmi_s
*fdmi
,
1145 enum port_fdmi_event event
);
1147 * Start in offline state - awaiting MS to send start.
1150 bfa_fcs_lport_fdmi_sm_offline(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1151 enum port_fdmi_event event
)
1153 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1155 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
1156 bfa_trc(port
->fcs
, event
);
1158 fdmi
->retry_cnt
= 0;
1161 case FDMISM_EVENT_PORT_ONLINE
:
1164 * For Vports, register a new port.
1166 bfa_sm_set_state(fdmi
,
1167 bfa_fcs_lport_fdmi_sm_sending_rprt
);
1168 bfa_fcs_lport_fdmi_send_rprt(fdmi
, NULL
);
1171 * For a base port, we should first register the HBA
1172 * atribute. The HBA attribute also contains the base
1173 * port registration.
1175 bfa_sm_set_state(fdmi
,
1176 bfa_fcs_lport_fdmi_sm_sending_rhba
);
1177 bfa_fcs_lport_fdmi_send_rhba(fdmi
, NULL
);
1181 case FDMISM_EVENT_PORT_OFFLINE
:
1185 bfa_sm_fault(port
->fcs
, event
);
1190 bfa_fcs_lport_fdmi_sm_sending_rhba(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1191 enum port_fdmi_event event
)
1193 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1195 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
1196 bfa_trc(port
->fcs
, event
);
1199 case FDMISM_EVENT_RHBA_SENT
:
1200 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_rhba
);
1203 case FDMISM_EVENT_PORT_OFFLINE
:
1204 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_offline
);
1205 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(port
),
1210 bfa_sm_fault(port
->fcs
, event
);
1215 bfa_fcs_lport_fdmi_sm_rhba(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1216 enum port_fdmi_event event
)
1218 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1220 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
1221 bfa_trc(port
->fcs
, event
);
1224 case FDMISM_EVENT_RSP_ERROR
:
1226 * if max retries have not been reached, start timer for a
1229 if (fdmi
->retry_cnt
++ < BFA_FCS_FDMI_CMD_MAX_RETRIES
) {
1230 bfa_sm_set_state(fdmi
,
1231 bfa_fcs_lport_fdmi_sm_rhba_retry
);
1232 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(port
),
1234 bfa_fcs_lport_fdmi_timeout
, fdmi
,
1235 BFA_FCS_RETRY_TIMEOUT
);
1238 * set state to offline
1240 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_offline
);
1244 case FDMISM_EVENT_RSP_OK
:
1246 * Initiate Register Port Attributes
1248 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_sending_rpa
);
1249 fdmi
->retry_cnt
= 0;
1250 bfa_fcs_lport_fdmi_send_rpa(fdmi
, NULL
);
1253 case FDMISM_EVENT_PORT_OFFLINE
:
1254 bfa_fcxp_discard(fdmi
->fcxp
);
1255 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_offline
);
1259 bfa_sm_fault(port
->fcs
, event
);
1264 bfa_fcs_lport_fdmi_sm_rhba_retry(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1265 enum port_fdmi_event event
)
1267 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1269 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
1270 bfa_trc(port
->fcs
, event
);
1273 case FDMISM_EVENT_TIMEOUT
:
1275 * Retry Timer Expired. Re-send
1277 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_sending_rhba
);
1278 bfa_fcs_lport_fdmi_send_rhba(fdmi
, NULL
);
1281 case FDMISM_EVENT_PORT_OFFLINE
:
1282 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_offline
);
1283 bfa_timer_stop(&fdmi
->timer
);
1287 bfa_sm_fault(port
->fcs
, event
);
1292 * RPRT : Register Port
1295 bfa_fcs_lport_fdmi_sm_sending_rprt(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1296 enum port_fdmi_event event
)
1298 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1300 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
1301 bfa_trc(port
->fcs
, event
);
1304 case FDMISM_EVENT_RPRT_SENT
:
1305 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_rprt
);
1308 case FDMISM_EVENT_PORT_OFFLINE
:
1309 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_offline
);
1310 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(port
),
1315 bfa_sm_fault(port
->fcs
, event
);
1320 bfa_fcs_lport_fdmi_sm_rprt(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1321 enum port_fdmi_event event
)
1323 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1325 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
1326 bfa_trc(port
->fcs
, event
);
1329 case FDMISM_EVENT_RSP_ERROR
:
1331 * if max retries have not been reached, start timer for a
1334 if (fdmi
->retry_cnt
++ < BFA_FCS_FDMI_CMD_MAX_RETRIES
) {
1335 bfa_sm_set_state(fdmi
,
1336 bfa_fcs_lport_fdmi_sm_rprt_retry
);
1337 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(port
),
1339 bfa_fcs_lport_fdmi_timeout
, fdmi
,
1340 BFA_FCS_RETRY_TIMEOUT
);
1344 * set state to offline
1346 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_offline
);
1347 fdmi
->retry_cnt
= 0;
1351 case FDMISM_EVENT_RSP_OK
:
1352 fdmi
->retry_cnt
= 0;
1353 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_online
);
1356 case FDMISM_EVENT_PORT_OFFLINE
:
1357 bfa_fcxp_discard(fdmi
->fcxp
);
1358 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_offline
);
1362 bfa_sm_fault(port
->fcs
, event
);
1367 bfa_fcs_lport_fdmi_sm_rprt_retry(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1368 enum port_fdmi_event event
)
1370 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1372 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
1373 bfa_trc(port
->fcs
, event
);
1376 case FDMISM_EVENT_TIMEOUT
:
1378 * Retry Timer Expired. Re-send
1380 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_sending_rprt
);
1381 bfa_fcs_lport_fdmi_send_rprt(fdmi
, NULL
);
1384 case FDMISM_EVENT_PORT_OFFLINE
:
1385 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_offline
);
1386 bfa_timer_stop(&fdmi
->timer
);
1390 bfa_sm_fault(port
->fcs
, event
);
1395 * Register Port Attributes
1398 bfa_fcs_lport_fdmi_sm_sending_rpa(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1399 enum port_fdmi_event event
)
1401 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1403 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
1404 bfa_trc(port
->fcs
, event
);
1407 case FDMISM_EVENT_RPA_SENT
:
1408 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_rpa
);
1411 case FDMISM_EVENT_PORT_OFFLINE
:
1412 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_offline
);
1413 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(port
),
1418 bfa_sm_fault(port
->fcs
, event
);
1423 bfa_fcs_lport_fdmi_sm_rpa(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1424 enum port_fdmi_event event
)
1426 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1428 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
1429 bfa_trc(port
->fcs
, event
);
1432 case FDMISM_EVENT_RSP_ERROR
:
1434 * if max retries have not been reached, start timer for a
1437 if (fdmi
->retry_cnt
++ < BFA_FCS_FDMI_CMD_MAX_RETRIES
) {
1438 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_rpa_retry
);
1439 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(port
),
1441 bfa_fcs_lport_fdmi_timeout
, fdmi
,
1442 BFA_FCS_RETRY_TIMEOUT
);
1445 * set state to offline
1447 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_offline
);
1448 fdmi
->retry_cnt
= 0;
1452 case FDMISM_EVENT_RSP_OK
:
1453 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_online
);
1454 fdmi
->retry_cnt
= 0;
1457 case FDMISM_EVENT_PORT_OFFLINE
:
1458 bfa_fcxp_discard(fdmi
->fcxp
);
1459 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_offline
);
1463 bfa_sm_fault(port
->fcs
, event
);
1468 bfa_fcs_lport_fdmi_sm_rpa_retry(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1469 enum port_fdmi_event event
)
1471 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1473 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
1474 bfa_trc(port
->fcs
, event
);
1477 case FDMISM_EVENT_TIMEOUT
:
1479 * Retry Timer Expired. Re-send
1481 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_sending_rpa
);
1482 bfa_fcs_lport_fdmi_send_rpa(fdmi
, NULL
);
1485 case FDMISM_EVENT_PORT_OFFLINE
:
1486 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_offline
);
1487 bfa_timer_stop(&fdmi
->timer
);
1491 bfa_sm_fault(port
->fcs
, event
);
1496 bfa_fcs_lport_fdmi_sm_online(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1497 enum port_fdmi_event event
)
1499 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1501 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
1502 bfa_trc(port
->fcs
, event
);
1505 case FDMISM_EVENT_PORT_OFFLINE
:
1506 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_offline
);
1510 bfa_sm_fault(port
->fcs
, event
);
1514 * FDMI is disabled state.
1517 bfa_fcs_lport_fdmi_sm_disabled(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1518 enum port_fdmi_event event
)
1520 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1522 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
1523 bfa_trc(port
->fcs
, event
);
1525 /* No op State. It can only be enabled at Driver Init. */
1529 * RHBA : Register HBA Attributes.
1532 bfa_fcs_lport_fdmi_send_rhba(void *fdmi_cbarg
, struct bfa_fcxp_s
*fcxp_alloced
)
1534 struct bfa_fcs_lport_fdmi_s
*fdmi
= fdmi_cbarg
;
1535 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1538 struct bfa_fcxp_s
*fcxp
;
1541 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
1543 fcxp
= fcxp_alloced
? fcxp_alloced
: bfa_fcs_fcxp_alloc(port
->fcs
);
1545 bfa_fcs_fcxp_alloc_wait(port
->fcs
->bfa
, &fdmi
->fcxp_wqe
,
1546 bfa_fcs_lport_fdmi_send_rhba
, fdmi
);
1551 pyld
= bfa_fcxp_get_reqbuf(fcxp
);
1552 bfa_os_memset(pyld
, 0, FC_MAX_PDUSZ
);
1554 len
= fc_fdmi_reqhdr_build(&fchs
, pyld
, bfa_fcs_lport_get_fcid(port
),
1558 bfa_fcs_lport_fdmi_build_rhba_pyld(fdmi
,
1559 (u8
*) ((struct ct_hdr_s
*) pyld
1562 bfa_fcxp_send(fcxp
, NULL
, port
->fabric
->vf_id
, port
->lp_tag
, BFA_FALSE
,
1563 FC_CLASS_3
, (len
+ attr_len
), &fchs
,
1564 bfa_fcs_lport_fdmi_rhba_response
, (void *)fdmi
,
1565 FC_MAX_PDUSZ
, FC_FCCT_TOV
);
1567 bfa_sm_send_event(fdmi
, FDMISM_EVENT_RHBA_SENT
);
1571 bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s
*fdmi
, u8
*pyld
)
1573 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1574 struct bfa_fcs_fdmi_hba_attr_s hba_attr
;
1575 struct bfa_fcs_fdmi_hba_attr_s
*fcs_hba_attr
= &hba_attr
;
1576 struct fdmi_rhba_s
*rhba
= (struct fdmi_rhba_s
*) pyld
;
1577 struct fdmi_attr_s
*attr
;
1582 * get hba attributes
1584 bfa_fcs_fdmi_get_hbaattr(fdmi
, fcs_hba_attr
);
1586 rhba
->hba_id
= bfa_fcs_lport_get_pwwn(port
);
1587 rhba
->port_list
.num_ports
= bfa_os_htonl(1);
1588 rhba
->port_list
.port_entry
= bfa_fcs_lport_get_pwwn(port
);
1590 len
= sizeof(rhba
->hba_id
) + sizeof(rhba
->port_list
);
1593 len
+= sizeof(rhba
->hba_attr_blk
.attr_count
);
1596 * fill out the invididual entries of the HBA attrib Block
1598 curr_ptr
= (u8
*) &rhba
->hba_attr_blk
.hba_attr
;
1603 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1604 attr
->type
= bfa_os_htons(FDMI_HBA_ATTRIB_NODENAME
);
1605 attr
->len
= sizeof(wwn_t
);
1606 memcpy(attr
->value
, &bfa_fcs_lport_get_nwwn(port
), attr
->len
);
1607 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1611 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1617 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1618 attr
->type
= bfa_os_htons(FDMI_HBA_ATTRIB_MANUFACTURER
);
1619 attr
->len
= (u16
) strlen(fcs_hba_attr
->manufacturer
);
1620 memcpy(attr
->value
, fcs_hba_attr
->manufacturer
, attr
->len
);
1621 attr
->len
= fc_roundup(attr
->len
, sizeof(u32
)); /* variable
1625 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1629 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1635 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1636 attr
->type
= bfa_os_htons(FDMI_HBA_ATTRIB_SERIALNUM
);
1637 attr
->len
= (u16
) strlen(fcs_hba_attr
->serial_num
);
1638 memcpy(attr
->value
, fcs_hba_attr
->serial_num
, attr
->len
);
1639 attr
->len
= fc_roundup(attr
->len
, sizeof(u32
)); /* variable
1643 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1647 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1653 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1654 attr
->type
= bfa_os_htons(FDMI_HBA_ATTRIB_MODEL
);
1655 attr
->len
= (u16
) strlen(fcs_hba_attr
->model
);
1656 memcpy(attr
->value
, fcs_hba_attr
->model
, attr
->len
);
1657 attr
->len
= fc_roundup(attr
->len
, sizeof(u32
)); /* variable
1661 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1665 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1671 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1672 attr
->type
= bfa_os_htons(FDMI_HBA_ATTRIB_MODEL_DESC
);
1673 attr
->len
= (u16
) strlen(fcs_hba_attr
->model_desc
);
1674 memcpy(attr
->value
, fcs_hba_attr
->model_desc
, attr
->len
);
1675 attr
->len
= fc_roundup(attr
->len
, sizeof(u32
)); /* variable
1679 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1683 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1689 if (fcs_hba_attr
->hw_version
[0] != '\0') {
1690 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1691 attr
->type
= bfa_os_htons(FDMI_HBA_ATTRIB_HW_VERSION
);
1692 attr
->len
= (u16
) strlen(fcs_hba_attr
->hw_version
);
1693 memcpy(attr
->value
, fcs_hba_attr
->hw_version
, attr
->len
);
1694 attr
->len
= fc_roundup(attr
->len
, sizeof(u32
)); /* variable
1698 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1702 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1709 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1710 attr
->type
= bfa_os_htons(FDMI_HBA_ATTRIB_DRIVER_VERSION
);
1711 attr
->len
= (u16
) strlen(fcs_hba_attr
->driver_version
);
1712 memcpy(attr
->value
, fcs_hba_attr
->driver_version
, attr
->len
);
1713 attr
->len
= fc_roundup(attr
->len
, sizeof(u32
)); /* variable
1717 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1721 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1725 * Option Rom Version
1727 if (fcs_hba_attr
->option_rom_ver
[0] != '\0') {
1728 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1729 attr
->type
= bfa_os_htons(FDMI_HBA_ATTRIB_ROM_VERSION
);
1730 attr
->len
= (u16
) strlen(fcs_hba_attr
->option_rom_ver
);
1731 memcpy(attr
->value
, fcs_hba_attr
->option_rom_ver
, attr
->len
);
1732 attr
->len
= fc_roundup(attr
->len
, sizeof(u32
)); /* variable
1736 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1740 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1745 * f/w Version = driver version
1747 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1748 attr
->type
= bfa_os_htons(FDMI_HBA_ATTRIB_FW_VERSION
);
1749 attr
->len
= (u16
) strlen(fcs_hba_attr
->driver_version
);
1750 memcpy(attr
->value
, fcs_hba_attr
->driver_version
, attr
->len
);
1751 attr
->len
= fc_roundup(attr
->len
, sizeof(u32
)); /* variable
1755 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1759 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1765 if (fcs_hba_attr
->os_name
[0] != '\0') {
1766 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1767 attr
->type
= bfa_os_htons(FDMI_HBA_ATTRIB_OS_NAME
);
1768 attr
->len
= (u16
) strlen(fcs_hba_attr
->os_name
);
1769 memcpy(attr
->value
, fcs_hba_attr
->os_name
, attr
->len
);
1770 attr
->len
= fc_roundup(attr
->len
, sizeof(u32
)); /* variable
1774 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1778 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1785 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1786 attr
->type
= bfa_os_htons(FDMI_HBA_ATTRIB_MAX_CT
);
1787 attr
->len
= sizeof(fcs_hba_attr
->max_ct_pyld
);
1788 memcpy(attr
->value
, &fcs_hba_attr
->max_ct_pyld
, attr
->len
);
1792 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1796 * Update size of payload
1798 len
+= ((sizeof(attr
->type
) +
1799 sizeof(attr
->len
)) * count
);
1801 rhba
->hba_attr_blk
.attr_count
= bfa_os_htonl(count
);
1806 bfa_fcs_lport_fdmi_rhba_response(void *fcsarg
, struct bfa_fcxp_s
*fcxp
,
1807 void *cbarg
, bfa_status_t req_status
,
1808 u32 rsp_len
, u32 resid_len
,
1809 struct fchs_s
*rsp_fchs
)
1811 struct bfa_fcs_lport_fdmi_s
*fdmi
=
1812 (struct bfa_fcs_lport_fdmi_s
*) cbarg
;
1813 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1814 struct ct_hdr_s
*cthdr
= NULL
;
1816 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
1821 if (req_status
!= BFA_STATUS_OK
) {
1822 bfa_trc(port
->fcs
, req_status
);
1823 bfa_sm_send_event(fdmi
, FDMISM_EVENT_RSP_ERROR
);
1827 cthdr
= (struct ct_hdr_s
*) BFA_FCXP_RSP_PLD(fcxp
);
1828 cthdr
->cmd_rsp_code
= bfa_os_ntohs(cthdr
->cmd_rsp_code
);
1830 if (cthdr
->cmd_rsp_code
== CT_RSP_ACCEPT
) {
1831 bfa_sm_send_event(fdmi
, FDMISM_EVENT_RSP_OK
);
1835 bfa_trc(port
->fcs
, cthdr
->reason_code
);
1836 bfa_trc(port
->fcs
, cthdr
->exp_code
);
1837 bfa_sm_send_event(fdmi
, FDMISM_EVENT_RSP_ERROR
);
1841 * RPRT : Register Port
1844 bfa_fcs_lport_fdmi_send_rprt(void *fdmi_cbarg
, struct bfa_fcxp_s
*fcxp_alloced
)
1846 struct bfa_fcs_lport_fdmi_s
*fdmi
= fdmi_cbarg
;
1847 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
1850 struct bfa_fcxp_s
*fcxp
;
1853 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
1855 fcxp
= fcxp_alloced
? fcxp_alloced
: bfa_fcs_fcxp_alloc(port
->fcs
);
1857 bfa_fcs_fcxp_alloc_wait(port
->fcs
->bfa
, &fdmi
->fcxp_wqe
,
1858 bfa_fcs_lport_fdmi_send_rprt
, fdmi
);
1863 pyld
= bfa_fcxp_get_reqbuf(fcxp
);
1864 bfa_os_memset(pyld
, 0, FC_MAX_PDUSZ
);
1866 len
= fc_fdmi_reqhdr_build(&fchs
, pyld
, bfa_fcs_lport_get_fcid(port
),
1870 bfa_fcs_lport_fdmi_build_rprt_pyld(fdmi
,
1871 (u8
*) ((struct ct_hdr_s
*) pyld
1874 bfa_fcxp_send(fcxp
, NULL
, port
->fabric
->vf_id
, port
->lp_tag
, BFA_FALSE
,
1875 FC_CLASS_3
, len
+ attr_len
, &fchs
,
1876 bfa_fcs_lport_fdmi_rprt_response
, (void *)fdmi
,
1877 FC_MAX_PDUSZ
, FC_FCCT_TOV
);
1879 bfa_sm_send_event(fdmi
, FDMISM_EVENT_RPRT_SENT
);
1883 * This routine builds Port Attribute Block that used in RPA, RPRT commands.
1886 bfa_fcs_lport_fdmi_build_portattr_block(struct bfa_fcs_lport_fdmi_s
*fdmi
,
1889 struct bfa_fcs_fdmi_port_attr_s fcs_port_attr
;
1890 struct fdmi_port_attr_s
*port_attrib
= (struct fdmi_port_attr_s
*) pyld
;
1891 struct fdmi_attr_s
*attr
;
1897 * get port attributes
1899 bfa_fcs_fdmi_get_portattr(fdmi
, &fcs_port_attr
);
1901 len
= sizeof(port_attrib
->attr_count
);
1904 * fill out the invididual entries
1906 curr_ptr
= (u8
*) &port_attrib
->port_attr
;
1911 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1912 attr
->type
= bfa_os_htons(FDMI_PORT_ATTRIB_FC4_TYPES
);
1913 attr
->len
= sizeof(fcs_port_attr
.supp_fc4_types
);
1914 memcpy(attr
->value
, fcs_port_attr
.supp_fc4_types
, attr
->len
);
1915 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1919 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1925 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1926 attr
->type
= bfa_os_htons(FDMI_PORT_ATTRIB_SUPP_SPEED
);
1927 attr
->len
= sizeof(fcs_port_attr
.supp_speed
);
1928 memcpy(attr
->value
, &fcs_port_attr
.supp_speed
, attr
->len
);
1929 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1933 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1937 * current Port Speed
1939 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1940 attr
->type
= bfa_os_htons(FDMI_PORT_ATTRIB_PORT_SPEED
);
1941 attr
->len
= sizeof(fcs_port_attr
.curr_speed
);
1942 memcpy(attr
->value
, &fcs_port_attr
.curr_speed
, attr
->len
);
1943 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1947 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1953 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1954 attr
->type
= bfa_os_htons(FDMI_PORT_ATTRIB_FRAME_SIZE
);
1955 attr
->len
= sizeof(fcs_port_attr
.max_frm_size
);
1956 memcpy(attr
->value
, &fcs_port_attr
.max_frm_size
, attr
->len
);
1957 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1961 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1967 if (fcs_port_attr
.os_device_name
[0] != '\0') {
1968 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1969 attr
->type
= bfa_os_htons(FDMI_PORT_ATTRIB_DEV_NAME
);
1970 attr
->len
= (u16
) strlen(fcs_port_attr
.os_device_name
);
1971 memcpy(attr
->value
, fcs_port_attr
.os_device_name
, attr
->len
);
1972 attr
->len
= fc_roundup(attr
->len
, sizeof(u32
)); /* variable
1976 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1980 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
1986 if (fcs_port_attr
.host_name
[0] != '\0') {
1987 attr
= (struct fdmi_attr_s
*) curr_ptr
;
1988 attr
->type
= bfa_os_htons(FDMI_PORT_ATTRIB_HOST_NAME
);
1989 attr
->len
= (u16
) strlen(fcs_port_attr
.host_name
);
1990 memcpy(attr
->value
, fcs_port_attr
.host_name
, attr
->len
);
1991 attr
->len
= fc_roundup(attr
->len
, sizeof(u32
)); /* variable
1995 curr_ptr
+= sizeof(attr
->type
) + sizeof(attr
->len
) + attr
->len
;
1999 bfa_os_htons(attr
->len
+ sizeof(attr
->type
) +
2004 * Update size of payload
2006 port_attrib
->attr_count
= bfa_os_htonl(count
);
2007 len
+= ((sizeof(attr
->type
) +
2008 sizeof(attr
->len
)) * count
);
2013 bfa_fcs_lport_fdmi_build_rprt_pyld(struct bfa_fcs_lport_fdmi_s
*fdmi
, u8
*pyld
)
2015 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
2016 struct fdmi_rprt_s
*rprt
= (struct fdmi_rprt_s
*) pyld
;
2019 rprt
->hba_id
= bfa_fcs_lport_get_pwwn(bfa_fcs_get_base_port(port
->fcs
));
2020 rprt
->port_name
= bfa_fcs_lport_get_pwwn(port
);
2022 len
= bfa_fcs_lport_fdmi_build_portattr_block(fdmi
,
2023 (u8
*) &rprt
->port_attr_blk
);
2025 len
+= sizeof(rprt
->hba_id
) + sizeof(rprt
->port_name
);
2031 bfa_fcs_lport_fdmi_rprt_response(void *fcsarg
, struct bfa_fcxp_s
*fcxp
,
2032 void *cbarg
, bfa_status_t req_status
,
2033 u32 rsp_len
, u32 resid_len
,
2034 struct fchs_s
*rsp_fchs
)
2036 struct bfa_fcs_lport_fdmi_s
*fdmi
=
2037 (struct bfa_fcs_lport_fdmi_s
*) cbarg
;
2038 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
2039 struct ct_hdr_s
*cthdr
= NULL
;
2041 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
2046 if (req_status
!= BFA_STATUS_OK
) {
2047 bfa_trc(port
->fcs
, req_status
);
2048 bfa_sm_send_event(fdmi
, FDMISM_EVENT_RSP_ERROR
);
2052 cthdr
= (struct ct_hdr_s
*) BFA_FCXP_RSP_PLD(fcxp
);
2053 cthdr
->cmd_rsp_code
= bfa_os_ntohs(cthdr
->cmd_rsp_code
);
2055 if (cthdr
->cmd_rsp_code
== CT_RSP_ACCEPT
) {
2056 bfa_sm_send_event(fdmi
, FDMISM_EVENT_RSP_OK
);
2060 bfa_trc(port
->fcs
, cthdr
->reason_code
);
2061 bfa_trc(port
->fcs
, cthdr
->exp_code
);
2062 bfa_sm_send_event(fdmi
, FDMISM_EVENT_RSP_ERROR
);
2066 * RPA : Register Port Attributes.
2069 bfa_fcs_lport_fdmi_send_rpa(void *fdmi_cbarg
, struct bfa_fcxp_s
*fcxp_alloced
)
2071 struct bfa_fcs_lport_fdmi_s
*fdmi
= fdmi_cbarg
;
2072 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
2075 struct bfa_fcxp_s
*fcxp
;
2078 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
2080 fcxp
= fcxp_alloced
? fcxp_alloced
: bfa_fcs_fcxp_alloc(port
->fcs
);
2082 bfa_fcs_fcxp_alloc_wait(port
->fcs
->bfa
, &fdmi
->fcxp_wqe
,
2083 bfa_fcs_lport_fdmi_send_rpa
, fdmi
);
2088 pyld
= bfa_fcxp_get_reqbuf(fcxp
);
2089 bfa_os_memset(pyld
, 0, FC_MAX_PDUSZ
);
2091 len
= fc_fdmi_reqhdr_build(&fchs
, pyld
, bfa_fcs_lport_get_fcid(port
),
2095 bfa_fcs_lport_fdmi_build_rpa_pyld(fdmi
,
2096 (u8
*) ((struct ct_hdr_s
*) pyld
2099 bfa_fcxp_send(fcxp
, NULL
, port
->fabric
->vf_id
, port
->lp_tag
, BFA_FALSE
,
2100 FC_CLASS_3
, len
+ attr_len
, &fchs
,
2101 bfa_fcs_lport_fdmi_rpa_response
, (void *)fdmi
,
2102 FC_MAX_PDUSZ
, FC_FCCT_TOV
);
2104 bfa_sm_send_event(fdmi
, FDMISM_EVENT_RPA_SENT
);
2108 bfa_fcs_lport_fdmi_build_rpa_pyld(struct bfa_fcs_lport_fdmi_s
*fdmi
, u8
*pyld
)
2110 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
2111 struct fdmi_rpa_s
*rpa
= (struct fdmi_rpa_s
*) pyld
;
2114 rpa
->port_name
= bfa_fcs_lport_get_pwwn(port
);
2116 len
= bfa_fcs_lport_fdmi_build_portattr_block(fdmi
,
2117 (u8
*) &rpa
->port_attr_blk
);
2119 len
+= sizeof(rpa
->port_name
);
2125 bfa_fcs_lport_fdmi_rpa_response(void *fcsarg
, struct bfa_fcxp_s
*fcxp
,
2126 void *cbarg
, bfa_status_t req_status
, u32 rsp_len
,
2127 u32 resid_len
, struct fchs_s
*rsp_fchs
)
2129 struct bfa_fcs_lport_fdmi_s
*fdmi
=
2130 (struct bfa_fcs_lport_fdmi_s
*) cbarg
;
2131 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
2132 struct ct_hdr_s
*cthdr
= NULL
;
2134 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
2139 if (req_status
!= BFA_STATUS_OK
) {
2140 bfa_trc(port
->fcs
, req_status
);
2141 bfa_sm_send_event(fdmi
, FDMISM_EVENT_RSP_ERROR
);
2145 cthdr
= (struct ct_hdr_s
*) BFA_FCXP_RSP_PLD(fcxp
);
2146 cthdr
->cmd_rsp_code
= bfa_os_ntohs(cthdr
->cmd_rsp_code
);
2148 if (cthdr
->cmd_rsp_code
== CT_RSP_ACCEPT
) {
2149 bfa_sm_send_event(fdmi
, FDMISM_EVENT_RSP_OK
);
2153 bfa_trc(port
->fcs
, cthdr
->reason_code
);
2154 bfa_trc(port
->fcs
, cthdr
->exp_code
);
2155 bfa_sm_send_event(fdmi
, FDMISM_EVENT_RSP_ERROR
);
2159 bfa_fcs_lport_fdmi_timeout(void *arg
)
2161 struct bfa_fcs_lport_fdmi_s
*fdmi
= (struct bfa_fcs_lport_fdmi_s
*) arg
;
2163 bfa_sm_send_event(fdmi
, FDMISM_EVENT_TIMEOUT
);
2167 bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_lport_fdmi_s
*fdmi
,
2168 struct bfa_fcs_fdmi_hba_attr_s
*hba_attr
)
2170 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
2171 struct bfa_fcs_driver_info_s
*driver_info
= &port
->fcs
->driver_info
;
2173 bfa_os_memset(hba_attr
, 0, sizeof(struct bfa_fcs_fdmi_hba_attr_s
));
2175 bfa_ioc_get_adapter_manufacturer(&port
->fcs
->bfa
->ioc
,
2176 hba_attr
->manufacturer
);
2177 bfa_ioc_get_adapter_serial_num(&port
->fcs
->bfa
->ioc
,
2178 hba_attr
->serial_num
);
2179 bfa_ioc_get_adapter_model(&port
->fcs
->bfa
->ioc
,
2181 bfa_ioc_get_adapter_model(&port
->fcs
->bfa
->ioc
,
2182 hba_attr
->model_desc
);
2183 bfa_ioc_get_pci_chip_rev(&port
->fcs
->bfa
->ioc
,
2184 hba_attr
->hw_version
);
2185 bfa_ioc_get_adapter_optrom_ver(&port
->fcs
->bfa
->ioc
,
2186 hba_attr
->option_rom_ver
);
2187 bfa_ioc_get_adapter_fw_ver(&port
->fcs
->bfa
->ioc
,
2188 hba_attr
->fw_version
);
2190 strncpy(hba_attr
->driver_version
, (char *)driver_info
->version
,
2191 sizeof(hba_attr
->driver_version
));
2193 strncpy(hba_attr
->os_name
, driver_info
->host_os_name
,
2194 sizeof(hba_attr
->os_name
));
2197 * If there is a patch level, append it
2198 * to the os name along with a separator
2200 if (driver_info
->host_os_patch
[0] != '\0') {
2201 strncat(hba_attr
->os_name
, BFA_FCS_PORT_SYMBNAME_SEPARATOR
,
2202 sizeof(BFA_FCS_PORT_SYMBNAME_SEPARATOR
));
2203 strncat(hba_attr
->os_name
, driver_info
->host_os_patch
,
2204 sizeof(driver_info
->host_os_patch
));
2207 hba_attr
->max_ct_pyld
= bfa_os_htonl(FC_MAX_PDUSZ
);
2211 bfa_fcs_fdmi_get_portattr(struct bfa_fcs_lport_fdmi_s
*fdmi
,
2212 struct bfa_fcs_fdmi_port_attr_s
*port_attr
)
2214 struct bfa_fcs_lport_s
*port
= fdmi
->ms
->port
;
2215 struct bfa_fcs_driver_info_s
*driver_info
= &port
->fcs
->driver_info
;
2216 struct bfa_port_attr_s pport_attr
;
2218 bfa_os_memset(port_attr
, 0, sizeof(struct bfa_fcs_fdmi_port_attr_s
));
2221 * get pport attributes from hal
2223 bfa_fcport_get_attr(port
->fcs
->bfa
, &pport_attr
);
2226 * get FC4 type Bitmask
2228 fc_get_fc4type_bitmask(FC_TYPE_FCP
, port_attr
->supp_fc4_types
);
2233 port_attr
->supp_speed
= bfa_os_htonl(BFA_FCS_FDMI_SUPORTED_SPEEDS
);
2238 port_attr
->curr_speed
= bfa_os_htonl(pport_attr
.speed
);
2243 port_attr
->max_frm_size
= bfa_os_htonl(FC_MAX_PDUSZ
);
2248 strncpy(port_attr
->os_device_name
, (char *)driver_info
->os_device_name
,
2249 sizeof(port_attr
->os_device_name
));
2254 strncpy(port_attr
->host_name
, (char *)driver_info
->host_machine_name
,
2255 sizeof(port_attr
->host_name
));
2261 bfa_fcs_lport_fdmi_init(struct bfa_fcs_lport_ms_s
*ms
)
2263 struct bfa_fcs_lport_fdmi_s
*fdmi
= &ms
->fdmi
;
2266 if (ms
->port
->fcs
->fdmi_enabled
)
2267 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_offline
);
2269 bfa_sm_set_state(fdmi
, bfa_fcs_lport_fdmi_sm_disabled
);
2273 bfa_fcs_lport_fdmi_offline(struct bfa_fcs_lport_ms_s
*ms
)
2275 struct bfa_fcs_lport_fdmi_s
*fdmi
= &ms
->fdmi
;
2278 bfa_sm_send_event(fdmi
, FDMISM_EVENT_PORT_OFFLINE
);
2282 bfa_fcs_lport_fdmi_online(struct bfa_fcs_lport_ms_s
*ms
)
2284 struct bfa_fcs_lport_fdmi_s
*fdmi
= &ms
->fdmi
;
2287 bfa_sm_send_event(fdmi
, FDMISM_EVENT_PORT_ONLINE
);
2290 #define BFA_FCS_MS_CMD_MAX_RETRIES 2
2293 * forward declarations
2295 static void bfa_fcs_lport_ms_send_plogi(void *ms_cbarg
,
2296 struct bfa_fcxp_s
*fcxp_alloced
);
2297 static void bfa_fcs_lport_ms_timeout(void *arg
);
2298 static void bfa_fcs_lport_ms_plogi_response(void *fcsarg
,
2299 struct bfa_fcxp_s
*fcxp
,
2301 bfa_status_t req_status
,
2304 struct fchs_s
*rsp_fchs
);
2306 static void bfa_fcs_lport_ms_send_gmal(void *ms_cbarg
,
2307 struct bfa_fcxp_s
*fcxp_alloced
);
2308 static void bfa_fcs_lport_ms_gmal_response(void *fcsarg
,
2309 struct bfa_fcxp_s
*fcxp
,
2311 bfa_status_t req_status
,
2314 struct fchs_s
*rsp_fchs
);
2315 static void bfa_fcs_lport_ms_send_gfn(void *ms_cbarg
,
2316 struct bfa_fcxp_s
*fcxp_alloced
);
2317 static void bfa_fcs_lport_ms_gfn_response(void *fcsarg
,
2318 struct bfa_fcxp_s
*fcxp
,
2320 bfa_status_t req_status
,
2323 struct fchs_s
*rsp_fchs
);
2325 * fcs_ms_sm FCS MS state machine
2329 * MS State Machine events
2331 enum port_ms_event
{
2332 MSSM_EVENT_PORT_ONLINE
= 1,
2333 MSSM_EVENT_PORT_OFFLINE
= 2,
2334 MSSM_EVENT_RSP_OK
= 3,
2335 MSSM_EVENT_RSP_ERROR
= 4,
2336 MSSM_EVENT_TIMEOUT
= 5,
2337 MSSM_EVENT_FCXP_SENT
= 6,
2338 MSSM_EVENT_PORT_FABRIC_RSCN
= 7
2341 static void bfa_fcs_lport_ms_sm_offline(struct bfa_fcs_lport_ms_s
*ms
,
2342 enum port_ms_event event
);
2343 static void bfa_fcs_lport_ms_sm_plogi_sending(struct bfa_fcs_lport_ms_s
*ms
,
2344 enum port_ms_event event
);
2345 static void bfa_fcs_lport_ms_sm_plogi(struct bfa_fcs_lport_ms_s
*ms
,
2346 enum port_ms_event event
);
2347 static void bfa_fcs_lport_ms_sm_plogi_retry(struct bfa_fcs_lport_ms_s
*ms
,
2348 enum port_ms_event event
);
2349 static void bfa_fcs_lport_ms_sm_gmal_sending(struct bfa_fcs_lport_ms_s
*ms
,
2350 enum port_ms_event event
);
2351 static void bfa_fcs_lport_ms_sm_gmal(struct bfa_fcs_lport_ms_s
*ms
,
2352 enum port_ms_event event
);
2353 static void bfa_fcs_lport_ms_sm_gmal_retry(struct bfa_fcs_lport_ms_s
*ms
,
2354 enum port_ms_event event
);
2355 static void bfa_fcs_lport_ms_sm_gfn_sending(struct bfa_fcs_lport_ms_s
*ms
,
2356 enum port_ms_event event
);
2357 static void bfa_fcs_lport_ms_sm_gfn(struct bfa_fcs_lport_ms_s
*ms
,
2358 enum port_ms_event event
);
2359 static void bfa_fcs_lport_ms_sm_gfn_retry(struct bfa_fcs_lport_ms_s
*ms
,
2360 enum port_ms_event event
);
2361 static void bfa_fcs_lport_ms_sm_online(struct bfa_fcs_lport_ms_s
*ms
,
2362 enum port_ms_event event
);
2364 * Start in offline state - awaiting NS to send start.
2367 bfa_fcs_lport_ms_sm_offline(struct bfa_fcs_lport_ms_s
*ms
,
2368 enum port_ms_event event
)
2370 bfa_trc(ms
->port
->fcs
, ms
->port
->port_cfg
.pwwn
);
2371 bfa_trc(ms
->port
->fcs
, event
);
2374 case MSSM_EVENT_PORT_ONLINE
:
2375 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_plogi_sending
);
2376 bfa_fcs_lport_ms_send_plogi(ms
, NULL
);
2379 case MSSM_EVENT_PORT_OFFLINE
:
2383 bfa_sm_fault(ms
->port
->fcs
, event
);
2388 bfa_fcs_lport_ms_sm_plogi_sending(struct bfa_fcs_lport_ms_s
*ms
,
2389 enum port_ms_event event
)
2391 bfa_trc(ms
->port
->fcs
, ms
->port
->port_cfg
.pwwn
);
2392 bfa_trc(ms
->port
->fcs
, event
);
2395 case MSSM_EVENT_FCXP_SENT
:
2396 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_plogi
);
2399 case MSSM_EVENT_PORT_OFFLINE
:
2400 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_offline
);
2401 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ms
->port
),
2406 bfa_sm_fault(ms
->port
->fcs
, event
);
2411 bfa_fcs_lport_ms_sm_plogi(struct bfa_fcs_lport_ms_s
*ms
,
2412 enum port_ms_event event
)
2414 bfa_trc(ms
->port
->fcs
, ms
->port
->port_cfg
.pwwn
);
2415 bfa_trc(ms
->port
->fcs
, event
);
2418 case MSSM_EVENT_RSP_ERROR
:
2420 * Start timer for a delayed retry
2422 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_plogi_retry
);
2423 ms
->port
->stats
.ms_retries
++;
2424 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ms
->port
),
2425 &ms
->timer
, bfa_fcs_lport_ms_timeout
, ms
,
2426 BFA_FCS_RETRY_TIMEOUT
);
2429 case MSSM_EVENT_RSP_OK
:
2431 * since plogi is done, now invoke MS related sub-modules
2433 bfa_fcs_lport_fdmi_online(ms
);
2436 * if this is a Vport, go to online state.
2438 if (ms
->port
->vport
) {
2439 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_online
);
2444 * For a base port we need to get the
2445 * switch's IP address.
2447 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_gmal_sending
);
2448 bfa_fcs_lport_ms_send_gmal(ms
, NULL
);
2451 case MSSM_EVENT_PORT_OFFLINE
:
2452 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_offline
);
2453 bfa_fcxp_discard(ms
->fcxp
);
2457 bfa_sm_fault(ms
->port
->fcs
, event
);
2462 bfa_fcs_lport_ms_sm_plogi_retry(struct bfa_fcs_lport_ms_s
*ms
,
2463 enum port_ms_event event
)
2465 bfa_trc(ms
->port
->fcs
, ms
->port
->port_cfg
.pwwn
);
2466 bfa_trc(ms
->port
->fcs
, event
);
2469 case MSSM_EVENT_TIMEOUT
:
2471 * Retry Timer Expired. Re-send
2473 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_plogi_sending
);
2474 bfa_fcs_lport_ms_send_plogi(ms
, NULL
);
2477 case MSSM_EVENT_PORT_OFFLINE
:
2478 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_offline
);
2479 bfa_timer_stop(&ms
->timer
);
2483 bfa_sm_fault(ms
->port
->fcs
, event
);
2488 bfa_fcs_lport_ms_sm_online(struct bfa_fcs_lport_ms_s
*ms
,
2489 enum port_ms_event event
)
2491 bfa_trc(ms
->port
->fcs
, ms
->port
->port_cfg
.pwwn
);
2492 bfa_trc(ms
->port
->fcs
, event
);
2495 case MSSM_EVENT_PORT_OFFLINE
:
2496 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_offline
);
2499 case MSSM_EVENT_PORT_FABRIC_RSCN
:
2500 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_gfn_sending
);
2502 bfa_fcs_lport_ms_send_gfn(ms
, NULL
);
2506 bfa_sm_fault(ms
->port
->fcs
, event
);
2511 bfa_fcs_lport_ms_sm_gmal_sending(struct bfa_fcs_lport_ms_s
*ms
,
2512 enum port_ms_event event
)
2514 bfa_trc(ms
->port
->fcs
, ms
->port
->port_cfg
.pwwn
);
2515 bfa_trc(ms
->port
->fcs
, event
);
2518 case MSSM_EVENT_FCXP_SENT
:
2519 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_gmal
);
2522 case MSSM_EVENT_PORT_OFFLINE
:
2523 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_offline
);
2524 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ms
->port
),
2529 bfa_sm_fault(ms
->port
->fcs
, event
);
2534 bfa_fcs_lport_ms_sm_gmal(struct bfa_fcs_lport_ms_s
*ms
,
2535 enum port_ms_event event
)
2537 bfa_trc(ms
->port
->fcs
, ms
->port
->port_cfg
.pwwn
);
2538 bfa_trc(ms
->port
->fcs
, event
);
2541 case MSSM_EVENT_RSP_ERROR
:
2543 * Start timer for a delayed retry
2545 if (ms
->retry_cnt
++ < BFA_FCS_MS_CMD_MAX_RETRIES
) {
2546 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_gmal_retry
);
2547 ms
->port
->stats
.ms_retries
++;
2548 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ms
->port
),
2549 &ms
->timer
, bfa_fcs_lport_ms_timeout
, ms
,
2550 BFA_FCS_RETRY_TIMEOUT
);
2552 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_gfn_sending
);
2553 bfa_fcs_lport_ms_send_gfn(ms
, NULL
);
2558 case MSSM_EVENT_RSP_OK
:
2559 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_gfn_sending
);
2560 bfa_fcs_lport_ms_send_gfn(ms
, NULL
);
2563 case MSSM_EVENT_PORT_OFFLINE
:
2564 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_offline
);
2565 bfa_fcxp_discard(ms
->fcxp
);
2569 bfa_sm_fault(ms
->port
->fcs
, event
);
2574 bfa_fcs_lport_ms_sm_gmal_retry(struct bfa_fcs_lport_ms_s
*ms
,
2575 enum port_ms_event event
)
2577 bfa_trc(ms
->port
->fcs
, ms
->port
->port_cfg
.pwwn
);
2578 bfa_trc(ms
->port
->fcs
, event
);
2581 case MSSM_EVENT_TIMEOUT
:
2583 * Retry Timer Expired. Re-send
2585 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_gmal_sending
);
2586 bfa_fcs_lport_ms_send_gmal(ms
, NULL
);
2589 case MSSM_EVENT_PORT_OFFLINE
:
2590 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_offline
);
2591 bfa_timer_stop(&ms
->timer
);
2595 bfa_sm_fault(ms
->port
->fcs
, event
);
2599 * ms_pvt MS local functions
2603 bfa_fcs_lport_ms_send_gmal(void *ms_cbarg
, struct bfa_fcxp_s
*fcxp_alloced
)
2605 struct bfa_fcs_lport_ms_s
*ms
= ms_cbarg
;
2606 bfa_fcs_lport_t
*port
= ms
->port
;
2609 struct bfa_fcxp_s
*fcxp
;
2611 bfa_trc(port
->fcs
, port
->pid
);
2613 fcxp
= fcxp_alloced
? fcxp_alloced
: bfa_fcs_fcxp_alloc(port
->fcs
);
2615 bfa_fcs_fcxp_alloc_wait(port
->fcs
->bfa
, &ms
->fcxp_wqe
,
2616 bfa_fcs_lport_ms_send_gmal
, ms
);
2621 len
= fc_gmal_req_build(&fchs
, bfa_fcxp_get_reqbuf(fcxp
),
2622 bfa_fcs_lport_get_fcid(port
),
2623 bfa_lps_get_peer_nwwn(port
->fabric
->lps
));
2625 bfa_fcxp_send(fcxp
, NULL
, port
->fabric
->vf_id
, port
->lp_tag
, BFA_FALSE
,
2626 FC_CLASS_3
, len
, &fchs
,
2627 bfa_fcs_lport_ms_gmal_response
, (void *)ms
,
2628 FC_MAX_PDUSZ
, FC_FCCT_TOV
);
2630 bfa_sm_send_event(ms
, MSSM_EVENT_FCXP_SENT
);
2634 bfa_fcs_lport_ms_gmal_response(void *fcsarg
, struct bfa_fcxp_s
*fcxp
,
2635 void *cbarg
, bfa_status_t req_status
,
2636 u32 rsp_len
, u32 resid_len
,
2637 struct fchs_s
*rsp_fchs
)
2639 struct bfa_fcs_lport_ms_s
*ms
= (struct bfa_fcs_lport_ms_s
*) cbarg
;
2640 bfa_fcs_lport_t
*port
= ms
->port
;
2641 struct ct_hdr_s
*cthdr
= NULL
;
2642 struct fcgs_gmal_resp_s
*gmal_resp
;
2643 struct fcgs_gmal_entry_s
*gmal_entry
;
2647 bfa_trc(port
->fcs
, req_status
);
2648 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
2653 if (req_status
!= BFA_STATUS_OK
) {
2654 bfa_trc(port
->fcs
, req_status
);
2655 bfa_sm_send_event(ms
, MSSM_EVENT_RSP_ERROR
);
2659 cthdr
= (struct ct_hdr_s
*) BFA_FCXP_RSP_PLD(fcxp
);
2660 cthdr
->cmd_rsp_code
= bfa_os_ntohs(cthdr
->cmd_rsp_code
);
2662 if (cthdr
->cmd_rsp_code
== CT_RSP_ACCEPT
) {
2663 gmal_resp
= (struct fcgs_gmal_resp_s
*)(cthdr
+ 1);
2665 num_entries
= bfa_os_ntohl(gmal_resp
->ms_len
);
2666 if (num_entries
== 0) {
2667 bfa_sm_send_event(ms
, MSSM_EVENT_RSP_ERROR
);
2671 * The response could contain multiple Entries.
2672 * Entries for SNMP interface, etc.
2673 * We look for the entry with a telnet prefix.
2674 * First "http://" entry refers to IP addr
2677 gmal_entry
= (struct fcgs_gmal_entry_s
*)gmal_resp
->ms_ma
;
2678 while (num_entries
> 0) {
2679 if (strncmp(gmal_entry
->prefix
,
2680 CT_GMAL_RESP_PREFIX_HTTP
,
2681 sizeof(gmal_entry
->prefix
)) == 0) {
2684 * if the IP address is terminating with a '/',
2686 * Byte 0 consists of the length of the string.
2688 rsp_str
= &(gmal_entry
->prefix
[0]);
2689 if (rsp_str
[gmal_entry
->len
-1] == '/')
2690 rsp_str
[gmal_entry
->len
-1] = 0;
2692 /* copy IP Address to fabric */
2693 strncpy(bfa_fcs_lport_get_fabric_ipaddr(port
),
2694 gmal_entry
->ip_addr
,
2695 BFA_FCS_FABRIC_IPADDR_SZ
);
2703 bfa_sm_send_event(ms
, MSSM_EVENT_RSP_OK
);
2707 bfa_trc(port
->fcs
, cthdr
->reason_code
);
2708 bfa_trc(port
->fcs
, cthdr
->exp_code
);
2709 bfa_sm_send_event(ms
, MSSM_EVENT_RSP_ERROR
);
2713 bfa_fcs_lport_ms_sm_gfn_sending(struct bfa_fcs_lport_ms_s
*ms
,
2714 enum port_ms_event event
)
2716 bfa_trc(ms
->port
->fcs
, ms
->port
->port_cfg
.pwwn
);
2717 bfa_trc(ms
->port
->fcs
, event
);
2720 case MSSM_EVENT_FCXP_SENT
:
2721 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_gfn
);
2724 case MSSM_EVENT_PORT_OFFLINE
:
2725 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_offline
);
2726 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ms
->port
),
2731 bfa_sm_fault(ms
->port
->fcs
, event
);
2736 bfa_fcs_lport_ms_sm_gfn(struct bfa_fcs_lport_ms_s
*ms
,
2737 enum port_ms_event event
)
2739 bfa_trc(ms
->port
->fcs
, ms
->port
->port_cfg
.pwwn
);
2740 bfa_trc(ms
->port
->fcs
, event
);
2743 case MSSM_EVENT_RSP_ERROR
:
2745 * Start timer for a delayed retry
2747 if (ms
->retry_cnt
++ < BFA_FCS_MS_CMD_MAX_RETRIES
) {
2748 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_gfn_retry
);
2749 ms
->port
->stats
.ms_retries
++;
2750 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ms
->port
),
2751 &ms
->timer
, bfa_fcs_lport_ms_timeout
, ms
,
2752 BFA_FCS_RETRY_TIMEOUT
);
2754 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_online
);
2759 case MSSM_EVENT_RSP_OK
:
2760 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_online
);
2763 case MSSM_EVENT_PORT_OFFLINE
:
2764 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_offline
);
2765 bfa_fcxp_discard(ms
->fcxp
);
2769 bfa_sm_fault(ms
->port
->fcs
, event
);
2774 bfa_fcs_lport_ms_sm_gfn_retry(struct bfa_fcs_lport_ms_s
*ms
,
2775 enum port_ms_event event
)
2777 bfa_trc(ms
->port
->fcs
, ms
->port
->port_cfg
.pwwn
);
2778 bfa_trc(ms
->port
->fcs
, event
);
2781 case MSSM_EVENT_TIMEOUT
:
2783 * Retry Timer Expired. Re-send
2785 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_gfn_sending
);
2786 bfa_fcs_lport_ms_send_gfn(ms
, NULL
);
2789 case MSSM_EVENT_PORT_OFFLINE
:
2790 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_offline
);
2791 bfa_timer_stop(&ms
->timer
);
2795 bfa_sm_fault(ms
->port
->fcs
, event
);
2799 * ms_pvt MS local functions
2803 bfa_fcs_lport_ms_send_gfn(void *ms_cbarg
, struct bfa_fcxp_s
*fcxp_alloced
)
2805 struct bfa_fcs_lport_ms_s
*ms
= ms_cbarg
;
2806 bfa_fcs_lport_t
*port
= ms
->port
;
2809 struct bfa_fcxp_s
*fcxp
;
2811 bfa_trc(port
->fcs
, port
->pid
);
2813 fcxp
= fcxp_alloced
? fcxp_alloced
: bfa_fcs_fcxp_alloc(port
->fcs
);
2815 bfa_fcs_fcxp_alloc_wait(port
->fcs
->bfa
, &ms
->fcxp_wqe
,
2816 bfa_fcs_lport_ms_send_gfn
, ms
);
2821 len
= fc_gfn_req_build(&fchs
, bfa_fcxp_get_reqbuf(fcxp
),
2822 bfa_fcs_lport_get_fcid(port
),
2823 bfa_lps_get_peer_nwwn(port
->fabric
->lps
));
2825 bfa_fcxp_send(fcxp
, NULL
, port
->fabric
->vf_id
, port
->lp_tag
, BFA_FALSE
,
2826 FC_CLASS_3
, len
, &fchs
,
2827 bfa_fcs_lport_ms_gfn_response
, (void *)ms
,
2828 FC_MAX_PDUSZ
, FC_FCCT_TOV
);
2830 bfa_sm_send_event(ms
, MSSM_EVENT_FCXP_SENT
);
2834 bfa_fcs_lport_ms_gfn_response(void *fcsarg
, struct bfa_fcxp_s
*fcxp
,
2835 void *cbarg
, bfa_status_t req_status
, u32 rsp_len
,
2836 u32 resid_len
, struct fchs_s
*rsp_fchs
)
2838 struct bfa_fcs_lport_ms_s
*ms
= (struct bfa_fcs_lport_ms_s
*) cbarg
;
2839 bfa_fcs_lport_t
*port
= ms
->port
;
2840 struct ct_hdr_s
*cthdr
= NULL
;
2843 bfa_trc(port
->fcs
, req_status
);
2844 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
2849 if (req_status
!= BFA_STATUS_OK
) {
2850 bfa_trc(port
->fcs
, req_status
);
2851 bfa_sm_send_event(ms
, MSSM_EVENT_RSP_ERROR
);
2855 cthdr
= (struct ct_hdr_s
*) BFA_FCXP_RSP_PLD(fcxp
);
2856 cthdr
->cmd_rsp_code
= bfa_os_ntohs(cthdr
->cmd_rsp_code
);
2858 if (cthdr
->cmd_rsp_code
== CT_RSP_ACCEPT
) {
2859 gfn_resp
= (wwn_t
*)(cthdr
+ 1);
2860 /* check if it has actually changed */
2861 if ((memcmp((void *)&bfa_fcs_lport_get_fabric_name(port
),
2862 gfn_resp
, sizeof(wwn_t
)) != 0)) {
2863 bfa_fcs_fabric_set_fabric_name(port
->fabric
, *gfn_resp
);
2865 bfa_sm_send_event(ms
, MSSM_EVENT_RSP_OK
);
2869 bfa_trc(port
->fcs
, cthdr
->reason_code
);
2870 bfa_trc(port
->fcs
, cthdr
->exp_code
);
2871 bfa_sm_send_event(ms
, MSSM_EVENT_RSP_ERROR
);
2875 * ms_pvt MS local functions
2879 bfa_fcs_lport_ms_send_plogi(void *ms_cbarg
, struct bfa_fcxp_s
*fcxp_alloced
)
2881 struct bfa_fcs_lport_ms_s
*ms
= ms_cbarg
;
2882 struct bfa_fcs_lport_s
*port
= ms
->port
;
2885 struct bfa_fcxp_s
*fcxp
;
2887 bfa_trc(port
->fcs
, port
->pid
);
2889 fcxp
= fcxp_alloced
? fcxp_alloced
: bfa_fcs_fcxp_alloc(port
->fcs
);
2891 port
->stats
.ms_plogi_alloc_wait
++;
2892 bfa_fcs_fcxp_alloc_wait(port
->fcs
->bfa
, &ms
->fcxp_wqe
,
2893 bfa_fcs_lport_ms_send_plogi
, ms
);
2898 len
= fc_plogi_build(&fchs
, bfa_fcxp_get_reqbuf(fcxp
),
2899 bfa_os_hton3b(FC_MGMT_SERVER
),
2900 bfa_fcs_lport_get_fcid(port
), 0,
2901 port
->port_cfg
.pwwn
, port
->port_cfg
.nwwn
,
2902 bfa_fcport_get_maxfrsize(port
->fcs
->bfa
));
2904 bfa_fcxp_send(fcxp
, NULL
, port
->fabric
->vf_id
, port
->lp_tag
, BFA_FALSE
,
2905 FC_CLASS_3
, len
, &fchs
,
2906 bfa_fcs_lport_ms_plogi_response
, (void *)ms
,
2907 FC_MAX_PDUSZ
, FC_ELS_TOV
);
2909 port
->stats
.ms_plogi_sent
++;
2910 bfa_sm_send_event(ms
, MSSM_EVENT_FCXP_SENT
);
2914 bfa_fcs_lport_ms_plogi_response(void *fcsarg
, struct bfa_fcxp_s
*fcxp
,
2915 void *cbarg
, bfa_status_t req_status
,
2916 u32 rsp_len
, u32 resid_len
, struct fchs_s
*rsp_fchs
)
2918 struct bfa_fcs_lport_ms_s
*ms
= (struct bfa_fcs_lport_ms_s
*) cbarg
;
2919 struct bfa_fcs_lport_s
*port
= ms
->port
;
2920 struct fc_els_cmd_s
*els_cmd
;
2921 struct fc_ls_rjt_s
*ls_rjt
;
2923 bfa_trc(port
->fcs
, req_status
);
2924 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
2929 if (req_status
!= BFA_STATUS_OK
) {
2930 port
->stats
.ms_plogi_rsp_err
++;
2931 bfa_trc(port
->fcs
, req_status
);
2932 bfa_sm_send_event(ms
, MSSM_EVENT_RSP_ERROR
);
2936 els_cmd
= (struct fc_els_cmd_s
*) BFA_FCXP_RSP_PLD(fcxp
);
2938 switch (els_cmd
->els_code
) {
2941 if (rsp_len
< sizeof(struct fc_logi_s
)) {
2942 bfa_trc(port
->fcs
, rsp_len
);
2943 port
->stats
.ms_plogi_acc_err
++;
2944 bfa_sm_send_event(ms
, MSSM_EVENT_RSP_ERROR
);
2947 port
->stats
.ms_plogi_accepts
++;
2948 bfa_sm_send_event(ms
, MSSM_EVENT_RSP_OK
);
2952 ls_rjt
= (struct fc_ls_rjt_s
*) BFA_FCXP_RSP_PLD(fcxp
);
2954 bfa_trc(port
->fcs
, ls_rjt
->reason_code
);
2955 bfa_trc(port
->fcs
, ls_rjt
->reason_code_expl
);
2957 port
->stats
.ms_rejects
++;
2958 bfa_sm_send_event(ms
, MSSM_EVENT_RSP_ERROR
);
2962 port
->stats
.ms_plogi_unknown_rsp
++;
2963 bfa_trc(port
->fcs
, els_cmd
->els_code
);
2964 bfa_sm_send_event(ms
, MSSM_EVENT_RSP_ERROR
);
2969 bfa_fcs_lport_ms_timeout(void *arg
)
2971 struct bfa_fcs_lport_ms_s
*ms
= (struct bfa_fcs_lport_ms_s
*) arg
;
2973 ms
->port
->stats
.ms_timeouts
++;
2974 bfa_sm_send_event(ms
, MSSM_EVENT_TIMEOUT
);
2979 bfa_fcs_lport_ms_init(struct bfa_fcs_lport_s
*port
)
2981 struct bfa_fcs_lport_ms_s
*ms
= BFA_FCS_GET_MS_FROM_PORT(port
);
2984 bfa_sm_set_state(ms
, bfa_fcs_lport_ms_sm_offline
);
2987 * Invoke init routines of sub modules.
2989 bfa_fcs_lport_fdmi_init(ms
);
2993 bfa_fcs_lport_ms_offline(struct bfa_fcs_lport_s
*port
)
2995 struct bfa_fcs_lport_ms_s
*ms
= BFA_FCS_GET_MS_FROM_PORT(port
);
2998 bfa_sm_send_event(ms
, MSSM_EVENT_PORT_OFFLINE
);
2999 bfa_fcs_lport_fdmi_offline(ms
);
3003 bfa_fcs_lport_ms_online(struct bfa_fcs_lport_s
*port
)
3005 struct bfa_fcs_lport_ms_s
*ms
= BFA_FCS_GET_MS_FROM_PORT(port
);
3008 bfa_sm_send_event(ms
, MSSM_EVENT_PORT_ONLINE
);
3011 bfa_fcs_lport_ms_fabric_rscn(struct bfa_fcs_lport_s
*port
)
3013 struct bfa_fcs_lport_ms_s
*ms
= BFA_FCS_GET_MS_FROM_PORT(port
);
3015 /* todo. Handle this only when in Online state */
3016 if (bfa_sm_cmp_state(ms
, bfa_fcs_lport_ms_sm_online
))
3017 bfa_sm_send_event(ms
, MSSM_EVENT_PORT_FABRIC_RSCN
);
3021 * @page ns_sm_info VPORT NS State Machine
3023 * @section ns_sm_interactions VPORT NS State Machine Interactions
3025 * @section ns_sm VPORT NS State Machine
3030 * forward declarations
3032 static void bfa_fcs_lport_ns_send_plogi(void *ns_cbarg
,
3033 struct bfa_fcxp_s
*fcxp_alloced
);
3034 static void bfa_fcs_lport_ns_send_rspn_id(void *ns_cbarg
,
3035 struct bfa_fcxp_s
*fcxp_alloced
);
3036 static void bfa_fcs_lport_ns_send_rft_id(void *ns_cbarg
,
3037 struct bfa_fcxp_s
*fcxp_alloced
);
3038 static void bfa_fcs_lport_ns_send_rff_id(void *ns_cbarg
,
3039 struct bfa_fcxp_s
*fcxp_alloced
);
3040 static void bfa_fcs_lport_ns_send_gid_ft(void *ns_cbarg
,
3041 struct bfa_fcxp_s
*fcxp_alloced
);
3042 static void bfa_fcs_lport_ns_timeout(void *arg
);
3043 static void bfa_fcs_lport_ns_plogi_response(void *fcsarg
,
3044 struct bfa_fcxp_s
*fcxp
,
3046 bfa_status_t req_status
,
3049 struct fchs_s
*rsp_fchs
);
3050 static void bfa_fcs_lport_ns_rspn_id_response(void *fcsarg
,
3051 struct bfa_fcxp_s
*fcxp
,
3053 bfa_status_t req_status
,
3056 struct fchs_s
*rsp_fchs
);
3057 static void bfa_fcs_lport_ns_rft_id_response(void *fcsarg
,
3058 struct bfa_fcxp_s
*fcxp
,
3060 bfa_status_t req_status
,
3063 struct fchs_s
*rsp_fchs
);
3064 static void bfa_fcs_lport_ns_rff_id_response(void *fcsarg
,
3065 struct bfa_fcxp_s
*fcxp
,
3067 bfa_status_t req_status
,
3070 struct fchs_s
*rsp_fchs
);
3071 static void bfa_fcs_lport_ns_gid_ft_response(void *fcsarg
,
3072 struct bfa_fcxp_s
*fcxp
,
3074 bfa_status_t req_status
,
3077 struct fchs_s
*rsp_fchs
);
3078 static void bfa_fcs_lport_ns_process_gidft_pids(
3079 struct bfa_fcs_lport_s
*port
,
3080 u32
*pid_buf
, u32 n_pids
);
3082 static void bfa_fcs_lport_ns_boot_target_disc(bfa_fcs_lport_t
*port
);
3084 * fcs_ns_sm FCS nameserver interface state machine
3088 * VPort NS State Machine events
3090 enum vport_ns_event
{
3091 NSSM_EVENT_PORT_ONLINE
= 1,
3092 NSSM_EVENT_PORT_OFFLINE
= 2,
3093 NSSM_EVENT_PLOGI_SENT
= 3,
3094 NSSM_EVENT_RSP_OK
= 4,
3095 NSSM_EVENT_RSP_ERROR
= 5,
3096 NSSM_EVENT_TIMEOUT
= 6,
3097 NSSM_EVENT_NS_QUERY
= 7,
3098 NSSM_EVENT_RSPNID_SENT
= 8,
3099 NSSM_EVENT_RFTID_SENT
= 9,
3100 NSSM_EVENT_RFFID_SENT
= 10,
3101 NSSM_EVENT_GIDFT_SENT
= 11,
3104 static void bfa_fcs_lport_ns_sm_offline(struct bfa_fcs_lport_ns_s
*ns
,
3105 enum vport_ns_event event
);
3106 static void bfa_fcs_lport_ns_sm_plogi_sending(struct bfa_fcs_lport_ns_s
*ns
,
3107 enum vport_ns_event event
);
3108 static void bfa_fcs_lport_ns_sm_plogi(struct bfa_fcs_lport_ns_s
*ns
,
3109 enum vport_ns_event event
);
3110 static void bfa_fcs_lport_ns_sm_plogi_retry(struct bfa_fcs_lport_ns_s
*ns
,
3111 enum vport_ns_event event
);
3112 static void bfa_fcs_lport_ns_sm_sending_rspn_id(
3113 struct bfa_fcs_lport_ns_s
*ns
,
3114 enum vport_ns_event event
);
3115 static void bfa_fcs_lport_ns_sm_rspn_id(struct bfa_fcs_lport_ns_s
*ns
,
3116 enum vport_ns_event event
);
3117 static void bfa_fcs_lport_ns_sm_rspn_id_retry(struct bfa_fcs_lport_ns_s
*ns
,
3118 enum vport_ns_event event
);
3119 static void bfa_fcs_lport_ns_sm_sending_rft_id(
3120 struct bfa_fcs_lport_ns_s
*ns
,
3121 enum vport_ns_event event
);
3122 static void bfa_fcs_lport_ns_sm_rft_id_retry(struct bfa_fcs_lport_ns_s
*ns
,
3123 enum vport_ns_event event
);
3124 static void bfa_fcs_lport_ns_sm_rft_id(struct bfa_fcs_lport_ns_s
*ns
,
3125 enum vport_ns_event event
);
3126 static void bfa_fcs_lport_ns_sm_sending_rff_id(
3127 struct bfa_fcs_lport_ns_s
*ns
,
3128 enum vport_ns_event event
);
3129 static void bfa_fcs_lport_ns_sm_rff_id_retry(struct bfa_fcs_lport_ns_s
*ns
,
3130 enum vport_ns_event event
);
3131 static void bfa_fcs_lport_ns_sm_rff_id(struct bfa_fcs_lport_ns_s
*ns
,
3132 enum vport_ns_event event
);
3133 static void bfa_fcs_lport_ns_sm_sending_gid_ft(
3134 struct bfa_fcs_lport_ns_s
*ns
,
3135 enum vport_ns_event event
);
3136 static void bfa_fcs_lport_ns_sm_gid_ft(struct bfa_fcs_lport_ns_s
*ns
,
3137 enum vport_ns_event event
);
3138 static void bfa_fcs_lport_ns_sm_gid_ft_retry(struct bfa_fcs_lport_ns_s
*ns
,
3139 enum vport_ns_event event
);
3140 static void bfa_fcs_lport_ns_sm_online(struct bfa_fcs_lport_ns_s
*ns
,
3141 enum vport_ns_event event
);
3143 * Start in offline state - awaiting linkup
3146 bfa_fcs_lport_ns_sm_offline(struct bfa_fcs_lport_ns_s
*ns
,
3147 enum vport_ns_event event
)
3149 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3150 bfa_trc(ns
->port
->fcs
, event
);
3153 case NSSM_EVENT_PORT_ONLINE
:
3154 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_plogi_sending
);
3155 bfa_fcs_lport_ns_send_plogi(ns
, NULL
);
3158 case NSSM_EVENT_PORT_OFFLINE
:
3162 bfa_sm_fault(ns
->port
->fcs
, event
);
3167 bfa_fcs_lport_ns_sm_plogi_sending(struct bfa_fcs_lport_ns_s
*ns
,
3168 enum vport_ns_event event
)
3170 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3171 bfa_trc(ns
->port
->fcs
, event
);
3174 case NSSM_EVENT_PLOGI_SENT
:
3175 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_plogi
);
3178 case NSSM_EVENT_PORT_OFFLINE
:
3179 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3180 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns
->port
),
3185 bfa_sm_fault(ns
->port
->fcs
, event
);
3190 bfa_fcs_lport_ns_sm_plogi(struct bfa_fcs_lport_ns_s
*ns
,
3191 enum vport_ns_event event
)
3193 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3194 bfa_trc(ns
->port
->fcs
, event
);
3197 case NSSM_EVENT_RSP_ERROR
:
3199 * Start timer for a delayed retry
3201 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_plogi_retry
);
3202 ns
->port
->stats
.ns_retries
++;
3203 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns
->port
),
3204 &ns
->timer
, bfa_fcs_lport_ns_timeout
, ns
,
3205 BFA_FCS_RETRY_TIMEOUT
);
3208 case NSSM_EVENT_RSP_OK
:
3209 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_sending_rspn_id
);
3210 bfa_fcs_lport_ns_send_rspn_id(ns
, NULL
);
3213 case NSSM_EVENT_PORT_OFFLINE
:
3214 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3215 bfa_fcxp_discard(ns
->fcxp
);
3219 bfa_sm_fault(ns
->port
->fcs
, event
);
3224 bfa_fcs_lport_ns_sm_plogi_retry(struct bfa_fcs_lport_ns_s
*ns
,
3225 enum vport_ns_event event
)
3227 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3228 bfa_trc(ns
->port
->fcs
, event
);
3231 case NSSM_EVENT_TIMEOUT
:
3233 * Retry Timer Expired. Re-send
3235 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_plogi_sending
);
3236 bfa_fcs_lport_ns_send_plogi(ns
, NULL
);
3239 case NSSM_EVENT_PORT_OFFLINE
:
3240 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3241 bfa_timer_stop(&ns
->timer
);
3245 bfa_sm_fault(ns
->port
->fcs
, event
);
3250 bfa_fcs_lport_ns_sm_sending_rspn_id(struct bfa_fcs_lport_ns_s
*ns
,
3251 enum vport_ns_event event
)
3253 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3254 bfa_trc(ns
->port
->fcs
, event
);
3257 case NSSM_EVENT_RSPNID_SENT
:
3258 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_rspn_id
);
3261 case NSSM_EVENT_PORT_OFFLINE
:
3262 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3263 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns
->port
),
3268 bfa_sm_fault(ns
->port
->fcs
, event
);
3273 bfa_fcs_lport_ns_sm_rspn_id(struct bfa_fcs_lport_ns_s
*ns
,
3274 enum vport_ns_event event
)
3276 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3277 bfa_trc(ns
->port
->fcs
, event
);
3280 case NSSM_EVENT_RSP_ERROR
:
3282 * Start timer for a delayed retry
3284 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_rspn_id_retry
);
3285 ns
->port
->stats
.ns_retries
++;
3286 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns
->port
),
3287 &ns
->timer
, bfa_fcs_lport_ns_timeout
, ns
,
3288 BFA_FCS_RETRY_TIMEOUT
);
3291 case NSSM_EVENT_RSP_OK
:
3292 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_sending_rft_id
);
3293 bfa_fcs_lport_ns_send_rft_id(ns
, NULL
);
3296 case NSSM_EVENT_PORT_OFFLINE
:
3297 bfa_fcxp_discard(ns
->fcxp
);
3298 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3302 bfa_sm_fault(ns
->port
->fcs
, event
);
3307 bfa_fcs_lport_ns_sm_rspn_id_retry(struct bfa_fcs_lport_ns_s
*ns
,
3308 enum vport_ns_event event
)
3310 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3311 bfa_trc(ns
->port
->fcs
, event
);
3314 case NSSM_EVENT_TIMEOUT
:
3316 * Retry Timer Expired. Re-send
3318 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_sending_rspn_id
);
3319 bfa_fcs_lport_ns_send_rspn_id(ns
, NULL
);
3322 case NSSM_EVENT_PORT_OFFLINE
:
3323 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3324 bfa_timer_stop(&ns
->timer
);
3328 bfa_sm_fault(ns
->port
->fcs
, event
);
3333 bfa_fcs_lport_ns_sm_sending_rft_id(struct bfa_fcs_lport_ns_s
*ns
,
3334 enum vport_ns_event event
)
3336 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3337 bfa_trc(ns
->port
->fcs
, event
);
3340 case NSSM_EVENT_RFTID_SENT
:
3341 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_rft_id
);
3344 case NSSM_EVENT_PORT_OFFLINE
:
3345 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3346 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns
->port
),
3351 bfa_sm_fault(ns
->port
->fcs
, event
);
3356 bfa_fcs_lport_ns_sm_rft_id(struct bfa_fcs_lport_ns_s
*ns
,
3357 enum vport_ns_event event
)
3359 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3360 bfa_trc(ns
->port
->fcs
, event
);
3363 case NSSM_EVENT_RSP_OK
:
3364 /* Now move to register FC4 Features */
3365 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_sending_rff_id
);
3366 bfa_fcs_lport_ns_send_rff_id(ns
, NULL
);
3369 case NSSM_EVENT_RSP_ERROR
:
3371 * Start timer for a delayed retry
3373 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_rft_id_retry
);
3374 ns
->port
->stats
.ns_retries
++;
3375 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns
->port
),
3376 &ns
->timer
, bfa_fcs_lport_ns_timeout
, ns
,
3377 BFA_FCS_RETRY_TIMEOUT
);
3380 case NSSM_EVENT_PORT_OFFLINE
:
3381 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3382 bfa_fcxp_discard(ns
->fcxp
);
3386 bfa_sm_fault(ns
->port
->fcs
, event
);
3391 bfa_fcs_lport_ns_sm_rft_id_retry(struct bfa_fcs_lport_ns_s
*ns
,
3392 enum vport_ns_event event
)
3394 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3395 bfa_trc(ns
->port
->fcs
, event
);
3398 case NSSM_EVENT_TIMEOUT
:
3399 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_sending_rft_id
);
3400 bfa_fcs_lport_ns_send_rft_id(ns
, NULL
);
3403 case NSSM_EVENT_PORT_OFFLINE
:
3404 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3405 bfa_timer_stop(&ns
->timer
);
3409 bfa_sm_fault(ns
->port
->fcs
, event
);
3414 bfa_fcs_lport_ns_sm_sending_rff_id(struct bfa_fcs_lport_ns_s
*ns
,
3415 enum vport_ns_event event
)
3417 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3418 bfa_trc(ns
->port
->fcs
, event
);
3421 case NSSM_EVENT_RFFID_SENT
:
3422 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_rff_id
);
3425 case NSSM_EVENT_PORT_OFFLINE
:
3426 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3427 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns
->port
),
3432 bfa_sm_fault(ns
->port
->fcs
, event
);
3437 bfa_fcs_lport_ns_sm_rff_id(struct bfa_fcs_lport_ns_s
*ns
,
3438 enum vport_ns_event event
)
3440 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3441 bfa_trc(ns
->port
->fcs
, event
);
3444 case NSSM_EVENT_RSP_OK
:
3447 * If min cfg mode is enabled, we donot initiate rport
3448 * discovery with the fabric. Instead, we will retrieve the
3449 * boot targets from HAL/FW.
3451 if (__fcs_min_cfg(ns
->port
->fcs
)) {
3452 bfa_fcs_lport_ns_boot_target_disc(ns
->port
);
3453 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_online
);
3458 * If the port role is Initiator Mode issue NS query.
3459 * If it is Target Mode, skip this and go to online.
3461 if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns
->port
)) {
3462 bfa_sm_set_state(ns
,
3463 bfa_fcs_lport_ns_sm_sending_gid_ft
);
3464 bfa_fcs_lport_ns_send_gid_ft(ns
, NULL
);
3467 * kick off mgmt srvr state machine
3469 bfa_fcs_lport_ms_online(ns
->port
);
3472 case NSSM_EVENT_RSP_ERROR
:
3474 * Start timer for a delayed retry
3476 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_rff_id_retry
);
3477 ns
->port
->stats
.ns_retries
++;
3478 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns
->port
),
3479 &ns
->timer
, bfa_fcs_lport_ns_timeout
, ns
,
3480 BFA_FCS_RETRY_TIMEOUT
);
3483 case NSSM_EVENT_PORT_OFFLINE
:
3484 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3485 bfa_fcxp_discard(ns
->fcxp
);
3489 bfa_sm_fault(ns
->port
->fcs
, event
);
3494 bfa_fcs_lport_ns_sm_rff_id_retry(struct bfa_fcs_lport_ns_s
*ns
,
3495 enum vport_ns_event event
)
3497 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3498 bfa_trc(ns
->port
->fcs
, event
);
3501 case NSSM_EVENT_TIMEOUT
:
3502 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_sending_rff_id
);
3503 bfa_fcs_lport_ns_send_rff_id(ns
, NULL
);
3506 case NSSM_EVENT_PORT_OFFLINE
:
3507 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3508 bfa_timer_stop(&ns
->timer
);
3512 bfa_sm_fault(ns
->port
->fcs
, event
);
3516 bfa_fcs_lport_ns_sm_sending_gid_ft(struct bfa_fcs_lport_ns_s
*ns
,
3517 enum vport_ns_event event
)
3519 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3520 bfa_trc(ns
->port
->fcs
, event
);
3523 case NSSM_EVENT_GIDFT_SENT
:
3524 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_gid_ft
);
3527 case NSSM_EVENT_PORT_OFFLINE
:
3528 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3529 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns
->port
),
3534 bfa_sm_fault(ns
->port
->fcs
, event
);
3539 bfa_fcs_lport_ns_sm_gid_ft(struct bfa_fcs_lport_ns_s
*ns
,
3540 enum vport_ns_event event
)
3542 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3543 bfa_trc(ns
->port
->fcs
, event
);
3546 case NSSM_EVENT_RSP_OK
:
3547 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_online
);
3550 case NSSM_EVENT_RSP_ERROR
:
3552 * TBD: for certain reject codes, we don't need to retry
3555 * Start timer for a delayed retry
3557 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_gid_ft_retry
);
3558 ns
->port
->stats
.ns_retries
++;
3559 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns
->port
),
3560 &ns
->timer
, bfa_fcs_lport_ns_timeout
, ns
,
3561 BFA_FCS_RETRY_TIMEOUT
);
3564 case NSSM_EVENT_PORT_OFFLINE
:
3565 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3566 bfa_fcxp_discard(ns
->fcxp
);
3569 case NSSM_EVENT_NS_QUERY
:
3573 bfa_sm_fault(ns
->port
->fcs
, event
);
3578 bfa_fcs_lport_ns_sm_gid_ft_retry(struct bfa_fcs_lport_ns_s
*ns
,
3579 enum vport_ns_event event
)
3581 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3582 bfa_trc(ns
->port
->fcs
, event
);
3585 case NSSM_EVENT_TIMEOUT
:
3586 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_sending_gid_ft
);
3587 bfa_fcs_lport_ns_send_gid_ft(ns
, NULL
);
3590 case NSSM_EVENT_PORT_OFFLINE
:
3591 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3592 bfa_timer_stop(&ns
->timer
);
3596 bfa_sm_fault(ns
->port
->fcs
, event
);
3601 bfa_fcs_lport_ns_sm_online(struct bfa_fcs_lport_ns_s
*ns
,
3602 enum vport_ns_event event
)
3604 bfa_trc(ns
->port
->fcs
, ns
->port
->port_cfg
.pwwn
);
3605 bfa_trc(ns
->port
->fcs
, event
);
3608 case NSSM_EVENT_PORT_OFFLINE
:
3609 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
3612 case NSSM_EVENT_NS_QUERY
:
3614 * If the port role is Initiator Mode issue NS query.
3615 * If it is Target Mode, skip this and go to online.
3617 if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns
->port
)) {
3618 bfa_sm_set_state(ns
,
3619 bfa_fcs_lport_ns_sm_sending_gid_ft
);
3620 bfa_fcs_lport_ns_send_gid_ft(ns
, NULL
);
3625 bfa_sm_fault(ns
->port
->fcs
, event
);
3632 * ns_pvt Nameserver local functions
3636 bfa_fcs_lport_ns_send_plogi(void *ns_cbarg
, struct bfa_fcxp_s
*fcxp_alloced
)
3638 struct bfa_fcs_lport_ns_s
*ns
= ns_cbarg
;
3639 struct bfa_fcs_lport_s
*port
= ns
->port
;
3642 struct bfa_fcxp_s
*fcxp
;
3644 bfa_trc(port
->fcs
, port
->pid
);
3646 fcxp
= fcxp_alloced
? fcxp_alloced
: bfa_fcs_fcxp_alloc(port
->fcs
);
3648 port
->stats
.ns_plogi_alloc_wait
++;
3649 bfa_fcs_fcxp_alloc_wait(port
->fcs
->bfa
, &ns
->fcxp_wqe
,
3650 bfa_fcs_lport_ns_send_plogi
, ns
);
3655 len
= fc_plogi_build(&fchs
, bfa_fcxp_get_reqbuf(fcxp
),
3656 bfa_os_hton3b(FC_NAME_SERVER
),
3657 bfa_fcs_lport_get_fcid(port
), 0,
3658 port
->port_cfg
.pwwn
, port
->port_cfg
.nwwn
,
3659 bfa_fcport_get_maxfrsize(port
->fcs
->bfa
));
3661 bfa_fcxp_send(fcxp
, NULL
, port
->fabric
->vf_id
, port
->lp_tag
, BFA_FALSE
,
3662 FC_CLASS_3
, len
, &fchs
,
3663 bfa_fcs_lport_ns_plogi_response
, (void *)ns
,
3664 FC_MAX_PDUSZ
, FC_ELS_TOV
);
3665 port
->stats
.ns_plogi_sent
++;
3667 bfa_sm_send_event(ns
, NSSM_EVENT_PLOGI_SENT
);
3671 bfa_fcs_lport_ns_plogi_response(void *fcsarg
, struct bfa_fcxp_s
*fcxp
,
3672 void *cbarg
, bfa_status_t req_status
, u32 rsp_len
,
3673 u32 resid_len
, struct fchs_s
*rsp_fchs
)
3675 struct bfa_fcs_lport_ns_s
*ns
= (struct bfa_fcs_lport_ns_s
*) cbarg
;
3676 struct bfa_fcs_lport_s
*port
= ns
->port
;
3677 /* struct fc_logi_s *plogi_resp; */
3678 struct fc_els_cmd_s
*els_cmd
;
3679 struct fc_ls_rjt_s
*ls_rjt
;
3681 bfa_trc(port
->fcs
, req_status
);
3682 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
3687 if (req_status
!= BFA_STATUS_OK
) {
3688 bfa_trc(port
->fcs
, req_status
);
3689 port
->stats
.ns_plogi_rsp_err
++;
3690 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_ERROR
);
3694 els_cmd
= (struct fc_els_cmd_s
*) BFA_FCXP_RSP_PLD(fcxp
);
3696 switch (els_cmd
->els_code
) {
3699 if (rsp_len
< sizeof(struct fc_logi_s
)) {
3700 bfa_trc(port
->fcs
, rsp_len
);
3701 port
->stats
.ns_plogi_acc_err
++;
3702 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_ERROR
);
3705 port
->stats
.ns_plogi_accepts
++;
3706 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_OK
);
3710 ls_rjt
= (struct fc_ls_rjt_s
*) BFA_FCXP_RSP_PLD(fcxp
);
3712 bfa_trc(port
->fcs
, ls_rjt
->reason_code
);
3713 bfa_trc(port
->fcs
, ls_rjt
->reason_code_expl
);
3715 port
->stats
.ns_rejects
++;
3717 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_ERROR
);
3721 port
->stats
.ns_plogi_unknown_rsp
++;
3722 bfa_trc(port
->fcs
, els_cmd
->els_code
);
3723 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_ERROR
);
3728 * Register the symbolic port name.
3731 bfa_fcs_lport_ns_send_rspn_id(void *ns_cbarg
, struct bfa_fcxp_s
*fcxp_alloced
)
3733 struct bfa_fcs_lport_ns_s
*ns
= ns_cbarg
;
3734 struct bfa_fcs_lport_s
*port
= ns
->port
;
3737 struct bfa_fcxp_s
*fcxp
;
3739 u8
*psymbl
= &symbl
[0];
3741 bfa_os_memset(symbl
, 0, sizeof(symbl
));
3743 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
3745 fcxp
= fcxp_alloced
? fcxp_alloced
: bfa_fcs_fcxp_alloc(port
->fcs
);
3747 port
->stats
.ns_rspnid_alloc_wait
++;
3748 bfa_fcs_fcxp_alloc_wait(port
->fcs
->bfa
, &ns
->fcxp_wqe
,
3749 bfa_fcs_lport_ns_send_rspn_id
, ns
);
3755 * for V-Port, form a Port Symbolic Name
3759 * For Vports, we append the vport's port symbolic name
3760 * to that of the base port.
3763 strncpy((char *)psymbl
,
3765 (bfa_fcs_lport_get_psym_name
3766 (bfa_fcs_get_base_port(port
->fcs
))),
3768 bfa_fcs_lport_get_psym_name(bfa_fcs_get_base_port
3771 /* Ensure we have a null terminating string. */
3772 ((char *)psymbl
)[strlen((char *) &
3773 bfa_fcs_lport_get_psym_name(bfa_fcs_get_base_port
3775 strncat((char *)psymbl
,
3776 (char *) &(bfa_fcs_lport_get_psym_name(port
)),
3777 strlen((char *) &bfa_fcs_lport_get_psym_name(port
)));
3779 psymbl
= (u8
*) &(bfa_fcs_lport_get_psym_name(port
));
3782 len
= fc_rspnid_build(&fchs
, bfa_fcxp_get_reqbuf(fcxp
),
3783 bfa_fcs_lport_get_fcid(port
), 0, psymbl
);
3785 bfa_fcxp_send(fcxp
, NULL
, port
->fabric
->vf_id
, port
->lp_tag
, BFA_FALSE
,
3786 FC_CLASS_3
, len
, &fchs
,
3787 bfa_fcs_lport_ns_rspn_id_response
, (void *)ns
,
3788 FC_MAX_PDUSZ
, FC_FCCT_TOV
);
3790 port
->stats
.ns_rspnid_sent
++;
3792 bfa_sm_send_event(ns
, NSSM_EVENT_RSPNID_SENT
);
3796 bfa_fcs_lport_ns_rspn_id_response(void *fcsarg
, struct bfa_fcxp_s
*fcxp
,
3797 void *cbarg
, bfa_status_t req_status
,
3798 u32 rsp_len
, u32 resid_len
,
3799 struct fchs_s
*rsp_fchs
)
3801 struct bfa_fcs_lport_ns_s
*ns
= (struct bfa_fcs_lport_ns_s
*) cbarg
;
3802 struct bfa_fcs_lport_s
*port
= ns
->port
;
3803 struct ct_hdr_s
*cthdr
= NULL
;
3805 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
3810 if (req_status
!= BFA_STATUS_OK
) {
3811 bfa_trc(port
->fcs
, req_status
);
3812 port
->stats
.ns_rspnid_rsp_err
++;
3813 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_ERROR
);
3817 cthdr
= (struct ct_hdr_s
*) BFA_FCXP_RSP_PLD(fcxp
);
3818 cthdr
->cmd_rsp_code
= bfa_os_ntohs(cthdr
->cmd_rsp_code
);
3820 if (cthdr
->cmd_rsp_code
== CT_RSP_ACCEPT
) {
3821 port
->stats
.ns_rspnid_accepts
++;
3822 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_OK
);
3826 port
->stats
.ns_rspnid_rejects
++;
3827 bfa_trc(port
->fcs
, cthdr
->reason_code
);
3828 bfa_trc(port
->fcs
, cthdr
->exp_code
);
3829 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_ERROR
);
3833 * Register FC4-Types
3836 bfa_fcs_lport_ns_send_rft_id(void *ns_cbarg
, struct bfa_fcxp_s
*fcxp_alloced
)
3838 struct bfa_fcs_lport_ns_s
*ns
= ns_cbarg
;
3839 struct bfa_fcs_lport_s
*port
= ns
->port
;
3842 struct bfa_fcxp_s
*fcxp
;
3844 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
3846 fcxp
= fcxp_alloced
? fcxp_alloced
: bfa_fcs_fcxp_alloc(port
->fcs
);
3848 port
->stats
.ns_rftid_alloc_wait
++;
3849 bfa_fcs_fcxp_alloc_wait(port
->fcs
->bfa
, &ns
->fcxp_wqe
,
3850 bfa_fcs_lport_ns_send_rft_id
, ns
);
3855 len
= fc_rftid_build(&fchs
, bfa_fcxp_get_reqbuf(fcxp
),
3856 bfa_fcs_lport_get_fcid(port
), 0, port
->port_cfg
.roles
);
3858 bfa_fcxp_send(fcxp
, NULL
, port
->fabric
->vf_id
, port
->lp_tag
, BFA_FALSE
,
3859 FC_CLASS_3
, len
, &fchs
,
3860 bfa_fcs_lport_ns_rft_id_response
, (void *)ns
,
3861 FC_MAX_PDUSZ
, FC_FCCT_TOV
);
3863 port
->stats
.ns_rftid_sent
++;
3864 bfa_sm_send_event(ns
, NSSM_EVENT_RFTID_SENT
);
3868 bfa_fcs_lport_ns_rft_id_response(void *fcsarg
, struct bfa_fcxp_s
*fcxp
,
3869 void *cbarg
, bfa_status_t req_status
,
3870 u32 rsp_len
, u32 resid_len
,
3871 struct fchs_s
*rsp_fchs
)
3873 struct bfa_fcs_lport_ns_s
*ns
= (struct bfa_fcs_lport_ns_s
*) cbarg
;
3874 struct bfa_fcs_lport_s
*port
= ns
->port
;
3875 struct ct_hdr_s
*cthdr
= NULL
;
3877 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
3882 if (req_status
!= BFA_STATUS_OK
) {
3883 bfa_trc(port
->fcs
, req_status
);
3884 port
->stats
.ns_rftid_rsp_err
++;
3885 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_ERROR
);
3889 cthdr
= (struct ct_hdr_s
*) BFA_FCXP_RSP_PLD(fcxp
);
3890 cthdr
->cmd_rsp_code
= bfa_os_ntohs(cthdr
->cmd_rsp_code
);
3892 if (cthdr
->cmd_rsp_code
== CT_RSP_ACCEPT
) {
3893 port
->stats
.ns_rftid_accepts
++;
3894 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_OK
);
3898 port
->stats
.ns_rftid_rejects
++;
3899 bfa_trc(port
->fcs
, cthdr
->reason_code
);
3900 bfa_trc(port
->fcs
, cthdr
->exp_code
);
3901 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_ERROR
);
3905 * Register FC4-Features : Should be done after RFT_ID
3908 bfa_fcs_lport_ns_send_rff_id(void *ns_cbarg
, struct bfa_fcxp_s
*fcxp_alloced
)
3910 struct bfa_fcs_lport_ns_s
*ns
= ns_cbarg
;
3911 struct bfa_fcs_lport_s
*port
= ns
->port
;
3914 struct bfa_fcxp_s
*fcxp
;
3917 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
3919 fcxp
= fcxp_alloced
? fcxp_alloced
: bfa_fcs_fcxp_alloc(port
->fcs
);
3921 port
->stats
.ns_rffid_alloc_wait
++;
3922 bfa_fcs_fcxp_alloc_wait(port
->fcs
->bfa
, &ns
->fcxp_wqe
,
3923 bfa_fcs_lport_ns_send_rff_id
, ns
);
3928 if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns
->port
))
3929 fc4_ftrs
= FC_GS_FCP_FC4_FEATURE_INITIATOR
;
3931 len
= fc_rffid_build(&fchs
, bfa_fcxp_get_reqbuf(fcxp
),
3932 bfa_fcs_lport_get_fcid(port
), 0,
3933 FC_TYPE_FCP
, fc4_ftrs
);
3935 bfa_fcxp_send(fcxp
, NULL
, port
->fabric
->vf_id
, port
->lp_tag
, BFA_FALSE
,
3936 FC_CLASS_3
, len
, &fchs
,
3937 bfa_fcs_lport_ns_rff_id_response
, (void *)ns
,
3938 FC_MAX_PDUSZ
, FC_FCCT_TOV
);
3940 port
->stats
.ns_rffid_sent
++;
3941 bfa_sm_send_event(ns
, NSSM_EVENT_RFFID_SENT
);
3945 bfa_fcs_lport_ns_rff_id_response(void *fcsarg
, struct bfa_fcxp_s
*fcxp
,
3946 void *cbarg
, bfa_status_t req_status
,
3947 u32 rsp_len
, u32 resid_len
,
3948 struct fchs_s
*rsp_fchs
)
3950 struct bfa_fcs_lport_ns_s
*ns
= (struct bfa_fcs_lport_ns_s
*) cbarg
;
3951 struct bfa_fcs_lport_s
*port
= ns
->port
;
3952 struct ct_hdr_s
*cthdr
= NULL
;
3954 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
3959 if (req_status
!= BFA_STATUS_OK
) {
3960 bfa_trc(port
->fcs
, req_status
);
3961 port
->stats
.ns_rffid_rsp_err
++;
3962 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_ERROR
);
3966 cthdr
= (struct ct_hdr_s
*) BFA_FCXP_RSP_PLD(fcxp
);
3967 cthdr
->cmd_rsp_code
= bfa_os_ntohs(cthdr
->cmd_rsp_code
);
3969 if (cthdr
->cmd_rsp_code
== CT_RSP_ACCEPT
) {
3970 port
->stats
.ns_rffid_accepts
++;
3971 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_OK
);
3975 port
->stats
.ns_rffid_rejects
++;
3976 bfa_trc(port
->fcs
, cthdr
->reason_code
);
3977 bfa_trc(port
->fcs
, cthdr
->exp_code
);
3979 if (cthdr
->reason_code
== CT_RSN_NOT_SUPP
) {
3980 /* if this command is not supported, we don't retry */
3981 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_OK
);
3983 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_ERROR
);
3986 * Query Fabric for FC4-Types Devices.
3988 * TBD : Need to use a local (FCS private) response buffer, since the response
3989 * can be larger than 2K.
3992 bfa_fcs_lport_ns_send_gid_ft(void *ns_cbarg
, struct bfa_fcxp_s
*fcxp_alloced
)
3994 struct bfa_fcs_lport_ns_s
*ns
= ns_cbarg
;
3995 struct bfa_fcs_lport_s
*port
= ns
->port
;
3998 struct bfa_fcxp_s
*fcxp
;
4000 bfa_trc(port
->fcs
, port
->pid
);
4002 fcxp
= fcxp_alloced
? fcxp_alloced
: bfa_fcs_fcxp_alloc(port
->fcs
);
4004 port
->stats
.ns_gidft_alloc_wait
++;
4005 bfa_fcs_fcxp_alloc_wait(port
->fcs
->bfa
, &ns
->fcxp_wqe
,
4006 bfa_fcs_lport_ns_send_gid_ft
, ns
);
4012 * This query is only initiated for FCP initiator mode.
4014 len
= fc_gid_ft_build(&fchs
, bfa_fcxp_get_reqbuf(fcxp
),
4015 ns
->port
->pid
, FC_TYPE_FCP
);
4017 bfa_fcxp_send(fcxp
, NULL
, port
->fabric
->vf_id
, port
->lp_tag
, BFA_FALSE
,
4018 FC_CLASS_3
, len
, &fchs
,
4019 bfa_fcs_lport_ns_gid_ft_response
, (void *)ns
,
4020 bfa_fcxp_get_maxrsp(port
->fcs
->bfa
), FC_FCCT_TOV
);
4022 port
->stats
.ns_gidft_sent
++;
4024 bfa_sm_send_event(ns
, NSSM_EVENT_GIDFT_SENT
);
4028 bfa_fcs_lport_ns_gid_ft_response(void *fcsarg
, struct bfa_fcxp_s
*fcxp
,
4029 void *cbarg
, bfa_status_t req_status
,
4030 u32 rsp_len
, u32 resid_len
,
4031 struct fchs_s
*rsp_fchs
)
4033 struct bfa_fcs_lport_ns_s
*ns
= (struct bfa_fcs_lport_ns_s
*) cbarg
;
4034 struct bfa_fcs_lport_s
*port
= ns
->port
;
4035 struct ct_hdr_s
*cthdr
= NULL
;
4038 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
4043 if (req_status
!= BFA_STATUS_OK
) {
4044 bfa_trc(port
->fcs
, req_status
);
4045 port
->stats
.ns_gidft_rsp_err
++;
4046 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_ERROR
);
4050 if (resid_len
!= 0) {
4052 * TBD : we will need to allocate a larger buffer & retry the
4055 bfa_trc(port
->fcs
, rsp_len
);
4056 bfa_trc(port
->fcs
, resid_len
);
4060 cthdr
= (struct ct_hdr_s
*) BFA_FCXP_RSP_PLD(fcxp
);
4061 cthdr
->cmd_rsp_code
= bfa_os_ntohs(cthdr
->cmd_rsp_code
);
4063 switch (cthdr
->cmd_rsp_code
) {
4067 port
->stats
.ns_gidft_accepts
++;
4068 n_pids
= (fc_get_ctresp_pyld_len(rsp_len
) / sizeof(u32
));
4069 bfa_trc(port
->fcs
, n_pids
);
4070 bfa_fcs_lport_ns_process_gidft_pids(port
,
4071 (u32
*) (cthdr
+ 1),
4073 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_OK
);
4079 * Check the reason code & explanation.
4080 * There may not have been any FC4 devices in the fabric
4082 port
->stats
.ns_gidft_rejects
++;
4083 bfa_trc(port
->fcs
, cthdr
->reason_code
);
4084 bfa_trc(port
->fcs
, cthdr
->exp_code
);
4086 if ((cthdr
->reason_code
== CT_RSN_UNABLE_TO_PERF
)
4087 && (cthdr
->exp_code
== CT_NS_EXP_FT_NOT_REG
)) {
4089 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_OK
);
4092 * for all other errors, retry
4094 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_ERROR
);
4099 port
->stats
.ns_gidft_unknown_rsp
++;
4100 bfa_trc(port
->fcs
, cthdr
->cmd_rsp_code
);
4101 bfa_sm_send_event(ns
, NSSM_EVENT_RSP_ERROR
);
4106 * This routine will be called by bfa_timer on timer timeouts.
4108 * param[in] port - pointer to bfa_fcs_lport_t.
4113 * Special Considerations:
4118 bfa_fcs_lport_ns_timeout(void *arg
)
4120 struct bfa_fcs_lport_ns_s
*ns
= (struct bfa_fcs_lport_ns_s
*) arg
;
4122 ns
->port
->stats
.ns_timeouts
++;
4123 bfa_sm_send_event(ns
, NSSM_EVENT_TIMEOUT
);
4127 * Process the PID list in GID_FT response
4130 bfa_fcs_lport_ns_process_gidft_pids(struct bfa_fcs_lport_s
*port
, u32
*pid_buf
,
4133 struct fcgs_gidft_resp_s
*gidft_entry
;
4134 struct bfa_fcs_rport_s
*rport
;
4137 for (ii
= 0; ii
< n_pids
; ii
++) {
4138 gidft_entry
= (struct fcgs_gidft_resp_s
*) &pid_buf
[ii
];
4140 if (gidft_entry
->pid
== port
->pid
)
4144 * Check if this rport already exists
4146 rport
= bfa_fcs_lport_get_rport_by_pid(port
, gidft_entry
->pid
);
4147 if (rport
== NULL
) {
4149 * this is a new device. create rport
4151 rport
= bfa_fcs_rport_create(port
, gidft_entry
->pid
);
4154 * this rport already exists
4156 bfa_fcs_rport_scn(rport
);
4159 bfa_trc(port
->fcs
, gidft_entry
->pid
);
4162 * if the last entry bit is set, bail out.
4164 if (gidft_entry
->last
)
4170 * fcs_ns_public FCS nameserver public interfaces
4174 * Functions called by port/fab.
4175 * These will send relevant Events to the ns state machine.
4178 bfa_fcs_lport_ns_init(struct bfa_fcs_lport_s
*port
)
4180 struct bfa_fcs_lport_ns_s
*ns
= BFA_FCS_GET_NS_FROM_PORT(port
);
4183 bfa_sm_set_state(ns
, bfa_fcs_lport_ns_sm_offline
);
4187 bfa_fcs_lport_ns_offline(struct bfa_fcs_lport_s
*port
)
4189 struct bfa_fcs_lport_ns_s
*ns
= BFA_FCS_GET_NS_FROM_PORT(port
);
4192 bfa_sm_send_event(ns
, NSSM_EVENT_PORT_OFFLINE
);
4196 bfa_fcs_lport_ns_online(struct bfa_fcs_lport_s
*port
)
4198 struct bfa_fcs_lport_ns_s
*ns
= BFA_FCS_GET_NS_FROM_PORT(port
);
4201 bfa_sm_send_event(ns
, NSSM_EVENT_PORT_ONLINE
);
4205 bfa_fcs_lport_ns_query(struct bfa_fcs_lport_s
*port
)
4207 struct bfa_fcs_lport_ns_s
*ns
= BFA_FCS_GET_NS_FROM_PORT(port
);
4209 bfa_trc(port
->fcs
, port
->pid
);
4210 bfa_sm_send_event(ns
, NSSM_EVENT_NS_QUERY
);
4214 bfa_fcs_lport_ns_boot_target_disc(bfa_fcs_lport_t
*port
)
4217 struct bfa_fcs_rport_s
*rport
;
4219 wwn_t wwns
[BFA_PREBOOT_BOOTLUN_MAX
];
4222 bfa_iocfc_get_bootwwns(port
->fcs
->bfa
, &nwwns
, wwns
);
4224 for (ii
= 0 ; ii
< nwwns
; ++ii
) {
4225 rport
= bfa_fcs_rport_create_by_wwn(port
, wwns
[ii
]);
4234 #define FC_QOS_RSCN_EVENT 0x0c
4235 #define FC_FABRIC_NAME_RSCN_EVENT 0x0d
4238 * forward declarations
4240 static void bfa_fcs_lport_scn_send_scr(void *scn_cbarg
,
4241 struct bfa_fcxp_s
*fcxp_alloced
);
4242 static void bfa_fcs_lport_scn_scr_response(void *fcsarg
,
4243 struct bfa_fcxp_s
*fcxp
,
4245 bfa_status_t req_status
,
4248 struct fchs_s
*rsp_fchs
);
4249 static void bfa_fcs_lport_scn_send_ls_acc(struct bfa_fcs_lport_s
*port
,
4250 struct fchs_s
*rx_fchs
);
4251 static void bfa_fcs_lport_scn_timeout(void *arg
);
4254 * fcs_scm_sm FCS SCN state machine
4258 * VPort SCN State Machine events
4260 enum port_scn_event
{
4261 SCNSM_EVENT_PORT_ONLINE
= 1,
4262 SCNSM_EVENT_PORT_OFFLINE
= 2,
4263 SCNSM_EVENT_RSP_OK
= 3,
4264 SCNSM_EVENT_RSP_ERROR
= 4,
4265 SCNSM_EVENT_TIMEOUT
= 5,
4266 SCNSM_EVENT_SCR_SENT
= 6,
4269 static void bfa_fcs_lport_scn_sm_offline(struct bfa_fcs_lport_scn_s
*scn
,
4270 enum port_scn_event event
);
4271 static void bfa_fcs_lport_scn_sm_sending_scr(
4272 struct bfa_fcs_lport_scn_s
*scn
,
4273 enum port_scn_event event
);
4274 static void bfa_fcs_lport_scn_sm_scr(struct bfa_fcs_lport_scn_s
*scn
,
4275 enum port_scn_event event
);
4276 static void bfa_fcs_lport_scn_sm_scr_retry(struct bfa_fcs_lport_scn_s
*scn
,
4277 enum port_scn_event event
);
4278 static void bfa_fcs_lport_scn_sm_online(struct bfa_fcs_lport_scn_s
*scn
,
4279 enum port_scn_event event
);
4282 * Starting state - awaiting link up.
4285 bfa_fcs_lport_scn_sm_offline(struct bfa_fcs_lport_scn_s
*scn
,
4286 enum port_scn_event event
)
4289 case SCNSM_EVENT_PORT_ONLINE
:
4290 bfa_sm_set_state(scn
, bfa_fcs_lport_scn_sm_sending_scr
);
4291 bfa_fcs_lport_scn_send_scr(scn
, NULL
);
4294 case SCNSM_EVENT_PORT_OFFLINE
:
4298 bfa_sm_fault(scn
->port
->fcs
, event
);
4303 bfa_fcs_lport_scn_sm_sending_scr(struct bfa_fcs_lport_scn_s
*scn
,
4304 enum port_scn_event event
)
4307 case SCNSM_EVENT_SCR_SENT
:
4308 bfa_sm_set_state(scn
, bfa_fcs_lport_scn_sm_scr
);
4311 case SCNSM_EVENT_PORT_OFFLINE
:
4312 bfa_sm_set_state(scn
, bfa_fcs_lport_scn_sm_offline
);
4313 bfa_fcxp_walloc_cancel(scn
->port
->fcs
->bfa
, &scn
->fcxp_wqe
);
4317 bfa_sm_fault(scn
->port
->fcs
, event
);
4322 bfa_fcs_lport_scn_sm_scr(struct bfa_fcs_lport_scn_s
*scn
,
4323 enum port_scn_event event
)
4325 struct bfa_fcs_lport_s
*port
= scn
->port
;
4328 case SCNSM_EVENT_RSP_OK
:
4329 bfa_sm_set_state(scn
, bfa_fcs_lport_scn_sm_online
);
4332 case SCNSM_EVENT_RSP_ERROR
:
4333 bfa_sm_set_state(scn
, bfa_fcs_lport_scn_sm_scr_retry
);
4334 bfa_timer_start(port
->fcs
->bfa
, &scn
->timer
,
4335 bfa_fcs_lport_scn_timeout
, scn
,
4336 BFA_FCS_RETRY_TIMEOUT
);
4339 case SCNSM_EVENT_PORT_OFFLINE
:
4340 bfa_sm_set_state(scn
, bfa_fcs_lport_scn_sm_offline
);
4341 bfa_fcxp_discard(scn
->fcxp
);
4345 bfa_sm_fault(port
->fcs
, event
);
4350 bfa_fcs_lport_scn_sm_scr_retry(struct bfa_fcs_lport_scn_s
*scn
,
4351 enum port_scn_event event
)
4354 case SCNSM_EVENT_TIMEOUT
:
4355 bfa_sm_set_state(scn
, bfa_fcs_lport_scn_sm_sending_scr
);
4356 bfa_fcs_lport_scn_send_scr(scn
, NULL
);
4359 case SCNSM_EVENT_PORT_OFFLINE
:
4360 bfa_sm_set_state(scn
, bfa_fcs_lport_scn_sm_offline
);
4361 bfa_timer_stop(&scn
->timer
);
4365 bfa_sm_fault(scn
->port
->fcs
, event
);
4370 bfa_fcs_lport_scn_sm_online(struct bfa_fcs_lport_scn_s
*scn
,
4371 enum port_scn_event event
)
4374 case SCNSM_EVENT_PORT_OFFLINE
:
4375 bfa_sm_set_state(scn
, bfa_fcs_lport_scn_sm_offline
);
4379 bfa_sm_fault(scn
->port
->fcs
, event
);
4386 * fcs_scn_private FCS SCN private functions
4390 * This routine will be called to send a SCR command.
4393 bfa_fcs_lport_scn_send_scr(void *scn_cbarg
, struct bfa_fcxp_s
*fcxp_alloced
)
4395 struct bfa_fcs_lport_scn_s
*scn
= scn_cbarg
;
4396 struct bfa_fcs_lport_s
*port
= scn
->port
;
4399 struct bfa_fcxp_s
*fcxp
;
4401 bfa_trc(port
->fcs
, port
->pid
);
4402 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
4404 fcxp
= fcxp_alloced
? fcxp_alloced
: bfa_fcs_fcxp_alloc(port
->fcs
);
4406 bfa_fcs_fcxp_alloc_wait(port
->fcs
->bfa
, &scn
->fcxp_wqe
,
4407 bfa_fcs_lport_scn_send_scr
, scn
);
4412 /* Handle VU registrations for Base port only */
4413 if ((!port
->vport
) && bfa_ioc_get_fcmode(&port
->fcs
->bfa
->ioc
)) {
4414 len
= fc_scr_build(&fchs
, bfa_fcxp_get_reqbuf(fcxp
),
4415 bfa_lps_is_brcd_fabric(port
->fabric
->lps
),
4418 len
= fc_scr_build(&fchs
, bfa_fcxp_get_reqbuf(fcxp
),
4423 bfa_fcxp_send(fcxp
, NULL
, port
->fabric
->vf_id
, port
->lp_tag
, BFA_FALSE
,
4424 FC_CLASS_3
, len
, &fchs
,
4425 bfa_fcs_lport_scn_scr_response
,
4426 (void *)scn
, FC_MAX_PDUSZ
, FC_ELS_TOV
);
4428 bfa_sm_send_event(scn
, SCNSM_EVENT_SCR_SENT
);
4432 bfa_fcs_lport_scn_scr_response(void *fcsarg
, struct bfa_fcxp_s
*fcxp
,
4433 void *cbarg
, bfa_status_t req_status
, u32 rsp_len
,
4434 u32 resid_len
, struct fchs_s
*rsp_fchs
)
4436 struct bfa_fcs_lport_scn_s
*scn
= (struct bfa_fcs_lport_scn_s
*) cbarg
;
4437 struct bfa_fcs_lport_s
*port
= scn
->port
;
4438 struct fc_els_cmd_s
*els_cmd
;
4439 struct fc_ls_rjt_s
*ls_rjt
;
4441 bfa_trc(port
->fcs
, port
->port_cfg
.pwwn
);
4446 if (req_status
!= BFA_STATUS_OK
) {
4447 bfa_trc(port
->fcs
, req_status
);
4448 bfa_sm_send_event(scn
, SCNSM_EVENT_RSP_ERROR
);
4452 els_cmd
= (struct fc_els_cmd_s
*) BFA_FCXP_RSP_PLD(fcxp
);
4454 switch (els_cmd
->els_code
) {
4457 bfa_sm_send_event(scn
, SCNSM_EVENT_RSP_OK
);
4462 ls_rjt
= (struct fc_ls_rjt_s
*) BFA_FCXP_RSP_PLD(fcxp
);
4464 bfa_trc(port
->fcs
, ls_rjt
->reason_code
);
4465 bfa_trc(port
->fcs
, ls_rjt
->reason_code_expl
);
4467 bfa_sm_send_event(scn
, SCNSM_EVENT_RSP_ERROR
);
4471 bfa_sm_send_event(scn
, SCNSM_EVENT_RSP_ERROR
);
4479 bfa_fcs_lport_scn_send_ls_acc(struct bfa_fcs_lport_s
*port
,
4480 struct fchs_s
*rx_fchs
)
4483 struct bfa_fcxp_s
*fcxp
;
4484 struct bfa_rport_s
*bfa_rport
= NULL
;
4487 bfa_trc(port
->fcs
, rx_fchs
->s_id
);
4489 fcxp
= bfa_fcs_fcxp_alloc(port
->fcs
);
4493 len
= fc_ls_acc_build(&fchs
, bfa_fcxp_get_reqbuf(fcxp
),
4494 rx_fchs
->s_id
, bfa_fcs_lport_get_fcid(port
),
4497 bfa_fcxp_send(fcxp
, bfa_rport
, port
->fabric
->vf_id
, port
->lp_tag
,
4498 BFA_FALSE
, FC_CLASS_3
, len
, &fchs
, NULL
, NULL
,
4503 * This routine will be called by bfa_timer on timer timeouts.
4505 * param[in] vport - pointer to bfa_fcs_lport_t.
4506 * param[out] vport_status - pointer to return vport status in
4511 * Special Considerations:
4516 bfa_fcs_lport_scn_timeout(void *arg
)
4518 struct bfa_fcs_lport_scn_s
*scn
= (struct bfa_fcs_lport_scn_s
*) arg
;
4520 bfa_sm_send_event(scn
, SCNSM_EVENT_TIMEOUT
);
4526 * fcs_scn_public FCS state change notification public interfaces
4530 * Functions called by port/fab
4533 bfa_fcs_lport_scn_init(struct bfa_fcs_lport_s
*port
)
4535 struct bfa_fcs_lport_scn_s
*scn
= BFA_FCS_GET_SCN_FROM_PORT(port
);
4538 bfa_sm_set_state(scn
, bfa_fcs_lport_scn_sm_offline
);
4542 bfa_fcs_lport_scn_offline(struct bfa_fcs_lport_s
*port
)
4544 struct bfa_fcs_lport_scn_s
*scn
= BFA_FCS_GET_SCN_FROM_PORT(port
);
4547 bfa_sm_send_event(scn
, SCNSM_EVENT_PORT_OFFLINE
);
4551 bfa_fcs_lport_scn_online(struct bfa_fcs_lport_s
*port
)
4553 struct bfa_fcs_lport_scn_s
*scn
= BFA_FCS_GET_SCN_FROM_PORT(port
);
4556 bfa_sm_send_event(scn
, SCNSM_EVENT_PORT_ONLINE
);
4560 bfa_fcs_lport_scn_portid_rscn(struct bfa_fcs_lport_s
*port
, u32 rpid
)
4562 struct bfa_fcs_rport_s
*rport
;
4564 bfa_trc(port
->fcs
, rpid
);
4567 * If this is an unknown device, then it just came online.
4568 * Otherwise let rport handle the RSCN event.
4570 rport
= bfa_fcs_lport_get_rport_by_pid(port
, rpid
);
4571 if (rport
== NULL
) {
4573 * If min cfg mode is enabled, we donot need to
4574 * discover any new rports.
4576 if (!__fcs_min_cfg(port
->fcs
))
4577 rport
= bfa_fcs_rport_create(port
, rpid
);
4579 bfa_fcs_rport_scn(rport
);
4583 * rscn format based PID comparison
4585 #define __fc_pid_match(__c0, __c1, __fmt) \
4586 (((__fmt) == FC_RSCN_FORMAT_FABRIC) || \
4587 (((__fmt) == FC_RSCN_FORMAT_DOMAIN) && \
4588 ((__c0)[0] == (__c1)[0])) || \
4589 (((__fmt) == FC_RSCN_FORMAT_AREA) && \
4590 ((__c0)[0] == (__c1)[0]) && \
4591 ((__c0)[1] == (__c1)[1])))
4594 bfa_fcs_lport_scn_multiport_rscn(struct bfa_fcs_lport_s
*port
,
4595 enum fc_rscn_format format
,
4598 struct bfa_fcs_rport_s
*rport
;
4599 struct list_head
*qe
, *qe_next
;
4602 bfa_trc(port
->fcs
, format
);
4603 bfa_trc(port
->fcs
, rscn_pid
);
4605 c0
= (u8
*) &rscn_pid
;
4607 list_for_each_safe(qe
, qe_next
, &port
->rport_q
) {
4608 rport
= (struct bfa_fcs_rport_s
*) qe
;
4609 c1
= (u8
*) &rport
->pid
;
4610 if (__fc_pid_match(c0
, c1
, format
))
4611 bfa_fcs_rport_scn(rport
);
4617 bfa_fcs_lport_scn_process_rscn(struct bfa_fcs_lport_s
*port
,
4618 struct fchs_s
*fchs
, u32 len
)
4620 struct fc_rscn_pl_s
*rscn
= (struct fc_rscn_pl_s
*) (fchs
+ 1);
4623 bfa_boolean_t nsquery
= BFA_FALSE
, found
;
4627 (bfa_os_ntohs(rscn
->payldlen
) -
4628 sizeof(u32
)) / sizeof(rscn
->event
[0]);
4630 bfa_trc(port
->fcs
, num_entries
);
4632 port
->stats
.num_rscn
++;
4634 bfa_fcs_lport_scn_send_ls_acc(port
, fchs
);
4636 for (i
= 0; i
< num_entries
; i
++) {
4637 rscn_pid
= rscn
->event
[i
].portid
;
4639 bfa_trc(port
->fcs
, rscn
->event
[i
].format
);
4640 bfa_trc(port
->fcs
, rscn_pid
);
4642 /* check for duplicate entries in the list */
4644 for (j
= 0; j
< i
; j
++) {
4645 if (rscn
->event
[j
].portid
== rscn_pid
) {
4651 /* if found in down the list, pid has been already processed */
4653 bfa_trc(port
->fcs
, rscn_pid
);
4657 switch (rscn
->event
[i
].format
) {
4658 case FC_RSCN_FORMAT_PORTID
:
4659 if (rscn
->event
[i
].qualifier
== FC_QOS_RSCN_EVENT
) {
4661 * Ignore this event.
4662 * f/w would have processed it
4664 bfa_trc(port
->fcs
, rscn_pid
);
4666 port
->stats
.num_portid_rscn
++;
4667 bfa_fcs_lport_scn_portid_rscn(port
, rscn_pid
);
4671 case FC_RSCN_FORMAT_FABRIC
:
4672 if (rscn
->event
[i
].qualifier
==
4673 FC_FABRIC_NAME_RSCN_EVENT
) {
4674 bfa_fcs_lport_ms_fabric_rscn(port
);
4677 /* !!!!!!!!! Fall Through !!!!!!!!!!!!! */
4679 case FC_RSCN_FORMAT_AREA
:
4680 case FC_RSCN_FORMAT_DOMAIN
:
4682 bfa_fcs_lport_scn_multiport_rscn(port
,
4683 rscn
->event
[i
].format
,
4695 * If any of area, domain or fabric RSCN is received, do a fresh discovery
4696 * to find new devices.
4699 bfa_fcs_lport_ns_query(port
);
4706 * fcs_port_api BFA FCS port API
4708 struct bfa_fcs_lport_s
*
4709 bfa_fcs_get_base_port(struct bfa_fcs_s
*fcs
)
4711 return &fcs
->fabric
.bport
;
4715 bfa_fcs_lport_get_rport(struct bfa_fcs_lport_s
*port
, wwn_t wwn
, int index
,
4716 int nrports
, bfa_boolean_t bwwn
)
4718 struct list_head
*qh
, *qe
;
4719 struct bfa_fcs_rport_s
*rport
= NULL
;
4721 struct bfa_fcs_s
*fcs
;
4723 if (port
== NULL
|| nrports
== 0)
4727 bfa_trc(fcs
, (u32
) nrports
);
4730 qh
= &port
->rport_q
;
4731 qe
= bfa_q_first(qh
);
4733 while ((qe
!= qh
) && (i
< nrports
)) {
4734 rport
= (struct bfa_fcs_rport_s
*) qe
;
4735 if (bfa_os_ntoh3b(rport
->pid
) > 0xFFF000) {
4736 qe
= bfa_q_next(qe
);
4737 bfa_trc(fcs
, (u32
) rport
->pwwn
);
4738 bfa_trc(fcs
, rport
->pid
);
4744 if (!memcmp(&wwn
, &rport
->pwwn
, 8))
4752 qe
= bfa_q_next(qe
);
4763 bfa_fcs_lport_get_rports(struct bfa_fcs_lport_s
*port
,
4764 wwn_t rport_wwns
[], int *nrports
)
4766 struct list_head
*qh
, *qe
;
4767 struct bfa_fcs_rport_s
*rport
= NULL
;
4769 struct bfa_fcs_s
*fcs
;
4771 if (port
== NULL
|| rport_wwns
== NULL
|| *nrports
== 0)
4775 bfa_trc(fcs
, (u32
) *nrports
);
4778 qh
= &port
->rport_q
;
4779 qe
= bfa_q_first(qh
);
4781 while ((qe
!= qh
) && (i
< *nrports
)) {
4782 rport
= (struct bfa_fcs_rport_s
*) qe
;
4783 if (bfa_os_ntoh3b(rport
->pid
) > 0xFFF000) {
4784 qe
= bfa_q_next(qe
);
4785 bfa_trc(fcs
, (u32
) rport
->pwwn
);
4786 bfa_trc(fcs
, rport
->pid
);
4791 rport_wwns
[i
] = rport
->pwwn
;
4794 qe
= bfa_q_next(qe
);
4802 * Iterate's through all the rport's in the given port to
4803 * determine the maximum operating speed.
4805 * !!!! To be used in TRL Functionality only !!!!
4808 bfa_fcs_lport_get_rport_max_speed(bfa_fcs_lport_t
*port
)
4810 struct list_head
*qh
, *qe
;
4811 struct bfa_fcs_rport_s
*rport
= NULL
;
4812 struct bfa_fcs_s
*fcs
;
4813 bfa_port_speed_t max_speed
= 0;
4814 struct bfa_port_attr_s port_attr
;
4815 bfa_port_speed_t port_speed
, rport_speed
;
4816 bfa_boolean_t trl_enabled
= bfa_fcport_is_ratelim(port
->fcs
->bfa
);
4824 /* Get Physical port's current speed */
4825 bfa_fcport_get_attr(port
->fcs
->bfa
, &port_attr
);
4826 port_speed
= port_attr
.speed
;
4827 bfa_trc(fcs
, port_speed
);
4829 qh
= &port
->rport_q
;
4830 qe
= bfa_q_first(qh
);
4833 rport
= (struct bfa_fcs_rport_s
*) qe
;
4834 if ((bfa_os_ntoh3b(rport
->pid
) > 0xFFF000) ||
4835 (bfa_fcs_rport_get_state(rport
) ==
4836 BFA_RPORT_OFFLINE
)) {
4837 qe
= bfa_q_next(qe
);
4841 rport_speed
= rport
->rpf
.rpsc_speed
;
4842 if ((trl_enabled
) && (rport_speed
==
4843 BFA_PORT_SPEED_UNKNOWN
)) {
4844 /* Use default ratelim speed setting */
4846 bfa_fcport_get_ratelim_speed(port
->fcs
->bfa
);
4849 if ((rport_speed
== BFA_PORT_SPEED_8GBPS
) ||
4850 (rport_speed
> port_speed
)) {
4851 max_speed
= rport_speed
;
4853 } else if (rport_speed
> max_speed
) {
4854 max_speed
= rport_speed
;
4857 qe
= bfa_q_next(qe
);
4860 bfa_trc(fcs
, max_speed
);
4864 struct bfa_fcs_lport_s
*
4865 bfa_fcs_lookup_port(struct bfa_fcs_s
*fcs
, u16 vf_id
, wwn_t lpwwn
)
4867 struct bfa_fcs_vport_s
*vport
;
4870 bfa_assert(fcs
!= NULL
);
4872 vf
= bfa_fcs_vf_lookup(fcs
, vf_id
);
4874 bfa_trc(fcs
, vf_id
);
4878 if (!lpwwn
|| (vf
->bport
.port_cfg
.pwwn
== lpwwn
))
4881 vport
= bfa_fcs_fabric_vport_lookup(vf
, lpwwn
);
4883 return &vport
->lport
;
4889 * API corresponding to NPIV_VPORT_GETINFO.
4892 bfa_fcs_lport_get_info(struct bfa_fcs_lport_s
*port
,
4893 struct bfa_lport_info_s
*port_info
)
4896 bfa_trc(port
->fcs
, port
->fabric
->fabric_name
);
4898 if (port
->vport
== NULL
) {
4900 * This is a Physical port
4902 port_info
->port_type
= BFA_LPORT_TYPE_PHYSICAL
;
4905 * @todo : need to fix the state & reason
4907 port_info
->port_state
= 0;
4908 port_info
->offline_reason
= 0;
4910 port_info
->port_wwn
= bfa_fcs_lport_get_pwwn(port
);
4911 port_info
->node_wwn
= bfa_fcs_lport_get_nwwn(port
);
4913 port_info
->max_vports_supp
=
4914 bfa_lps_get_max_vport(port
->fcs
->bfa
);
4915 port_info
->num_vports_inuse
=
4916 bfa_fcs_fabric_vport_count(port
->fabric
);
4917 port_info
->max_rports_supp
= BFA_FCS_MAX_RPORTS_SUPP
;
4918 port_info
->num_rports_inuse
= port
->num_rports
;
4921 * This is a virtual port
4923 port_info
->port_type
= BFA_LPORT_TYPE_VIRTUAL
;
4926 * @todo : need to fix the state & reason
4928 port_info
->port_state
= 0;
4929 port_info
->offline_reason
= 0;
4931 port_info
->port_wwn
= bfa_fcs_lport_get_pwwn(port
);
4932 port_info
->node_wwn
= bfa_fcs_lport_get_nwwn(port
);
4937 bfa_fcs_lport_get_stats(struct bfa_fcs_lport_s
*fcs_port
,
4938 struct bfa_lport_stats_s
*port_stats
)
4940 *port_stats
= fcs_port
->stats
;
4944 bfa_fcs_lport_clear_stats(struct bfa_fcs_lport_s
*fcs_port
)
4946 bfa_os_memset(&fcs_port
->stats
, 0, sizeof(struct bfa_lport_stats_s
));
4950 * FCS virtual port state machine
4953 #define __vport_fcs(__vp) ((__vp)->lport.fcs)
4954 #define __vport_pwwn(__vp) ((__vp)->lport.port_cfg.pwwn)
4955 #define __vport_nwwn(__vp) ((__vp)->lport.port_cfg.nwwn)
4956 #define __vport_bfa(__vp) ((__vp)->lport.fcs->bfa)
4957 #define __vport_fcid(__vp) ((__vp)->lport.pid)
4958 #define __vport_fabric(__vp) ((__vp)->lport.fabric)
4959 #define __vport_vfid(__vp) ((__vp)->lport.fabric->vf_id)
4961 #define BFA_FCS_VPORT_MAX_RETRIES 5
4963 * Forward declarations
4965 static void bfa_fcs_vport_do_fdisc(struct bfa_fcs_vport_s
*vport
);
4966 static void bfa_fcs_vport_timeout(void *vport_arg
);
4967 static void bfa_fcs_vport_do_logo(struct bfa_fcs_vport_s
*vport
);
4968 static void bfa_fcs_vport_free(struct bfa_fcs_vport_s
*vport
);
4971 * fcs_vport_sm FCS virtual port state machine
4975 * VPort State Machine events
4977 enum bfa_fcs_vport_event
{
4978 BFA_FCS_VPORT_SM_CREATE
= 1, /* vport create event */
4979 BFA_FCS_VPORT_SM_DELETE
= 2, /* vport delete event */
4980 BFA_FCS_VPORT_SM_START
= 3, /* vport start request */
4981 BFA_FCS_VPORT_SM_STOP
= 4, /* stop: unsupported */
4982 BFA_FCS_VPORT_SM_ONLINE
= 5, /* fabric online */
4983 BFA_FCS_VPORT_SM_OFFLINE
= 6, /* fabric offline event */
4984 BFA_FCS_VPORT_SM_FRMSENT
= 7, /* fdisc/logo sent events */
4985 BFA_FCS_VPORT_SM_RSP_OK
= 8, /* good response */
4986 BFA_FCS_VPORT_SM_RSP_ERROR
= 9, /* error/bad response */
4987 BFA_FCS_VPORT_SM_TIMEOUT
= 10, /* delay timer event */
4988 BFA_FCS_VPORT_SM_DELCOMP
= 11, /* lport delete completion */
4989 BFA_FCS_VPORT_SM_RSP_DUP_WWN
= 12, /* Dup wnn error*/
4990 BFA_FCS_VPORT_SM_RSP_FAILED
= 13, /* non-retryable failure */
4993 static void bfa_fcs_vport_sm_uninit(struct bfa_fcs_vport_s
*vport
,
4994 enum bfa_fcs_vport_event event
);
4995 static void bfa_fcs_vport_sm_created(struct bfa_fcs_vport_s
*vport
,
4996 enum bfa_fcs_vport_event event
);
4997 static void bfa_fcs_vport_sm_offline(struct bfa_fcs_vport_s
*vport
,
4998 enum bfa_fcs_vport_event event
);
4999 static void bfa_fcs_vport_sm_fdisc(struct bfa_fcs_vport_s
*vport
,
5000 enum bfa_fcs_vport_event event
);
5001 static void bfa_fcs_vport_sm_fdisc_retry(struct bfa_fcs_vport_s
*vport
,
5002 enum bfa_fcs_vport_event event
);
5003 static void bfa_fcs_vport_sm_online(struct bfa_fcs_vport_s
*vport
,
5004 enum bfa_fcs_vport_event event
);
5005 static void bfa_fcs_vport_sm_deleting(struct bfa_fcs_vport_s
*vport
,
5006 enum bfa_fcs_vport_event event
);
5007 static void bfa_fcs_vport_sm_cleanup(struct bfa_fcs_vport_s
*vport
,
5008 enum bfa_fcs_vport_event event
);
5009 static void bfa_fcs_vport_sm_logo(struct bfa_fcs_vport_s
*vport
,
5010 enum bfa_fcs_vport_event event
);
5011 static void bfa_fcs_vport_sm_error(struct bfa_fcs_vport_s
*vport
,
5012 enum bfa_fcs_vport_event event
);
5014 static struct bfa_sm_table_s vport_sm_table
[] = {
5015 {BFA_SM(bfa_fcs_vport_sm_uninit
), BFA_FCS_VPORT_UNINIT
},
5016 {BFA_SM(bfa_fcs_vport_sm_created
), BFA_FCS_VPORT_CREATED
},
5017 {BFA_SM(bfa_fcs_vport_sm_offline
), BFA_FCS_VPORT_OFFLINE
},
5018 {BFA_SM(bfa_fcs_vport_sm_fdisc
), BFA_FCS_VPORT_FDISC
},
5019 {BFA_SM(bfa_fcs_vport_sm_fdisc_retry
), BFA_FCS_VPORT_FDISC_RETRY
},
5020 {BFA_SM(bfa_fcs_vport_sm_online
), BFA_FCS_VPORT_ONLINE
},
5021 {BFA_SM(bfa_fcs_vport_sm_deleting
), BFA_FCS_VPORT_DELETING
},
5022 {BFA_SM(bfa_fcs_vport_sm_cleanup
), BFA_FCS_VPORT_CLEANUP
},
5023 {BFA_SM(bfa_fcs_vport_sm_logo
), BFA_FCS_VPORT_LOGO
},
5024 {BFA_SM(bfa_fcs_vport_sm_error
), BFA_FCS_VPORT_ERROR
}
5031 bfa_fcs_vport_sm_uninit(struct bfa_fcs_vport_s
*vport
,
5032 enum bfa_fcs_vport_event event
)
5034 bfa_trc(__vport_fcs(vport
), __vport_pwwn(vport
));
5035 bfa_trc(__vport_fcs(vport
), event
);
5038 case BFA_FCS_VPORT_SM_CREATE
:
5039 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_created
);
5040 bfa_fcs_fabric_addvport(__vport_fabric(vport
), vport
);
5044 bfa_sm_fault(__vport_fcs(vport
), event
);
5049 * Created state - a start event is required to start up the state machine.
5052 bfa_fcs_vport_sm_created(struct bfa_fcs_vport_s
*vport
,
5053 enum bfa_fcs_vport_event event
)
5055 bfa_trc(__vport_fcs(vport
), __vport_pwwn(vport
));
5056 bfa_trc(__vport_fcs(vport
), event
);
5059 case BFA_FCS_VPORT_SM_START
:
5060 if (bfa_fcs_fabric_is_online(__vport_fabric(vport
))
5061 && bfa_fcs_fabric_npiv_capable(__vport_fabric(vport
))) {
5062 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_fdisc
);
5063 bfa_fcs_vport_do_fdisc(vport
);
5066 * Fabric is offline or not NPIV capable, stay in
5069 vport
->vport_stats
.fab_no_npiv
++;
5070 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_offline
);
5074 case BFA_FCS_VPORT_SM_DELETE
:
5075 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_cleanup
);
5076 bfa_fcs_lport_delete(&vport
->lport
);
5079 case BFA_FCS_VPORT_SM_ONLINE
:
5080 case BFA_FCS_VPORT_SM_OFFLINE
:
5082 * Ignore ONLINE/OFFLINE events from fabric
5083 * till vport is started.
5088 bfa_sm_fault(__vport_fcs(vport
), event
);
5093 * Offline state - awaiting ONLINE event from fabric SM.
5096 bfa_fcs_vport_sm_offline(struct bfa_fcs_vport_s
*vport
,
5097 enum bfa_fcs_vport_event event
)
5099 bfa_trc(__vport_fcs(vport
), __vport_pwwn(vport
));
5100 bfa_trc(__vport_fcs(vport
), event
);
5103 case BFA_FCS_VPORT_SM_DELETE
:
5104 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_cleanup
);
5105 bfa_fcs_lport_delete(&vport
->lport
);
5108 case BFA_FCS_VPORT_SM_ONLINE
:
5109 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_fdisc
);
5110 vport
->fdisc_retries
= 0;
5111 bfa_fcs_vport_do_fdisc(vport
);
5114 case BFA_FCS_VPORT_SM_OFFLINE
:
5116 * This can happen if the vport couldn't be initialzied
5117 * due the fact that the npiv was not enabled on the switch.
5118 * In that case we will put the vport in offline state.
5119 * However, the link can go down and cause the this event to
5120 * be sent when we are already offline. Ignore it.
5125 bfa_sm_fault(__vport_fcs(vport
), event
);
5131 * FDISC is sent and awaiting reply from fabric.
5134 bfa_fcs_vport_sm_fdisc(struct bfa_fcs_vport_s
*vport
,
5135 enum bfa_fcs_vport_event event
)
5137 bfa_trc(__vport_fcs(vport
), __vport_pwwn(vport
));
5138 bfa_trc(__vport_fcs(vport
), event
);
5141 case BFA_FCS_VPORT_SM_DELETE
:
5142 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_cleanup
);
5143 bfa_lps_discard(vport
->lps
);
5144 bfa_fcs_lport_delete(&vport
->lport
);
5147 case BFA_FCS_VPORT_SM_OFFLINE
:
5148 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_offline
);
5149 bfa_lps_discard(vport
->lps
);
5152 case BFA_FCS_VPORT_SM_RSP_OK
:
5153 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_online
);
5154 bfa_fcs_lport_online(&vport
->lport
);
5157 case BFA_FCS_VPORT_SM_RSP_ERROR
:
5158 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_fdisc_retry
);
5159 bfa_timer_start(__vport_bfa(vport
), &vport
->timer
,
5160 bfa_fcs_vport_timeout
, vport
,
5161 BFA_FCS_RETRY_TIMEOUT
);
5164 case BFA_FCS_VPORT_SM_RSP_FAILED
:
5165 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_offline
);
5168 case BFA_FCS_VPORT_SM_RSP_DUP_WWN
:
5169 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_error
);
5173 bfa_sm_fault(__vport_fcs(vport
), event
);
5178 * FDISC attempt failed - a timer is active to retry FDISC.
5181 bfa_fcs_vport_sm_fdisc_retry(struct bfa_fcs_vport_s
*vport
,
5182 enum bfa_fcs_vport_event event
)
5184 bfa_trc(__vport_fcs(vport
), __vport_pwwn(vport
));
5185 bfa_trc(__vport_fcs(vport
), event
);
5188 case BFA_FCS_VPORT_SM_DELETE
:
5189 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_cleanup
);
5190 bfa_timer_stop(&vport
->timer
);
5191 bfa_fcs_lport_delete(&vport
->lport
);
5194 case BFA_FCS_VPORT_SM_OFFLINE
:
5195 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_offline
);
5196 bfa_timer_stop(&vport
->timer
);
5199 case BFA_FCS_VPORT_SM_TIMEOUT
:
5200 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_fdisc
);
5201 vport
->vport_stats
.fdisc_retries
++;
5202 vport
->fdisc_retries
++;
5203 bfa_fcs_vport_do_fdisc(vport
);
5207 bfa_sm_fault(__vport_fcs(vport
), event
);
5212 * Vport is online (FDISC is complete).
5215 bfa_fcs_vport_sm_online(struct bfa_fcs_vport_s
*vport
,
5216 enum bfa_fcs_vport_event event
)
5218 bfa_trc(__vport_fcs(vport
), __vport_pwwn(vport
));
5219 bfa_trc(__vport_fcs(vport
), event
);
5222 case BFA_FCS_VPORT_SM_DELETE
:
5223 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_deleting
);
5224 bfa_fcs_lport_delete(&vport
->lport
);
5227 case BFA_FCS_VPORT_SM_OFFLINE
:
5228 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_offline
);
5229 bfa_lps_discard(vport
->lps
);
5230 bfa_fcs_lport_offline(&vport
->lport
);
5234 bfa_sm_fault(__vport_fcs(vport
), event
);
5239 * Vport is being deleted - awaiting lport delete completion to send
5243 bfa_fcs_vport_sm_deleting(struct bfa_fcs_vport_s
*vport
,
5244 enum bfa_fcs_vport_event event
)
5246 bfa_trc(__vport_fcs(vport
), __vport_pwwn(vport
));
5247 bfa_trc(__vport_fcs(vport
), event
);
5250 case BFA_FCS_VPORT_SM_DELETE
:
5253 case BFA_FCS_VPORT_SM_DELCOMP
:
5254 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_logo
);
5255 bfa_fcs_vport_do_logo(vport
);
5258 case BFA_FCS_VPORT_SM_OFFLINE
:
5259 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_cleanup
);
5263 bfa_sm_fault(__vport_fcs(vport
), event
);
5269 * This state will be set when the Vport Creation fails due
5270 * to errors like Dup WWN. In this state only operation allowed
5271 * is a Vport Delete.
5274 bfa_fcs_vport_sm_error(struct bfa_fcs_vport_s
*vport
,
5275 enum bfa_fcs_vport_event event
)
5277 bfa_trc(__vport_fcs(vport
), __vport_pwwn(vport
));
5278 bfa_trc(__vport_fcs(vport
), event
);
5281 case BFA_FCS_VPORT_SM_DELETE
:
5282 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_cleanup
);
5283 bfa_fcs_lport_delete(&vport
->lport
);
5287 bfa_trc(__vport_fcs(vport
), event
);
5292 * Lport cleanup is in progress since vport is being deleted. Fabric is
5293 * offline, so no LOGO is needed to complete vport deletion.
5296 bfa_fcs_vport_sm_cleanup(struct bfa_fcs_vport_s
*vport
,
5297 enum bfa_fcs_vport_event event
)
5299 bfa_trc(__vport_fcs(vport
), __vport_pwwn(vport
));
5300 bfa_trc(__vport_fcs(vport
), event
);
5303 case BFA_FCS_VPORT_SM_DELCOMP
:
5304 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_uninit
);
5305 bfa_fcs_vport_free(vport
);
5308 case BFA_FCS_VPORT_SM_DELETE
:
5312 bfa_sm_fault(__vport_fcs(vport
), event
);
5317 * LOGO is sent to fabric. Vport delete is in progress. Lport delete cleanup
5321 bfa_fcs_vport_sm_logo(struct bfa_fcs_vport_s
*vport
,
5322 enum bfa_fcs_vport_event event
)
5324 bfa_trc(__vport_fcs(vport
), __vport_pwwn(vport
));
5325 bfa_trc(__vport_fcs(vport
), event
);
5328 case BFA_FCS_VPORT_SM_OFFLINE
:
5329 bfa_lps_discard(vport
->lps
);
5331 * !!! fall through !!!
5334 case BFA_FCS_VPORT_SM_RSP_OK
:
5335 case BFA_FCS_VPORT_SM_RSP_ERROR
:
5336 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_uninit
);
5337 bfa_fcs_vport_free(vport
);
5340 case BFA_FCS_VPORT_SM_DELETE
:
5344 bfa_sm_fault(__vport_fcs(vport
), event
);
5351 * fcs_vport_private FCS virtual port private functions
5354 * This routine will be called to send a FDISC command.
5357 bfa_fcs_vport_do_fdisc(struct bfa_fcs_vport_s
*vport
)
5359 bfa_lps_fdisc(vport
->lps
, vport
,
5360 bfa_fcport_get_maxfrsize(__vport_bfa(vport
)),
5361 __vport_pwwn(vport
), __vport_nwwn(vport
));
5362 vport
->vport_stats
.fdisc_sent
++;
5366 bfa_fcs_vport_fdisc_rejected(struct bfa_fcs_vport_s
*vport
)
5368 u8 lsrjt_rsn
= bfa_lps_get_lsrjt_rsn(vport
->lps
);
5369 u8 lsrjt_expl
= bfa_lps_get_lsrjt_expl(vport
->lps
);
5371 bfa_trc(__vport_fcs(vport
), lsrjt_rsn
);
5372 bfa_trc(__vport_fcs(vport
), lsrjt_expl
);
5374 /* For certain reason codes, we don't want to retry. */
5375 switch (bfa_lps_get_lsrjt_expl(vport
->lps
)) {
5376 case FC_LS_RJT_EXP_INV_PORT_NAME
: /* by brocade */
5377 case FC_LS_RJT_EXP_INVALID_NPORT_ID
: /* by Cisco */
5378 if (vport
->fdisc_retries
< BFA_FCS_VPORT_MAX_RETRIES
)
5379 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_RSP_ERROR
);
5381 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_RSP_DUP_WWN
);
5384 case FC_LS_RJT_EXP_INSUFF_RES
:
5386 * This means max logins per port/switch setting on the
5387 * switch was exceeded.
5389 if (vport
->fdisc_retries
< BFA_FCS_VPORT_MAX_RETRIES
)
5390 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_RSP_ERROR
);
5392 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_RSP_FAILED
);
5396 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_RSP_ERROR
);
5401 * Called to send a logout to the fabric. Used when a V-Port is
5405 bfa_fcs_vport_do_logo(struct bfa_fcs_vport_s
*vport
)
5407 bfa_trc(__vport_fcs(vport
), __vport_pwwn(vport
));
5409 vport
->vport_stats
.logo_sent
++;
5410 bfa_lps_fdisclogo(vport
->lps
);
5415 * This routine will be called by bfa_timer on timer timeouts.
5417 * param[in] vport - pointer to bfa_fcs_vport_t.
5418 * param[out] vport_status - pointer to return vport status in
5423 * Special Considerations:
5428 bfa_fcs_vport_timeout(void *vport_arg
)
5430 struct bfa_fcs_vport_s
*vport
= (struct bfa_fcs_vport_s
*) vport_arg
;
5432 vport
->vport_stats
.fdisc_timeouts
++;
5433 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_TIMEOUT
);
5437 bfa_fcs_vport_free(struct bfa_fcs_vport_s
*vport
)
5439 struct bfad_vport_s
*vport_drv
=
5440 (struct bfad_vport_s
*)vport
->vport_drv
;
5442 bfa_fcs_fabric_delvport(__vport_fabric(vport
), vport
);
5444 if (vport_drv
->comp_del
)
5445 complete(vport_drv
->comp_del
);
5447 bfa_lps_delete(vport
->lps
);
5453 * fcs_vport_public FCS virtual port public interfaces
5457 * Online notification from fabric SM.
5460 bfa_fcs_vport_online(struct bfa_fcs_vport_s
*vport
)
5462 vport
->vport_stats
.fab_online
++;
5463 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_ONLINE
);
5467 * Offline notification from fabric SM.
5470 bfa_fcs_vport_offline(struct bfa_fcs_vport_s
*vport
)
5472 vport
->vport_stats
.fab_offline
++;
5473 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_OFFLINE
);
5477 * Cleanup notification from fabric SM on link timer expiry.
5480 bfa_fcs_vport_cleanup(struct bfa_fcs_vport_s
*vport
)
5482 vport
->vport_stats
.fab_cleanup
++;
5485 * delete notification from fabric SM. To be invoked from within FCS.
5488 bfa_fcs_vport_fcs_delete(struct bfa_fcs_vport_s
*vport
)
5490 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_DELETE
);
5494 * Delete completion callback from associated lport
5497 bfa_fcs_vport_delete_comp(struct bfa_fcs_vport_s
*vport
)
5499 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_DELCOMP
);
5505 * fcs_vport_api Virtual port API
5509 * Use this function to instantiate a new FCS vport object. This
5510 * function will not trigger any HW initialization process (which will be
5511 * done in vport_start() call)
5513 * param[in] vport - pointer to bfa_fcs_vport_t. This space
5514 * needs to be allocated by the driver.
5515 * param[in] fcs - FCS instance
5516 * param[in] vport_cfg - vport configuration
5517 * param[in] vf_id - VF_ID if vport is created within a VF.
5518 * FC_VF_ID_NULL to specify base fabric.
5519 * param[in] vport_drv - Opaque handle back to the driver's vport
5522 * retval BFA_STATUS_OK - on success.
5523 * retval BFA_STATUS_FAILED - on failure.
5526 bfa_fcs_vport_create(struct bfa_fcs_vport_s
*vport
, struct bfa_fcs_s
*fcs
,
5527 u16 vf_id
, struct bfa_lport_cfg_s
*vport_cfg
,
5528 struct bfad_vport_s
*vport_drv
)
5530 if (vport_cfg
->pwwn
== 0)
5531 return BFA_STATUS_INVALID_WWN
;
5533 if (bfa_fcs_lport_get_pwwn(&fcs
->fabric
.bport
) == vport_cfg
->pwwn
)
5534 return BFA_STATUS_VPORT_WWN_BP
;
5536 if (bfa_fcs_vport_lookup(fcs
, vf_id
, vport_cfg
->pwwn
) != NULL
)
5537 return BFA_STATUS_VPORT_EXISTS
;
5539 if (bfa_fcs_fabric_vport_count(&fcs
->fabric
) ==
5540 bfa_lps_get_max_vport(fcs
->bfa
))
5541 return BFA_STATUS_VPORT_MAX
;
5543 vport
->lps
= bfa_lps_alloc(fcs
->bfa
);
5545 return BFA_STATUS_VPORT_MAX
;
5547 vport
->vport_drv
= vport_drv
;
5548 vport_cfg
->preboot_vp
= BFA_FALSE
;
5550 bfa_sm_set_state(vport
, bfa_fcs_vport_sm_uninit
);
5551 bfa_fcs_lport_attach(&vport
->lport
, fcs
, vf_id
, vport
);
5552 bfa_fcs_lport_init(&vport
->lport
, vport_cfg
);
5553 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_CREATE
);
5555 return BFA_STATUS_OK
;
5559 * Use this function to instantiate a new FCS PBC vport object. This
5560 * function will not trigger any HW initialization process (which will be
5561 * done in vport_start() call)
5563 * param[in] vport - pointer to bfa_fcs_vport_t. This space
5564 * needs to be allocated by the driver.
5565 * param[in] fcs - FCS instance
5566 * param[in] vport_cfg - vport configuration
5567 * param[in] vf_id - VF_ID if vport is created within a VF.
5568 * FC_VF_ID_NULL to specify base fabric.
5569 * param[in] vport_drv - Opaque handle back to the driver's vport
5572 * retval BFA_STATUS_OK - on success.
5573 * retval BFA_STATUS_FAILED - on failure.
5576 bfa_fcs_pbc_vport_create(struct bfa_fcs_vport_s
*vport
, struct bfa_fcs_s
*fcs
,
5577 u16 vf_id
, struct bfa_lport_cfg_s
*vport_cfg
,
5578 struct bfad_vport_s
*vport_drv
)
5582 rc
= bfa_fcs_vport_create(vport
, fcs
, vf_id
, vport_cfg
, vport_drv
);
5583 vport
->lport
.port_cfg
.preboot_vp
= BFA_TRUE
;
5589 * Use this function to findout if this is a pbc vport or not.
5591 * @param[in] vport - pointer to bfa_fcs_vport_t.
5596 bfa_fcs_is_pbc_vport(struct bfa_fcs_vport_s
*vport
)
5599 if (vport
&& (vport
->lport
.port_cfg
.preboot_vp
== BFA_TRUE
))
5607 * Use this function initialize the vport.
5609 * @param[in] vport - pointer to bfa_fcs_vport_t.
5614 bfa_fcs_vport_start(struct bfa_fcs_vport_s
*vport
)
5616 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_START
);
5618 return BFA_STATUS_OK
;
5622 * Use this function quiese the vport object. This function will return
5623 * immediately, when the vport is actually stopped, the
5624 * bfa_drv_vport_stop_cb() will be called.
5626 * param[in] vport - pointer to bfa_fcs_vport_t.
5631 bfa_fcs_vport_stop(struct bfa_fcs_vport_s
*vport
)
5633 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_STOP
);
5635 return BFA_STATUS_OK
;
5639 * Use this function to delete a vport object. Fabric object should
5640 * be stopped before this function call.
5642 * !!!!!!! Donot invoke this from within FCS !!!!!!!
5644 * param[in] vport - pointer to bfa_fcs_vport_t.
5649 bfa_fcs_vport_delete(struct bfa_fcs_vport_s
*vport
)
5652 if (vport
->lport
.port_cfg
.preboot_vp
)
5653 return BFA_STATUS_PBC
;
5655 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_DELETE
);
5657 return BFA_STATUS_OK
;
5661 * Use this function to get vport's current status info.
5663 * param[in] vport pointer to bfa_fcs_vport_t.
5664 * param[out] attr pointer to return vport attributes
5669 bfa_fcs_vport_get_attr(struct bfa_fcs_vport_s
*vport
,
5670 struct bfa_vport_attr_s
*attr
)
5672 if (vport
== NULL
|| attr
== NULL
)
5675 bfa_os_memset(attr
, 0, sizeof(struct bfa_vport_attr_s
));
5677 bfa_fcs_lport_get_attr(&vport
->lport
, &attr
->port_attr
);
5678 attr
->vport_state
= bfa_sm_to_state(vport_sm_table
, vport
->sm
);
5682 * Use this function to get vport's statistics.
5684 * param[in] vport pointer to bfa_fcs_vport_t.
5685 * param[out] stats pointer to return vport statistics in
5690 bfa_fcs_vport_get_stats(struct bfa_fcs_vport_s
*vport
,
5691 struct bfa_vport_stats_s
*stats
)
5693 *stats
= vport
->vport_stats
;
5697 * Use this function to clear vport's statistics.
5699 * param[in] vport pointer to bfa_fcs_vport_t.
5704 bfa_fcs_vport_clr_stats(struct bfa_fcs_vport_s
*vport
)
5706 bfa_os_memset(&vport
->vport_stats
, 0, sizeof(struct bfa_vport_stats_s
));
5710 * Lookup a virtual port. Excludes base port from lookup.
5712 struct bfa_fcs_vport_s
*
5713 bfa_fcs_vport_lookup(struct bfa_fcs_s
*fcs
, u16 vf_id
, wwn_t vpwwn
)
5715 struct bfa_fcs_vport_s
*vport
;
5716 struct bfa_fcs_fabric_s
*fabric
;
5718 bfa_trc(fcs
, vf_id
);
5719 bfa_trc(fcs
, vpwwn
);
5721 fabric
= bfa_fcs_vf_lookup(fcs
, vf_id
);
5723 bfa_trc(fcs
, vf_id
);
5727 vport
= bfa_fcs_fabric_vport_lookup(fabric
, vpwwn
);
5735 bfa_cb_lps_fdisc_comp(void *bfad
, void *uarg
, bfa_status_t status
)
5737 struct bfa_fcs_vport_s
*vport
= uarg
;
5739 bfa_trc(__vport_fcs(vport
), __vport_pwwn(vport
));
5740 bfa_trc(__vport_fcs(vport
), status
);
5745 * Initialize the V-Port fields
5747 __vport_fcid(vport
) = bfa_lps_get_pid(vport
->lps
);
5748 vport
->vport_stats
.fdisc_accepts
++;
5749 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_RSP_OK
);
5752 case BFA_STATUS_INVALID_MAC
:
5754 vport
->vport_stats
.fdisc_acc_bad
++;
5755 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_RSP_ERROR
);
5759 case BFA_STATUS_EPROTOCOL
:
5760 switch (bfa_lps_get_extstatus(vport
->lps
)) {
5761 case BFA_EPROTO_BAD_ACCEPT
:
5762 vport
->vport_stats
.fdisc_acc_bad
++;
5765 case BFA_EPROTO_UNKNOWN_RSP
:
5766 vport
->vport_stats
.fdisc_unknown_rsp
++;
5773 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_RSP_ERROR
);
5776 case BFA_STATUS_FABRIC_RJT
:
5777 vport
->vport_stats
.fdisc_rejects
++;
5778 bfa_fcs_vport_fdisc_rejected(vport
);
5782 vport
->vport_stats
.fdisc_rsp_err
++;
5783 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_RSP_ERROR
);
5791 bfa_cb_lps_fdisclogo_comp(void *bfad
, void *uarg
)
5793 struct bfa_fcs_vport_s
*vport
= uarg
;
5794 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_RSP_OK
);
5798 * Received clear virtual link
5801 bfa_cb_lps_cvl_event(void *bfad
, void *uarg
)
5803 struct bfa_fcs_vport_s
*vport
= uarg
;
5805 /* Send an Offline followed by an ONLINE */
5806 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_OFFLINE
);
5807 bfa_sm_send_event(vport
, BFA_FCS_VPORT_SM_ONLINE
);