projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-2.6.33' of git://linux-nfs.org/~bfields/linux
[deliverable/linux.git] / drivers / scsi / bfa / bfa_fcport.c
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 <cs/bfa_debug.h>
22 #include <aen/bfa_aen.h>
23 #include <cs/bfa_plog.h>
24 #include <aen/bfa_aen_port.h>
25
26 BFA_TRC_FILE(HAL, PPORT);
27 BFA_MODULE(pport);
28
29 #define bfa_pport_callback(__pport, __event) do { \
30 if ((__pport)->bfa->fcs) { \
31 (__pport)->event_cbfn((__pport)->event_cbarg, (__event)); \
32 } else { \
33 (__pport)->hcb_event = (__event); \
34 bfa_cb_queue((__pport)->bfa, &(__pport)->hcb_qe, \
35 __bfa_cb_port_event, (__pport)); \
36 } \
37 } while (0)
38
39 /*
40 * The port is considered disabled if corresponding physical port or IOC are
41 * disabled explicitly
42 */
43 #define BFA_PORT_IS_DISABLED(bfa) \
44 ((bfa_pport_is_disabled(bfa) == BFA_TRUE) || \
45 (bfa_ioc_is_disabled(&bfa->ioc) == BFA_TRUE))
46
47 /*
48 * forward declarations
49 */
50 static bfa_boolean_t bfa_pport_send_enable(struct bfa_pport_s *port);
51 static bfa_boolean_t bfa_pport_send_disable(struct bfa_pport_s *port);
52 static void bfa_pport_update_linkinfo(struct bfa_pport_s *pport);
53 static void bfa_pport_reset_linkinfo(struct bfa_pport_s *pport);
54 static void bfa_pport_set_wwns(struct bfa_pport_s *port);
55 static void __bfa_cb_port_event(void *cbarg, bfa_boolean_t complete);
56 static void __bfa_cb_port_stats(void *cbarg, bfa_boolean_t complete);
57 static void __bfa_cb_port_stats_clr(void *cbarg, bfa_boolean_t complete);
58 static void bfa_port_stats_timeout(void *cbarg);
59 static void bfa_port_stats_clr_timeout(void *cbarg);
60
61 /**
62 * bfa_pport_private
63 */
64
65 /**
66 * BFA port state machine events
67 */
68 enum bfa_pport_sm_event {
69 BFA_PPORT_SM_START = 1, /* start port state machine */
70 BFA_PPORT_SM_STOP = 2, /* stop port state machine */
71 BFA_PPORT_SM_ENABLE = 3, /* enable port */
72 BFA_PPORT_SM_DISABLE = 4, /* disable port state machine */
73 BFA_PPORT_SM_FWRSP = 5, /* firmware enable/disable rsp */
74 BFA_PPORT_SM_LINKUP = 6, /* firmware linkup event */
75 BFA_PPORT_SM_LINKDOWN = 7, /* firmware linkup down */
76 BFA_PPORT_SM_QRESUME = 8, /* CQ space available */
77 BFA_PPORT_SM_HWFAIL = 9, /* IOC h/w failure */
78 };
79
80 static void bfa_pport_sm_uninit(struct bfa_pport_s *pport,
81 enum bfa_pport_sm_event event);
82 static void bfa_pport_sm_enabling_qwait(struct bfa_pport_s *pport,
83 enum bfa_pport_sm_event event);
84 static void bfa_pport_sm_enabling(struct bfa_pport_s *pport,
85 enum bfa_pport_sm_event event);
86 static void bfa_pport_sm_linkdown(struct bfa_pport_s *pport,
87 enum bfa_pport_sm_event event);
88 static void bfa_pport_sm_linkup(struct bfa_pport_s *pport,
89 enum bfa_pport_sm_event event);
90 static void bfa_pport_sm_disabling(struct bfa_pport_s *pport,
91 enum bfa_pport_sm_event event);
92 static void bfa_pport_sm_disabling_qwait(struct bfa_pport_s *pport,
93 enum bfa_pport_sm_event event);
94 static void bfa_pport_sm_disabled(struct bfa_pport_s *pport,
95 enum bfa_pport_sm_event event);
96 static void bfa_pport_sm_stopped(struct bfa_pport_s *pport,
97 enum bfa_pport_sm_event event);
98 static void bfa_pport_sm_iocdown(struct bfa_pport_s *pport,
99 enum bfa_pport_sm_event event);
100 static void bfa_pport_sm_iocfail(struct bfa_pport_s *pport,
101 enum bfa_pport_sm_event event);
102
103 static struct bfa_sm_table_s hal_pport_sm_table[] = {
104 {BFA_SM(bfa_pport_sm_uninit), BFA_PPORT_ST_UNINIT},
105 {BFA_SM(bfa_pport_sm_enabling_qwait), BFA_PPORT_ST_ENABLING_QWAIT},
106 {BFA_SM(bfa_pport_sm_enabling), BFA_PPORT_ST_ENABLING},
107 {BFA_SM(bfa_pport_sm_linkdown), BFA_PPORT_ST_LINKDOWN},
108 {BFA_SM(bfa_pport_sm_linkup), BFA_PPORT_ST_LINKUP},
109 {BFA_SM(bfa_pport_sm_disabling_qwait),
110 BFA_PPORT_ST_DISABLING_QWAIT},
111 {BFA_SM(bfa_pport_sm_disabling), BFA_PPORT_ST_DISABLING},
112 {BFA_SM(bfa_pport_sm_disabled), BFA_PPORT_ST_DISABLED},
113 {BFA_SM(bfa_pport_sm_stopped), BFA_PPORT_ST_STOPPED},
114 {BFA_SM(bfa_pport_sm_iocdown), BFA_PPORT_ST_IOCDOWN},
115 {BFA_SM(bfa_pport_sm_iocfail), BFA_PPORT_ST_IOCDOWN},
116 };
117
118 static void
119 bfa_pport_aen_post(struct bfa_pport_s *pport, enum bfa_port_aen_event event)
120 {
121 union bfa_aen_data_u aen_data;
122 struct bfa_log_mod_s *logmod = pport->bfa->logm;
123 wwn_t pwwn = pport->pwwn;
124 char pwwn_ptr[BFA_STRING_32];
125 struct bfa_ioc_attr_s ioc_attr;
126
127 wwn2str(pwwn_ptr, pwwn);
128 switch (event) {
129 case BFA_PORT_AEN_ONLINE:
130 bfa_log(logmod, BFA_AEN_PORT_ONLINE, pwwn_ptr);
131 break;
132 case BFA_PORT_AEN_OFFLINE:
133 bfa_log(logmod, BFA_AEN_PORT_OFFLINE, pwwn_ptr);
134 break;
135 case BFA_PORT_AEN_ENABLE:
136 bfa_log(logmod, BFA_AEN_PORT_ENABLE, pwwn_ptr);
137 break;
138 case BFA_PORT_AEN_DISABLE:
139 bfa_log(logmod, BFA_AEN_PORT_DISABLE, pwwn_ptr);
140 break;
141 case BFA_PORT_AEN_DISCONNECT:
142 bfa_log(logmod, BFA_AEN_PORT_DISCONNECT, pwwn_ptr);
143 break;
144 case BFA_PORT_AEN_QOS_NEG:
145 bfa_log(logmod, BFA_AEN_PORT_QOS_NEG, pwwn_ptr);
146 break;
147 default:
148 break;
149 }
150
151 bfa_ioc_get_attr(&pport->bfa->ioc, &ioc_attr);
152 aen_data.port.ioc_type = ioc_attr.ioc_type;
153 aen_data.port.pwwn = pwwn;
154 }
155
156 static void
157 bfa_pport_sm_uninit(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
158 {
159 bfa_trc(pport->bfa, event);
160
161 switch (event) {
162 case BFA_PPORT_SM_START:
163 /**
164 * Start event after IOC is configured and BFA is started.
165 */
166 if (bfa_pport_send_enable(pport))
167 bfa_sm_set_state(pport, bfa_pport_sm_enabling);
168 else
169 bfa_sm_set_state(pport, bfa_pport_sm_enabling_qwait);
170 break;
171
172 case BFA_PPORT_SM_ENABLE:
173 /**
174 * Port is persistently configured to be in enabled state. Do
175 * not change state. Port enabling is done when START event is
176 * received.
177 */
178 break;
179
180 case BFA_PPORT_SM_DISABLE:
181 /**
182 * If a port is persistently configured to be disabled, the
183 * first event will a port disable request.
184 */
185 bfa_sm_set_state(pport, bfa_pport_sm_disabled);
186 break;
187
188 case BFA_PPORT_SM_HWFAIL:
189 bfa_sm_set_state(pport, bfa_pport_sm_iocdown);
190 break;
191
192 default:
193 bfa_sm_fault(pport->bfa, event);
194 }
195 }
196
197 static void
198 bfa_pport_sm_enabling_qwait(struct bfa_pport_s *pport,
199 enum bfa_pport_sm_event event)
200 {
201 bfa_trc(pport->bfa, event);
202
203 switch (event) {
204 case BFA_PPORT_SM_QRESUME:
205 bfa_sm_set_state(pport, bfa_pport_sm_enabling);
206 bfa_pport_send_enable(pport);
207 break;
208
209 case BFA_PPORT_SM_STOP:
210 bfa_reqq_wcancel(&pport->reqq_wait);
211 bfa_sm_set_state(pport, bfa_pport_sm_stopped);
212 break;
213
214 case BFA_PPORT_SM_ENABLE:
215 /**
216 * Already enable is in progress.
217 */
218 break;
219
220 case BFA_PPORT_SM_DISABLE:
221 /**
222 * Just send disable request to firmware when room becomes
223 * available in request queue.
224 */
225 bfa_sm_set_state(pport, bfa_pport_sm_disabled);
226 bfa_reqq_wcancel(&pport->reqq_wait);
227 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
228 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
229 bfa_pport_aen_post(pport, BFA_PORT_AEN_DISABLE);
230 break;
231
232 case BFA_PPORT_SM_LINKUP:
233 case BFA_PPORT_SM_LINKDOWN:
234 /**
235 * Possible to get link events when doing back-to-back
236 * enable/disables.
237 */
238 break;
239
240 case BFA_PPORT_SM_HWFAIL:
241 bfa_reqq_wcancel(&pport->reqq_wait);
242 bfa_sm_set_state(pport, bfa_pport_sm_iocdown);
243 break;
244
245 default:
246 bfa_sm_fault(pport->bfa, event);
247 }
248 }
249
250 static void
251 bfa_pport_sm_enabling(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
252 {
253 bfa_trc(pport->bfa, event);
254
255 switch (event) {
256 case BFA_PPORT_SM_FWRSP:
257 case BFA_PPORT_SM_LINKDOWN:
258 bfa_sm_set_state(pport, bfa_pport_sm_linkdown);
259 break;
260
261 case BFA_PPORT_SM_LINKUP:
262 bfa_pport_update_linkinfo(pport);
263 bfa_sm_set_state(pport, bfa_pport_sm_linkup);
264
265 bfa_assert(pport->event_cbfn);
266 bfa_pport_callback(pport, BFA_PPORT_LINKUP);
267 break;
268
269 case BFA_PPORT_SM_ENABLE:
270 /**
271 * Already being enabled.
272 */
273 break;
274
275 case BFA_PPORT_SM_DISABLE:
276 if (bfa_pport_send_disable(pport))
277 bfa_sm_set_state(pport, bfa_pport_sm_disabling);
278 else
279 bfa_sm_set_state(pport, bfa_pport_sm_disabling_qwait);
280
281 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
282 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
283 bfa_pport_aen_post(pport, BFA_PORT_AEN_DISABLE);
284 break;
285
286 case BFA_PPORT_SM_STOP:
287 bfa_sm_set_state(pport, bfa_pport_sm_stopped);
288 break;
289
290 case BFA_PPORT_SM_HWFAIL:
291 bfa_sm_set_state(pport, bfa_pport_sm_iocdown);
292 break;
293
294 default:
295 bfa_sm_fault(pport->bfa, event);
296 }
297 }
298
299 static void
300 bfa_pport_sm_linkdown(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
301 {
302 bfa_trc(pport->bfa, event);
303
304 switch (event) {
305 case BFA_PPORT_SM_LINKUP:
306 bfa_pport_update_linkinfo(pport);
307 bfa_sm_set_state(pport, bfa_pport_sm_linkup);
308 bfa_assert(pport->event_cbfn);
309 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
310 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkup");
311 bfa_pport_callback(pport, BFA_PPORT_LINKUP);
312 bfa_pport_aen_post(pport, BFA_PORT_AEN_ONLINE);
313 /**
314 * If QoS is enabled and it is not online,
315 * Send a separate event.
316 */
317 if ((pport->cfg.qos_enabled)
318 && (bfa_os_ntohl(pport->qos_attr.state) != BFA_QOS_ONLINE))
319 bfa_pport_aen_post(pport, BFA_PORT_AEN_QOS_NEG);
320
321 break;
322
323 case BFA_PPORT_SM_LINKDOWN:
324 /**
325 * Possible to get link down event.
326 */
327 break;
328
329 case BFA_PPORT_SM_ENABLE:
330 /**
331 * Already enabled.
332 */
333 break;
334
335 case BFA_PPORT_SM_DISABLE:
336 if (bfa_pport_send_disable(pport))
337 bfa_sm_set_state(pport, bfa_pport_sm_disabling);
338 else
339 bfa_sm_set_state(pport, bfa_pport_sm_disabling_qwait);
340
341 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
342 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
343 bfa_pport_aen_post(pport, BFA_PORT_AEN_DISABLE);
344 break;
345
346 case BFA_PPORT_SM_STOP:
347 bfa_sm_set_state(pport, bfa_pport_sm_stopped);
348 break;
349
350 case BFA_PPORT_SM_HWFAIL:
351 bfa_sm_set_state(pport, bfa_pport_sm_iocdown);
352 break;
353
354 default:
355 bfa_sm_fault(pport->bfa, event);
356 }
357 }
358
359 static void
360 bfa_pport_sm_linkup(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
361 {
362 bfa_trc(pport->bfa, event);
363
364 switch (event) {
365 case BFA_PPORT_SM_ENABLE:
366 /**
367 * Already enabled.
368 */
369 break;
370
371 case BFA_PPORT_SM_DISABLE:
372 if (bfa_pport_send_disable(pport))
373 bfa_sm_set_state(pport, bfa_pport_sm_disabling);
374 else
375 bfa_sm_set_state(pport, bfa_pport_sm_disabling_qwait);
376
377 bfa_pport_reset_linkinfo(pport);
378 bfa_pport_callback(pport, BFA_PPORT_LINKDOWN);
379 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
380 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
381 bfa_pport_aen_post(pport, BFA_PORT_AEN_OFFLINE);
382 bfa_pport_aen_post(pport, BFA_PORT_AEN_DISABLE);
383 break;
384
385 case BFA_PPORT_SM_LINKDOWN:
386 bfa_sm_set_state(pport, bfa_pport_sm_linkdown);
387 bfa_pport_reset_linkinfo(pport);
388 bfa_pport_callback(pport, BFA_PPORT_LINKDOWN);
389 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
390 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkdown");
391 if (BFA_PORT_IS_DISABLED(pport->bfa))
392 bfa_pport_aen_post(pport, BFA_PORT_AEN_OFFLINE);
393 else
394 bfa_pport_aen_post(pport, BFA_PORT_AEN_DISCONNECT);
395 break;
396
397 case BFA_PPORT_SM_STOP:
398 bfa_sm_set_state(pport, bfa_pport_sm_stopped);
399 bfa_pport_reset_linkinfo(pport);
400 if (BFA_PORT_IS_DISABLED(pport->bfa))
401 bfa_pport_aen_post(pport, BFA_PORT_AEN_OFFLINE);
402 else
403 bfa_pport_aen_post(pport, BFA_PORT_AEN_DISCONNECT);
404 break;
405
406 case BFA_PPORT_SM_HWFAIL:
407 bfa_sm_set_state(pport, bfa_pport_sm_iocdown);
408 bfa_pport_reset_linkinfo(pport);
409 bfa_pport_callback(pport, BFA_PPORT_LINKDOWN);
410 if (BFA_PORT_IS_DISABLED(pport->bfa))
411 bfa_pport_aen_post(pport, BFA_PORT_AEN_OFFLINE);
412 else
413 bfa_pport_aen_post(pport, BFA_PORT_AEN_DISCONNECT);
414 break;
415
416 default:
417 bfa_sm_fault(pport->bfa, event);
418 }
419 }
420
421 static void
422 bfa_pport_sm_disabling_qwait(struct bfa_pport_s *pport,
423 enum bfa_pport_sm_event event)
424 {
425 bfa_trc(pport->bfa, event);
426
427 switch (event) {
428 case BFA_PPORT_SM_QRESUME:
429 bfa_sm_set_state(pport, bfa_pport_sm_disabling);
430 bfa_pport_send_disable(pport);
431 break;
432
433 case BFA_PPORT_SM_STOP:
434 bfa_sm_set_state(pport, bfa_pport_sm_stopped);
435 bfa_reqq_wcancel(&pport->reqq_wait);
436 break;
437
438 case BFA_PPORT_SM_DISABLE:
439 /**
440 * Already being disabled.
441 */
442 break;
443
444 case BFA_PPORT_SM_LINKUP:
445 case BFA_PPORT_SM_LINKDOWN:
446 /**
447 * Possible to get link events when doing back-to-back
448 * enable/disables.
449 */
450 break;
451
452 case BFA_PPORT_SM_HWFAIL:
453 bfa_sm_set_state(pport, bfa_pport_sm_iocfail);
454 bfa_reqq_wcancel(&pport->reqq_wait);
455 break;
456
457 default:
458 bfa_sm_fault(pport->bfa, event);
459 }
460 }
461
462 static void
463 bfa_pport_sm_disabling(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
464 {
465 bfa_trc(pport->bfa, event);
466
467 switch (event) {
468 case BFA_PPORT_SM_FWRSP:
469 bfa_sm_set_state(pport, bfa_pport_sm_disabled);
470 break;
471
472 case BFA_PPORT_SM_DISABLE:
473 /**
474 * Already being disabled.
475 */
476 break;
477
478 case BFA_PPORT_SM_ENABLE:
479 if (bfa_pport_send_enable(pport))
480 bfa_sm_set_state(pport, bfa_pport_sm_enabling);
481 else
482 bfa_sm_set_state(pport, bfa_pport_sm_enabling_qwait);
483
484 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
485 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
486 bfa_pport_aen_post(pport, BFA_PORT_AEN_ENABLE);
487 break;
488
489 case BFA_PPORT_SM_STOP:
490 bfa_sm_set_state(pport, bfa_pport_sm_stopped);
491 break;
492
493 case BFA_PPORT_SM_LINKUP:
494 case BFA_PPORT_SM_LINKDOWN:
495 /**
496 * Possible to get link events when doing back-to-back
497 * enable/disables.
498 */
499 break;
500
501 case BFA_PPORT_SM_HWFAIL:
502 bfa_sm_set_state(pport, bfa_pport_sm_iocfail);
503 break;
504
505 default:
506 bfa_sm_fault(pport->bfa, event);
507 }
508 }
509
510 static void
511 bfa_pport_sm_disabled(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
512 {
513 bfa_trc(pport->bfa, event);
514
515 switch (event) {
516 case BFA_PPORT_SM_START:
517 /**
518 * Ignore start event for a port that is disabled.
519 */
520 break;
521
522 case BFA_PPORT_SM_STOP:
523 bfa_sm_set_state(pport, bfa_pport_sm_stopped);
524 break;
525
526 case BFA_PPORT_SM_ENABLE:
527 if (bfa_pport_send_enable(pport))
528 bfa_sm_set_state(pport, bfa_pport_sm_enabling);
529 else
530 bfa_sm_set_state(pport, bfa_pport_sm_enabling_qwait);
531
532 bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
533 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
534 bfa_pport_aen_post(pport, BFA_PORT_AEN_ENABLE);
535 break;
536
537 case BFA_PPORT_SM_DISABLE:
538 /**
539 * Already disabled.
540 */
541 break;
542
543 case BFA_PPORT_SM_HWFAIL:
544 bfa_sm_set_state(pport, bfa_pport_sm_iocfail);
545 break;
546
547 default:
548 bfa_sm_fault(pport->bfa, event);
549 }
550 }
551
552 static void
553 bfa_pport_sm_stopped(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
554 {
555 bfa_trc(pport->bfa, event);
556
557 switch (event) {
558 case BFA_PPORT_SM_START:
559 if (bfa_pport_send_enable(pport))
560 bfa_sm_set_state(pport, bfa_pport_sm_enabling);
561 else
562 bfa_sm_set_state(pport, bfa_pport_sm_enabling_qwait);
563 break;
564
565 default:
566 /**
567 * Ignore all other events.
568 */
569 ;
570 }
571 }
572
573 /**
574 * Port is enabled. IOC is down/failed.
575 */
576 static void
577 bfa_pport_sm_iocdown(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
578 {
579 bfa_trc(pport->bfa, event);
580
581 switch (event) {
582 case BFA_PPORT_SM_START:
583 if (bfa_pport_send_enable(pport))
584 bfa_sm_set_state(pport, bfa_pport_sm_enabling);
585 else
586 bfa_sm_set_state(pport, bfa_pport_sm_enabling_qwait);
587 break;
588
589 default:
590 /**
591 * Ignore all events.
592 */
593 ;
594 }
595 }
596
597 /**
598 * Port is disabled. IOC is down/failed.
599 */
600 static void
601 bfa_pport_sm_iocfail(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
602 {
603 bfa_trc(pport->bfa, event);
604
605 switch (event) {
606 case BFA_PPORT_SM_START:
607 bfa_sm_set_state(pport, bfa_pport_sm_disabled);
608 break;
609
610 case BFA_PPORT_SM_ENABLE:
611 bfa_sm_set_state(pport, bfa_pport_sm_iocdown);
612 break;
613
614 default:
615 /**
616 * Ignore all events.
617 */
618 ;
619 }
620 }
621
622
623
624 /**
625 * bfa_pport_private
626 */
627
628 static void
629 __bfa_cb_port_event(void *cbarg, bfa_boolean_t complete)
630 {
631 struct bfa_pport_s *pport = cbarg;
632
633 if (complete)
634 pport->event_cbfn(pport->event_cbarg, pport->hcb_event);
635 }
636
637 #define PPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_pport_stats_u), \
638 BFA_CACHELINE_SZ))
639
640 static void
641 bfa_pport_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
642 u32 *dm_len)
643 {
644 *dm_len += PPORT_STATS_DMA_SZ;
645 }
646
647 static void
648 bfa_pport_qresume(void *cbarg)
649 {
650 struct bfa_pport_s *port = cbarg;
651
652 bfa_sm_send_event(port, BFA_PPORT_SM_QRESUME);
653 }
654
655 static void
656 bfa_pport_mem_claim(struct bfa_pport_s *pport, struct bfa_meminfo_s *meminfo)
657 {
658 u8 *dm_kva;
659 u64 dm_pa;
660
661 dm_kva = bfa_meminfo_dma_virt(meminfo);
662 dm_pa = bfa_meminfo_dma_phys(meminfo);
663
664 pport->stats_kva = dm_kva;
665 pport->stats_pa = dm_pa;
666 pport->stats = (union bfa_pport_stats_u *)dm_kva;
667
668 dm_kva += PPORT_STATS_DMA_SZ;
669 dm_pa += PPORT_STATS_DMA_SZ;
670
671 bfa_meminfo_dma_virt(meminfo) = dm_kva;
672 bfa_meminfo_dma_phys(meminfo) = dm_pa;
673 }
674
675 /**
676 * Memory initialization.
677 */
678 static void
679 bfa_pport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
680 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
681 {
682 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
683 struct bfa_pport_cfg_s *port_cfg = &pport->cfg;
684
685 bfa_os_memset(pport, 0, sizeof(struct bfa_pport_s));
686 pport->bfa = bfa;
687
688 bfa_pport_mem_claim(pport, meminfo);
689
690 bfa_sm_set_state(pport, bfa_pport_sm_uninit);
691
692 /**
693 * initialize and set default configuration
694 */
695 port_cfg->topology = BFA_PPORT_TOPOLOGY_P2P;
696 port_cfg->speed = BFA_PPORT_SPEED_AUTO;
697 port_cfg->trunked = BFA_FALSE;
698 port_cfg->maxfrsize = 0;
699
700 port_cfg->trl_def_speed = BFA_PPORT_SPEED_1GBPS;
701
702 bfa_reqq_winit(&pport->reqq_wait, bfa_pport_qresume, pport);
703 }
704
705 static void
706 bfa_pport_initdone(struct bfa_s *bfa)
707 {
708 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
709
710 /**
711 * Initialize port attributes from IOC hardware data.
712 */
713 bfa_pport_set_wwns(pport);
714 if (pport->cfg.maxfrsize == 0)
715 pport->cfg.maxfrsize = bfa_ioc_maxfrsize(&bfa->ioc);
716 pport->cfg.rx_bbcredit = bfa_ioc_rx_bbcredit(&bfa->ioc);
717 pport->speed_sup = bfa_ioc_speed_sup(&bfa->ioc);
718
719 bfa_assert(pport->cfg.maxfrsize);
720 bfa_assert(pport->cfg.rx_bbcredit);
721 bfa_assert(pport->speed_sup);
722 }
723
724 static void
725 bfa_pport_detach(struct bfa_s *bfa)
726 {
727 }
728
729 /**
730 * Called when IOC is ready.
731 */
732 static void
733 bfa_pport_start(struct bfa_s *bfa)
734 {
735 bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_START);
736 }
737
738 /**
739 * Called before IOC is stopped.
740 */
741 static void
742 bfa_pport_stop(struct bfa_s *bfa)
743 {
744 bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_STOP);
745 }
746
747 /**
748 * Called when IOC failure is detected.
749 */
750 static void
751 bfa_pport_iocdisable(struct bfa_s *bfa)
752 {
753 bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_HWFAIL);
754 }
755
756 static void
757 bfa_pport_update_linkinfo(struct bfa_pport_s *pport)
758 {
759 struct bfi_pport_event_s *pevent = pport->event_arg.i2hmsg.event;
760
761 pport->speed = pevent->link_state.speed;
762 pport->topology = pevent->link_state.topology;
763
764 if (pport->topology == BFA_PPORT_TOPOLOGY_LOOP)
765 pport->myalpa = pevent->link_state.tl.loop_info.myalpa;
766
767 /*
768 * QoS Details
769 */
770 bfa_os_assign(pport->qos_attr, pevent->link_state.qos_attr);
771 bfa_os_assign(pport->qos_vc_attr, pevent->link_state.qos_vc_attr);
772
773 bfa_trc(pport->bfa, pport->speed);
774 bfa_trc(pport->bfa, pport->topology);
775 }
776
777 static void
778 bfa_pport_reset_linkinfo(struct bfa_pport_s *pport)
779 {
780 pport->speed = BFA_PPORT_SPEED_UNKNOWN;
781 pport->topology = BFA_PPORT_TOPOLOGY_NONE;
782 }
783
784 /**
785 * Send port enable message to firmware.
786 */
787 static bfa_boolean_t
788 bfa_pport_send_enable(struct bfa_pport_s *port)
789 {
790 struct bfi_pport_enable_req_s *m;
791
792 /**
793 * Increment message tag before queue check, so that responses to old
794 * requests are discarded.
795 */
796 port->msgtag++;
797
798 /**
799 * check for room in queue to send request now
800 */
801 m = bfa_reqq_next(port->bfa, BFA_REQQ_PORT);
802 if (!m) {
803 bfa_reqq_wait(port->bfa, BFA_REQQ_PORT, &port->reqq_wait);
804 return BFA_FALSE;
805 }
806
807 bfi_h2i_set(m->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_ENABLE_REQ,
808 bfa_lpuid(port->bfa));
809 m->nwwn = port->nwwn;
810 m->pwwn = port->pwwn;
811 m->port_cfg = port->cfg;
812 m->msgtag = port->msgtag;
813 m->port_cfg.maxfrsize = bfa_os_htons(port->cfg.maxfrsize);
814 bfa_dma_be_addr_set(m->stats_dma_addr, port->stats_pa);
815 bfa_trc(port->bfa, m->stats_dma_addr.a32.addr_lo);
816 bfa_trc(port->bfa, m->stats_dma_addr.a32.addr_hi);
817
818 /**
819 * queue I/O message to firmware
820 */
821 bfa_reqq_produce(port->bfa, BFA_REQQ_PORT);
822 return BFA_TRUE;
823 }
824
825 /**
826 * Send port disable message to firmware.
827 */
828 static bfa_boolean_t
829 bfa_pport_send_disable(struct bfa_pport_s *port)
830 {
831 bfi_pport_disable_req_t *m;
832
833 /**
834 * Increment message tag before queue check, so that responses to old
835 * requests are discarded.
836 */
837 port->msgtag++;
838
839 /**
840 * check for room in queue to send request now
841 */
842 m = bfa_reqq_next(port->bfa, BFA_REQQ_PORT);
843 if (!m) {
844 bfa_reqq_wait(port->bfa, BFA_REQQ_PORT, &port->reqq_wait);
845 return BFA_FALSE;
846 }
847
848 bfi_h2i_set(m->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_DISABLE_REQ,
849 bfa_lpuid(port->bfa));
850 m->msgtag = port->msgtag;
851
852 /**
853 * queue I/O message to firmware
854 */
855 bfa_reqq_produce(port->bfa, BFA_REQQ_PORT);
856
857 return BFA_TRUE;
858 }
859
860 static void
861 bfa_pport_set_wwns(struct bfa_pport_s *port)
862 {
863 port->pwwn = bfa_ioc_get_pwwn(&port->bfa->ioc);
864 port->nwwn = bfa_ioc_get_nwwn(&port->bfa->ioc);
865
866 bfa_trc(port->bfa, port->pwwn);
867 bfa_trc(port->bfa, port->nwwn);
868 }
869
870 static void
871 bfa_port_send_txcredit(void *port_cbarg)
872 {
873
874 struct bfa_pport_s *port = port_cbarg;
875 struct bfi_pport_set_svc_params_req_s *m;
876
877 /**
878 * check for room in queue to send request now
879 */
880 m = bfa_reqq_next(port->bfa, BFA_REQQ_PORT);
881 if (!m) {
882 bfa_trc(port->bfa, port->cfg.tx_bbcredit);
883 return;
884 }
885
886 bfi_h2i_set(m->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_SET_SVC_PARAMS_REQ,
887 bfa_lpuid(port->bfa));
888 m->tx_bbcredit = bfa_os_htons((u16) port->cfg.tx_bbcredit);
889
890 /**
891 * queue I/O message to firmware
892 */
893 bfa_reqq_produce(port->bfa, BFA_REQQ_PORT);
894 }
895
896
897
898 /**
899 * bfa_pport_public
900 */
901
902 /**
903 * Firmware message handler.
904 */
905 void
906 bfa_pport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
907 {
908 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
909 union bfi_pport_i2h_msg_u i2hmsg;
910
911 i2hmsg.msg = msg;
912 pport->event_arg.i2hmsg = i2hmsg;
913
914 switch (msg->mhdr.msg_id) {
915 case BFI_PPORT_I2H_ENABLE_RSP:
916 if (pport->msgtag == i2hmsg.enable_rsp->msgtag)
917 bfa_sm_send_event(pport, BFA_PPORT_SM_FWRSP);
918 break;
919
920 case BFI_PPORT_I2H_DISABLE_RSP:
921 if (pport->msgtag == i2hmsg.enable_rsp->msgtag)
922 bfa_sm_send_event(pport, BFA_PPORT_SM_FWRSP);
923 break;
924
925 case BFI_PPORT_I2H_EVENT:
926 switch (i2hmsg.event->link_state.linkstate) {
927 case BFA_PPORT_LINKUP:
928 bfa_sm_send_event(pport, BFA_PPORT_SM_LINKUP);
929 break;
930 case BFA_PPORT_LINKDOWN:
931 bfa_sm_send_event(pport, BFA_PPORT_SM_LINKDOWN);
932 break;
933 case BFA_PPORT_TRUNK_LINKDOWN:
934 /** todo: event notification */
935 break;
936 }
937 break;
938
939 case BFI_PPORT_I2H_GET_STATS_RSP:
940 case BFI_PPORT_I2H_GET_QOS_STATS_RSP:
941 /*
942 * check for timer pop before processing the rsp
943 */
944 if (pport->stats_busy == BFA_FALSE
945 || pport->stats_status == BFA_STATUS_ETIMER)
946 break;
947
948 bfa_timer_stop(&pport->timer);
949 pport->stats_status = i2hmsg.getstats_rsp->status;
950 bfa_cb_queue(pport->bfa, &pport->hcb_qe, __bfa_cb_port_stats,
951 pport);
952 break;
953 case BFI_PPORT_I2H_CLEAR_STATS_RSP:
954 case BFI_PPORT_I2H_CLEAR_QOS_STATS_RSP:
955 /*
956 * check for timer pop before processing the rsp
957 */
958 if (pport->stats_busy == BFA_FALSE
959 || pport->stats_status == BFA_STATUS_ETIMER)
960 break;
961
962 bfa_timer_stop(&pport->timer);
963 pport->stats_status = BFA_STATUS_OK;
964 bfa_cb_queue(pport->bfa, &pport->hcb_qe,
965 __bfa_cb_port_stats_clr, pport);
966 break;
967
968 default:
969 bfa_assert(0);
970 }
971 }
972
973
974
975 /**
976 * bfa_pport_api
977 */
978
979 /**
980 * Registered callback for port events.
981 */
982 void
983 bfa_pport_event_register(struct bfa_s *bfa,
984 void (*cbfn) (void *cbarg, bfa_pport_event_t event),
985 void *cbarg)
986 {
987 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
988
989 pport->event_cbfn = cbfn;
990 pport->event_cbarg = cbarg;
991 }
992
993 bfa_status_t
994 bfa_pport_enable(struct bfa_s *bfa)
995 {
996 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
997
998 if (pport->diag_busy)
999 return BFA_STATUS_DIAG_BUSY;
1000 else if (bfa_sm_cmp_state
1001 (BFA_PORT_MOD(bfa), bfa_pport_sm_disabling_qwait))
1002 return BFA_STATUS_DEVBUSY;
1003
1004 bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_ENABLE);
1005 return BFA_STATUS_OK;
1006 }
1007
1008 bfa_status_t
1009 bfa_pport_disable(struct bfa_s *bfa)
1010 {
1011 bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_DISABLE);
1012 return BFA_STATUS_OK;
1013 }
1014
1015 /**
1016 * Configure port speed.
1017 */
1018 bfa_status_t
1019 bfa_pport_cfg_speed(struct bfa_s *bfa, enum bfa_pport_speed speed)
1020 {
1021 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1022
1023 bfa_trc(bfa, speed);
1024
1025 if ((speed != BFA_PPORT_SPEED_AUTO) && (speed > pport->speed_sup)) {
1026 bfa_trc(bfa, pport->speed_sup);
1027 return BFA_STATUS_UNSUPP_SPEED;
1028 }
1029
1030 pport->cfg.speed = speed;
1031
1032 return BFA_STATUS_OK;
1033 }
1034
1035 /**
1036 * Get current speed.
1037 */
1038 enum bfa_pport_speed
1039 bfa_pport_get_speed(struct bfa_s *bfa)
1040 {
1041 struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
1042
1043 return port->speed;
1044 }
1045
1046 /**
1047 * Configure port topology.
1048 */
1049 bfa_status_t
1050 bfa_pport_cfg_topology(struct bfa_s *bfa, enum bfa_pport_topology topology)
1051 {
1052 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1053
1054 bfa_trc(bfa, topology);
1055 bfa_trc(bfa, pport->cfg.topology);
1056
1057 switch (topology) {
1058 case BFA_PPORT_TOPOLOGY_P2P:
1059 case BFA_PPORT_TOPOLOGY_LOOP:
1060 case BFA_PPORT_TOPOLOGY_AUTO:
1061 break;
1062
1063 default:
1064 return BFA_STATUS_EINVAL;
1065 }
1066
1067 pport->cfg.topology = topology;
1068 return BFA_STATUS_OK;
1069 }
1070
1071 /**
1072 * Get current topology.
1073 */
1074 enum bfa_pport_topology
1075 bfa_pport_get_topology(struct bfa_s *bfa)
1076 {
1077 struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
1078
1079 return port->topology;
1080 }
1081
1082 bfa_status_t
1083 bfa_pport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa)
1084 {
1085 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1086
1087 bfa_trc(bfa, alpa);
1088 bfa_trc(bfa, pport->cfg.cfg_hardalpa);
1089 bfa_trc(bfa, pport->cfg.hardalpa);
1090
1091 pport->cfg.cfg_hardalpa = BFA_TRUE;
1092 pport->cfg.hardalpa = alpa;
1093
1094 return BFA_STATUS_OK;
1095 }
1096
1097 bfa_status_t
1098 bfa_pport_clr_hardalpa(struct bfa_s *bfa)
1099 {
1100 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1101
1102 bfa_trc(bfa, pport->cfg.cfg_hardalpa);
1103 bfa_trc(bfa, pport->cfg.hardalpa);
1104
1105 pport->cfg.cfg_hardalpa = BFA_FALSE;
1106 return BFA_STATUS_OK;
1107 }
1108
1109 bfa_boolean_t
1110 bfa_pport_get_hardalpa(struct bfa_s *bfa, u8 *alpa)
1111 {
1112 struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
1113
1114 *alpa = port->cfg.hardalpa;
1115 return port->cfg.cfg_hardalpa;
1116 }
1117
1118 u8
1119 bfa_pport_get_myalpa(struct bfa_s *bfa)
1120 {
1121 struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
1122
1123 return port->myalpa;
1124 }
1125
1126 bfa_status_t
1127 bfa_pport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxfrsize)
1128 {
1129 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1130
1131 bfa_trc(bfa, maxfrsize);
1132 bfa_trc(bfa, pport->cfg.maxfrsize);
1133
1134 /*
1135 * with in range
1136 */
1137 if ((maxfrsize > FC_MAX_PDUSZ) || (maxfrsize < FC_MIN_PDUSZ))
1138 return BFA_STATUS_INVLD_DFSZ;
1139
1140 /*
1141 * power of 2, if not the max frame size of 2112
1142 */
1143 if ((maxfrsize != FC_MAX_PDUSZ) && (maxfrsize & (maxfrsize - 1)))
1144 return BFA_STATUS_INVLD_DFSZ;
1145
1146 pport->cfg.maxfrsize = maxfrsize;
1147 return BFA_STATUS_OK;
1148 }
1149
1150 u16
1151 bfa_pport_get_maxfrsize(struct bfa_s *bfa)
1152 {
1153 struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
1154
1155 return port->cfg.maxfrsize;
1156 }
1157
1158 u32
1159 bfa_pport_mypid(struct bfa_s *bfa)
1160 {
1161 struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
1162
1163 return port->mypid;
1164 }
1165
1166 u8
1167 bfa_pport_get_rx_bbcredit(struct bfa_s *bfa)
1168 {
1169 struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
1170
1171 return port->cfg.rx_bbcredit;
1172 }
1173
1174 void
1175 bfa_pport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit)
1176 {
1177 struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
1178
1179 port->cfg.tx_bbcredit = (u8) tx_bbcredit;
1180 bfa_port_send_txcredit(port);
1181 }
1182
1183 /**
1184 * Get port attributes.
1185 */
1186
1187 wwn_t
1188 bfa_pport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node)
1189 {
1190 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1191 if (node)
1192 return pport->nwwn;
1193 else
1194 return pport->pwwn;
1195 }
1196
1197 void
1198 bfa_pport_get_attr(struct bfa_s *bfa, struct bfa_pport_attr_s *attr)
1199 {
1200 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1201
1202 bfa_os_memset(attr, 0, sizeof(struct bfa_pport_attr_s));
1203
1204 attr->nwwn = pport->nwwn;
1205 attr->pwwn = pport->pwwn;
1206
1207 bfa_os_memcpy(&attr->pport_cfg, &pport->cfg,
1208 sizeof(struct bfa_pport_cfg_s));
1209 /*
1210 * speed attributes
1211 */
1212 attr->pport_cfg.speed = pport->cfg.speed;
1213 attr->speed_supported = pport->speed_sup;
1214 attr->speed = pport->speed;
1215 attr->cos_supported = FC_CLASS_3;
1216
1217 /*
1218 * topology attributes
1219 */
1220 attr->pport_cfg.topology = pport->cfg.topology;
1221 attr->topology = pport->topology;
1222
1223 /*
1224 * beacon attributes
1225 */
1226 attr->beacon = pport->beacon;
1227 attr->link_e2e_beacon = pport->link_e2e_beacon;
1228 attr->plog_enabled = bfa_plog_get_setting(pport->bfa->plog);
1229
1230 attr->pport_cfg.path_tov = bfa_fcpim_path_tov_get(bfa);
1231 attr->pport_cfg.q_depth = bfa_fcpim_qdepth_get(bfa);
1232 attr->port_state = bfa_sm_to_state(hal_pport_sm_table, pport->sm);
1233 if (bfa_ioc_is_disabled(&pport->bfa->ioc))
1234 attr->port_state = BFA_PPORT_ST_IOCDIS;
1235 else if (bfa_ioc_fw_mismatch(&pport->bfa->ioc))
1236 attr->port_state = BFA_PPORT_ST_FWMISMATCH;
1237 }
1238
1239 static void
1240 bfa_port_stats_query(void *cbarg)
1241 {
1242 struct bfa_pport_s *port = (struct bfa_pport_s *)cbarg;
1243 bfi_pport_get_stats_req_t *msg;
1244
1245 msg = bfa_reqq_next(port->bfa, BFA_REQQ_PORT);
1246
1247 if (!msg) {
1248 port->stats_qfull = BFA_TRUE;
1249 bfa_reqq_winit(&port->stats_reqq_wait, bfa_port_stats_query,
1250 port);
1251 bfa_reqq_wait(port->bfa, BFA_REQQ_PORT, &port->stats_reqq_wait);
1252 return;
1253 }
1254 port->stats_qfull = BFA_FALSE;
1255
1256 bfa_os_memset(msg, 0, sizeof(bfi_pport_get_stats_req_t));
1257 bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_GET_STATS_REQ,
1258 bfa_lpuid(port->bfa));
1259 bfa_reqq_produce(port->bfa, BFA_REQQ_PORT);
1260
1261 return;
1262 }
1263
1264 static void
1265 bfa_port_stats_clear(void *cbarg)
1266 {
1267 struct bfa_pport_s *port = (struct bfa_pport_s *)cbarg;
1268 bfi_pport_clear_stats_req_t *msg;
1269
1270 msg = bfa_reqq_next(port->bfa, BFA_REQQ_PORT);
1271
1272 if (!msg) {
1273 port->stats_qfull = BFA_TRUE;
1274 bfa_reqq_winit(&port->stats_reqq_wait, bfa_port_stats_clear,
1275 port);
1276 bfa_reqq_wait(port->bfa, BFA_REQQ_PORT, &port->stats_reqq_wait);
1277 return;
1278 }
1279 port->stats_qfull = BFA_FALSE;
1280
1281 bfa_os_memset(msg, 0, sizeof(bfi_pport_clear_stats_req_t));
1282 bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_CLEAR_STATS_REQ,
1283 bfa_lpuid(port->bfa));
1284 bfa_reqq_produce(port->bfa, BFA_REQQ_PORT);
1285 return;
1286 }
1287
1288 static void
1289 bfa_port_qos_stats_clear(void *cbarg)
1290 {
1291 struct bfa_pport_s *port = (struct bfa_pport_s *)cbarg;
1292 bfi_pport_clear_qos_stats_req_t *msg;
1293
1294 msg = bfa_reqq_next(port->bfa, BFA_REQQ_PORT);
1295
1296 if (!msg) {
1297 port->stats_qfull = BFA_TRUE;
1298 bfa_reqq_winit(&port->stats_reqq_wait, bfa_port_qos_stats_clear,
1299 port);
1300 bfa_reqq_wait(port->bfa, BFA_REQQ_PORT, &port->stats_reqq_wait);
1301 return;
1302 }
1303 port->stats_qfull = BFA_FALSE;
1304
1305 bfa_os_memset(msg, 0, sizeof(bfi_pport_clear_qos_stats_req_t));
1306 bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_CLEAR_QOS_STATS_REQ,
1307 bfa_lpuid(port->bfa));
1308 bfa_reqq_produce(port->bfa, BFA_REQQ_PORT);
1309 return;
1310 }
1311
1312 static void
1313 bfa_pport_stats_swap(union bfa_pport_stats_u *d, union bfa_pport_stats_u *s)
1314 {
1315 u32 *dip = (u32 *) d;
1316 u32 *sip = (u32 *) s;
1317 int i;
1318
1319 /*
1320 * Do 64 bit fields swap first
1321 */
1322 for (i = 0;
1323 i <
1324 ((sizeof(union bfa_pport_stats_u) -
1325 sizeof(struct bfa_qos_stats_s)) / sizeof(u32)); i = i + 2) {
1326 #ifdef __BIGENDIAN
1327 dip[i] = bfa_os_ntohl(sip[i]);
1328 dip[i + 1] = bfa_os_ntohl(sip[i + 1]);
1329 #else
1330 dip[i] = bfa_os_ntohl(sip[i + 1]);
1331 dip[i + 1] = bfa_os_ntohl(sip[i]);
1332 #endif
1333 }
1334
1335 /*
1336 * Now swap the 32 bit fields
1337 */
1338 for (; i < (sizeof(union bfa_pport_stats_u) / sizeof(u32)); ++i)
1339 dip[i] = bfa_os_ntohl(sip[i]);
1340 }
1341
1342 static void
1343 __bfa_cb_port_stats_clr(void *cbarg, bfa_boolean_t complete)
1344 {
1345 struct bfa_pport_s *port = cbarg;
1346
1347 if (complete) {
1348 port->stats_cbfn(port->stats_cbarg, port->stats_status);
1349 } else {
1350 port->stats_busy = BFA_FALSE;
1351 port->stats_status = BFA_STATUS_OK;
1352 }
1353 }
1354
1355 static void
1356 bfa_port_stats_clr_timeout(void *cbarg)
1357 {
1358 struct bfa_pport_s *port = (struct bfa_pport_s *)cbarg;
1359
1360 bfa_trc(port->bfa, port->stats_qfull);
1361
1362 if (port->stats_qfull) {
1363 bfa_reqq_wcancel(&port->stats_reqq_wait);
1364 port->stats_qfull = BFA_FALSE;
1365 }
1366
1367 port->stats_status = BFA_STATUS_ETIMER;
1368 bfa_cb_queue(port->bfa, &port->hcb_qe, __bfa_cb_port_stats_clr, port);
1369 }
1370
1371 static void
1372 __bfa_cb_port_stats(void *cbarg, bfa_boolean_t complete)
1373 {
1374 struct bfa_pport_s *port = cbarg;
1375
1376 if (complete) {
1377 if (port->stats_status == BFA_STATUS_OK)
1378 bfa_pport_stats_swap(port->stats_ret, port->stats);
1379 port->stats_cbfn(port->stats_cbarg, port->stats_status);
1380 } else {
1381 port->stats_busy = BFA_FALSE;
1382 port->stats_status = BFA_STATUS_OK;
1383 }
1384 }
1385
1386 static void
1387 bfa_port_stats_timeout(void *cbarg)
1388 {
1389 struct bfa_pport_s *port = (struct bfa_pport_s *)cbarg;
1390
1391 bfa_trc(port->bfa, port->stats_qfull);
1392
1393 if (port->stats_qfull) {
1394 bfa_reqq_wcancel(&port->stats_reqq_wait);
1395 port->stats_qfull = BFA_FALSE;
1396 }
1397
1398 port->stats_status = BFA_STATUS_ETIMER;
1399 bfa_cb_queue(port->bfa, &port->hcb_qe, __bfa_cb_port_stats, port);
1400 }
1401
1402 #define BFA_PORT_STATS_TOV 1000
1403
1404 /**
1405 * Fetch port attributes.
1406 */
1407 bfa_status_t
1408 bfa_pport_get_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats,
1409 bfa_cb_pport_t cbfn, void *cbarg)
1410 {
1411 struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
1412
1413 if (port->stats_busy) {
1414 bfa_trc(bfa, port->stats_busy);
1415 return BFA_STATUS_DEVBUSY;
1416 }
1417
1418 port->stats_busy = BFA_TRUE;
1419 port->stats_ret = stats;
1420 port->stats_cbfn = cbfn;
1421 port->stats_cbarg = cbarg;
1422
1423 bfa_port_stats_query(port);
1424
1425 bfa_timer_start(bfa, &port->timer, bfa_port_stats_timeout, port,
1426 BFA_PORT_STATS_TOV);
1427 return BFA_STATUS_OK;
1428 }
1429
1430 bfa_status_t
1431 bfa_pport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
1432 {
1433 struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
1434
1435 if (port->stats_busy) {
1436 bfa_trc(bfa, port->stats_busy);
1437 return BFA_STATUS_DEVBUSY;
1438 }
1439
1440 port->stats_busy = BFA_TRUE;
1441 port->stats_cbfn = cbfn;
1442 port->stats_cbarg = cbarg;
1443
1444 bfa_port_stats_clear(port);
1445
1446 bfa_timer_start(bfa, &port->timer, bfa_port_stats_clr_timeout, port,
1447 BFA_PORT_STATS_TOV);
1448 return BFA_STATUS_OK;
1449 }
1450
1451 bfa_status_t
1452 bfa_pport_trunk_enable(struct bfa_s *bfa, u8 bitmap)
1453 {
1454 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1455
1456 bfa_trc(bfa, bitmap);
1457 bfa_trc(bfa, pport->cfg.trunked);
1458 bfa_trc(bfa, pport->cfg.trunk_ports);
1459
1460 if (!bitmap || (bitmap & (bitmap - 1)))
1461 return BFA_STATUS_EINVAL;
1462
1463 pport->cfg.trunked = BFA_TRUE;
1464 pport->cfg.trunk_ports = bitmap;
1465
1466 return BFA_STATUS_OK;
1467 }
1468
1469 void
1470 bfa_pport_qos_get_attr(struct bfa_s *bfa, struct bfa_qos_attr_s *qos_attr)
1471 {
1472 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1473
1474 qos_attr->state = bfa_os_ntohl(pport->qos_attr.state);
1475 qos_attr->total_bb_cr = bfa_os_ntohl(pport->qos_attr.total_bb_cr);
1476 }
1477
1478 void
1479 bfa_pport_qos_get_vc_attr(struct bfa_s *bfa,
1480 struct bfa_qos_vc_attr_s *qos_vc_attr)
1481 {
1482 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1483 struct bfa_qos_vc_attr_s *bfa_vc_attr = &pport->qos_vc_attr;
1484 u32 i = 0;
1485
1486 qos_vc_attr->total_vc_count = bfa_os_ntohs(bfa_vc_attr->total_vc_count);
1487 qos_vc_attr->shared_credit = bfa_os_ntohs(bfa_vc_attr->shared_credit);
1488 qos_vc_attr->elp_opmode_flags =
1489 bfa_os_ntohl(bfa_vc_attr->elp_opmode_flags);
1490
1491 /*
1492 * Individual VC info
1493 */
1494 while (i < qos_vc_attr->total_vc_count) {
1495 qos_vc_attr->vc_info[i].vc_credit =
1496 bfa_vc_attr->vc_info[i].vc_credit;
1497 qos_vc_attr->vc_info[i].borrow_credit =
1498 bfa_vc_attr->vc_info[i].borrow_credit;
1499 qos_vc_attr->vc_info[i].priority =
1500 bfa_vc_attr->vc_info[i].priority;
1501 ++i;
1502 }
1503 }
1504
1505 /**
1506 * Fetch QoS Stats.
1507 */
1508 bfa_status_t
1509 bfa_pport_get_qos_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats,
1510 bfa_cb_pport_t cbfn, void *cbarg)
1511 {
1512 /*
1513 * QoS stats is embedded in port stats
1514 */
1515 return bfa_pport_get_stats(bfa, stats, cbfn, cbarg);
1516 }
1517
1518 bfa_status_t
1519 bfa_pport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
1520 {
1521 struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
1522
1523 if (port->stats_busy) {
1524 bfa_trc(bfa, port->stats_busy);
1525 return BFA_STATUS_DEVBUSY;
1526 }
1527
1528 port->stats_busy = BFA_TRUE;
1529 port->stats_cbfn = cbfn;
1530 port->stats_cbarg = cbarg;
1531
1532 bfa_port_qos_stats_clear(port);
1533
1534 bfa_timer_start(bfa, &port->timer, bfa_port_stats_clr_timeout, port,
1535 BFA_PORT_STATS_TOV);
1536 return BFA_STATUS_OK;
1537 }
1538
1539 /**
1540 * Fetch port attributes.
1541 */
1542 bfa_status_t
1543 bfa_pport_trunk_disable(struct bfa_s *bfa)
1544 {
1545 return BFA_STATUS_OK;
1546 }
1547
1548 bfa_boolean_t
1549 bfa_pport_trunk_query(struct bfa_s *bfa, u32 *bitmap)
1550 {
1551 struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
1552
1553 *bitmap = port->cfg.trunk_ports;
1554 return port->cfg.trunked;
1555 }
1556
1557 bfa_boolean_t
1558 bfa_pport_is_disabled(struct bfa_s *bfa)
1559 {
1560 struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
1561
1562 return bfa_sm_to_state(hal_pport_sm_table, port->sm) ==
1563 BFA_PPORT_ST_DISABLED;
1564
1565 }
1566
1567 bfa_boolean_t
1568 bfa_pport_is_ratelim(struct bfa_s *bfa)
1569 {
1570 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1571
1572 return pport->cfg.ratelimit ? BFA_TRUE : BFA_FALSE;
1573
1574 }
1575
1576 void
1577 bfa_pport_cfg_qos(struct bfa_s *bfa, bfa_boolean_t on_off)
1578 {
1579 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1580
1581 bfa_trc(bfa, on_off);
1582 bfa_trc(bfa, pport->cfg.qos_enabled);
1583
1584 pport->cfg.qos_enabled = on_off;
1585 }
1586
1587 void
1588 bfa_pport_cfg_ratelim(struct bfa_s *bfa, bfa_boolean_t on_off)
1589 {
1590 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1591
1592 bfa_trc(bfa, on_off);
1593 bfa_trc(bfa, pport->cfg.ratelimit);
1594
1595 pport->cfg.ratelimit = on_off;
1596 if (pport->cfg.trl_def_speed == BFA_PPORT_SPEED_UNKNOWN)
1597 pport->cfg.trl_def_speed = BFA_PPORT_SPEED_1GBPS;
1598 }
1599
1600 /**
1601 * Configure default minimum ratelim speed
1602 */
1603 bfa_status_t
1604 bfa_pport_cfg_ratelim_speed(struct bfa_s *bfa, enum bfa_pport_speed speed)
1605 {
1606 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1607
1608 bfa_trc(bfa, speed);
1609
1610 /*
1611 * Auto and speeds greater than the supported speed, are invalid
1612 */
1613 if ((speed == BFA_PPORT_SPEED_AUTO) || (speed > pport->speed_sup)) {
1614 bfa_trc(bfa, pport->speed_sup);
1615 return BFA_STATUS_UNSUPP_SPEED;
1616 }
1617
1618 pport->cfg.trl_def_speed = speed;
1619
1620 return BFA_STATUS_OK;
1621 }
1622
1623 /**
1624 * Get default minimum ratelim speed
1625 */
1626 enum bfa_pport_speed
1627 bfa_pport_get_ratelim_speed(struct bfa_s *bfa)
1628 {
1629 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1630
1631 bfa_trc(bfa, pport->cfg.trl_def_speed);
1632 return pport->cfg.trl_def_speed;
1633
1634 }
1635
1636 void
1637 bfa_pport_busy(struct bfa_s *bfa, bfa_boolean_t status)
1638 {
1639 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1640
1641 bfa_trc(bfa, status);
1642 bfa_trc(bfa, pport->diag_busy);
1643
1644 pport->diag_busy = status;
1645 }
1646
1647 void
1648 bfa_pport_beacon(struct bfa_s *bfa, bfa_boolean_t beacon,
1649 bfa_boolean_t link_e2e_beacon)
1650 {
1651 struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
1652
1653 bfa_trc(bfa, beacon);
1654 bfa_trc(bfa, link_e2e_beacon);
1655 bfa_trc(bfa, pport->beacon);
1656 bfa_trc(bfa, pport->link_e2e_beacon);
1657
1658 pport->beacon = beacon;
1659 pport->link_e2e_beacon = link_e2e_beacon;
1660 }
1661
1662 bfa_boolean_t
1663 bfa_pport_is_linkup(struct bfa_s *bfa)
1664 {
1665 return bfa_sm_cmp_state(BFA_PORT_MOD(bfa), bfa_pport_sm_linkup);
1666 }
1667
1668
Linux kernel - Deliverables
This page took 0.087753 seconds and 5 git commands to generate.