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