1 /*
2 * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
3 * All rights reserved
4 * www.brocade.com
5 *
6 * Linux driver for Brocade Fibre Channel Host Bus Adapter.
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License (GPL) Version 2 as
10 * published by the Free Software Foundation
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 */
17
18 #include "bfad_drv.h"
19 #include "bfa_defs_svc.h"
20 #include "bfa_port.h"
21 #include "bfi.h"
22 #include "bfa_ioc.h"
23
24
25 BFA_TRC_FILE(CNA, PORT);
26
27 static void
bfa_port_stats_swap(struct bfa_port_s * port,union bfa_port_stats_u * stats)28 bfa_port_stats_swap(struct bfa_port_s *port, union bfa_port_stats_u *stats)
29 {
30 u32 *dip = (u32 *) stats;
31 __be32 t0, t1;
32 int i;
33
34 for (i = 0; i < sizeof(union bfa_port_stats_u)/sizeof(u32);
35 i += 2) {
36 t0 = dip[i];
37 t1 = dip[i + 1];
38 #ifdef __BIG_ENDIAN
39 dip[i] = be32_to_cpu(t0);
40 dip[i + 1] = be32_to_cpu(t1);
41 #else
42 dip[i] = be32_to_cpu(t1);
43 dip[i + 1] = be32_to_cpu(t0);
44 #endif
45 }
46 }
47
48 /*
49 * bfa_port_enable_isr()
50 *
51 *
52 * @param[in] port - Pointer to the port module
53 * status - Return status from the f/w
54 *
55 * @return void
56 */
57 static void
bfa_port_enable_isr(struct bfa_port_s * port,bfa_status_t status)58 bfa_port_enable_isr(struct bfa_port_s *port, bfa_status_t status)
59 {
60 bfa_trc(port, status);
61 port->endis_pending = BFA_FALSE;
62 port->endis_cbfn(port->endis_cbarg, status);
63 }
64
65 /*
66 * bfa_port_disable_isr()
67 *
68 *
69 * @param[in] port - Pointer to the port module
70 * status - Return status from the f/w
71 *
72 * @return void
73 */
74 static void
bfa_port_disable_isr(struct bfa_port_s * port,bfa_status_t status)75 bfa_port_disable_isr(struct bfa_port_s *port, bfa_status_t status)
76 {
77 bfa_trc(port, status);
78 port->endis_pending = BFA_FALSE;
79 port->endis_cbfn(port->endis_cbarg, status);
80 }
81
82 /*
83 * bfa_port_get_stats_isr()
84 *
85 *
86 * @param[in] port - Pointer to the Port module
87 * status - Return status from the f/w
88 *
89 * @return void
90 */
91 static void
bfa_port_get_stats_isr(struct bfa_port_s * port,bfa_status_t status)92 bfa_port_get_stats_isr(struct bfa_port_s *port, bfa_status_t status)
93 {
94 port->stats_status = status;
95 port->stats_busy = BFA_FALSE;
96
97 if (status == BFA_STATUS_OK) {
98 struct timeval tv;
99
100 memcpy(port->stats, port->stats_dma.kva,
101 sizeof(union bfa_port_stats_u));
102 bfa_port_stats_swap(port, port->stats);
103
104 do_gettimeofday(&tv);
105 port->stats->fc.secs_reset = tv.tv_sec - port->stats_reset_time;
106 }
107
108 if (port->stats_cbfn) {
109 port->stats_cbfn(port->stats_cbarg, status);
110 port->stats_cbfn = NULL;
111 }
112 }
113
114 /*
115 * bfa_port_clear_stats_isr()
116 *
117 *
118 * @param[in] port - Pointer to the Port module
119 * status - Return status from the f/w
120 *
121 * @return void
122 */
123 static void
bfa_port_clear_stats_isr(struct bfa_port_s * port,bfa_status_t status)124 bfa_port_clear_stats_isr(struct bfa_port_s *port, bfa_status_t status)
125 {
126 struct timeval tv;
127
128 port->stats_status = status;
129 port->stats_busy = BFA_FALSE;
130
131 /*
132 * re-initialize time stamp for stats reset
133 */
134 do_gettimeofday(&tv);
135 port->stats_reset_time = tv.tv_sec;
136
137 if (port->stats_cbfn) {
138 port->stats_cbfn(port->stats_cbarg, status);
139 port->stats_cbfn = NULL;
140 }
141 }
142
143 /*
144 * bfa_port_isr()
145 *
146 *
147 * @param[in] Pointer to the Port module data structure.
148 *
149 * @return void
150 */
151 static void
bfa_port_isr(void * cbarg,struct bfi_mbmsg_s * m)152 bfa_port_isr(void *cbarg, struct bfi_mbmsg_s *m)
153 {
154 struct bfa_port_s *port = (struct bfa_port_s *) cbarg;
155 union bfi_port_i2h_msg_u *i2hmsg;
156
157 i2hmsg = (union bfi_port_i2h_msg_u *) m;
158 bfa_trc(port, m->mh.msg_id);
159
160 switch (m->mh.msg_id) {
161 case BFI_PORT_I2H_ENABLE_RSP:
162 if (port->endis_pending == BFA_FALSE)
163 break;
164 bfa_port_enable_isr(port, i2hmsg->enable_rsp.status);
165 break;
166
167 case BFI_PORT_I2H_DISABLE_RSP:
168 if (port->endis_pending == BFA_FALSE)
169 break;
170 bfa_port_disable_isr(port, i2hmsg->disable_rsp.status);
171 break;
172
173 case BFI_PORT_I2H_GET_STATS_RSP:
174 /* Stats busy flag is still set? (may be cmd timed out) */
175 if (port->stats_busy == BFA_FALSE)
176 break;
177 bfa_port_get_stats_isr(port, i2hmsg->getstats_rsp.status);
178 break;
179
180 case BFI_PORT_I2H_CLEAR_STATS_RSP:
181 if (port->stats_busy == BFA_FALSE)
182 break;
183 bfa_port_clear_stats_isr(port, i2hmsg->clearstats_rsp.status);
184 break;
185
186 default:
187 WARN_ON(1);
188 }
189 }
190
191 /*
192 * bfa_port_meminfo()
193 *
194 *
195 * @param[in] void
196 *
197 * @return Size of DMA region
198 */
199 u32
bfa_port_meminfo(void)200 bfa_port_meminfo(void)
201 {
202 return BFA_ROUNDUP(sizeof(union bfa_port_stats_u), BFA_DMA_ALIGN_SZ);
203 }
204
205 /*
206 * bfa_port_mem_claim()
207 *
208 *
209 * @param[in] port Port module pointer
210 * dma_kva Kernel Virtual Address of Port DMA Memory
211 * dma_pa Physical Address of Port DMA Memory
212 *
213 * @return void
214 */
215 void
bfa_port_mem_claim(struct bfa_port_s * port,u8 * dma_kva,u64 dma_pa)216 bfa_port_mem_claim(struct bfa_port_s *port, u8 *dma_kva, u64 dma_pa)
217 {
218 port->stats_dma.kva = dma_kva;
219 port->stats_dma.pa = dma_pa;
220 }
221
222 /*
223 * bfa_port_enable()
224 *
225 * Send the Port enable request to the f/w
226 *
227 * @param[in] Pointer to the Port module data structure.
228 *
229 * @return Status
230 */
231 bfa_status_t
bfa_port_enable(struct bfa_port_s * port,bfa_port_endis_cbfn_t cbfn,void * cbarg)232 bfa_port_enable(struct bfa_port_s *port, bfa_port_endis_cbfn_t cbfn,
233 void *cbarg)
234 {
235 struct bfi_port_generic_req_s *m;
236
237 /* If port is PBC disabled, return error */
238 if (port->pbc_disabled) {
239 bfa_trc(port, BFA_STATUS_PBC);
240 return BFA_STATUS_PBC;
241 }
242
243 if (bfa_ioc_is_disabled(port->ioc)) {
244 bfa_trc(port, BFA_STATUS_IOC_DISABLED);
245 return BFA_STATUS_IOC_DISABLED;
246 }
247
248 if (!bfa_ioc_is_operational(port->ioc)) {
249 bfa_trc(port, BFA_STATUS_IOC_FAILURE);
250 return BFA_STATUS_IOC_FAILURE;
251 }
252
253 if (port->endis_pending) {
254 bfa_trc(port, BFA_STATUS_DEVBUSY);
255 return BFA_STATUS_DEVBUSY;
256 }
257
258 m = (struct bfi_port_generic_req_s *) port->endis_mb.msg;
259
260 port->msgtag++;
261 port->endis_cbfn = cbfn;
262 port->endis_cbarg = cbarg;
263 port->endis_pending = BFA_TRUE;
264
265 bfi_h2i_set(m->mh, BFI_MC_PORT, BFI_PORT_H2I_ENABLE_REQ,
266 bfa_ioc_portid(port->ioc));
267 bfa_ioc_mbox_queue(port->ioc, &port->endis_mb);
268
269 return BFA_STATUS_OK;
270 }
271
272 /*
273 * bfa_port_disable()
274 *
275 * Send the Port disable request to the f/w
276 *
277 * @param[in] Pointer to the Port module data structure.
278 *
279 * @return Status
280 */
281 bfa_status_t
bfa_port_disable(struct bfa_port_s * port,bfa_port_endis_cbfn_t cbfn,void * cbarg)282 bfa_port_disable(struct bfa_port_s *port, bfa_port_endis_cbfn_t cbfn,
283 void *cbarg)
284 {
285 struct bfi_port_generic_req_s *m;
286
287 /* If port is PBC disabled, return error */
288 if (port->pbc_disabled) {
289 bfa_trc(port, BFA_STATUS_PBC);
290 return BFA_STATUS_PBC;
291 }
292
293 if (bfa_ioc_is_disabled(port->ioc)) {
294 bfa_trc(port, BFA_STATUS_IOC_DISABLED);
295 return BFA_STATUS_IOC_DISABLED;
296 }
297
298 if (!bfa_ioc_is_operational(port->ioc)) {
299 bfa_trc(port, BFA_STATUS_IOC_FAILURE);
300 return BFA_STATUS_IOC_FAILURE;
301 }
302
303 if (port->endis_pending) {
304 bfa_trc(port, BFA_STATUS_DEVBUSY);
305 return BFA_STATUS_DEVBUSY;
306 }
307
308 m = (struct bfi_port_generic_req_s *) port->endis_mb.msg;
309
310 port->msgtag++;
311 port->endis_cbfn = cbfn;
312 port->endis_cbarg = cbarg;
313 port->endis_pending = BFA_TRUE;
314
315 bfi_h2i_set(m->mh, BFI_MC_PORT, BFI_PORT_H2I_DISABLE_REQ,
316 bfa_ioc_portid(port->ioc));
317 bfa_ioc_mbox_queue(port->ioc, &port->endis_mb);
318
319 return BFA_STATUS_OK;
320 }
321
322 /*
323 * bfa_port_get_stats()
324 *
325 * Send the request to the f/w to fetch Port statistics.
326 *
327 * @param[in] Pointer to the Port module data structure.
328 *
329 * @return Status
330 */
331 bfa_status_t
bfa_port_get_stats(struct bfa_port_s * port,union bfa_port_stats_u * stats,bfa_port_stats_cbfn_t cbfn,void * cbarg)332 bfa_port_get_stats(struct bfa_port_s *port, union bfa_port_stats_u *stats,
333 bfa_port_stats_cbfn_t cbfn, void *cbarg)
334 {
335 struct bfi_port_get_stats_req_s *m;
336
337 if (!bfa_ioc_is_operational(port->ioc)) {
338 bfa_trc(port, BFA_STATUS_IOC_FAILURE);
339 return BFA_STATUS_IOC_FAILURE;
340 }
341
342 if (port->stats_busy) {
343 bfa_trc(port, BFA_STATUS_DEVBUSY);
344 return BFA_STATUS_DEVBUSY;
345 }
346
347 m = (struct bfi_port_get_stats_req_s *) port->stats_mb.msg;
348
349 port->stats = stats;
350 port->stats_cbfn = cbfn;
351 port->stats_cbarg = cbarg;
352 port->stats_busy = BFA_TRUE;
353 bfa_dma_be_addr_set(m->dma_addr, port->stats_dma.pa);
354
355 bfi_h2i_set(m->mh, BFI_MC_PORT, BFI_PORT_H2I_GET_STATS_REQ,
356 bfa_ioc_portid(port->ioc));
357 bfa_ioc_mbox_queue(port->ioc, &port->stats_mb);
358
359 return BFA_STATUS_OK;
360 }
361
362 /*
363 * bfa_port_clear_stats()
364 *
365 *
366 * @param[in] Pointer to the Port module data structure.
367 *
368 * @return Status
369 */
370 bfa_status_t
bfa_port_clear_stats(struct bfa_port_s * port,bfa_port_stats_cbfn_t cbfn,void * cbarg)371 bfa_port_clear_stats(struct bfa_port_s *port, bfa_port_stats_cbfn_t cbfn,
372 void *cbarg)
373 {
374 struct bfi_port_generic_req_s *m;
375
376 if (!bfa_ioc_is_operational(port->ioc)) {
377 bfa_trc(port, BFA_STATUS_IOC_FAILURE);
378 return BFA_STATUS_IOC_FAILURE;
379 }
380
381 if (port->stats_busy) {
382 bfa_trc(port, BFA_STATUS_DEVBUSY);
383 return BFA_STATUS_DEVBUSY;
384 }
385
386 m = (struct bfi_port_generic_req_s *) port->stats_mb.msg;
387
388 port->stats_cbfn = cbfn;
389 port->stats_cbarg = cbarg;
390 port->stats_busy = BFA_TRUE;
391
392 bfi_h2i_set(m->mh, BFI_MC_PORT, BFI_PORT_H2I_CLEAR_STATS_REQ,
393 bfa_ioc_portid(port->ioc));
394 bfa_ioc_mbox_queue(port->ioc, &port->stats_mb);
395
396 return BFA_STATUS_OK;
397 }
398
399 /*
400 * bfa_port_notify()
401 *
402 * Port module IOC event handler
403 *
404 * @param[in] Pointer to the Port module data structure.
405 * @param[in] IOC event structure
406 *
407 * @return void
408 */
409 void
bfa_port_notify(void * arg,enum bfa_ioc_event_e event)410 bfa_port_notify(void *arg, enum bfa_ioc_event_e event)
411 {
412 struct bfa_port_s *port = (struct bfa_port_s *) arg;
413
414 switch (event) {
415 case BFA_IOC_E_DISABLED:
416 case BFA_IOC_E_FAILED:
417 /* Fail any pending get_stats/clear_stats requests */
418 if (port->stats_busy) {
419 if (port->stats_cbfn)
420 port->stats_cbfn(port->stats_cbarg,
421 BFA_STATUS_FAILED);
422 port->stats_cbfn = NULL;
423 port->stats_busy = BFA_FALSE;
424 }
425
426 /* Clear any enable/disable is pending */
427 if (port->endis_pending) {
428 if (port->endis_cbfn)
429 port->endis_cbfn(port->endis_cbarg,
430 BFA_STATUS_FAILED);
431 port->endis_cbfn = NULL;
432 port->endis_pending = BFA_FALSE;
433 }
434 break;
435 default:
436 break;
437 }
438 }
439
440 /*
441 * bfa_port_attach()
442 *
443 *
444 * @param[in] port - Pointer to the Port module data structure
445 * ioc - Pointer to the ioc module data structure
446 * dev - Pointer to the device driver module data structure
447 * The device driver specific mbox ISR functions have
448 * this pointer as one of the parameters.
449 * trcmod -
450 *
451 * @return void
452 */
453 void
bfa_port_attach(struct bfa_port_s * port,struct bfa_ioc_s * ioc,void * dev,struct bfa_trc_mod_s * trcmod)454 bfa_port_attach(struct bfa_port_s *port, struct bfa_ioc_s *ioc,
455 void *dev, struct bfa_trc_mod_s *trcmod)
456 {
457 struct timeval tv;
458
459 WARN_ON(!port);
460
461 port->dev = dev;
462 port->ioc = ioc;
463 port->trcmod = trcmod;
464
465 port->stats_busy = BFA_FALSE;
466 port->endis_pending = BFA_FALSE;
467 port->stats_cbfn = NULL;
468 port->endis_cbfn = NULL;
469 port->pbc_disabled = BFA_FALSE;
470
471 bfa_ioc_mbox_regisr(port->ioc, BFI_MC_PORT, bfa_port_isr, port);
472 bfa_q_qe_init(&port->ioc_notify);
473 bfa_ioc_notify_init(&port->ioc_notify, bfa_port_notify, port);
474 list_add_tail(&port->ioc_notify.qe, &port->ioc->notify_q);
475
476 /*
477 * initialize time stamp for stats reset
478 */
479 do_gettimeofday(&tv);
480 port->stats_reset_time = tv.tv_sec;
481
482 bfa_trc(port, 0);
483 }
484
485 /*
486 * CEE module specific definitions
487 */
488
489 /*
490 * bfa_cee_get_attr_isr()
491 *
492 * @brief CEE ISR for get-attributes responses from f/w
493 *
494 * @param[in] cee - Pointer to the CEE module
495 * status - Return status from the f/w
496 *
497 * @return void
498 */
499 static void
bfa_cee_get_attr_isr(struct bfa_cee_s * cee,bfa_status_t status)500 bfa_cee_get_attr_isr(struct bfa_cee_s *cee, bfa_status_t status)
501 {
502 struct bfa_cee_lldp_cfg_s *lldp_cfg = &cee->attr->lldp_remote;
503
504 cee->get_attr_status = status;
505 bfa_trc(cee, 0);
506 if (status == BFA_STATUS_OK) {
507 bfa_trc(cee, 0);
508 memcpy(cee->attr, cee->attr_dma.kva,
509 sizeof(struct bfa_cee_attr_s));
510 lldp_cfg->time_to_live = be16_to_cpu(lldp_cfg->time_to_live);
511 lldp_cfg->enabled_system_cap =
512 be16_to_cpu(lldp_cfg->enabled_system_cap);
513 }
514 cee->get_attr_pending = BFA_FALSE;
515 if (cee->cbfn.get_attr_cbfn) {
516 bfa_trc(cee, 0);
517 cee->cbfn.get_attr_cbfn(cee->cbfn.get_attr_cbarg, status);
518 }
519 }
520
521 /*
522 * bfa_cee_get_stats_isr()
523 *
524 * @brief CEE ISR for get-stats responses from f/w
525 *
526 * @param[in] cee - Pointer to the CEE module
527 * status - Return status from the f/w
528 *
529 * @return void
530 */
531 static void
bfa_cee_get_stats_isr(struct bfa_cee_s * cee,bfa_status_t status)532 bfa_cee_get_stats_isr(struct bfa_cee_s *cee, bfa_status_t status)
533 {
534 u32 *buffer;
535 int i;
536
537 cee->get_stats_status = status;
538 bfa_trc(cee, 0);
539 if (status == BFA_STATUS_OK) {
540 bfa_trc(cee, 0);
541 memcpy(cee->stats, cee->stats_dma.kva,
542 sizeof(struct bfa_cee_stats_s));
543 /* swap the cee stats */
544 buffer = (u32 *)cee->stats;
545 for (i = 0; i < (sizeof(struct bfa_cee_stats_s) /
546 sizeof(u32)); i++)
547 buffer[i] = cpu_to_be32(buffer[i]);
548 }
549 cee->get_stats_pending = BFA_FALSE;
550 bfa_trc(cee, 0);
551 if (cee->cbfn.get_stats_cbfn) {
552 bfa_trc(cee, 0);
553 cee->cbfn.get_stats_cbfn(cee->cbfn.get_stats_cbarg, status);
554 }
555 }
556
557 /*
558 * bfa_cee_reset_stats_isr()
559 *
560 * @brief CEE ISR for reset-stats responses from f/w
561 *
562 * @param[in] cee - Pointer to the CEE module
563 * status - Return status from the f/w
564 *
565 * @return void
566 */
567 static void
bfa_cee_reset_stats_isr(struct bfa_cee_s * cee,bfa_status_t status)568 bfa_cee_reset_stats_isr(struct bfa_cee_s *cee, bfa_status_t status)
569 {
570 cee->reset_stats_status = status;
571 cee->reset_stats_pending = BFA_FALSE;
572 if (cee->cbfn.reset_stats_cbfn)
573 cee->cbfn.reset_stats_cbfn(cee->cbfn.reset_stats_cbarg, status);
574 }
575
576 /*
577 * bfa_cee_meminfo()
578 *
579 * @brief Returns the size of the DMA memory needed by CEE module
580 *
581 * @param[in] void
582 *
583 * @return Size of DMA region
584 */
585 u32
bfa_cee_meminfo(void)586 bfa_cee_meminfo(void)
587 {
588 return BFA_ROUNDUP(sizeof(struct bfa_cee_attr_s), BFA_DMA_ALIGN_SZ) +
589 BFA_ROUNDUP(sizeof(struct bfa_cee_stats_s), BFA_DMA_ALIGN_SZ);
590 }
591
592 /*
593 * bfa_cee_mem_claim()
594 *
595 * @brief Initialized CEE DMA Memory
596 *
597 * @param[in] cee CEE module pointer
598 * dma_kva Kernel Virtual Address of CEE DMA Memory
599 * dma_pa Physical Address of CEE DMA Memory
600 *
601 * @return void
602 */
603 void
bfa_cee_mem_claim(struct bfa_cee_s * cee,u8 * dma_kva,u64 dma_pa)604 bfa_cee_mem_claim(struct bfa_cee_s *cee, u8 *dma_kva, u64 dma_pa)
605 {
606 cee->attr_dma.kva = dma_kva;
607 cee->attr_dma.pa = dma_pa;
608 cee->stats_dma.kva = dma_kva + BFA_ROUNDUP(
609 sizeof(struct bfa_cee_attr_s), BFA_DMA_ALIGN_SZ);
610 cee->stats_dma.pa = dma_pa + BFA_ROUNDUP(
611 sizeof(struct bfa_cee_attr_s), BFA_DMA_ALIGN_SZ);
612 cee->attr = (struct bfa_cee_attr_s *) dma_kva;
613 cee->stats = (struct bfa_cee_stats_s *) (dma_kva + BFA_ROUNDUP(
614 sizeof(struct bfa_cee_attr_s), BFA_DMA_ALIGN_SZ));
615 }
616
617 /*
618 * bfa_cee_get_attr()
619 *
620 * @brief
621 * Send the request to the f/w to fetch CEE attributes.
622 *
623 * @param[in] Pointer to the CEE module data structure.
624 *
625 * @return Status
626 */
627
628 bfa_status_t
bfa_cee_get_attr(struct bfa_cee_s * cee,struct bfa_cee_attr_s * attr,bfa_cee_get_attr_cbfn_t cbfn,void * cbarg)629 bfa_cee_get_attr(struct bfa_cee_s *cee, struct bfa_cee_attr_s *attr,
630 bfa_cee_get_attr_cbfn_t cbfn, void *cbarg)
631 {
632 struct bfi_cee_get_req_s *cmd;
633
634 WARN_ON((cee == NULL) || (cee->ioc == NULL));
635 bfa_trc(cee, 0);
636 if (!bfa_ioc_is_operational(cee->ioc)) {
637 bfa_trc(cee, 0);
638 return BFA_STATUS_IOC_FAILURE;
639 }
640 if (cee->get_attr_pending == BFA_TRUE) {
641 bfa_trc(cee, 0);
642 return BFA_STATUS_DEVBUSY;
643 }
644 cee->get_attr_pending = BFA_TRUE;
645 cmd = (struct bfi_cee_get_req_s *) cee->get_cfg_mb.msg;
646 cee->attr = attr;
647 cee->cbfn.get_attr_cbfn = cbfn;
648 cee->cbfn.get_attr_cbarg = cbarg;
649 bfi_h2i_set(cmd->mh, BFI_MC_CEE, BFI_CEE_H2I_GET_CFG_REQ,
650 bfa_ioc_portid(cee->ioc));
651 bfa_dma_be_addr_set(cmd->dma_addr, cee->attr_dma.pa);
652 bfa_ioc_mbox_queue(cee->ioc, &cee->get_cfg_mb);
653
654 return BFA_STATUS_OK;
655 }
656
657 /*
658 * bfa_cee_get_stats()
659 *
660 * @brief
661 * Send the request to the f/w to fetch CEE statistics.
662 *
663 * @param[in] Pointer to the CEE module data structure.
664 *
665 * @return Status
666 */
667
668 bfa_status_t
bfa_cee_get_stats(struct bfa_cee_s * cee,struct bfa_cee_stats_s * stats,bfa_cee_get_stats_cbfn_t cbfn,void * cbarg)669 bfa_cee_get_stats(struct bfa_cee_s *cee, struct bfa_cee_stats_s *stats,
670 bfa_cee_get_stats_cbfn_t cbfn, void *cbarg)
671 {
672 struct bfi_cee_get_req_s *cmd;
673
674 WARN_ON((cee == NULL) || (cee->ioc == NULL));
675
676 if (!bfa_ioc_is_operational(cee->ioc)) {
677 bfa_trc(cee, 0);
678 return BFA_STATUS_IOC_FAILURE;
679 }
680 if (cee->get_stats_pending == BFA_TRUE) {
681 bfa_trc(cee, 0);
682 return BFA_STATUS_DEVBUSY;
683 }
684 cee->get_stats_pending = BFA_TRUE;
685 cmd = (struct bfi_cee_get_req_s *) cee->get_stats_mb.msg;
686 cee->stats = stats;
687 cee->cbfn.get_stats_cbfn = cbfn;
688 cee->cbfn.get_stats_cbarg = cbarg;
689 bfi_h2i_set(cmd->mh, BFI_MC_CEE, BFI_CEE_H2I_GET_STATS_REQ,
690 bfa_ioc_portid(cee->ioc));
691 bfa_dma_be_addr_set(cmd->dma_addr, cee->stats_dma.pa);
692 bfa_ioc_mbox_queue(cee->ioc, &cee->get_stats_mb);
693
694 return BFA_STATUS_OK;
695 }
696
697 /*
698 * bfa_cee_reset_stats()
699 *
700 * @brief Clears CEE Stats in the f/w.
701 *
702 * @param[in] Pointer to the CEE module data structure.
703 *
704 * @return Status
705 */
706
707 bfa_status_t
bfa_cee_reset_stats(struct bfa_cee_s * cee,bfa_cee_reset_stats_cbfn_t cbfn,void * cbarg)708 bfa_cee_reset_stats(struct bfa_cee_s *cee,
709 bfa_cee_reset_stats_cbfn_t cbfn, void *cbarg)
710 {
711 struct bfi_cee_reset_stats_s *cmd;
712
713 WARN_ON((cee == NULL) || (cee->ioc == NULL));
714 if (!bfa_ioc_is_operational(cee->ioc)) {
715 bfa_trc(cee, 0);
716 return BFA_STATUS_IOC_FAILURE;
717 }
718 if (cee->reset_stats_pending == BFA_TRUE) {
719 bfa_trc(cee, 0);
720 return BFA_STATUS_DEVBUSY;
721 }
722 cee->reset_stats_pending = BFA_TRUE;
723 cmd = (struct bfi_cee_reset_stats_s *) cee->reset_stats_mb.msg;
724 cee->cbfn.reset_stats_cbfn = cbfn;
725 cee->cbfn.reset_stats_cbarg = cbarg;
726 bfi_h2i_set(cmd->mh, BFI_MC_CEE, BFI_CEE_H2I_RESET_STATS,
727 bfa_ioc_portid(cee->ioc));
728 bfa_ioc_mbox_queue(cee->ioc, &cee->reset_stats_mb);
729
730 return BFA_STATUS_OK;
731 }
732
733 /*
734 * bfa_cee_isrs()
735 *
736 * @brief Handles Mail-box interrupts for CEE module.
737 *
738 * @param[in] Pointer to the CEE module data structure.
739 *
740 * @return void
741 */
742
743 void
bfa_cee_isr(void * cbarg,struct bfi_mbmsg_s * m)744 bfa_cee_isr(void *cbarg, struct bfi_mbmsg_s *m)
745 {
746 union bfi_cee_i2h_msg_u *msg;
747 struct bfi_cee_get_rsp_s *get_rsp;
748 struct bfa_cee_s *cee = (struct bfa_cee_s *) cbarg;
749 msg = (union bfi_cee_i2h_msg_u *) m;
750 get_rsp = (struct bfi_cee_get_rsp_s *) m;
751 bfa_trc(cee, msg->mh.msg_id);
752 switch (msg->mh.msg_id) {
753 case BFI_CEE_I2H_GET_CFG_RSP:
754 bfa_trc(cee, get_rsp->cmd_status);
755 bfa_cee_get_attr_isr(cee, get_rsp->cmd_status);
756 break;
757 case BFI_CEE_I2H_GET_STATS_RSP:
758 bfa_cee_get_stats_isr(cee, get_rsp->cmd_status);
759 break;
760 case BFI_CEE_I2H_RESET_STATS_RSP:
761 bfa_cee_reset_stats_isr(cee, get_rsp->cmd_status);
762 break;
763 default:
764 WARN_ON(1);
765 }
766 }
767
768 /*
769 * bfa_cee_notify()
770 *
771 * @brief CEE module IOC event handler.
772 *
773 * @param[in] Pointer to the CEE module data structure.
774 * @param[in] IOC event type
775 *
776 * @return void
777 */
778
779 void
bfa_cee_notify(void * arg,enum bfa_ioc_event_e event)780 bfa_cee_notify(void *arg, enum bfa_ioc_event_e event)
781 {
782 struct bfa_cee_s *cee = (struct bfa_cee_s *) arg;
783
784 bfa_trc(cee, event);
785
786 switch (event) {
787 case BFA_IOC_E_DISABLED:
788 case BFA_IOC_E_FAILED:
789 if (cee->get_attr_pending == BFA_TRUE) {
790 cee->get_attr_status = BFA_STATUS_FAILED;
791 cee->get_attr_pending = BFA_FALSE;
792 if (cee->cbfn.get_attr_cbfn) {
793 cee->cbfn.get_attr_cbfn(
794 cee->cbfn.get_attr_cbarg,
795 BFA_STATUS_FAILED);
796 }
797 }
798 if (cee->get_stats_pending == BFA_TRUE) {
799 cee->get_stats_status = BFA_STATUS_FAILED;
800 cee->get_stats_pending = BFA_FALSE;
801 if (cee->cbfn.get_stats_cbfn) {
802 cee->cbfn.get_stats_cbfn(
803 cee->cbfn.get_stats_cbarg,
804 BFA_STATUS_FAILED);
805 }
806 }
807 if (cee->reset_stats_pending == BFA_TRUE) {
808 cee->reset_stats_status = BFA_STATUS_FAILED;
809 cee->reset_stats_pending = BFA_FALSE;
810 if (cee->cbfn.reset_stats_cbfn) {
811 cee->cbfn.reset_stats_cbfn(
812 cee->cbfn.reset_stats_cbarg,
813 BFA_STATUS_FAILED);
814 }
815 }
816 break;
817
818 default:
819 break;
820 }
821 }
822
823 /*
824 * bfa_cee_attach()
825 *
826 * @brief CEE module-attach API
827 *
828 * @param[in] cee - Pointer to the CEE module data structure
829 * ioc - Pointer to the ioc module data structure
830 * dev - Pointer to the device driver module data structure
831 * The device driver specific mbox ISR functions have
832 * this pointer as one of the parameters.
833 *
834 * @return void
835 */
836 void
bfa_cee_attach(struct bfa_cee_s * cee,struct bfa_ioc_s * ioc,void * dev)837 bfa_cee_attach(struct bfa_cee_s *cee, struct bfa_ioc_s *ioc,
838 void *dev)
839 {
840 WARN_ON(cee == NULL);
841 cee->dev = dev;
842 cee->ioc = ioc;
843
844 bfa_ioc_mbox_regisr(cee->ioc, BFI_MC_CEE, bfa_cee_isr, cee);
845 bfa_q_qe_init(&cee->ioc_notify);
846 bfa_ioc_notify_init(&cee->ioc_notify, bfa_cee_notify, cee);
847 list_add_tail(&cee->ioc_notify.qe, &cee->ioc->notify_q);
848 }
849