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