]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - drivers/scsi/bfa/bfa_fcs_lport.c
projects / mirror_ubuntu-hirsute-kernel.git / blob
? search:


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