aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/bfa/bfa_fcport.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/scsi/bfa/bfa_fcport.c')
-rw-r--r--drivers/scsi/bfa/bfa_fcport.c1962
1 files changed, 0 insertions, 1962 deletions
diff --git a/drivers/scsi/bfa/bfa_fcport.c b/drivers/scsi/bfa/bfa_fcport.c
deleted file mode 100644
index 76867b5577fa..000000000000
--- a/drivers/scsi/bfa/bfa_fcport.c
+++ /dev/null
@@ -1,1962 +0,0 @@
1/*
2 * Copyright (c) 2005-2009 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#include <bfa.h>
19#include <bfa_svc.h>
20#include <bfi/bfi_pport.h>
21#include <bfi/bfi_pbc.h>
22#include <cs/bfa_debug.h>
23#include <aen/bfa_aen.h>
24#include <cs/bfa_plog.h>
25#include <aen/bfa_aen_port.h>
26
27BFA_TRC_FILE(HAL, FCPORT);
28BFA_MODULE(fcport);
29
30/*
31 * The port is considered disabled if corresponding physical port or IOC are
32 * disabled explicitly
33 */
34#define BFA_PORT_IS_DISABLED(bfa) \
35 ((bfa_fcport_is_disabled(bfa) == BFA_TRUE) || \
36 (bfa_ioc_is_disabled(&bfa->ioc) == BFA_TRUE))
37
38/*
39 * forward declarations
40 */
41static bfa_boolean_t bfa_fcport_send_enable(struct bfa_fcport_s *fcport);
42static bfa_boolean_t bfa_fcport_send_disable(struct bfa_fcport_s *fcport);
43static void bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport);
44static void bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport);
45static void bfa_fcport_set_wwns(struct bfa_fcport_s *fcport);
46static void __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete);
47static void bfa_fcport_callback(struct bfa_fcport_s *fcport,
48 enum bfa_pport_linkstate event);
49static void bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln,
50 enum bfa_pport_linkstate event);
51static void __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete);
52static void bfa_fcport_stats_get_timeout(void *cbarg);
53static void bfa_fcport_stats_clr_timeout(void *cbarg);
54
55/**
56 * bfa_pport_private
57 */
58
59/**
60 * BFA port state machine events
61 */
62enum bfa_fcport_sm_event {
63 BFA_FCPORT_SM_START = 1, /* start port state machine */
64 BFA_FCPORT_SM_STOP = 2, /* stop port state machine */
65 BFA_FCPORT_SM_ENABLE = 3, /* enable port */
66 BFA_FCPORT_SM_DISABLE = 4, /* disable port state machine */
67 BFA_FCPORT_SM_FWRSP = 5, /* firmware enable/disable rsp */
68 BFA_FCPORT_SM_LINKUP = 6, /* firmware linkup event */
69 BFA_FCPORT_SM_LINKDOWN = 7, /* firmware linkup down */
70 BFA_FCPORT_SM_QRESUME = 8, /* CQ space available */
71 BFA_FCPORT_SM_HWFAIL = 9, /* IOC h/w failure */
72};
73
74/**
75 * BFA port link notification state machine events
76 */
77
78enum bfa_fcport_ln_sm_event {
79 BFA_FCPORT_LN_SM_LINKUP = 1, /* linkup event */
80 BFA_FCPORT_LN_SM_LINKDOWN = 2, /* linkdown event */
81 BFA_FCPORT_LN_SM_NOTIFICATION = 3 /* done notification */
82};
83
84static void bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
85 enum bfa_fcport_sm_event event);
86static void bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
87 enum bfa_fcport_sm_event event);
88static void bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
89 enum bfa_fcport_sm_event event);
90static void bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
91 enum bfa_fcport_sm_event event);
92static void bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
93 enum bfa_fcport_sm_event event);
94static void bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
95 enum bfa_fcport_sm_event event);
96static void bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
97 enum bfa_fcport_sm_event event);
98static void bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
99 enum bfa_fcport_sm_event event);
100static void bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
101 enum bfa_fcport_sm_event event);
102static void bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
103 enum bfa_fcport_sm_event event);
104static void bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
105 enum bfa_fcport_sm_event event);
106
107static void bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
108 enum bfa_fcport_ln_sm_event event);
109static void bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
110 enum bfa_fcport_ln_sm_event event);
111static void bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
112 enum bfa_fcport_ln_sm_event event);
113static void bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
114 enum bfa_fcport_ln_sm_event event);
115static void bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
116 enum bfa_fcport_ln_sm_event event);
117static void bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
118 enum bfa_fcport_ln_sm_event event);
119static void bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
120 enum bfa_fcport_ln_sm_event event);
121
122static struct bfa_sm_table_s hal_pport_sm_table[] = {
123 {BFA_SM(bfa_fcport_sm_uninit), BFA_PPORT_ST_UNINIT},
124 {BFA_SM(bfa_fcport_sm_enabling_qwait), BFA_PPORT_ST_ENABLING_QWAIT},
125 {BFA_SM(bfa_fcport_sm_enabling), BFA_PPORT_ST_ENABLING},
126 {BFA_SM(bfa_fcport_sm_linkdown), BFA_PPORT_ST_LINKDOWN},
127 {BFA_SM(bfa_fcport_sm_linkup), BFA_PPORT_ST_LINKUP},
128 {BFA_SM(bfa_fcport_sm_disabling_qwait), BFA_PPORT_ST_DISABLING_QWAIT},
129 {BFA_SM(bfa_fcport_sm_disabling), BFA_PPORT_ST_DISABLING},
130 {BFA_SM(bfa_fcport_sm_disabled), BFA_PPORT_ST_DISABLED},
131 {BFA_SM(bfa_fcport_sm_stopped), BFA_PPORT_ST_STOPPED},
132 {BFA_SM(bfa_fcport_sm_iocdown), BFA_PPORT_ST_IOCDOWN},
133 {BFA_SM(bfa_fcport_sm_iocfail), BFA_PPORT_ST_IOCDOWN},
134};
135
136static void
137bfa_fcport_aen_post(struct bfa_fcport_s *fcport, enum bfa_port_aen_event event)
138{
139 union bfa_aen_data_u aen_data;
140 struct bfa_log_mod_s *logmod = fcport->bfa->logm;
141 wwn_t pwwn = fcport->pwwn;
142 char pwwn_ptr[BFA_STRING_32];
143
144 memset(&aen_data, 0, sizeof(aen_data));
145 wwn2str(pwwn_ptr, pwwn);
146 bfa_log(logmod, BFA_LOG_CREATE_ID(BFA_AEN_CAT_PORT, event), pwwn_ptr);
147
148 aen_data.port.ioc_type = bfa_get_type(fcport->bfa);
149 aen_data.port.pwwn = pwwn;
150}
151
152static void
153bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
154 enum bfa_fcport_sm_event event)
155{
156 bfa_trc(fcport->bfa, event);
157
158 switch (event) {
159 case BFA_FCPORT_SM_START:
160 /**
161 * Start event after IOC is configured and BFA is started.
162 */
163 if (bfa_fcport_send_enable(fcport))
164 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
165 else
166 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling_qwait);
167 break;
168
169 case BFA_FCPORT_SM_ENABLE:
170 /**
171 * Port is persistently configured to be in enabled state. Do
172 * not change state. Port enabling is done when START event is
173 * received.
174 */
175 break;
176
177 case BFA_FCPORT_SM_DISABLE:
178 /**
179 * If a port is persistently configured to be disabled, the
180 * first event will a port disable request.
181 */
182 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
183 break;
184
185 case BFA_FCPORT_SM_HWFAIL:
186 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
187 break;
188
189 default:
190 bfa_sm_fault(fcport->bfa, event);
191 }
192}
193
194static void
195bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
196 enum bfa_fcport_sm_event event)
197{
198 bfa_trc(fcport->bfa, event);
199
200 switch (event) {
201 case BFA_FCPORT_SM_QRESUME:
202 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
203 bfa_fcport_send_enable(fcport);
204 break;
205
206 case BFA_FCPORT_SM_STOP:
207 bfa_reqq_wcancel(&fcport->reqq_wait);
208 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
209 break;
210
211 case BFA_FCPORT_SM_ENABLE:
212 /**
213 * Already enable is in progress.
214 */
215 break;
216
217 case BFA_FCPORT_SM_DISABLE:
218 /**
219 * Just send disable request to firmware when room becomes
220 * available in request queue.
221 */
222 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
223 bfa_reqq_wcancel(&fcport->reqq_wait);
224 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
225 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
226 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
227 break;
228
229 case BFA_FCPORT_SM_LINKUP:
230 case BFA_FCPORT_SM_LINKDOWN:
231 /**
232 * Possible to get link events when doing back-to-back
233 * enable/disables.
234 */
235 break;
236
237 case BFA_FCPORT_SM_HWFAIL:
238 bfa_reqq_wcancel(&fcport->reqq_wait);
239 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
240 break;
241
242 default:
243 bfa_sm_fault(fcport->bfa, event);
244 }
245}
246
247static void
248bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
249 enum bfa_fcport_sm_event event)
250{
251 bfa_trc(fcport->bfa, event);
252
253 switch (event) {
254 case BFA_FCPORT_SM_FWRSP:
255 case BFA_FCPORT_SM_LINKDOWN:
256 bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
257 break;
258
259 case BFA_FCPORT_SM_LINKUP:
260 bfa_fcport_update_linkinfo(fcport);
261 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
262
263 bfa_assert(fcport->event_cbfn);
264 bfa_fcport_callback(fcport, BFA_PPORT_LINKUP);
265 break;
266
267 case BFA_FCPORT_SM_ENABLE:
268 /**
269 * Already being enabled.
270 */
271 break;
272
273 case BFA_FCPORT_SM_DISABLE:
274 if (bfa_fcport_send_disable(fcport))
275 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
276 else
277 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
278
279 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
280 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
281 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
282 break;
283
284 case BFA_FCPORT_SM_STOP:
285 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
286 break;
287
288 case BFA_FCPORT_SM_HWFAIL:
289 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
290 break;
291
292 default:
293 bfa_sm_fault(fcport->bfa, event);
294 }
295}
296
297static void
298bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
299 enum bfa_fcport_sm_event event)
300{
301 struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
302 bfa_trc(fcport->bfa, event);
303
304 switch (event) {
305 case BFA_FCPORT_SM_LINKUP:
306 bfa_fcport_update_linkinfo(fcport);
307 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
308 bfa_assert(fcport->event_cbfn);
309 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
310 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkup");
311
312 if (!bfa_ioc_get_fcmode(&fcport->bfa->ioc)) {
313
314 bfa_trc(fcport->bfa,
315 pevent->link_state.vc_fcf.fcf.fipenabled);
316 bfa_trc(fcport->bfa,
317 pevent->link_state.vc_fcf.fcf.fipfailed);
318
319 if (pevent->link_state.vc_fcf.fcf.fipfailed)
320 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
321 BFA_PL_EID_FIP_FCF_DISC, 0,
322 "FIP FCF Discovery Failed");
323 else
324 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
325 BFA_PL_EID_FIP_FCF_DISC, 0,
326 "FIP FCF Discovered");
327 }
328
329 bfa_fcport_callback(fcport, BFA_PPORT_LINKUP);
330 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ONLINE);
331 /**
332 * If QoS is enabled and it is not online,
333 * Send a separate event.
334 */
335 if ((fcport->cfg.qos_enabled)
336 && (bfa_os_ntohl(fcport->qos_attr.state) != BFA_QOS_ONLINE))
337 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_QOS_NEG);
338
339 break;
340
341 case BFA_FCPORT_SM_LINKDOWN:
342 /**
343 * Possible to get link down event.
344 */
345 break;
346
347 case BFA_FCPORT_SM_ENABLE:
348 /**
349 * Already enabled.
350 */
351 break;
352
353 case BFA_FCPORT_SM_DISABLE:
354 if (bfa_fcport_send_disable(fcport))
355 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
356 else
357 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
358
359 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
360 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
361 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
362 break;
363
364 case BFA_FCPORT_SM_STOP:
365 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
366 break;
367
368 case BFA_FCPORT_SM_HWFAIL:
369 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
370 break;
371
372 default:
373 bfa_sm_fault(fcport->bfa, event);
374 }
375}
376
377static void
378bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
379 enum bfa_fcport_sm_event event)
380{
381 bfa_trc(fcport->bfa, event);
382
383 switch (event) {
384 case BFA_FCPORT_SM_ENABLE:
385 /**
386 * Already enabled.
387 */
388 break;
389
390 case BFA_FCPORT_SM_DISABLE:
391 if (bfa_fcport_send_disable(fcport))
392 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
393 else
394 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
395
396 bfa_fcport_reset_linkinfo(fcport);
397 bfa_fcport_callback(fcport, BFA_PPORT_LINKDOWN);
398 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
399 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
400 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
401 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
402 break;
403
404 case BFA_FCPORT_SM_LINKDOWN:
405 bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
406 bfa_fcport_reset_linkinfo(fcport);
407 bfa_fcport_callback(fcport, BFA_PPORT_LINKDOWN);
408 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
409 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkdown");
410 if (BFA_PORT_IS_DISABLED(fcport->bfa))
411 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
412 else
413 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
414 break;
415
416 case BFA_FCPORT_SM_STOP:
417 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
418 bfa_fcport_reset_linkinfo(fcport);
419 if (BFA_PORT_IS_DISABLED(fcport->bfa))
420 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
421 else
422 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
423 break;
424
425 case BFA_FCPORT_SM_HWFAIL:
426 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
427 bfa_fcport_reset_linkinfo(fcport);
428 bfa_fcport_callback(fcport, BFA_PPORT_LINKDOWN);
429 if (BFA_PORT_IS_DISABLED(fcport->bfa))
430 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
431 else
432 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
433 break;
434
435 default:
436 bfa_sm_fault(fcport->bfa, event);
437 }
438}
439
440static void
441bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
442 enum bfa_fcport_sm_event event)
443{
444 bfa_trc(fcport->bfa, event);
445
446 switch (event) {
447 case BFA_FCPORT_SM_QRESUME:
448 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
449 bfa_fcport_send_disable(fcport);
450 break;
451
452 case BFA_FCPORT_SM_STOP:
453 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
454 bfa_reqq_wcancel(&fcport->reqq_wait);
455 break;
456
457 case BFA_FCPORT_SM_DISABLE:
458 /**
459 * Already being disabled.
460 */
461 break;
462
463 case BFA_FCPORT_SM_LINKUP:
464 case BFA_FCPORT_SM_LINKDOWN:
465 /**
466 * Possible to get link events when doing back-to-back
467 * enable/disables.
468 */
469 break;
470
471 case BFA_FCPORT_SM_HWFAIL:
472 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
473 bfa_reqq_wcancel(&fcport->reqq_wait);
474 break;
475
476 default:
477 bfa_sm_fault(fcport->bfa, event);
478 }
479}
480
481static void
482bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
483 enum bfa_fcport_sm_event event)
484{
485 bfa_trc(fcport->bfa, event);
486
487 switch (event) {
488 case BFA_FCPORT_SM_FWRSP:
489 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
490 break;
491
492 case BFA_FCPORT_SM_DISABLE:
493 /**
494 * Already being disabled.
495 */
496 break;
497
498 case BFA_FCPORT_SM_ENABLE:
499 if (bfa_fcport_send_enable(fcport))
500 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
501 else
502 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling_qwait);
503
504 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
505 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
506 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE);
507 break;
508
509 case BFA_FCPORT_SM_STOP:
510 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
511 break;
512
513 case BFA_FCPORT_SM_LINKUP:
514 case BFA_FCPORT_SM_LINKDOWN:
515 /**
516 * Possible to get link events when doing back-to-back
517 * enable/disables.
518 */
519 break;
520
521 case BFA_FCPORT_SM_HWFAIL:
522 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
523 break;
524
525 default:
526 bfa_sm_fault(fcport->bfa, event);
527 }
528}
529
530static void
531bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
532 enum bfa_fcport_sm_event event)
533{
534 bfa_trc(fcport->bfa, event);
535
536 switch (event) {
537 case BFA_FCPORT_SM_START:
538 /**
539 * Ignore start event for a port that is disabled.
540 */
541 break;
542
543 case BFA_FCPORT_SM_STOP:
544 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
545 break;
546
547 case BFA_FCPORT_SM_ENABLE:
548 if (bfa_fcport_send_enable(fcport))
549 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
550 else
551 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling_qwait);
552
553 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
554 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
555 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE);
556 break;
557
558 case BFA_FCPORT_SM_DISABLE:
559 /**
560 * Already disabled.
561 */
562 break;
563
564 case BFA_FCPORT_SM_HWFAIL:
565 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
566 break;
567
568 default:
569 bfa_sm_fault(fcport->bfa, event);
570 }
571}
572
573static void
574bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
575 enum bfa_fcport_sm_event event)
576{
577 bfa_trc(fcport->bfa, event);
578
579 switch (event) {
580 case BFA_FCPORT_SM_START:
581 if (bfa_fcport_send_enable(fcport))
582 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
583 else
584 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling_qwait);
585 break;
586
587 default:
588 /**
589 * Ignore all other events.
590 */
591 ;
592 }
593}
594
595/**
596 * Port is enabled. IOC is down/failed.
597 */
598static void
599bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
600 enum bfa_fcport_sm_event event)
601{
602 bfa_trc(fcport->bfa, event);
603
604 switch (event) {
605 case BFA_FCPORT_SM_START:
606 if (bfa_fcport_send_enable(fcport))
607 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
608 else
609 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling_qwait);
610 break;
611
612 default:
613 /**
614 * Ignore all events.
615 */
616 ;
617 }
618}
619
620/**
621 * Port is disabled. IOC is down/failed.
622 */
623static void
624bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
625 enum bfa_fcport_sm_event event)
626{
627 bfa_trc(fcport->bfa, event);
628
629 switch (event) {
630 case BFA_FCPORT_SM_START:
631 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
632 break;
633
634 case BFA_FCPORT_SM_ENABLE:
635 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
636 break;
637
638 default:
639 /**
640 * Ignore all events.
641 */
642 ;
643 }
644}
645
646/**
647 * Link state is down
648 */
649static void
650bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
651 enum bfa_fcport_ln_sm_event event)
652{
653 bfa_trc(ln->fcport->bfa, event);
654
655 switch (event) {
656 case BFA_FCPORT_LN_SM_LINKUP:
657 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
658 bfa_fcport_queue_cb(ln, BFA_PPORT_LINKUP);
659 break;
660
661 default:
662 bfa_sm_fault(ln->fcport->bfa, event);
663 }
664}
665
666/**
667 * Link state is waiting for down notification
668 */
669static void
670bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
671 enum bfa_fcport_ln_sm_event event)
672{
673 bfa_trc(ln->fcport->bfa, event);
674
675 switch (event) {
676 case BFA_FCPORT_LN_SM_LINKUP:
677 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
678 break;
679
680 case BFA_FCPORT_LN_SM_NOTIFICATION:
681 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
682 break;
683
684 default:
685 bfa_sm_fault(ln->fcport->bfa, event);
686 }
687}
688
689/**
690 * Link state is waiting for down notification and there is a pending up
691 */
692static void
693bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
694 enum bfa_fcport_ln_sm_event event)
695{
696 bfa_trc(ln->fcport->bfa, event);
697
698 switch (event) {
699 case BFA_FCPORT_LN_SM_LINKDOWN:
700 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
701 break;
702
703 case BFA_FCPORT_LN_SM_NOTIFICATION:
704 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
705 bfa_fcport_queue_cb(ln, BFA_PPORT_LINKUP);
706 break;
707
708 default:
709 bfa_sm_fault(ln->fcport->bfa, event);
710 }
711}
712
713/**
714 * Link state is up
715 */
716static void
717bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
718 enum bfa_fcport_ln_sm_event event)
719{
720 bfa_trc(ln->fcport->bfa, event);
721
722 switch (event) {
723 case BFA_FCPORT_LN_SM_LINKDOWN:
724 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
725 bfa_fcport_queue_cb(ln, BFA_PPORT_LINKDOWN);
726 break;
727
728 default:
729 bfa_sm_fault(ln->fcport->bfa, event);
730 }
731}
732
733/**
734 * Link state is waiting for up notification
735 */
736static void
737bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
738 enum bfa_fcport_ln_sm_event event)
739{
740 bfa_trc(ln->fcport->bfa, event);
741
742 switch (event) {
743 case BFA_FCPORT_LN_SM_LINKDOWN:
744 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
745 break;
746
747 case BFA_FCPORT_LN_SM_NOTIFICATION:
748 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up);
749 break;
750
751 default:
752 bfa_sm_fault(ln->fcport->bfa, event);
753 }
754}
755
756/**
757 * Link state is waiting for up notification and there is a pending down
758 */
759static void
760bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
761 enum bfa_fcport_ln_sm_event event)
762{
763 bfa_trc(ln->fcport->bfa, event);
764
765 switch (event) {
766 case BFA_FCPORT_LN_SM_LINKUP:
767 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_up_nf);
768 break;
769
770 case BFA_FCPORT_LN_SM_NOTIFICATION:
771 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
772 bfa_fcport_queue_cb(ln, BFA_PPORT_LINKDOWN);
773 break;
774
775 default:
776 bfa_sm_fault(ln->fcport->bfa, event);
777 }
778}
779
780/**
781 * Link state is waiting for up notification and there are pending down and up
782 */
783static void
784bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
785 enum bfa_fcport_ln_sm_event event)
786{
787 bfa_trc(ln->fcport->bfa, event);
788
789 switch (event) {
790 case BFA_FCPORT_LN_SM_LINKDOWN:
791 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
792 break;
793
794 case BFA_FCPORT_LN_SM_NOTIFICATION:
795 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
796 bfa_fcport_queue_cb(ln, BFA_PPORT_LINKDOWN);
797 break;
798
799 default:
800 bfa_sm_fault(ln->fcport->bfa, event);
801 }
802}
803
804/**
805 * bfa_pport_private
806 */
807
808static void
809__bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete)
810{
811 struct bfa_fcport_ln_s *ln = cbarg;
812
813 if (complete)
814 ln->fcport->event_cbfn(ln->fcport->event_cbarg, ln->ln_event);
815 else
816 bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
817}
818
819static void
820bfa_fcport_callback(struct bfa_fcport_s *fcport, enum bfa_pport_linkstate event)
821{
822 if (fcport->bfa->fcs) {
823 fcport->event_cbfn(fcport->event_cbarg, event);
824 return;
825 }
826
827 switch (event) {
828 case BFA_PPORT_LINKUP:
829 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKUP);
830 break;
831 case BFA_PPORT_LINKDOWN:
832 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKDOWN);
833 break;
834 default:
835 bfa_assert(0);
836 }
837}
838
839static void
840bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln, enum bfa_pport_linkstate event)
841{
842 ln->ln_event = event;
843 bfa_cb_queue(ln->fcport->bfa, &ln->ln_qe, __bfa_cb_fcport_event, ln);
844}
845
846#define FCPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_fcport_stats_u), \
847 BFA_CACHELINE_SZ))
848
849static void
850bfa_fcport_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
851 u32 *dm_len)
852{
853 *dm_len += FCPORT_STATS_DMA_SZ;
854}
855
856static void
857bfa_fcport_qresume(void *cbarg)
858{
859 struct bfa_fcport_s *fcport = cbarg;
860
861 bfa_sm_send_event(fcport, BFA_FCPORT_SM_QRESUME);
862}
863
864static void
865bfa_fcport_mem_claim(struct bfa_fcport_s *fcport, struct bfa_meminfo_s *meminfo)
866{
867 u8 *dm_kva;
868 u64 dm_pa;
869
870 dm_kva = bfa_meminfo_dma_virt(meminfo);
871 dm_pa = bfa_meminfo_dma_phys(meminfo);
872
873 fcport->stats_kva = dm_kva;
874 fcport->stats_pa = dm_pa;
875 fcport->stats = (union bfa_fcport_stats_u *)dm_kva;
876
877 dm_kva += FCPORT_STATS_DMA_SZ;
878 dm_pa += FCPORT_STATS_DMA_SZ;
879
880 bfa_meminfo_dma_virt(meminfo) = dm_kva;
881 bfa_meminfo_dma_phys(meminfo) = dm_pa;
882}
883
884/**
885 * Memory initialization.
886 */
887static void
888bfa_fcport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
889 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
890{
891 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
892 struct bfa_pport_cfg_s *port_cfg = &fcport->cfg;
893 struct bfa_fcport_ln_s *ln = &fcport->ln;
894 struct bfa_timeval_s tv;
895
896 bfa_os_memset(fcport, 0, sizeof(struct bfa_fcport_s));
897 fcport->bfa = bfa;
898 ln->fcport = fcport;
899
900 bfa_fcport_mem_claim(fcport, meminfo);
901
902 bfa_sm_set_state(fcport, bfa_fcport_sm_uninit);
903 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
904
905 /**
906 * initialize time stamp for stats reset
907 */
908 bfa_os_gettimeofday(&tv);
909 fcport->stats_reset_time = tv.tv_sec;
910
911 /**
912 * initialize and set default configuration
913 */
914 port_cfg->topology = BFA_PPORT_TOPOLOGY_P2P;
915 port_cfg->speed = BFA_PPORT_SPEED_AUTO;
916 port_cfg->trunked = BFA_FALSE;
917 port_cfg->maxfrsize = 0;
918
919 port_cfg->trl_def_speed = BFA_PPORT_SPEED_1GBPS;
920
921 bfa_reqq_winit(&fcport->reqq_wait, bfa_fcport_qresume, fcport);
922}
923
924static void
925bfa_fcport_detach(struct bfa_s *bfa)
926{
927}
928
929/**
930 * Called when IOC is ready.
931 */
932static void
933bfa_fcport_start(struct bfa_s *bfa)
934{
935 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_START);
936}
937
938/**
939 * Called before IOC is stopped.
940 */
941static void
942bfa_fcport_stop(struct bfa_s *bfa)
943{
944 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_STOP);
945}
946
947/**
948 * Called when IOC failure is detected.
949 */
950static void
951bfa_fcport_iocdisable(struct bfa_s *bfa)
952{
953 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_HWFAIL);
954}
955
956static void
957bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport)
958{
959 struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
960
961 fcport->speed = pevent->link_state.speed;
962 fcport->topology = pevent->link_state.topology;
963
964 if (fcport->topology == BFA_PPORT_TOPOLOGY_LOOP)
965 fcport->myalpa = 0;
966
967 /*
968 * QoS Details
969 */
970 bfa_os_assign(fcport->qos_attr, pevent->link_state.qos_attr);
971 bfa_os_assign(fcport->qos_vc_attr,
972 pevent->link_state.vc_fcf.qos_vc_attr);
973
974
975 bfa_trc(fcport->bfa, fcport->speed);
976 bfa_trc(fcport->bfa, fcport->topology);
977}
978
979static void
980bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport)
981{
982 fcport->speed = BFA_PPORT_SPEED_UNKNOWN;
983 fcport->topology = BFA_PPORT_TOPOLOGY_NONE;
984}
985
986/**
987 * Send port enable message to firmware.
988 */
989static bfa_boolean_t
990bfa_fcport_send_enable(struct bfa_fcport_s *fcport)
991{
992 struct bfi_fcport_enable_req_s *m;
993
994 /**
995 * Increment message tag before queue check, so that responses to old
996 * requests are discarded.
997 */
998 fcport->msgtag++;
999
1000 /**
1001 * check for room in queue to send request now
1002 */
1003 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
1004 if (!m) {
1005 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
1006 &fcport->reqq_wait);
1007 return BFA_FALSE;
1008 }
1009
1010 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_ENABLE_REQ,
1011 bfa_lpuid(fcport->bfa));
1012 m->nwwn = fcport->nwwn;
1013 m->pwwn = fcport->pwwn;
1014 m->port_cfg = fcport->cfg;
1015 m->msgtag = fcport->msgtag;
1016 m->port_cfg.maxfrsize = bfa_os_htons(fcport->cfg.maxfrsize);
1017 bfa_dma_be_addr_set(m->stats_dma_addr, fcport->stats_pa);
1018 bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_lo);
1019 bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_hi);
1020
1021 /**
1022 * queue I/O message to firmware
1023 */
1024 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
1025 return BFA_TRUE;
1026}
1027
1028/**
1029 * Send port disable message to firmware.
1030 */
1031static bfa_boolean_t
1032bfa_fcport_send_disable(struct bfa_fcport_s *fcport)
1033{
1034 struct bfi_fcport_req_s *m;
1035
1036 /**
1037 * Increment message tag before queue check, so that responses to old
1038 * requests are discarded.
1039 */
1040 fcport->msgtag++;
1041
1042 /**
1043 * check for room in queue to send request now
1044 */
1045 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
1046 if (!m) {
1047 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
1048 &fcport->reqq_wait);
1049 return BFA_FALSE;
1050 }
1051
1052 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_DISABLE_REQ,
1053 bfa_lpuid(fcport->bfa));
1054 m->msgtag = fcport->msgtag;
1055
1056 /**
1057 * queue I/O message to firmware
1058 */
1059 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
1060
1061 return BFA_TRUE;
1062}
1063
1064static void
1065bfa_fcport_set_wwns(struct bfa_fcport_s *fcport)
1066{
1067 fcport->pwwn = bfa_ioc_get_pwwn(&fcport->bfa->ioc);
1068 fcport->nwwn = bfa_ioc_get_nwwn(&fcport->bfa->ioc);
1069
1070 bfa_trc(fcport->bfa, fcport->pwwn);
1071 bfa_trc(fcport->bfa, fcport->nwwn);
1072}
1073
1074static void
1075bfa_fcport_send_txcredit(void *port_cbarg)
1076{
1077
1078 struct bfa_fcport_s *fcport = port_cbarg;
1079 struct bfi_fcport_set_svc_params_req_s *m;
1080
1081 /**
1082 * check for room in queue to send request now
1083 */
1084 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
1085 if (!m) {
1086 bfa_trc(fcport->bfa, fcport->cfg.tx_bbcredit);
1087 return;
1088 }
1089
1090 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_SET_SVC_PARAMS_REQ,
1091 bfa_lpuid(fcport->bfa));
1092 m->tx_bbcredit = bfa_os_htons((u16) fcport->cfg.tx_bbcredit);
1093
1094 /**
1095 * queue I/O message to firmware
1096 */
1097 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
1098}
1099
1100static void
1101bfa_fcport_qos_stats_swap(struct bfa_qos_stats_s *d,
1102 struct bfa_qos_stats_s *s)
1103{
1104 u32 *dip = (u32 *) d;
1105 u32 *sip = (u32 *) s;
1106 int i;
1107
1108 /* Now swap the 32 bit fields */
1109 for (i = 0; i < (sizeof(struct bfa_qos_stats_s)/sizeof(u32)); ++i)
1110 dip[i] = bfa_os_ntohl(sip[i]);
1111}
1112
1113static void
1114bfa_fcport_fcoe_stats_swap(struct bfa_fcoe_stats_s *d,
1115 struct bfa_fcoe_stats_s *s)
1116{
1117 u32 *dip = (u32 *) d;
1118 u32 *sip = (u32 *) s;
1119 int i;
1120
1121 for (i = 0; i < ((sizeof(struct bfa_fcoe_stats_s))/sizeof(u32));
1122 i = i + 2) {
1123#ifdef __BIGENDIAN
1124 dip[i] = bfa_os_ntohl(sip[i]);
1125 dip[i + 1] = bfa_os_ntohl(sip[i + 1]);
1126#else
1127 dip[i] = bfa_os_ntohl(sip[i + 1]);
1128 dip[i + 1] = bfa_os_ntohl(sip[i]);
1129#endif
1130 }
1131}
1132
1133static void
1134__bfa_cb_fcport_stats_get(void *cbarg, bfa_boolean_t complete)
1135{
1136 struct bfa_fcport_s *fcport = cbarg;
1137
1138 if (complete) {
1139 if (fcport->stats_status == BFA_STATUS_OK) {
1140 struct bfa_timeval_s tv;
1141
1142 /* Swap FC QoS or FCoE stats */
1143 if (bfa_ioc_get_fcmode(&fcport->bfa->ioc)) {
1144 bfa_fcport_qos_stats_swap(
1145 &fcport->stats_ret->fcqos,
1146 &fcport->stats->fcqos);
1147 } else {
1148 bfa_fcport_fcoe_stats_swap(
1149 &fcport->stats_ret->fcoe,
1150 &fcport->stats->fcoe);
1151
1152 bfa_os_gettimeofday(&tv);
1153 fcport->stats_ret->fcoe.secs_reset =
1154 tv.tv_sec - fcport->stats_reset_time;
1155 }
1156 }
1157 fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
1158 } else {
1159 fcport->stats_busy = BFA_FALSE;
1160 fcport->stats_status = BFA_STATUS_OK;
1161 }
1162}
1163
1164static void
1165bfa_fcport_stats_get_timeout(void *cbarg)
1166{
1167 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
1168
1169 bfa_trc(fcport->bfa, fcport->stats_qfull);
1170
1171 if (fcport->stats_qfull) {
1172 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
1173 fcport->stats_qfull = BFA_FALSE;
1174 }
1175
1176 fcport->stats_status = BFA_STATUS_ETIMER;
1177 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, __bfa_cb_fcport_stats_get,
1178 fcport);
1179}
1180
1181static void
1182bfa_fcport_send_stats_get(void *cbarg)
1183{
1184 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
1185 struct bfi_fcport_req_s *msg;
1186
1187 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
1188
1189 if (!msg) {
1190 fcport->stats_qfull = BFA_TRUE;
1191 bfa_reqq_winit(&fcport->stats_reqq_wait,
1192 bfa_fcport_send_stats_get, fcport);
1193 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
1194 &fcport->stats_reqq_wait);
1195 return;
1196 }
1197 fcport->stats_qfull = BFA_FALSE;
1198
1199 bfa_os_memset(msg, 0, sizeof(struct bfi_fcport_req_s));
1200 bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_GET_REQ,
1201 bfa_lpuid(fcport->bfa));
1202 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
1203}
1204
1205static void
1206__bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete)
1207{
1208 struct bfa_fcport_s *fcport = cbarg;
1209
1210 if (complete) {
1211 struct bfa_timeval_s tv;
1212
1213 /**
1214 * re-initialize time stamp for stats reset
1215 */
1216 bfa_os_gettimeofday(&tv);
1217 fcport->stats_reset_time = tv.tv_sec;
1218
1219 fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
1220 } else {
1221 fcport->stats_busy = BFA_FALSE;
1222 fcport->stats_status = BFA_STATUS_OK;
1223 }
1224}
1225
1226static void
1227bfa_fcport_stats_clr_timeout(void *cbarg)
1228{
1229 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
1230
1231 bfa_trc(fcport->bfa, fcport->stats_qfull);
1232
1233 if (fcport->stats_qfull) {
1234 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
1235 fcport->stats_qfull = BFA_FALSE;
1236 }
1237
1238 fcport->stats_status = BFA_STATUS_ETIMER;
1239 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
1240 __bfa_cb_fcport_stats_clr, fcport);
1241}
1242
1243static void
1244bfa_fcport_send_stats_clear(void *cbarg)
1245{
1246 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
1247 struct bfi_fcport_req_s *msg;
1248
1249 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
1250
1251 if (!msg) {
1252 fcport->stats_qfull = BFA_TRUE;
1253 bfa_reqq_winit(&fcport->stats_reqq_wait,
1254 bfa_fcport_send_stats_clear, fcport);
1255 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
1256 &fcport->stats_reqq_wait);
1257 return;
1258 }
1259 fcport->stats_qfull = BFA_FALSE;
1260
1261 bfa_os_memset(msg, 0, sizeof(struct bfi_fcport_req_s));
1262 bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_CLEAR_REQ,
1263 bfa_lpuid(fcport->bfa));
1264 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
1265}
1266
1267/**
1268 * bfa_pport_public
1269 */
1270
1271/**
1272 * Called to initialize port attributes
1273 */
1274void
1275bfa_fcport_init(struct bfa_s *bfa)
1276{
1277 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1278
1279 /**
1280 * Initialize port attributes from IOC hardware data.
1281 */
1282 bfa_fcport_set_wwns(fcport);
1283 if (fcport->cfg.maxfrsize == 0)
1284 fcport->cfg.maxfrsize = bfa_ioc_maxfrsize(&bfa->ioc);
1285 fcport->cfg.rx_bbcredit = bfa_ioc_rx_bbcredit(&bfa->ioc);
1286 fcport->speed_sup = bfa_ioc_speed_sup(&bfa->ioc);
1287
1288 bfa_assert(fcport->cfg.maxfrsize);
1289 bfa_assert(fcport->cfg.rx_bbcredit);
1290 bfa_assert(fcport->speed_sup);
1291}
1292
1293
1294/**
1295 * Firmware message handler.
1296 */
1297void
1298bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
1299{
1300 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1301 union bfi_fcport_i2h_msg_u i2hmsg;
1302
1303 i2hmsg.msg = msg;
1304 fcport->event_arg.i2hmsg = i2hmsg;
1305
1306 switch (msg->mhdr.msg_id) {
1307 case BFI_FCPORT_I2H_ENABLE_RSP:
1308 if (fcport->msgtag == i2hmsg.penable_rsp->msgtag)
1309 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
1310 break;
1311
1312 case BFI_FCPORT_I2H_DISABLE_RSP:
1313 if (fcport->msgtag == i2hmsg.pdisable_rsp->msgtag)
1314 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
1315 break;
1316
1317 case BFI_FCPORT_I2H_EVENT:
1318 switch (i2hmsg.event->link_state.linkstate) {
1319 case BFA_PPORT_LINKUP:
1320 bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKUP);
1321 break;
1322 case BFA_PPORT_LINKDOWN:
1323 bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKDOWN);
1324 break;
1325 case BFA_PPORT_TRUNK_LINKDOWN:
1326 /** todo: event notification */
1327 break;
1328 }
1329 break;
1330
1331 case BFI_FCPORT_I2H_STATS_GET_RSP:
1332 /*
1333 * check for timer pop before processing the rsp
1334 */
1335 if (fcport->stats_busy == BFA_FALSE ||
1336 fcport->stats_status == BFA_STATUS_ETIMER)
1337 break;
1338
1339 bfa_timer_stop(&fcport->timer);
1340 fcport->stats_status = i2hmsg.pstatsget_rsp->status;
1341 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
1342 __bfa_cb_fcport_stats_get, fcport);
1343 break;
1344
1345 case BFI_FCPORT_I2H_STATS_CLEAR_RSP:
1346 /*
1347 * check for timer pop before processing the rsp
1348 */
1349 if (fcport->stats_busy == BFA_FALSE ||
1350 fcport->stats_status == BFA_STATUS_ETIMER)
1351 break;
1352
1353 bfa_timer_stop(&fcport->timer);
1354 fcport->stats_status = BFA_STATUS_OK;
1355 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
1356 __bfa_cb_fcport_stats_clr, fcport);
1357 break;
1358
1359 default:
1360 bfa_assert(0);
1361 break;
1362 }
1363}
1364
1365/**
1366 * bfa_pport_api
1367 */
1368
1369/**
1370 * Registered callback for port events.
1371 */
1372void
1373bfa_fcport_event_register(struct bfa_s *bfa,
1374 void (*cbfn) (void *cbarg, bfa_pport_event_t event),
1375 void *cbarg)
1376{
1377 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1378
1379 fcport->event_cbfn = cbfn;
1380 fcport->event_cbarg = cbarg;
1381}
1382
1383bfa_status_t
1384bfa_fcport_enable(struct bfa_s *bfa)
1385{
1386 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1387 struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1388 struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp;
1389
1390 /* if port is PBC disabled, return error */
1391 if (cfgrsp->pbc_cfg.port_enabled == BFI_PBC_PORT_DISABLED) {
1392 bfa_trc(bfa, fcport->pwwn);
1393 return BFA_STATUS_PBC;
1394 }
1395
1396 if (bfa_ioc_is_disabled(&bfa->ioc))
1397 return BFA_STATUS_IOC_DISABLED;
1398
1399 if (fcport->diag_busy)
1400 return BFA_STATUS_DIAG_BUSY;
1401 else if (bfa_sm_cmp_state
1402 (BFA_FCPORT_MOD(bfa), bfa_fcport_sm_disabling_qwait))
1403 return BFA_STATUS_DEVBUSY;
1404
1405 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_ENABLE);
1406 return BFA_STATUS_OK;
1407}
1408
1409bfa_status_t
1410bfa_fcport_disable(struct bfa_s *bfa)
1411{
1412 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1413 struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1414 struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp;
1415
1416 /* if port is PBC disabled, return error */
1417 if (cfgrsp->pbc_cfg.port_enabled == BFI_PBC_PORT_DISABLED) {
1418 bfa_trc(bfa, fcport->pwwn);
1419 return BFA_STATUS_PBC;
1420 }
1421
1422 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DISABLE);
1423 return BFA_STATUS_OK;
1424}
1425
1426/**
1427 * Configure port speed.
1428 */
1429bfa_status_t
1430bfa_fcport_cfg_speed(struct bfa_s *bfa, enum bfa_pport_speed speed)
1431{
1432 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1433
1434 bfa_trc(bfa, speed);
1435
1436 if ((speed != BFA_PPORT_SPEED_AUTO) && (speed > fcport->speed_sup)) {
1437 bfa_trc(bfa, fcport->speed_sup);
1438 return BFA_STATUS_UNSUPP_SPEED;
1439 }
1440
1441 fcport->cfg.speed = speed;
1442
1443 return BFA_STATUS_OK;
1444}
1445
1446/**
1447 * Get current speed.
1448 */
1449enum bfa_pport_speed
1450bfa_fcport_get_speed(struct bfa_s *bfa)
1451{
1452 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1453
1454 return fcport->speed;
1455}
1456
1457/**
1458 * Configure port topology.
1459 */
1460bfa_status_t
1461bfa_fcport_cfg_topology(struct bfa_s *bfa, enum bfa_pport_topology topology)
1462{
1463 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1464
1465 bfa_trc(bfa, topology);
1466 bfa_trc(bfa, fcport->cfg.topology);
1467
1468 switch (topology) {
1469 case BFA_PPORT_TOPOLOGY_P2P:
1470 case BFA_PPORT_TOPOLOGY_LOOP:
1471 case BFA_PPORT_TOPOLOGY_AUTO:
1472 break;
1473
1474 default:
1475 return BFA_STATUS_EINVAL;
1476 }
1477
1478 fcport->cfg.topology = topology;
1479 return BFA_STATUS_OK;
1480}
1481
1482/**
1483 * Get current topology.
1484 */
1485enum bfa_pport_topology
1486bfa_fcport_get_topology(struct bfa_s *bfa)
1487{
1488 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1489
1490 return fcport->topology;
1491}
1492
1493bfa_status_t
1494bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa)
1495{
1496 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1497
1498 bfa_trc(bfa, alpa);
1499 bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
1500 bfa_trc(bfa, fcport->cfg.hardalpa);
1501
1502 fcport->cfg.cfg_hardalpa = BFA_TRUE;
1503 fcport->cfg.hardalpa = alpa;
1504
1505 return BFA_STATUS_OK;
1506}
1507
1508bfa_status_t
1509bfa_fcport_clr_hardalpa(struct bfa_s *bfa)
1510{
1511 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1512
1513 bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
1514 bfa_trc(bfa, fcport->cfg.hardalpa);
1515
1516 fcport->cfg.cfg_hardalpa = BFA_FALSE;
1517 return BFA_STATUS_OK;
1518}
1519
1520bfa_boolean_t
1521bfa_fcport_get_hardalpa(struct bfa_s *bfa, u8 *alpa)
1522{
1523 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1524
1525 *alpa = fcport->cfg.hardalpa;
1526 return fcport->cfg.cfg_hardalpa;
1527}
1528
1529u8
1530bfa_fcport_get_myalpa(struct bfa_s *bfa)
1531{
1532 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1533
1534 return fcport->myalpa;
1535}
1536
1537bfa_status_t
1538bfa_fcport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxfrsize)
1539{
1540 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1541
1542 bfa_trc(bfa, maxfrsize);
1543 bfa_trc(bfa, fcport->cfg.maxfrsize);
1544
1545 /*
1546 * with in range
1547 */
1548 if ((maxfrsize > FC_MAX_PDUSZ) || (maxfrsize < FC_MIN_PDUSZ))
1549 return BFA_STATUS_INVLD_DFSZ;
1550
1551 /*
1552 * power of 2, if not the max frame size of 2112
1553 */
1554 if ((maxfrsize != FC_MAX_PDUSZ) && (maxfrsize & (maxfrsize - 1)))
1555 return BFA_STATUS_INVLD_DFSZ;
1556
1557 fcport->cfg.maxfrsize = maxfrsize;
1558 return BFA_STATUS_OK;
1559}
1560
1561u16
1562bfa_fcport_get_maxfrsize(struct bfa_s *bfa)
1563{
1564 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1565
1566 return fcport->cfg.maxfrsize;
1567}
1568
1569u32
1570bfa_fcport_mypid(struct bfa_s *bfa)
1571{
1572 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1573
1574 return fcport->mypid;
1575}
1576
1577u8
1578bfa_fcport_get_rx_bbcredit(struct bfa_s *bfa)
1579{
1580 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1581
1582 return fcport->cfg.rx_bbcredit;
1583}
1584
1585void
1586bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit)
1587{
1588 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1589
1590 fcport->cfg.tx_bbcredit = (u8) tx_bbcredit;
1591 bfa_fcport_send_txcredit(fcport);
1592}
1593
1594/**
1595 * Get port attributes.
1596 */
1597
1598wwn_t
1599bfa_fcport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node)
1600{
1601 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1602 if (node)
1603 return fcport->nwwn;
1604 else
1605 return fcport->pwwn;
1606}
1607
1608void
1609bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_pport_attr_s *attr)
1610{
1611 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1612 struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1613 struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp;
1614
1615 bfa_os_memset(attr, 0, sizeof(struct bfa_pport_attr_s));
1616
1617 attr->nwwn = fcport->nwwn;
1618 attr->pwwn = fcport->pwwn;
1619
1620 attr->factorypwwn = bfa_ioc_get_mfg_pwwn(&bfa->ioc);
1621 attr->factorynwwn = bfa_ioc_get_mfg_nwwn(&bfa->ioc);
1622
1623 bfa_os_memcpy(&attr->pport_cfg, &fcport->cfg,
1624 sizeof(struct bfa_pport_cfg_s));
1625 /*
1626 * speed attributes
1627 */
1628 attr->pport_cfg.speed = fcport->cfg.speed;
1629 attr->speed_supported = fcport->speed_sup;
1630 attr->speed = fcport->speed;
1631 attr->cos_supported = FC_CLASS_3;
1632
1633 /*
1634 * topology attributes
1635 */
1636 attr->pport_cfg.topology = fcport->cfg.topology;
1637 attr->topology = fcport->topology;
1638
1639 /*
1640 * beacon attributes
1641 */
1642 attr->beacon = fcport->beacon;
1643 attr->link_e2e_beacon = fcport->link_e2e_beacon;
1644 attr->plog_enabled = bfa_plog_get_setting(fcport->bfa->plog);
1645
1646 attr->pport_cfg.path_tov = bfa_fcpim_path_tov_get(bfa);
1647 attr->pport_cfg.q_depth = bfa_fcpim_qdepth_get(bfa);
1648
1649 /* PBC Disabled State */
1650 if (cfgrsp->pbc_cfg.port_enabled == BFI_PBC_PORT_DISABLED)
1651 attr->port_state = BFA_PPORT_ST_PREBOOT_DISABLED;
1652 else {
1653 attr->port_state = bfa_sm_to_state(
1654 hal_pport_sm_table, fcport->sm);
1655 if (bfa_ioc_is_disabled(&fcport->bfa->ioc))
1656 attr->port_state = BFA_PPORT_ST_IOCDIS;
1657 else if (bfa_ioc_fw_mismatch(&fcport->bfa->ioc))
1658 attr->port_state = BFA_PPORT_ST_FWMISMATCH;
1659 }
1660}
1661
1662#define BFA_FCPORT_STATS_TOV 1000
1663
1664/**
1665 * Fetch port attributes (FCQoS or FCoE).
1666 */
1667bfa_status_t
1668bfa_fcport_get_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
1669 bfa_cb_pport_t cbfn, void *cbarg)
1670{
1671 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1672
1673 if (fcport->stats_busy) {
1674 bfa_trc(bfa, fcport->stats_busy);
1675 return BFA_STATUS_DEVBUSY;
1676 }
1677
1678 fcport->stats_busy = BFA_TRUE;
1679 fcport->stats_ret = stats;
1680 fcport->stats_cbfn = cbfn;
1681 fcport->stats_cbarg = cbarg;
1682
1683 bfa_fcport_send_stats_get(fcport);
1684
1685 bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_get_timeout,
1686 fcport, BFA_FCPORT_STATS_TOV);
1687 return BFA_STATUS_OK;
1688}
1689
1690/**
1691 * Reset port statistics (FCQoS or FCoE).
1692 */
1693bfa_status_t
1694bfa_fcport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
1695{
1696 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1697
1698 if (fcport->stats_busy) {
1699 bfa_trc(bfa, fcport->stats_busy);
1700 return BFA_STATUS_DEVBUSY;
1701 }
1702
1703 fcport->stats_busy = BFA_TRUE;
1704 fcport->stats_cbfn = cbfn;
1705 fcport->stats_cbarg = cbarg;
1706
1707 bfa_fcport_send_stats_clear(fcport);
1708
1709 bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_clr_timeout,
1710 fcport, BFA_FCPORT_STATS_TOV);
1711 return BFA_STATUS_OK;
1712}
1713
1714/**
1715 * Fetch FCQoS port statistics
1716 */
1717bfa_status_t
1718bfa_fcport_get_qos_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
1719 bfa_cb_pport_t cbfn, void *cbarg)
1720{
1721 /* Meaningful only for FC mode */
1722 bfa_assert(bfa_ioc_get_fcmode(&bfa->ioc));
1723
1724 return bfa_fcport_get_stats(bfa, stats, cbfn, cbarg);
1725}
1726
1727/**
1728 * Reset FCoE port statistics
1729 */
1730bfa_status_t
1731bfa_fcport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
1732{
1733 /* Meaningful only for FC mode */
1734 bfa_assert(bfa_ioc_get_fcmode(&bfa->ioc));
1735
1736 return bfa_fcport_clear_stats(bfa, cbfn, cbarg);
1737}
1738
1739/**
1740 * Fetch FCQoS port statistics
1741 */
1742bfa_status_t
1743bfa_fcport_get_fcoe_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
1744 bfa_cb_pport_t cbfn, void *cbarg)
1745{
1746 /* Meaningful only for FCoE mode */
1747 bfa_assert(!bfa_ioc_get_fcmode(&bfa->ioc));
1748
1749 return bfa_fcport_get_stats(bfa, stats, cbfn, cbarg);
1750}
1751
1752/**
1753 * Reset FCoE port statistics
1754 */
1755bfa_status_t
1756bfa_fcport_clear_fcoe_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
1757{
1758 /* Meaningful only for FCoE mode */
1759 bfa_assert(!bfa_ioc_get_fcmode(&bfa->ioc));
1760
1761 return bfa_fcport_clear_stats(bfa, cbfn, cbarg);
1762}
1763
1764bfa_status_t
1765bfa_fcport_trunk_enable(struct bfa_s *bfa, u8 bitmap)
1766{
1767 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1768
1769 bfa_trc(bfa, bitmap);
1770 bfa_trc(bfa, fcport->cfg.trunked);
1771 bfa_trc(bfa, fcport->cfg.trunk_ports);
1772
1773 if (!bitmap || (bitmap & (bitmap - 1)))
1774 return BFA_STATUS_EINVAL;
1775
1776 fcport->cfg.trunked = BFA_TRUE;
1777 fcport->cfg.trunk_ports = bitmap;
1778
1779 return BFA_STATUS_OK;
1780}
1781
1782void
1783bfa_fcport_qos_get_attr(struct bfa_s *bfa, struct bfa_qos_attr_s *qos_attr)
1784{
1785 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1786
1787 qos_attr->state = bfa_os_ntohl(fcport->qos_attr.state);
1788 qos_attr->total_bb_cr = bfa_os_ntohl(fcport->qos_attr.total_bb_cr);
1789}
1790
1791void
1792bfa_fcport_qos_get_vc_attr(struct bfa_s *bfa,
1793 struct bfa_qos_vc_attr_s *qos_vc_attr)
1794{
1795 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1796 struct bfa_qos_vc_attr_s *bfa_vc_attr = &fcport->qos_vc_attr;
1797 u32 i = 0;
1798
1799 qos_vc_attr->total_vc_count = bfa_os_ntohs(bfa_vc_attr->total_vc_count);
1800 qos_vc_attr->shared_credit = bfa_os_ntohs(bfa_vc_attr->shared_credit);
1801 qos_vc_attr->elp_opmode_flags =
1802 bfa_os_ntohl(bfa_vc_attr->elp_opmode_flags);
1803
1804 /*
1805 * Individual VC info
1806 */
1807 while (i < qos_vc_attr->total_vc_count) {
1808 qos_vc_attr->vc_info[i].vc_credit =
1809 bfa_vc_attr->vc_info[i].vc_credit;
1810 qos_vc_attr->vc_info[i].borrow_credit =
1811 bfa_vc_attr->vc_info[i].borrow_credit;
1812 qos_vc_attr->vc_info[i].priority =
1813 bfa_vc_attr->vc_info[i].priority;
1814 ++i;
1815 }
1816}
1817
1818/**
1819 * Fetch port attributes.
1820 */
1821bfa_status_t
1822bfa_fcport_trunk_disable(struct bfa_s *bfa)
1823{
1824 return BFA_STATUS_OK;
1825}
1826
1827bfa_boolean_t
1828bfa_fcport_trunk_query(struct bfa_s *bfa, u32 *bitmap)
1829{
1830 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1831
1832 *bitmap = fcport->cfg.trunk_ports;
1833 return fcport->cfg.trunked;
1834}
1835
1836bfa_boolean_t
1837bfa_fcport_is_disabled(struct bfa_s *bfa)
1838{
1839 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1840
1841 return bfa_sm_to_state(hal_pport_sm_table, fcport->sm) ==
1842 BFA_PPORT_ST_DISABLED;
1843
1844}
1845
1846bfa_boolean_t
1847bfa_fcport_is_ratelim(struct bfa_s *bfa)
1848{
1849 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1850
1851 return fcport->cfg.ratelimit ? BFA_TRUE : BFA_FALSE;
1852
1853}
1854
1855void
1856bfa_fcport_cfg_qos(struct bfa_s *bfa, bfa_boolean_t on_off)
1857{
1858 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1859 enum bfa_ioc_type_e ioc_type = bfa_get_type(bfa);
1860
1861 bfa_trc(bfa, on_off);
1862 bfa_trc(bfa, fcport->cfg.qos_enabled);
1863
1864 bfa_trc(bfa, ioc_type);
1865
1866 if (ioc_type == BFA_IOC_TYPE_FC) {
1867 fcport->cfg.qos_enabled = on_off;
1868 /**
1869 * Notify fcpim of the change in QoS state
1870 */
1871 bfa_fcpim_update_ioredirect(bfa);
1872 }
1873}
1874
1875void
1876bfa_fcport_cfg_ratelim(struct bfa_s *bfa, bfa_boolean_t on_off)
1877{
1878 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1879
1880 bfa_trc(bfa, on_off);
1881 bfa_trc(bfa, fcport->cfg.ratelimit);
1882
1883 fcport->cfg.ratelimit = on_off;
1884 if (fcport->cfg.trl_def_speed == BFA_PPORT_SPEED_UNKNOWN)
1885 fcport->cfg.trl_def_speed = BFA_PPORT_SPEED_1GBPS;
1886}
1887
1888/**
1889 * Configure default minimum ratelim speed
1890 */
1891bfa_status_t
1892bfa_fcport_cfg_ratelim_speed(struct bfa_s *bfa, enum bfa_pport_speed speed)
1893{
1894 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1895
1896 bfa_trc(bfa, speed);
1897
1898 /*
1899 * Auto and speeds greater than the supported speed, are invalid
1900 */
1901 if ((speed == BFA_PPORT_SPEED_AUTO) || (speed > fcport->speed_sup)) {
1902 bfa_trc(bfa, fcport->speed_sup);
1903 return BFA_STATUS_UNSUPP_SPEED;
1904 }
1905
1906 fcport->cfg.trl_def_speed = speed;
1907
1908 return BFA_STATUS_OK;
1909}
1910
1911/**
1912 * Get default minimum ratelim speed
1913 */
1914enum bfa_pport_speed
1915bfa_fcport_get_ratelim_speed(struct bfa_s *bfa)
1916{
1917 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1918
1919 bfa_trc(bfa, fcport->cfg.trl_def_speed);
1920 return fcport->cfg.trl_def_speed;
1921
1922}
1923
1924void
1925bfa_fcport_busy(struct bfa_s *bfa, bfa_boolean_t status)
1926{
1927 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1928
1929 bfa_trc(bfa, status);
1930 bfa_trc(bfa, fcport->diag_busy);
1931
1932 fcport->diag_busy = status;
1933}
1934
1935void
1936bfa_fcport_beacon(struct bfa_s *bfa, bfa_boolean_t beacon,
1937 bfa_boolean_t link_e2e_beacon)
1938{
1939 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1940
1941 bfa_trc(bfa, beacon);
1942 bfa_trc(bfa, link_e2e_beacon);
1943 bfa_trc(bfa, fcport->beacon);
1944 bfa_trc(bfa, fcport->link_e2e_beacon);
1945
1946 fcport->beacon = beacon;
1947 fcport->link_e2e_beacon = link_e2e_beacon;
1948}
1949
1950bfa_boolean_t
1951bfa_fcport_is_linkup(struct bfa_s *bfa)
1952{
1953 return bfa_sm_cmp_state(BFA_FCPORT_MOD(bfa), bfa_fcport_sm_linkup);
1954}
1955
1956bfa_boolean_t
1957bfa_fcport_is_qos_enabled(struct bfa_s *bfa)
1958{
1959 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
1960
1961 return fcport->cfg.qos_enabled;
1962}
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-28 04:03:46 -0500