xref: /openbmc/linux/drivers/scsi/bfa/bfa_port.c (revision e7bae9bb) 
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 static void
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 static void
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
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