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