xref: /dpdk/drivers/common/cnxk/roc_nix_queue.c (revision b8a0fbab) 
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(C) 2021 Marvell.
3  */
4 
5 #include "roc_api.h"
6 #include "roc_priv.h"
7 
8 static inline uint32_t
9 nix_qsize_to_val(enum nix_q_size qsize)
10 {
11 	return (16UL << (qsize * 2));
12 }
13 
14 static inline enum nix_q_size
15 nix_qsize_clampup(uint32_t val)
16 {
17 	int i = nix_q_size_16;
18 
19 	for (; i < nix_q_size_max; i++)
20 		if (val <= nix_qsize_to_val(i))
21 			break;
22 
23 	if (i >= nix_q_size_max)
24 		i = nix_q_size_max - 1;
25 
26 	return i;
27 }
28 
29 int
30 roc_nix_rq_ena_dis(struct roc_nix_rq *rq, bool enable)
31 {
32 	struct nix *nix = roc_nix_to_nix_priv(rq->roc_nix);
33 	struct mbox *mbox = (&nix->dev)->mbox;
34 	int rc;
35 
36 	/* Pkts will be dropped silently if RQ is disabled */
37 	if (roc_model_is_cn9k()) {
38 		struct nix_aq_enq_req *aq;
39 
40 		aq = mbox_alloc_msg_nix_aq_enq(mbox);
41 		aq->qidx = rq->qid;
42 		aq->ctype = NIX_AQ_CTYPE_RQ;
43 		aq->op = NIX_AQ_INSTOP_WRITE;
44 
45 		aq->rq.ena = enable;
46 		aq->rq_mask.ena = ~(aq->rq_mask.ena);
47 	} else {
48 		struct nix_cn10k_aq_enq_req *aq;
49 
50 		aq = mbox_alloc_msg_nix_cn10k_aq_enq(mbox);
51 		aq->qidx = rq->qid;
52 		aq->ctype = NIX_AQ_CTYPE_RQ;
53 		aq->op = NIX_AQ_INSTOP_WRITE;
54 
55 		aq->rq.ena = enable;
56 		aq->rq_mask.ena = ~(aq->rq_mask.ena);
57 	}
58 
59 	rc = mbox_process(mbox);
60 
61 	if (roc_model_is_cn10k())
62 		plt_write64(rq->qid, nix->base + NIX_LF_OP_VWQE_FLUSH);
63 	return rc;
64 }
65 
66 static int
67 rq_cn9k_cfg(struct nix *nix, struct roc_nix_rq *rq, bool cfg, bool ena)
68 {
69 	struct mbox *mbox = (&nix->dev)->mbox;
70 	struct nix_aq_enq_req *aq;
71 
72 	aq = mbox_alloc_msg_nix_aq_enq(mbox);
73 	aq->qidx = rq->qid;
74 	aq->ctype = NIX_AQ_CTYPE_RQ;
75 	aq->op = cfg ? NIX_AQ_INSTOP_WRITE : NIX_AQ_INSTOP_INIT;
76 
77 	if (rq->sso_ena) {
78 		/* SSO mode */
79 		aq->rq.sso_ena = 1;
80 		aq->rq.sso_tt = rq->tt;
81 		aq->rq.sso_grp = rq->hwgrp;
82 		aq->rq.ena_wqwd = 1;
83 		aq->rq.wqe_skip = rq->wqe_skip;
84 		aq->rq.wqe_caching = 1;
85 
86 		aq->rq.good_utag = rq->tag_mask >> 24;
87 		aq->rq.bad_utag = rq->tag_mask >> 24;
88 		aq->rq.ltag = rq->tag_mask & BITMASK_ULL(24, 0);
89 	} else {
90 		/* CQ mode */
91 		aq->rq.sso_ena = 0;
92 		aq->rq.good_utag = rq->tag_mask >> 24;
93 		aq->rq.bad_utag = rq->tag_mask >> 24;
94 		aq->rq.ltag = rq->tag_mask & BITMASK_ULL(24, 0);
95 		aq->rq.cq = rq->qid;
96 	}
97 
98 	if (rq->ipsech_ena)
99 		aq->rq.ipsech_ena = 1;
100 
101 	aq->rq.spb_ena = 0;
102 	aq->rq.lpb_aura = roc_npa_aura_handle_to_aura(rq->aura_handle);
103 
104 	/* Sizes must be aligned to 8 bytes */
105 	if (rq->first_skip & 0x7 || rq->later_skip & 0x7 || rq->lpb_size & 0x7)
106 		return -EINVAL;
107 
108 	/* Expressed in number of dwords */
109 	aq->rq.first_skip = rq->first_skip / 8;
110 	aq->rq.later_skip = rq->later_skip / 8;
111 	aq->rq.flow_tagw = rq->flow_tag_width; /* 32-bits */
112 	aq->rq.lpb_sizem1 = rq->lpb_size / 8;
113 	aq->rq.lpb_sizem1 -= 1; /* Expressed in size minus one */
114 	aq->rq.ena = ena;
115 	aq->rq.pb_caching = 0x2; /* First cache aligned block to LLC */
116 	aq->rq.xqe_imm_size = 0; /* No pkt data copy to CQE */
117 	aq->rq.rq_int_ena = 0;
118 	/* Many to one reduction */
119 	aq->rq.qint_idx = rq->qid % nix->qints;
120 	aq->rq.xqe_drop_ena = 1;
121 
122 	/* If RED enabled, then fill enable for all cases */
123 	if (rq->red_pass && (rq->red_pass >= rq->red_drop)) {
124 		aq->rq.spb_aura_pass = rq->spb_red_pass;
125 		aq->rq.lpb_aura_pass = rq->red_pass;
126 
127 		aq->rq.spb_aura_drop = rq->spb_red_drop;
128 		aq->rq.lpb_aura_drop = rq->red_drop;
129 	}
130 
131 	if (cfg) {
132 		if (rq->sso_ena) {
133 			/* SSO mode */
134 			aq->rq_mask.sso_ena = ~aq->rq_mask.sso_ena;
135 			aq->rq_mask.sso_tt = ~aq->rq_mask.sso_tt;
136 			aq->rq_mask.sso_grp = ~aq->rq_mask.sso_grp;
137 			aq->rq_mask.ena_wqwd = ~aq->rq_mask.ena_wqwd;
138 			aq->rq_mask.wqe_skip = ~aq->rq_mask.wqe_skip;
139 			aq->rq_mask.wqe_caching = ~aq->rq_mask.wqe_caching;
140 			aq->rq_mask.good_utag = ~aq->rq_mask.good_utag;
141 			aq->rq_mask.bad_utag = ~aq->rq_mask.bad_utag;
142 			aq->rq_mask.ltag = ~aq->rq_mask.ltag;
143 		} else {
144 			/* CQ mode */
145 			aq->rq_mask.sso_ena = ~aq->rq_mask.sso_ena;
146 			aq->rq_mask.good_utag = ~aq->rq_mask.good_utag;
147 			aq->rq_mask.bad_utag = ~aq->rq_mask.bad_utag;
148 			aq->rq_mask.ltag = ~aq->rq_mask.ltag;
149 			aq->rq_mask.cq = ~aq->rq_mask.cq;
150 		}
151 
152 		if (rq->ipsech_ena)
153 			aq->rq_mask.ipsech_ena = ~aq->rq_mask.ipsech_ena;
154 
155 		aq->rq_mask.spb_ena = ~aq->rq_mask.spb_ena;
156 		aq->rq_mask.lpb_aura = ~aq->rq_mask.lpb_aura;
157 		aq->rq_mask.first_skip = ~aq->rq_mask.first_skip;
158 		aq->rq_mask.later_skip = ~aq->rq_mask.later_skip;
159 		aq->rq_mask.flow_tagw = ~aq->rq_mask.flow_tagw;
160 		aq->rq_mask.lpb_sizem1 = ~aq->rq_mask.lpb_sizem1;
161 		aq->rq_mask.ena = ~aq->rq_mask.ena;
162 		aq->rq_mask.pb_caching = ~aq->rq_mask.pb_caching;
163 		aq->rq_mask.xqe_imm_size = ~aq->rq_mask.xqe_imm_size;
164 		aq->rq_mask.rq_int_ena = ~aq->rq_mask.rq_int_ena;
165 		aq->rq_mask.qint_idx = ~aq->rq_mask.qint_idx;
166 		aq->rq_mask.xqe_drop_ena = ~aq->rq_mask.xqe_drop_ena;
167 
168 		if (rq->red_pass && (rq->red_pass >= rq->red_drop)) {
169 			aq->rq_mask.spb_aura_pass = ~aq->rq_mask.spb_aura_pass;
170 			aq->rq_mask.lpb_aura_pass = ~aq->rq_mask.lpb_aura_pass;
171 
172 			aq->rq_mask.spb_aura_drop = ~aq->rq_mask.spb_aura_drop;
173 			aq->rq_mask.lpb_aura_drop = ~aq->rq_mask.lpb_aura_drop;
174 		}
175 	}
176 
177 	return 0;
178 }
179 
180 static int
181 rq_cfg(struct nix *nix, struct roc_nix_rq *rq, bool cfg, bool ena)
182 {
183 	struct mbox *mbox = (&nix->dev)->mbox;
184 	struct nix_cn10k_aq_enq_req *aq;
185 
186 	aq = mbox_alloc_msg_nix_cn10k_aq_enq(mbox);
187 	aq->qidx = rq->qid;
188 	aq->ctype = NIX_AQ_CTYPE_RQ;
189 	aq->op = cfg ? NIX_AQ_INSTOP_WRITE : NIX_AQ_INSTOP_INIT;
190 
191 	if (rq->sso_ena) {
192 		/* SSO mode */
193 		aq->rq.sso_ena = 1;
194 		aq->rq.sso_tt = rq->tt;
195 		aq->rq.sso_grp = rq->hwgrp;
196 		aq->rq.ena_wqwd = 1;
197 		aq->rq.wqe_skip = rq->wqe_skip;
198 		aq->rq.wqe_caching = 1;
199 
200 		aq->rq.good_utag = rq->tag_mask >> 24;
201 		aq->rq.bad_utag = rq->tag_mask >> 24;
202 		aq->rq.ltag = rq->tag_mask & BITMASK_ULL(24, 0);
203 
204 		if (rq->vwqe_ena) {
205 			aq->rq.vwqe_ena = true;
206 			aq->rq.vwqe_skip = rq->vwqe_first_skip;
207 			/* Maximal Vector size is (2^(MAX_VSIZE_EXP+2)) */
208 			aq->rq.max_vsize_exp = rq->vwqe_max_sz_exp - 2;
209 			aq->rq.vtime_wait = rq->vwqe_wait_tmo;
210 			aq->rq.wqe_aura = rq->vwqe_aura_handle;
211 		}
212 	} else {
213 		/* CQ mode */
214 		aq->rq.sso_ena = 0;
215 		aq->rq.good_utag = rq->tag_mask >> 24;
216 		aq->rq.bad_utag = rq->tag_mask >> 24;
217 		aq->rq.ltag = rq->tag_mask & BITMASK_ULL(24, 0);
218 		aq->rq.cq = rq->qid;
219 	}
220 
221 	if (rq->ipsech_ena)
222 		aq->rq.ipsech_ena = 1;
223 
224 	aq->rq.lpb_aura = roc_npa_aura_handle_to_aura(rq->aura_handle);
225 
226 	/* Sizes must be aligned to 8 bytes */
227 	if (rq->first_skip & 0x7 || rq->later_skip & 0x7 || rq->lpb_size & 0x7)
228 		return -EINVAL;
229 
230 	/* Expressed in number of dwords */
231 	aq->rq.first_skip = rq->first_skip / 8;
232 	aq->rq.later_skip = rq->later_skip / 8;
233 	aq->rq.flow_tagw = rq->flow_tag_width; /* 32-bits */
234 	aq->rq.lpb_sizem1 = rq->lpb_size / 8;
235 	aq->rq.lpb_sizem1 -= 1; /* Expressed in size minus one */
236 	aq->rq.ena = ena;
237 
238 	if (rq->spb_ena) {
239 		uint32_t spb_sizem1;
240 
241 		aq->rq.spb_ena = 1;
242 		aq->rq.spb_aura =
243 			roc_npa_aura_handle_to_aura(rq->spb_aura_handle);
244 
245 		if (rq->spb_size & 0x7 ||
246 		    rq->spb_size > NIX_RQ_CN10K_SPB_MAX_SIZE)
247 			return -EINVAL;
248 
249 		spb_sizem1 = rq->spb_size / 8; /* Expressed in no. of dwords */
250 		spb_sizem1 -= 1;	       /* Expressed in size minus one */
251 		aq->rq.spb_sizem1 = spb_sizem1 & 0x3F;
252 		aq->rq.spb_high_sizem1 = (spb_sizem1 >> 6) & 0x7;
253 	} else {
254 		aq->rq.spb_ena = 0;
255 	}
256 
257 	aq->rq.pb_caching = 0x2; /* First cache aligned block to LLC */
258 	aq->rq.xqe_imm_size = 0; /* No pkt data copy to CQE */
259 	aq->rq.rq_int_ena = 0;
260 	/* Many to one reduction */
261 	aq->rq.qint_idx = rq->qid % nix->qints;
262 	aq->rq.xqe_drop_ena = 1;
263 
264 	/* If RED enabled, then fill enable for all cases */
265 	if (rq->red_pass && (rq->red_pass >= rq->red_drop)) {
266 		aq->rq.spb_pool_pass = rq->red_pass;
267 		aq->rq.spb_aura_pass = rq->red_pass;
268 		aq->rq.lpb_pool_pass = rq->red_pass;
269 		aq->rq.lpb_aura_pass = rq->red_pass;
270 		aq->rq.wqe_pool_pass = rq->red_pass;
271 		aq->rq.xqe_pass = rq->red_pass;
272 
273 		aq->rq.spb_pool_drop = rq->red_drop;
274 		aq->rq.spb_aura_drop = rq->red_drop;
275 		aq->rq.lpb_pool_drop = rq->red_drop;
276 		aq->rq.lpb_aura_drop = rq->red_drop;
277 		aq->rq.wqe_pool_drop = rq->red_drop;
278 		aq->rq.xqe_drop = rq->red_drop;
279 	}
280 
281 	if (cfg) {
282 		if (rq->sso_ena) {
283 			/* SSO mode */
284 			aq->rq_mask.sso_ena = ~aq->rq_mask.sso_ena;
285 			aq->rq_mask.sso_tt = ~aq->rq_mask.sso_tt;
286 			aq->rq_mask.sso_grp = ~aq->rq_mask.sso_grp;
287 			aq->rq_mask.ena_wqwd = ~aq->rq_mask.ena_wqwd;
288 			aq->rq_mask.wqe_skip = ~aq->rq_mask.wqe_skip;
289 			aq->rq_mask.wqe_caching = ~aq->rq_mask.wqe_caching;
290 			aq->rq_mask.good_utag = ~aq->rq_mask.good_utag;
291 			aq->rq_mask.bad_utag = ~aq->rq_mask.bad_utag;
292 			aq->rq_mask.ltag = ~aq->rq_mask.ltag;
293 			if (rq->vwqe_ena) {
294 				aq->rq_mask.vwqe_ena = ~aq->rq_mask.vwqe_ena;
295 				aq->rq_mask.vwqe_skip = ~aq->rq_mask.vwqe_skip;
296 				aq->rq_mask.max_vsize_exp =
297 					~aq->rq_mask.max_vsize_exp;
298 				aq->rq_mask.vtime_wait =
299 					~aq->rq_mask.vtime_wait;
300 				aq->rq_mask.wqe_aura = ~aq->rq_mask.wqe_aura;
301 			}
302 		} else {
303 			/* CQ mode */
304 			aq->rq_mask.sso_ena = ~aq->rq_mask.sso_ena;
305 			aq->rq_mask.good_utag = ~aq->rq_mask.good_utag;
306 			aq->rq_mask.bad_utag = ~aq->rq_mask.bad_utag;
307 			aq->rq_mask.ltag = ~aq->rq_mask.ltag;
308 			aq->rq_mask.cq = ~aq->rq_mask.cq;
309 		}
310 
311 		if (rq->ipsech_ena)
312 			aq->rq_mask.ipsech_ena = ~aq->rq_mask.ipsech_ena;
313 
314 		if (rq->spb_ena) {
315 			aq->rq_mask.spb_aura = ~aq->rq_mask.spb_aura;
316 			aq->rq_mask.spb_sizem1 = ~aq->rq_mask.spb_sizem1;
317 			aq->rq_mask.spb_high_sizem1 =
318 				~aq->rq_mask.spb_high_sizem1;
319 		}
320 
321 		aq->rq_mask.spb_ena = ~aq->rq_mask.spb_ena;
322 		aq->rq_mask.lpb_aura = ~aq->rq_mask.lpb_aura;
323 		aq->rq_mask.first_skip = ~aq->rq_mask.first_skip;
324 		aq->rq_mask.later_skip = ~aq->rq_mask.later_skip;
325 		aq->rq_mask.flow_tagw = ~aq->rq_mask.flow_tagw;
326 		aq->rq_mask.lpb_sizem1 = ~aq->rq_mask.lpb_sizem1;
327 		aq->rq_mask.ena = ~aq->rq_mask.ena;
328 		aq->rq_mask.pb_caching = ~aq->rq_mask.pb_caching;
329 		aq->rq_mask.xqe_imm_size = ~aq->rq_mask.xqe_imm_size;
330 		aq->rq_mask.rq_int_ena = ~aq->rq_mask.rq_int_ena;
331 		aq->rq_mask.qint_idx = ~aq->rq_mask.qint_idx;
332 		aq->rq_mask.xqe_drop_ena = ~aq->rq_mask.xqe_drop_ena;
333 
334 		if (rq->red_pass && (rq->red_pass >= rq->red_drop)) {
335 			aq->rq_mask.spb_pool_pass = ~aq->rq_mask.spb_pool_pass;
336 			aq->rq_mask.spb_aura_pass = ~aq->rq_mask.spb_aura_pass;
337 			aq->rq_mask.lpb_pool_pass = ~aq->rq_mask.lpb_pool_pass;
338 			aq->rq_mask.lpb_aura_pass = ~aq->rq_mask.lpb_aura_pass;
339 			aq->rq_mask.wqe_pool_pass = ~aq->rq_mask.wqe_pool_pass;
340 			aq->rq_mask.xqe_pass = ~aq->rq_mask.xqe_pass;
341 
342 			aq->rq_mask.spb_pool_drop = ~aq->rq_mask.spb_pool_drop;
343 			aq->rq_mask.spb_aura_drop = ~aq->rq_mask.spb_aura_drop;
344 			aq->rq_mask.lpb_pool_drop = ~aq->rq_mask.lpb_pool_drop;
345 			aq->rq_mask.lpb_aura_drop = ~aq->rq_mask.lpb_aura_drop;
346 			aq->rq_mask.wqe_pool_drop = ~aq->rq_mask.wqe_pool_drop;
347 			aq->rq_mask.xqe_drop = ~aq->rq_mask.xqe_drop;
348 		}
349 	}
350 
351 	return 0;
352 }
353 
354 int
355 roc_nix_rq_init(struct roc_nix *roc_nix, struct roc_nix_rq *rq, bool ena)
356 {
357 	struct nix *nix = roc_nix_to_nix_priv(roc_nix);
358 	struct mbox *mbox = (&nix->dev)->mbox;
359 	bool is_cn9k = roc_model_is_cn9k();
360 	int rc;
361 
362 	if (roc_nix == NULL || rq == NULL)
363 		return NIX_ERR_PARAM;
364 
365 	if (rq->qid >= nix->nb_rx_queues)
366 		return NIX_ERR_QUEUE_INVALID_RANGE;
367 
368 	rq->roc_nix = roc_nix;
369 
370 	if (is_cn9k)
371 		rc = rq_cn9k_cfg(nix, rq, false, ena);
372 	else
373 		rc = rq_cfg(nix, rq, false, ena);
374 
375 	if (rc)
376 		return rc;
377 
378 	return mbox_process(mbox);
379 }
380 
381 int
382 roc_nix_rq_modify(struct roc_nix *roc_nix, struct roc_nix_rq *rq, bool ena)
383 {
384 	struct nix *nix = roc_nix_to_nix_priv(roc_nix);
385 	struct mbox *mbox = (&nix->dev)->mbox;
386 	bool is_cn9k = roc_model_is_cn9k();
387 	int rc;
388 
389 	if (roc_nix == NULL || rq == NULL)
390 		return NIX_ERR_PARAM;
391 
392 	if (rq->qid >= nix->nb_rx_queues)
393 		return NIX_ERR_QUEUE_INVALID_RANGE;
394 
395 	rq->roc_nix = roc_nix;
396 
397 	if (is_cn9k)
398 		rc = rq_cn9k_cfg(nix, rq, true, ena);
399 	else
400 		rc = rq_cfg(nix, rq, true, ena);
401 
402 	if (rc)
403 		return rc;
404 
405 	return mbox_process(mbox);
406 }
407 
408 int
409 roc_nix_rq_fini(struct roc_nix_rq *rq)
410 {
411 	/* Disabling RQ is sufficient */
412 	return roc_nix_rq_ena_dis(rq, false);
413 }
414 
415 int
416 roc_nix_cq_init(struct roc_nix *roc_nix, struct roc_nix_cq *cq)
417 {
418 	struct nix *nix = roc_nix_to_nix_priv(roc_nix);
419 	struct mbox *mbox = (&nix->dev)->mbox;
420 	volatile struct nix_cq_ctx_s *cq_ctx;
421 	enum nix_q_size qsize;
422 	size_t desc_sz;
423 	int rc;
424 
425 	if (cq == NULL)
426 		return NIX_ERR_PARAM;
427 
428 	if (cq->qid >= nix->nb_rx_queues)
429 		return NIX_ERR_QUEUE_INVALID_RANGE;
430 
431 	qsize = nix_qsize_clampup(cq->nb_desc);
432 	cq->nb_desc = nix_qsize_to_val(qsize);
433 	cq->qmask = cq->nb_desc - 1;
434 	cq->door = nix->base + NIX_LF_CQ_OP_DOOR;
435 	cq->status = (int64_t *)(nix->base + NIX_LF_CQ_OP_STATUS);
436 	cq->wdata = (uint64_t)cq->qid << 32;
437 	cq->roc_nix = roc_nix;
438 	cq->drop_thresh = NIX_CQ_THRESH_LEVEL;
439 
440 	/* CQE of W16 */
441 	desc_sz = cq->nb_desc * NIX_CQ_ENTRY_SZ;
442 	cq->desc_base = plt_zmalloc(desc_sz, NIX_CQ_ALIGN);
443 	if (cq->desc_base == NULL) {
444 		rc = NIX_ERR_NO_MEM;
445 		goto fail;
446 	}
447 
448 	if (roc_model_is_cn9k()) {
449 		struct nix_aq_enq_req *aq;
450 
451 		aq = mbox_alloc_msg_nix_aq_enq(mbox);
452 		aq->qidx = cq->qid;
453 		aq->ctype = NIX_AQ_CTYPE_CQ;
454 		aq->op = NIX_AQ_INSTOP_INIT;
455 		cq_ctx = &aq->cq;
456 	} else {
457 		struct nix_cn10k_aq_enq_req *aq;
458 
459 		aq = mbox_alloc_msg_nix_cn10k_aq_enq(mbox);
460 		aq->qidx = cq->qid;
461 		aq->ctype = NIX_AQ_CTYPE_CQ;
462 		aq->op = NIX_AQ_INSTOP_INIT;
463 		cq_ctx = &aq->cq;
464 	}
465 
466 	cq_ctx->ena = 1;
467 	cq_ctx->caching = 1;
468 	cq_ctx->qsize = qsize;
469 	cq_ctx->base = (uint64_t)cq->desc_base;
470 	cq_ctx->avg_level = 0xff;
471 	cq_ctx->cq_err_int_ena = BIT(NIX_CQERRINT_CQE_FAULT);
472 	cq_ctx->cq_err_int_ena |= BIT(NIX_CQERRINT_DOOR_ERR);
473 
474 	/* Many to one reduction */
475 	cq_ctx->qint_idx = cq->qid % nix->qints;
476 	/* Map CQ0 [RQ0] to CINT0 and so on till max 64 irqs */
477 	cq_ctx->cint_idx = cq->qid;
478 
479 	cq_ctx->drop = cq->drop_thresh;
480 	cq_ctx->drop_ena = 1;
481 
482 	/* TX pause frames enable flow ctrl on RX side */
483 	if (nix->tx_pause) {
484 		/* Single BPID is allocated for all rx channels for now */
485 		cq_ctx->bpid = nix->bpid[0];
486 		cq_ctx->bp = cq_ctx->drop;
487 		cq_ctx->bp_ena = 1;
488 	}
489 
490 	rc = mbox_process(mbox);
491 	if (rc)
492 		goto free_mem;
493 
494 	return 0;
495 
496 free_mem:
497 	plt_free(cq->desc_base);
498 fail:
499 	return rc;
500 }
501 
502 int
503 roc_nix_cq_fini(struct roc_nix_cq *cq)
504 {
505 	struct mbox *mbox;
506 	struct nix *nix;
507 	int rc;
508 
509 	if (cq == NULL)
510 		return NIX_ERR_PARAM;
511 
512 	nix = roc_nix_to_nix_priv(cq->roc_nix);
513 	mbox = (&nix->dev)->mbox;
514 
515 	/* Disable CQ */
516 	if (roc_model_is_cn9k()) {
517 		struct nix_aq_enq_req *aq;
518 
519 		aq = mbox_alloc_msg_nix_aq_enq(mbox);
520 		aq->qidx = cq->qid;
521 		aq->ctype = NIX_AQ_CTYPE_CQ;
522 		aq->op = NIX_AQ_INSTOP_WRITE;
523 		aq->cq.ena = 0;
524 		aq->cq.bp_ena = 0;
525 		aq->cq_mask.ena = ~aq->cq_mask.ena;
526 		aq->cq_mask.bp_ena = ~aq->cq_mask.bp_ena;
527 	} else {
528 		struct nix_cn10k_aq_enq_req *aq;
529 
530 		aq = mbox_alloc_msg_nix_cn10k_aq_enq(mbox);
531 		aq->qidx = cq->qid;
532 		aq->ctype = NIX_AQ_CTYPE_CQ;
533 		aq->op = NIX_AQ_INSTOP_WRITE;
534 		aq->cq.ena = 0;
535 		aq->cq.bp_ena = 0;
536 		aq->cq_mask.ena = ~aq->cq_mask.ena;
537 		aq->cq_mask.bp_ena = ~aq->cq_mask.bp_ena;
538 	}
539 
540 	rc = mbox_process(mbox);
541 	if (rc)
542 		return rc;
543 
544 	plt_free(cq->desc_base);
545 	return 0;
546 }
547 
548 static int
549 sqb_pool_populate(struct roc_nix *roc_nix, struct roc_nix_sq *sq)
550 {
551 	struct nix *nix = roc_nix_to_nix_priv(roc_nix);
552 	uint16_t sqes_per_sqb, count, nb_sqb_bufs;
553 	struct npa_pool_s pool;
554 	struct npa_aura_s aura;
555 	uint64_t blk_sz;
556 	uint64_t iova;
557 	int rc;
558 
559 	blk_sz = nix->sqb_size;
560 	if (sq->max_sqe_sz == roc_nix_maxsqesz_w16)
561 		sqes_per_sqb = (blk_sz / 8) / 16;
562 	else
563 		sqes_per_sqb = (blk_sz / 8) / 8;
564 
565 	sq->nb_desc = PLT_MAX(256U, sq->nb_desc);
566 	nb_sqb_bufs = sq->nb_desc / sqes_per_sqb;
567 	nb_sqb_bufs += NIX_SQB_LIST_SPACE;
568 	/* Clamp up the SQB count */
569 	nb_sqb_bufs = PLT_MIN(roc_nix->max_sqb_count,
570 			      (uint16_t)PLT_MAX(NIX_DEF_SQB, nb_sqb_bufs));
571 
572 	sq->nb_sqb_bufs = nb_sqb_bufs;
573 	sq->sqes_per_sqb_log2 = (uint16_t)plt_log2_u32(sqes_per_sqb);
574 	sq->nb_sqb_bufs_adj =
575 		nb_sqb_bufs -
576 		(PLT_ALIGN_MUL_CEIL(nb_sqb_bufs, sqes_per_sqb) / sqes_per_sqb);
577 	sq->nb_sqb_bufs_adj =
578 		(sq->nb_sqb_bufs_adj * NIX_SQB_LOWER_THRESH) / 100;
579 
580 	/* Explicitly set nat_align alone as by default pool is with both
581 	 * nat_align and buf_offset = 1 which we don't want for SQB.
582 	 */
583 	memset(&pool, 0, sizeof(struct npa_pool_s));
584 	pool.nat_align = 1;
585 
586 	memset(&aura, 0, sizeof(aura));
587 	aura.fc_ena = 1;
588 	if (roc_model_is_cn9k() || roc_model_is_cn10ka_a0())
589 		aura.fc_stype = 0x0; /* STF */
590 	else
591 		aura.fc_stype = 0x3; /* STSTP */
592 	aura.fc_addr = (uint64_t)sq->fc;
593 	aura.fc_hyst_bits = 0; /* Store count on all updates */
594 	rc = roc_npa_pool_create(&sq->aura_handle, blk_sz, NIX_MAX_SQB, &aura,
595 				 &pool);
596 	if (rc)
597 		goto fail;
598 
599 	sq->sqe_mem = plt_zmalloc(blk_sz * NIX_MAX_SQB, blk_sz);
600 	if (sq->sqe_mem == NULL) {
601 		rc = NIX_ERR_NO_MEM;
602 		goto nomem;
603 	}
604 
605 	/* Fill the initial buffers */
606 	iova = (uint64_t)sq->sqe_mem;
607 	for (count = 0; count < NIX_MAX_SQB; count++) {
608 		roc_npa_aura_op_free(sq->aura_handle, 0, iova);
609 		iova += blk_sz;
610 	}
611 	roc_npa_aura_op_range_set(sq->aura_handle, (uint64_t)sq->sqe_mem, iova);
612 	roc_npa_aura_limit_modify(sq->aura_handle, sq->nb_sqb_bufs);
613 	sq->aura_sqb_bufs = NIX_MAX_SQB;
614 
615 	return rc;
616 nomem:
617 	roc_npa_pool_destroy(sq->aura_handle);
618 fail:
619 	return rc;
620 }
621 
622 static void
623 sq_cn9k_init(struct nix *nix, struct roc_nix_sq *sq, uint32_t rr_quantum,
624 	     uint16_t smq)
625 {
626 	struct mbox *mbox = (&nix->dev)->mbox;
627 	struct nix_aq_enq_req *aq;
628 
629 	aq = mbox_alloc_msg_nix_aq_enq(mbox);
630 	aq->qidx = sq->qid;
631 	aq->ctype = NIX_AQ_CTYPE_SQ;
632 	aq->op = NIX_AQ_INSTOP_INIT;
633 	aq->sq.max_sqe_size = sq->max_sqe_sz;
634 
635 	aq->sq.max_sqe_size = sq->max_sqe_sz;
636 	aq->sq.smq = smq;
637 	aq->sq.smq_rr_quantum = rr_quantum;
638 	aq->sq.default_chan = nix->tx_chan_base;
639 	aq->sq.sqe_stype = NIX_STYPE_STF;
640 	aq->sq.ena = 1;
641 	aq->sq.sso_ena = !!sq->sso_ena;
642 	if (aq->sq.max_sqe_size == NIX_MAXSQESZ_W8)
643 		aq->sq.sqe_stype = NIX_STYPE_STP;
644 	aq->sq.sqb_aura = roc_npa_aura_handle_to_aura(sq->aura_handle);
645 	aq->sq.sq_int_ena = BIT(NIX_SQINT_LMT_ERR);
646 	aq->sq.sq_int_ena |= BIT(NIX_SQINT_SQB_ALLOC_FAIL);
647 	aq->sq.sq_int_ena |= BIT(NIX_SQINT_SEND_ERR);
648 	aq->sq.sq_int_ena |= BIT(NIX_SQINT_MNQ_ERR);
649 
650 	/* Many to one reduction */
651 	aq->sq.qint_idx = sq->qid % nix->qints;
652 }
653 
654 static int
655 sq_cn9k_fini(struct nix *nix, struct roc_nix_sq *sq)
656 {
657 	struct mbox *mbox = (&nix->dev)->mbox;
658 	struct nix_aq_enq_rsp *rsp;
659 	struct nix_aq_enq_req *aq;
660 	uint16_t sqes_per_sqb;
661 	void *sqb_buf;
662 	int rc, count;
663 
664 	aq = mbox_alloc_msg_nix_aq_enq(mbox);
665 	aq->qidx = sq->qid;
666 	aq->ctype = NIX_AQ_CTYPE_SQ;
667 	aq->op = NIX_AQ_INSTOP_READ;
668 	rc = mbox_process_msg(mbox, (void *)&rsp);
669 	if (rc)
670 		return rc;
671 
672 	/* Check if sq is already cleaned up */
673 	if (!rsp->sq.ena)
674 		return 0;
675 
676 	/* Disable sq */
677 	aq = mbox_alloc_msg_nix_aq_enq(mbox);
678 	aq->qidx = sq->qid;
679 	aq->ctype = NIX_AQ_CTYPE_SQ;
680 	aq->op = NIX_AQ_INSTOP_WRITE;
681 	aq->sq_mask.ena = ~aq->sq_mask.ena;
682 	aq->sq.ena = 0;
683 	rc = mbox_process(mbox);
684 	if (rc)
685 		return rc;
686 
687 	/* Read SQ and free sqb's */
688 	aq = mbox_alloc_msg_nix_aq_enq(mbox);
689 	aq->qidx = sq->qid;
690 	aq->ctype = NIX_AQ_CTYPE_SQ;
691 	aq->op = NIX_AQ_INSTOP_READ;
692 	rc = mbox_process_msg(mbox, (void *)&rsp);
693 	if (rc)
694 		return rc;
695 
696 	if (aq->sq.smq_pend)
697 		plt_err("SQ has pending SQE's");
698 
699 	count = aq->sq.sqb_count;
700 	sqes_per_sqb = 1 << sq->sqes_per_sqb_log2;
701 	/* Free SQB's that are used */
702 	sqb_buf = (void *)rsp->sq.head_sqb;
703 	while (count) {
704 		void *next_sqb;
705 
706 		next_sqb = *(void **)((uintptr_t)sqb_buf +
707 				      (uint32_t)((sqes_per_sqb - 1) *
708 						 sq->max_sqe_sz));
709 		roc_npa_aura_op_free(sq->aura_handle, 1, (uint64_t)sqb_buf);
710 		sqb_buf = next_sqb;
711 		count--;
712 	}
713 
714 	/* Free next to use sqb */
715 	if (rsp->sq.next_sqb)
716 		roc_npa_aura_op_free(sq->aura_handle, 1, rsp->sq.next_sqb);
717 	return 0;
718 }
719 
720 static void
721 sq_init(struct nix *nix, struct roc_nix_sq *sq, uint32_t rr_quantum,
722 	uint16_t smq)
723 {
724 	struct mbox *mbox = (&nix->dev)->mbox;
725 	struct nix_cn10k_aq_enq_req *aq;
726 
727 	aq = mbox_alloc_msg_nix_cn10k_aq_enq(mbox);
728 	aq->qidx = sq->qid;
729 	aq->ctype = NIX_AQ_CTYPE_SQ;
730 	aq->op = NIX_AQ_INSTOP_INIT;
731 	aq->sq.max_sqe_size = sq->max_sqe_sz;
732 
733 	aq->sq.max_sqe_size = sq->max_sqe_sz;
734 	aq->sq.smq = smq;
735 	aq->sq.smq_rr_weight = rr_quantum;
736 	aq->sq.default_chan = nix->tx_chan_base;
737 	aq->sq.sqe_stype = NIX_STYPE_STF;
738 	aq->sq.ena = 1;
739 	aq->sq.sso_ena = !!sq->sso_ena;
740 	if (aq->sq.max_sqe_size == NIX_MAXSQESZ_W8)
741 		aq->sq.sqe_stype = NIX_STYPE_STP;
742 	aq->sq.sqb_aura = roc_npa_aura_handle_to_aura(sq->aura_handle);
743 	aq->sq.sq_int_ena = BIT(NIX_SQINT_LMT_ERR);
744 	aq->sq.sq_int_ena |= BIT(NIX_SQINT_SQB_ALLOC_FAIL);
745 	aq->sq.sq_int_ena |= BIT(NIX_SQINT_SEND_ERR);
746 	aq->sq.sq_int_ena |= BIT(NIX_SQINT_MNQ_ERR);
747 
748 	/* Many to one reduction */
749 	aq->sq.qint_idx = sq->qid % nix->qints;
750 }
751 
752 static int
753 sq_fini(struct nix *nix, struct roc_nix_sq *sq)
754 {
755 	struct mbox *mbox = (&nix->dev)->mbox;
756 	struct nix_cn10k_aq_enq_rsp *rsp;
757 	struct nix_cn10k_aq_enq_req *aq;
758 	uint16_t sqes_per_sqb;
759 	void *sqb_buf;
760 	int rc, count;
761 
762 	aq = mbox_alloc_msg_nix_cn10k_aq_enq(mbox);
763 	aq->qidx = sq->qid;
764 	aq->ctype = NIX_AQ_CTYPE_SQ;
765 	aq->op = NIX_AQ_INSTOP_READ;
766 	rc = mbox_process_msg(mbox, (void *)&rsp);
767 	if (rc)
768 		return rc;
769 
770 	/* Check if sq is already cleaned up */
771 	if (!rsp->sq.ena)
772 		return 0;
773 
774 	/* Disable sq */
775 	aq = mbox_alloc_msg_nix_cn10k_aq_enq(mbox);
776 	aq->qidx = sq->qid;
777 	aq->ctype = NIX_AQ_CTYPE_SQ;
778 	aq->op = NIX_AQ_INSTOP_WRITE;
779 	aq->sq_mask.ena = ~aq->sq_mask.ena;
780 	aq->sq.ena = 0;
781 	rc = mbox_process(mbox);
782 	if (rc)
783 		return rc;
784 
785 	/* Read SQ and free sqb's */
786 	aq = mbox_alloc_msg_nix_cn10k_aq_enq(mbox);
787 	aq->qidx = sq->qid;
788 	aq->ctype = NIX_AQ_CTYPE_SQ;
789 	aq->op = NIX_AQ_INSTOP_READ;
790 	rc = mbox_process_msg(mbox, (void *)&rsp);
791 	if (rc)
792 		return rc;
793 
794 	if (aq->sq.smq_pend)
795 		plt_err("SQ has pending SQE's");
796 
797 	count = aq->sq.sqb_count;
798 	sqes_per_sqb = 1 << sq->sqes_per_sqb_log2;
799 	/* Free SQB's that are used */
800 	sqb_buf = (void *)rsp->sq.head_sqb;
801 	while (count) {
802 		void *next_sqb;
803 
804 		next_sqb = *(void **)((uintptr_t)sqb_buf +
805 				      (uint32_t)((sqes_per_sqb - 1) *
806 						 sq->max_sqe_sz));
807 		roc_npa_aura_op_free(sq->aura_handle, 1, (uint64_t)sqb_buf);
808 		sqb_buf = next_sqb;
809 		count--;
810 	}
811 
812 	/* Free next to use sqb */
813 	if (rsp->sq.next_sqb)
814 		roc_npa_aura_op_free(sq->aura_handle, 1, rsp->sq.next_sqb);
815 	return 0;
816 }
817 
818 int
819 roc_nix_sq_init(struct roc_nix *roc_nix, struct roc_nix_sq *sq)
820 {
821 	struct nix *nix = roc_nix_to_nix_priv(roc_nix);
822 	struct mbox *mbox = (&nix->dev)->mbox;
823 	uint16_t qid, smq = UINT16_MAX;
824 	uint32_t rr_quantum = 0;
825 	int rc;
826 
827 	if (sq == NULL)
828 		return NIX_ERR_PARAM;
829 
830 	qid = sq->qid;
831 	if (qid >= nix->nb_tx_queues)
832 		return NIX_ERR_QUEUE_INVALID_RANGE;
833 
834 	sq->roc_nix = roc_nix;
835 	/*
836 	 * Allocate memory for flow control updates from HW.
837 	 * Alloc one cache line, so that fits all FC_STYPE modes.
838 	 */
839 	sq->fc = plt_zmalloc(ROC_ALIGN, ROC_ALIGN);
840 	if (sq->fc == NULL) {
841 		rc = NIX_ERR_NO_MEM;
842 		goto fail;
843 	}
844 
845 	rc = sqb_pool_populate(roc_nix, sq);
846 	if (rc)
847 		goto nomem;
848 
849 	rc = nix_tm_leaf_data_get(nix, sq->qid, &rr_quantum, &smq);
850 	if (rc) {
851 		rc = NIX_ERR_TM_LEAF_NODE_GET;
852 		goto nomem;
853 	}
854 
855 	/* Init SQ context */
856 	if (roc_model_is_cn9k())
857 		sq_cn9k_init(nix, sq, rr_quantum, smq);
858 	else
859 		sq_init(nix, sq, rr_quantum, smq);
860 
861 	rc = mbox_process(mbox);
862 	if (rc)
863 		goto nomem;
864 
865 	nix->sqs[qid] = sq;
866 	sq->io_addr = nix->base + NIX_LF_OP_SENDX(0);
867 	/* Evenly distribute LMT slot for each sq */
868 	if (roc_model_is_cn9k()) {
869 		/* Multiple cores/SQ's can use same LMTLINE safely in CN9K */
870 		sq->lmt_addr = (void *)(nix->lmt_base +
871 					((qid & RVU_CN9K_LMT_SLOT_MASK) << 12));
872 	}
873 
874 	return rc;
875 nomem:
876 	plt_free(sq->fc);
877 fail:
878 	return rc;
879 }
880 
881 int
882 roc_nix_sq_fini(struct roc_nix_sq *sq)
883 {
884 	struct nix *nix;
885 	struct mbox *mbox;
886 	struct ndc_sync_op *ndc_req;
887 	uint16_t qid;
888 	int rc = 0;
889 
890 	if (sq == NULL)
891 		return NIX_ERR_PARAM;
892 
893 	nix = roc_nix_to_nix_priv(sq->roc_nix);
894 	mbox = (&nix->dev)->mbox;
895 
896 	qid = sq->qid;
897 
898 	rc = nix_tm_sq_flush_pre(sq);
899 
900 	/* Release SQ context */
901 	if (roc_model_is_cn9k())
902 		rc |= sq_cn9k_fini(roc_nix_to_nix_priv(sq->roc_nix), sq);
903 	else
904 		rc |= sq_fini(roc_nix_to_nix_priv(sq->roc_nix), sq);
905 
906 	/* Sync NDC-NIX-TX for LF */
907 	ndc_req = mbox_alloc_msg_ndc_sync_op(mbox);
908 	if (ndc_req == NULL)
909 		return -ENOSPC;
910 	ndc_req->nix_lf_tx_sync = 1;
911 	if (mbox_process(mbox))
912 		rc |= NIX_ERR_NDC_SYNC;
913 
914 	rc |= nix_tm_sq_flush_post(sq);
915 	rc |= roc_npa_pool_destroy(sq->aura_handle);
916 	plt_free(sq->fc);
917 	plt_free(sq->sqe_mem);
918 	nix->sqs[qid] = NULL;
919 
920 	return rc;
921 }
922