55075e7cb749dc8e5d696298eefbb7c30f596cf2
[muen/linux.git] / drivers / net / ethernet / marvell / octeontx2 / af / rvu_nix.c
1 // SPDX-License-Identifier: GPL-2.0
2 /* Marvell OcteonTx2 RVU Admin Function driver
3  *
4  * Copyright (C) 2018 Marvell International Ltd.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  */
10
11 #include <linux/module.h>
12 #include <linux/pci.h>
13
14 #include "rvu_struct.h"
15 #include "rvu_reg.h"
16 #include "rvu.h"
17 #include "npc.h"
18 #include "cgx.h"
19
20 static int nix_update_bcast_mce_list(struct rvu *rvu, u16 pcifunc, bool add);
21
22 enum mc_tbl_sz {
23         MC_TBL_SZ_256,
24         MC_TBL_SZ_512,
25         MC_TBL_SZ_1K,
26         MC_TBL_SZ_2K,
27         MC_TBL_SZ_4K,
28         MC_TBL_SZ_8K,
29         MC_TBL_SZ_16K,
30         MC_TBL_SZ_32K,
31         MC_TBL_SZ_64K,
32 };
33
34 enum mc_buf_cnt {
35         MC_BUF_CNT_8,
36         MC_BUF_CNT_16,
37         MC_BUF_CNT_32,
38         MC_BUF_CNT_64,
39         MC_BUF_CNT_128,
40         MC_BUF_CNT_256,
41         MC_BUF_CNT_512,
42         MC_BUF_CNT_1024,
43         MC_BUF_CNT_2048,
44 };
45
46 /* For now considering MC resources needed for broadcast
47  * pkt replication only. i.e 256 HWVFs + 12 PFs.
48  */
49 #define MC_TBL_SIZE     MC_TBL_SZ_512
50 #define MC_BUF_CNT      MC_BUF_CNT_128
51
52 struct mce {
53         struct hlist_node       node;
54         u16                     idx;
55         u16                     pcifunc;
56 };
57
58 int rvu_get_nixlf_count(struct rvu *rvu)
59 {
60         struct rvu_block *block;
61         int blkaddr;
62
63         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
64         if (blkaddr < 0)
65                 return 0;
66         block = &rvu->hw->block[blkaddr];
67         return block->lf.max;
68 }
69
70 static void nix_mce_list_init(struct nix_mce_list *list, int max)
71 {
72         INIT_HLIST_HEAD(&list->head);
73         list->count = 0;
74         list->max = max;
75 }
76
77 static u16 nix_alloc_mce_list(struct nix_mcast *mcast, int count)
78 {
79         int idx;
80
81         if (!mcast)
82                 return 0;
83
84         idx = mcast->next_free_mce;
85         mcast->next_free_mce += count;
86         return idx;
87 }
88
89 static inline struct nix_hw *get_nix_hw(struct rvu_hwinfo *hw, int blkaddr)
90 {
91         if (blkaddr == BLKADDR_NIX0 && hw->nix0)
92                 return hw->nix0;
93
94         return NULL;
95 }
96
97 static bool is_valid_txschq(struct rvu *rvu, int blkaddr,
98                             int lvl, u16 pcifunc, u16 schq)
99 {
100         struct nix_txsch *txsch;
101         struct nix_hw *nix_hw;
102
103         nix_hw = get_nix_hw(rvu->hw, blkaddr);
104         if (!nix_hw)
105                 return false;
106
107         txsch = &nix_hw->txsch[lvl];
108         /* Check out of bounds */
109         if (schq >= txsch->schq.max)
110                 return false;
111
112         spin_lock(&rvu->rsrc_lock);
113         if (txsch->pfvf_map[schq] != pcifunc) {
114                 spin_unlock(&rvu->rsrc_lock);
115                 return false;
116         }
117         spin_unlock(&rvu->rsrc_lock);
118         return true;
119 }
120
121 static int nix_interface_init(struct rvu *rvu, u16 pcifunc, int type, int nixlf)
122 {
123         struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, pcifunc);
124         u8 cgx_id, lmac_id;
125         int pkind, pf;
126         int err;
127
128         pf = rvu_get_pf(pcifunc);
129         if (!is_pf_cgxmapped(rvu, pf) && type != NIX_INTF_TYPE_LBK)
130                 return 0;
131
132         switch (type) {
133         case NIX_INTF_TYPE_CGX:
134                 pfvf->cgx_lmac = rvu->pf2cgxlmac_map[pf];
135                 rvu_get_cgx_lmac_id(pfvf->cgx_lmac, &cgx_id, &lmac_id);
136
137                 pkind = rvu_npc_get_pkind(rvu, pf);
138                 if (pkind < 0) {
139                         dev_err(rvu->dev,
140                                 "PF_Func 0x%x: Invalid pkind\n", pcifunc);
141                         return -EINVAL;
142                 }
143                 cgx_set_pkind(rvu_cgx_pdata(cgx_id, rvu), lmac_id, pkind);
144                 rvu_npc_set_pkind(rvu, pkind, pfvf);
145                 break;
146         case NIX_INTF_TYPE_LBK:
147                 break;
148         }
149
150         /* Add this PF_FUNC to bcast pkt replication list */
151         err = nix_update_bcast_mce_list(rvu, pcifunc, true);
152         if (err) {
153                 dev_err(rvu->dev,
154                         "Bcast list, failed to enable PF_FUNC 0x%x\n",
155                         pcifunc);
156         }
157         return 0;
158 }
159
160 static void nix_interface_deinit(struct rvu *rvu, u16 pcifunc, u8 nixlf)
161 {
162         int err;
163
164         /* Remove this PF_FUNC from bcast pkt replication list */
165         err = nix_update_bcast_mce_list(rvu, pcifunc, false);
166         if (err) {
167                 dev_err(rvu->dev,
168                         "Bcast list, failed to disable PF_FUNC 0x%x\n",
169                         pcifunc);
170         }
171 }
172
173 static void nix_setup_lso_tso_l3(struct rvu *rvu, int blkaddr,
174                                  u64 format, bool v4, u64 *fidx)
175 {
176         struct nix_lso_format field = {0};
177
178         /* IP's Length field */
179         field.layer = NIX_TXLAYER_OL3;
180         /* In ipv4, length field is at offset 2 bytes, for ipv6 it's 4 */
181         field.offset = v4 ? 2 : 4;
182         field.sizem1 = 1; /* i.e 2 bytes */
183         field.alg = NIX_LSOALG_ADD_PAYLEN;
184         rvu_write64(rvu, blkaddr,
185                     NIX_AF_LSO_FORMATX_FIELDX(format, (*fidx)++),
186                     *(u64 *)&field);
187
188         /* No ID field in IPv6 header */
189         if (!v4)
190                 return;
191
192         /* IP's ID field */
193         field.layer = NIX_TXLAYER_OL3;
194         field.offset = 4;
195         field.sizem1 = 1; /* i.e 2 bytes */
196         field.alg = NIX_LSOALG_ADD_SEGNUM;
197         rvu_write64(rvu, blkaddr,
198                     NIX_AF_LSO_FORMATX_FIELDX(format, (*fidx)++),
199                     *(u64 *)&field);
200 }
201
202 static void nix_setup_lso_tso_l4(struct rvu *rvu, int blkaddr,
203                                  u64 format, u64 *fidx)
204 {
205         struct nix_lso_format field = {0};
206
207         /* TCP's sequence number field */
208         field.layer = NIX_TXLAYER_OL4;
209         field.offset = 4;
210         field.sizem1 = 3; /* i.e 4 bytes */
211         field.alg = NIX_LSOALG_ADD_OFFSET;
212         rvu_write64(rvu, blkaddr,
213                     NIX_AF_LSO_FORMATX_FIELDX(format, (*fidx)++),
214                     *(u64 *)&field);
215
216         /* TCP's flags field */
217         field.layer = NIX_TXLAYER_OL4;
218         field.offset = 12;
219         field.sizem1 = 0; /* not needed */
220         field.alg = NIX_LSOALG_TCP_FLAGS;
221         rvu_write64(rvu, blkaddr,
222                     NIX_AF_LSO_FORMATX_FIELDX(format, (*fidx)++),
223                     *(u64 *)&field);
224 }
225
226 static void nix_setup_lso(struct rvu *rvu, int blkaddr)
227 {
228         u64 cfg, idx, fidx = 0;
229
230         /* Enable LSO */
231         cfg = rvu_read64(rvu, blkaddr, NIX_AF_LSO_CFG);
232         /* For TSO, set first and middle segment flags to
233          * mask out PSH, RST & FIN flags in TCP packet
234          */
235         cfg &= ~((0xFFFFULL << 32) | (0xFFFFULL << 16));
236         cfg |= (0xFFF2ULL << 32) | (0xFFF2ULL << 16);
237         rvu_write64(rvu, blkaddr, NIX_AF_LSO_CFG, cfg | BIT_ULL(63));
238
239         /* Configure format fields for TCPv4 segmentation offload */
240         idx = NIX_LSO_FORMAT_IDX_TSOV4;
241         nix_setup_lso_tso_l3(rvu, blkaddr, idx, true, &fidx);
242         nix_setup_lso_tso_l4(rvu, blkaddr, idx, &fidx);
243
244         /* Set rest of the fields to NOP */
245         for (; fidx < 8; fidx++) {
246                 rvu_write64(rvu, blkaddr,
247                             NIX_AF_LSO_FORMATX_FIELDX(idx, fidx), 0x0ULL);
248         }
249
250         /* Configure format fields for TCPv6 segmentation offload */
251         idx = NIX_LSO_FORMAT_IDX_TSOV6;
252         fidx = 0;
253         nix_setup_lso_tso_l3(rvu, blkaddr, idx, false, &fidx);
254         nix_setup_lso_tso_l4(rvu, blkaddr, idx, &fidx);
255
256         /* Set rest of the fields to NOP */
257         for (; fidx < 8; fidx++) {
258                 rvu_write64(rvu, blkaddr,
259                             NIX_AF_LSO_FORMATX_FIELDX(idx, fidx), 0x0ULL);
260         }
261 }
262
263 static void nix_ctx_free(struct rvu *rvu, struct rvu_pfvf *pfvf)
264 {
265         kfree(pfvf->rq_bmap);
266         kfree(pfvf->sq_bmap);
267         kfree(pfvf->cq_bmap);
268         if (pfvf->rq_ctx)
269                 qmem_free(rvu->dev, pfvf->rq_ctx);
270         if (pfvf->sq_ctx)
271                 qmem_free(rvu->dev, pfvf->sq_ctx);
272         if (pfvf->cq_ctx)
273                 qmem_free(rvu->dev, pfvf->cq_ctx);
274         if (pfvf->rss_ctx)
275                 qmem_free(rvu->dev, pfvf->rss_ctx);
276         if (pfvf->nix_qints_ctx)
277                 qmem_free(rvu->dev, pfvf->nix_qints_ctx);
278         if (pfvf->cq_ints_ctx)
279                 qmem_free(rvu->dev, pfvf->cq_ints_ctx);
280
281         pfvf->rq_bmap = NULL;
282         pfvf->cq_bmap = NULL;
283         pfvf->sq_bmap = NULL;
284         pfvf->rq_ctx = NULL;
285         pfvf->sq_ctx = NULL;
286         pfvf->cq_ctx = NULL;
287         pfvf->rss_ctx = NULL;
288         pfvf->nix_qints_ctx = NULL;
289         pfvf->cq_ints_ctx = NULL;
290 }
291
292 static int nixlf_rss_ctx_init(struct rvu *rvu, int blkaddr,
293                               struct rvu_pfvf *pfvf, int nixlf,
294                               int rss_sz, int rss_grps, int hwctx_size)
295 {
296         int err, grp, num_indices;
297
298         /* RSS is not requested for this NIXLF */
299         if (!rss_sz)
300                 return 0;
301         num_indices = rss_sz * rss_grps;
302
303         /* Alloc NIX RSS HW context memory and config the base */
304         err = qmem_alloc(rvu->dev, &pfvf->rss_ctx, num_indices, hwctx_size);
305         if (err)
306                 return err;
307
308         rvu_write64(rvu, blkaddr, NIX_AF_LFX_RSS_BASE(nixlf),
309                     (u64)pfvf->rss_ctx->iova);
310
311         /* Config full RSS table size, enable RSS and caching */
312         rvu_write64(rvu, blkaddr, NIX_AF_LFX_RSS_CFG(nixlf),
313                     BIT_ULL(36) | BIT_ULL(4) |
314                     ilog2(num_indices / MAX_RSS_INDIR_TBL_SIZE));
315         /* Config RSS group offset and sizes */
316         for (grp = 0; grp < rss_grps; grp++)
317                 rvu_write64(rvu, blkaddr, NIX_AF_LFX_RSS_GRPX(nixlf, grp),
318                             ((ilog2(rss_sz) - 1) << 16) | (rss_sz * grp));
319         return 0;
320 }
321
322 static int nix_aq_enqueue_wait(struct rvu *rvu, struct rvu_block *block,
323                                struct nix_aq_inst_s *inst)
324 {
325         struct admin_queue *aq = block->aq;
326         struct nix_aq_res_s *result;
327         int timeout = 1000;
328         u64 reg, head;
329
330         result = (struct nix_aq_res_s *)aq->res->base;
331
332         /* Get current head pointer where to append this instruction */
333         reg = rvu_read64(rvu, block->addr, NIX_AF_AQ_STATUS);
334         head = (reg >> 4) & AQ_PTR_MASK;
335
336         memcpy((void *)(aq->inst->base + (head * aq->inst->entry_sz)),
337                (void *)inst, aq->inst->entry_sz);
338         memset(result, 0, sizeof(*result));
339         /* sync into memory */
340         wmb();
341
342         /* Ring the doorbell and wait for result */
343         rvu_write64(rvu, block->addr, NIX_AF_AQ_DOOR, 1);
344         while (result->compcode == NIX_AQ_COMP_NOTDONE) {
345                 cpu_relax();
346                 udelay(1);
347                 timeout--;
348                 if (!timeout)
349                         return -EBUSY;
350         }
351
352         if (result->compcode != NIX_AQ_COMP_GOOD)
353                 /* TODO: Replace this with some error code */
354                 return -EBUSY;
355
356         return 0;
357 }
358
359 static int rvu_nix_aq_enq_inst(struct rvu *rvu, struct nix_aq_enq_req *req,
360                                struct nix_aq_enq_rsp *rsp)
361 {
362         struct rvu_hwinfo *hw = rvu->hw;
363         u16 pcifunc = req->hdr.pcifunc;
364         int nixlf, blkaddr, rc = 0;
365         struct nix_aq_inst_s inst;
366         struct rvu_block *block;
367         struct admin_queue *aq;
368         struct rvu_pfvf *pfvf;
369         void *ctx, *mask;
370         bool ena;
371         u64 cfg;
372
373         pfvf = rvu_get_pfvf(rvu, pcifunc);
374         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
375         if (!pfvf->nixlf || blkaddr < 0)
376                 return NIX_AF_ERR_AF_LF_INVALID;
377
378         block = &hw->block[blkaddr];
379         aq = block->aq;
380         if (!aq) {
381                 dev_warn(rvu->dev, "%s: NIX AQ not initialized\n", __func__);
382                 return NIX_AF_ERR_AQ_ENQUEUE;
383         }
384
385         nixlf = rvu_get_lf(rvu, block, pcifunc, 0);
386         if (nixlf < 0)
387                 return NIX_AF_ERR_AF_LF_INVALID;
388
389         switch (req->ctype) {
390         case NIX_AQ_CTYPE_RQ:
391                 /* Check if index exceeds max no of queues */
392                 if (!pfvf->rq_ctx || req->qidx >= pfvf->rq_ctx->qsize)
393                         rc = NIX_AF_ERR_AQ_ENQUEUE;
394                 break;
395         case NIX_AQ_CTYPE_SQ:
396                 if (!pfvf->sq_ctx || req->qidx >= pfvf->sq_ctx->qsize)
397                         rc = NIX_AF_ERR_AQ_ENQUEUE;
398                 break;
399         case NIX_AQ_CTYPE_CQ:
400                 if (!pfvf->cq_ctx || req->qidx >= pfvf->cq_ctx->qsize)
401                         rc = NIX_AF_ERR_AQ_ENQUEUE;
402                 break;
403         case NIX_AQ_CTYPE_RSS:
404                 /* Check if RSS is enabled and qidx is within range */
405                 cfg = rvu_read64(rvu, blkaddr, NIX_AF_LFX_RSS_CFG(nixlf));
406                 if (!(cfg & BIT_ULL(4)) || !pfvf->rss_ctx ||
407                     (req->qidx >= (256UL << (cfg & 0xF))))
408                         rc = NIX_AF_ERR_AQ_ENQUEUE;
409                 break;
410         case NIX_AQ_CTYPE_MCE:
411                 cfg = rvu_read64(rvu, blkaddr, NIX_AF_RX_MCAST_CFG);
412                 /* Check if index exceeds MCE list length */
413                 if (!hw->nix0->mcast.mce_ctx ||
414                     (req->qidx >= (256UL << (cfg & 0xF))))
415                         rc = NIX_AF_ERR_AQ_ENQUEUE;
416
417                 /* Adding multicast lists for requests from PF/VFs is not
418                  * yet supported, so ignore this.
419                  */
420                 if (rsp)
421                         rc = NIX_AF_ERR_AQ_ENQUEUE;
422                 break;
423         default:
424                 rc = NIX_AF_ERR_AQ_ENQUEUE;
425         }
426
427         if (rc)
428                 return rc;
429
430         /* Check if SQ pointed SMQ belongs to this PF/VF or not */
431         if (req->ctype == NIX_AQ_CTYPE_SQ &&
432             req->op != NIX_AQ_INSTOP_WRITE) {
433                 if (!is_valid_txschq(rvu, blkaddr, NIX_TXSCH_LVL_SMQ,
434                                      pcifunc, req->sq.smq))
435                         return NIX_AF_ERR_AQ_ENQUEUE;
436         }
437
438         memset(&inst, 0, sizeof(struct nix_aq_inst_s));
439         inst.lf = nixlf;
440         inst.cindex = req->qidx;
441         inst.ctype = req->ctype;
442         inst.op = req->op;
443         /* Currently we are not supporting enqueuing multiple instructions,
444          * so always choose first entry in result memory.
445          */
446         inst.res_addr = (u64)aq->res->iova;
447
448         /* Clean result + context memory */
449         memset(aq->res->base, 0, aq->res->entry_sz);
450         /* Context needs to be written at RES_ADDR + 128 */
451         ctx = aq->res->base + 128;
452         /* Mask needs to be written at RES_ADDR + 256 */
453         mask = aq->res->base + 256;
454
455         switch (req->op) {
456         case NIX_AQ_INSTOP_WRITE:
457                 if (req->ctype == NIX_AQ_CTYPE_RQ)
458                         memcpy(mask, &req->rq_mask,
459                                sizeof(struct nix_rq_ctx_s));
460                 else if (req->ctype == NIX_AQ_CTYPE_SQ)
461                         memcpy(mask, &req->sq_mask,
462                                sizeof(struct nix_sq_ctx_s));
463                 else if (req->ctype == NIX_AQ_CTYPE_CQ)
464                         memcpy(mask, &req->cq_mask,
465                                sizeof(struct nix_cq_ctx_s));
466                 else if (req->ctype == NIX_AQ_CTYPE_RSS)
467                         memcpy(mask, &req->rss_mask,
468                                sizeof(struct nix_rsse_s));
469                 else if (req->ctype == NIX_AQ_CTYPE_MCE)
470                         memcpy(mask, &req->mce_mask,
471                                sizeof(struct nix_rx_mce_s));
472                 /* Fall through */
473         case NIX_AQ_INSTOP_INIT:
474                 if (req->ctype == NIX_AQ_CTYPE_RQ)
475                         memcpy(ctx, &req->rq, sizeof(struct nix_rq_ctx_s));
476                 else if (req->ctype == NIX_AQ_CTYPE_SQ)
477                         memcpy(ctx, &req->sq, sizeof(struct nix_sq_ctx_s));
478                 else if (req->ctype == NIX_AQ_CTYPE_CQ)
479                         memcpy(ctx, &req->cq, sizeof(struct nix_cq_ctx_s));
480                 else if (req->ctype == NIX_AQ_CTYPE_RSS)
481                         memcpy(ctx, &req->rss, sizeof(struct nix_rsse_s));
482                 else if (req->ctype == NIX_AQ_CTYPE_MCE)
483                         memcpy(ctx, &req->mce, sizeof(struct nix_rx_mce_s));
484                 break;
485         case NIX_AQ_INSTOP_NOP:
486         case NIX_AQ_INSTOP_READ:
487         case NIX_AQ_INSTOP_LOCK:
488         case NIX_AQ_INSTOP_UNLOCK:
489                 break;
490         default:
491                 rc = NIX_AF_ERR_AQ_ENQUEUE;
492                 return rc;
493         }
494
495         spin_lock(&aq->lock);
496
497         /* Submit the instruction to AQ */
498         rc = nix_aq_enqueue_wait(rvu, block, &inst);
499         if (rc) {
500                 spin_unlock(&aq->lock);
501                 return rc;
502         }
503
504         /* Set RQ/SQ/CQ bitmap if respective queue hw context is enabled */
505         if (req->op == NIX_AQ_INSTOP_INIT) {
506                 if (req->ctype == NIX_AQ_CTYPE_RQ && req->rq.ena)
507                         __set_bit(req->qidx, pfvf->rq_bmap);
508                 if (req->ctype == NIX_AQ_CTYPE_SQ && req->sq.ena)
509                         __set_bit(req->qidx, pfvf->sq_bmap);
510                 if (req->ctype == NIX_AQ_CTYPE_CQ && req->cq.ena)
511                         __set_bit(req->qidx, pfvf->cq_bmap);
512         }
513
514         if (req->op == NIX_AQ_INSTOP_WRITE) {
515                 if (req->ctype == NIX_AQ_CTYPE_RQ) {
516                         ena = (req->rq.ena & req->rq_mask.ena) |
517                                 (test_bit(req->qidx, pfvf->rq_bmap) &
518                                 ~req->rq_mask.ena);
519                         if (ena)
520                                 __set_bit(req->qidx, pfvf->rq_bmap);
521                         else
522                                 __clear_bit(req->qidx, pfvf->rq_bmap);
523                 }
524                 if (req->ctype == NIX_AQ_CTYPE_SQ) {
525                         ena = (req->rq.ena & req->sq_mask.ena) |
526                                 (test_bit(req->qidx, pfvf->sq_bmap) &
527                                 ~req->sq_mask.ena);
528                         if (ena)
529                                 __set_bit(req->qidx, pfvf->sq_bmap);
530                         else
531                                 __clear_bit(req->qidx, pfvf->sq_bmap);
532                 }
533                 if (req->ctype == NIX_AQ_CTYPE_CQ) {
534                         ena = (req->rq.ena & req->cq_mask.ena) |
535                                 (test_bit(req->qidx, pfvf->cq_bmap) &
536                                 ~req->cq_mask.ena);
537                         if (ena)
538                                 __set_bit(req->qidx, pfvf->cq_bmap);
539                         else
540                                 __clear_bit(req->qidx, pfvf->cq_bmap);
541                 }
542         }
543
544         if (rsp) {
545                 /* Copy read context into mailbox */
546                 if (req->op == NIX_AQ_INSTOP_READ) {
547                         if (req->ctype == NIX_AQ_CTYPE_RQ)
548                                 memcpy(&rsp->rq, ctx,
549                                        sizeof(struct nix_rq_ctx_s));
550                         else if (req->ctype == NIX_AQ_CTYPE_SQ)
551                                 memcpy(&rsp->sq, ctx,
552                                        sizeof(struct nix_sq_ctx_s));
553                         else if (req->ctype == NIX_AQ_CTYPE_CQ)
554                                 memcpy(&rsp->cq, ctx,
555                                        sizeof(struct nix_cq_ctx_s));
556                         else if (req->ctype == NIX_AQ_CTYPE_RSS)
557                                 memcpy(&rsp->rss, ctx,
558                                        sizeof(struct nix_cq_ctx_s));
559                         else if (req->ctype == NIX_AQ_CTYPE_MCE)
560                                 memcpy(&rsp->mce, ctx,
561                                        sizeof(struct nix_rx_mce_s));
562                 }
563         }
564
565         spin_unlock(&aq->lock);
566         return 0;
567 }
568
569 static int nix_lf_hwctx_disable(struct rvu *rvu, struct hwctx_disable_req *req)
570 {
571         struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, req->hdr.pcifunc);
572         struct nix_aq_enq_req aq_req;
573         unsigned long *bmap;
574         int qidx, q_cnt = 0;
575         int err = 0, rc;
576
577         if (!pfvf->cq_ctx || !pfvf->sq_ctx || !pfvf->rq_ctx)
578                 return NIX_AF_ERR_AQ_ENQUEUE;
579
580         memset(&aq_req, 0, sizeof(struct nix_aq_enq_req));
581         aq_req.hdr.pcifunc = req->hdr.pcifunc;
582
583         if (req->ctype == NIX_AQ_CTYPE_CQ) {
584                 aq_req.cq.ena = 0;
585                 aq_req.cq_mask.ena = 1;
586                 q_cnt = pfvf->cq_ctx->qsize;
587                 bmap = pfvf->cq_bmap;
588         }
589         if (req->ctype == NIX_AQ_CTYPE_SQ) {
590                 aq_req.sq.ena = 0;
591                 aq_req.sq_mask.ena = 1;
592                 q_cnt = pfvf->sq_ctx->qsize;
593                 bmap = pfvf->sq_bmap;
594         }
595         if (req->ctype == NIX_AQ_CTYPE_RQ) {
596                 aq_req.rq.ena = 0;
597                 aq_req.rq_mask.ena = 1;
598                 q_cnt = pfvf->rq_ctx->qsize;
599                 bmap = pfvf->rq_bmap;
600         }
601
602         aq_req.ctype = req->ctype;
603         aq_req.op = NIX_AQ_INSTOP_WRITE;
604
605         for (qidx = 0; qidx < q_cnt; qidx++) {
606                 if (!test_bit(qidx, bmap))
607                         continue;
608                 aq_req.qidx = qidx;
609                 rc = rvu_nix_aq_enq_inst(rvu, &aq_req, NULL);
610                 if (rc) {
611                         err = rc;
612                         dev_err(rvu->dev, "Failed to disable %s:%d context\n",
613                                 (req->ctype == NIX_AQ_CTYPE_CQ) ?
614                                 "CQ" : ((req->ctype == NIX_AQ_CTYPE_RQ) ?
615                                 "RQ" : "SQ"), qidx);
616                 }
617         }
618
619         return err;
620 }
621
622 int rvu_mbox_handler_NIX_AQ_ENQ(struct rvu *rvu,
623                                 struct nix_aq_enq_req *req,
624                                 struct nix_aq_enq_rsp *rsp)
625 {
626         return rvu_nix_aq_enq_inst(rvu, req, rsp);
627 }
628
629 int rvu_mbox_handler_NIX_HWCTX_DISABLE(struct rvu *rvu,
630                                        struct hwctx_disable_req *req,
631                                        struct msg_rsp *rsp)
632 {
633         return nix_lf_hwctx_disable(rvu, req);
634 }
635
636 int rvu_mbox_handler_NIX_LF_ALLOC(struct rvu *rvu,
637                                   struct nix_lf_alloc_req *req,
638                                   struct nix_lf_alloc_rsp *rsp)
639 {
640         int nixlf, qints, hwctx_size, err, rc = 0;
641         struct rvu_hwinfo *hw = rvu->hw;
642         u16 pcifunc = req->hdr.pcifunc;
643         struct rvu_block *block;
644         struct rvu_pfvf *pfvf;
645         u64 cfg, ctx_cfg;
646         int blkaddr;
647
648         if (!req->rq_cnt || !req->sq_cnt || !req->cq_cnt)
649                 return NIX_AF_ERR_PARAM;
650
651         pfvf = rvu_get_pfvf(rvu, pcifunc);
652         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
653         if (!pfvf->nixlf || blkaddr < 0)
654                 return NIX_AF_ERR_AF_LF_INVALID;
655
656         block = &hw->block[blkaddr];
657         nixlf = rvu_get_lf(rvu, block, pcifunc, 0);
658         if (nixlf < 0)
659                 return NIX_AF_ERR_AF_LF_INVALID;
660
661         /* If RSS is being enabled, check if requested config is valid.
662          * RSS table size should be power of two, otherwise
663          * RSS_GRP::OFFSET + adder might go beyond that group or
664          * won't be able to use entire table.
665          */
666         if (req->rss_sz && (req->rss_sz > MAX_RSS_INDIR_TBL_SIZE ||
667                             !is_power_of_2(req->rss_sz)))
668                 return NIX_AF_ERR_RSS_SIZE_INVALID;
669
670         if (req->rss_sz &&
671             (!req->rss_grps || req->rss_grps > MAX_RSS_GROUPS))
672                 return NIX_AF_ERR_RSS_GRPS_INVALID;
673
674         /* Reset this NIX LF */
675         err = rvu_lf_reset(rvu, block, nixlf);
676         if (err) {
677                 dev_err(rvu->dev, "Failed to reset NIX%d LF%d\n",
678                         block->addr - BLKADDR_NIX0, nixlf);
679                 return NIX_AF_ERR_LF_RESET;
680         }
681
682         ctx_cfg = rvu_read64(rvu, blkaddr, NIX_AF_CONST3);
683
684         /* Alloc NIX RQ HW context memory and config the base */
685         hwctx_size = 1UL << ((ctx_cfg >> 4) & 0xF);
686         err = qmem_alloc(rvu->dev, &pfvf->rq_ctx, req->rq_cnt, hwctx_size);
687         if (err)
688                 goto free_mem;
689
690         pfvf->rq_bmap = kcalloc(req->rq_cnt, sizeof(long), GFP_KERNEL);
691         if (!pfvf->rq_bmap)
692                 goto free_mem;
693
694         rvu_write64(rvu, blkaddr, NIX_AF_LFX_RQS_BASE(nixlf),
695                     (u64)pfvf->rq_ctx->iova);
696
697         /* Set caching and queue count in HW */
698         cfg = BIT_ULL(36) | (req->rq_cnt - 1);
699         rvu_write64(rvu, blkaddr, NIX_AF_LFX_RQS_CFG(nixlf), cfg);
700
701         /* Alloc NIX SQ HW context memory and config the base */
702         hwctx_size = 1UL << (ctx_cfg & 0xF);
703         err = qmem_alloc(rvu->dev, &pfvf->sq_ctx, req->sq_cnt, hwctx_size);
704         if (err)
705                 goto free_mem;
706
707         pfvf->sq_bmap = kcalloc(req->sq_cnt, sizeof(long), GFP_KERNEL);
708         if (!pfvf->sq_bmap)
709                 goto free_mem;
710
711         rvu_write64(rvu, blkaddr, NIX_AF_LFX_SQS_BASE(nixlf),
712                     (u64)pfvf->sq_ctx->iova);
713         cfg = BIT_ULL(36) | (req->sq_cnt - 1);
714         rvu_write64(rvu, blkaddr, NIX_AF_LFX_SQS_CFG(nixlf), cfg);
715
716         /* Alloc NIX CQ HW context memory and config the base */
717         hwctx_size = 1UL << ((ctx_cfg >> 8) & 0xF);
718         err = qmem_alloc(rvu->dev, &pfvf->cq_ctx, req->cq_cnt, hwctx_size);
719         if (err)
720                 goto free_mem;
721
722         pfvf->cq_bmap = kcalloc(req->cq_cnt, sizeof(long), GFP_KERNEL);
723         if (!pfvf->cq_bmap)
724                 goto free_mem;
725
726         rvu_write64(rvu, blkaddr, NIX_AF_LFX_CQS_BASE(nixlf),
727                     (u64)pfvf->cq_ctx->iova);
728         cfg = BIT_ULL(36) | (req->cq_cnt - 1);
729         rvu_write64(rvu, blkaddr, NIX_AF_LFX_CQS_CFG(nixlf), cfg);
730
731         /* Initialize receive side scaling (RSS) */
732         hwctx_size = 1UL << ((ctx_cfg >> 12) & 0xF);
733         err = nixlf_rss_ctx_init(rvu, blkaddr, pfvf, nixlf,
734                                  req->rss_sz, req->rss_grps, hwctx_size);
735         if (err)
736                 goto free_mem;
737
738         /* Alloc memory for CQINT's HW contexts */
739         cfg = rvu_read64(rvu, blkaddr, NIX_AF_CONST2);
740         qints = (cfg >> 24) & 0xFFF;
741         hwctx_size = 1UL << ((ctx_cfg >> 24) & 0xF);
742         err = qmem_alloc(rvu->dev, &pfvf->cq_ints_ctx, qints, hwctx_size);
743         if (err)
744                 goto free_mem;
745
746         rvu_write64(rvu, blkaddr, NIX_AF_LFX_CINTS_BASE(nixlf),
747                     (u64)pfvf->cq_ints_ctx->iova);
748         rvu_write64(rvu, blkaddr, NIX_AF_LFX_CINTS_CFG(nixlf), BIT_ULL(36));
749
750         /* Alloc memory for QINT's HW contexts */
751         cfg = rvu_read64(rvu, blkaddr, NIX_AF_CONST2);
752         qints = (cfg >> 12) & 0xFFF;
753         hwctx_size = 1UL << ((ctx_cfg >> 20) & 0xF);
754         err = qmem_alloc(rvu->dev, &pfvf->nix_qints_ctx, qints, hwctx_size);
755         if (err)
756                 goto free_mem;
757
758         rvu_write64(rvu, blkaddr, NIX_AF_LFX_QINTS_BASE(nixlf),
759                     (u64)pfvf->nix_qints_ctx->iova);
760         rvu_write64(rvu, blkaddr, NIX_AF_LFX_QINTS_CFG(nixlf), BIT_ULL(36));
761
762         /* Enable LMTST for this NIX LF */
763         rvu_write64(rvu, blkaddr, NIX_AF_LFX_TX_CFG2(nixlf), BIT_ULL(0));
764
765         /* Set CQE/WQE size, NPA_PF_FUNC for SQBs and also SSO_PF_FUNC
766          * If requester has sent a 'RVU_DEFAULT_PF_FUNC' use this NIX LF's
767          * PCIFUNC itself.
768          */
769         if (req->npa_func == RVU_DEFAULT_PF_FUNC)
770                 cfg = pcifunc;
771         else
772                 cfg = req->npa_func;
773
774         if (req->sso_func == RVU_DEFAULT_PF_FUNC)
775                 cfg |= (u64)pcifunc << 16;
776         else
777                 cfg |= (u64)req->sso_func << 16;
778
779         cfg |= (u64)req->xqe_sz << 33;
780         rvu_write64(rvu, blkaddr, NIX_AF_LFX_CFG(nixlf), cfg);
781
782         /* Config Rx pkt length, csum checks and apad  enable / disable */
783         rvu_write64(rvu, blkaddr, NIX_AF_LFX_RX_CFG(nixlf), req->rx_cfg);
784
785         err = nix_interface_init(rvu, pcifunc, NIX_INTF_TYPE_CGX, nixlf);
786         if (err)
787                 goto free_mem;
788
789         goto exit;
790
791 free_mem:
792         nix_ctx_free(rvu, pfvf);
793         rc = -ENOMEM;
794
795 exit:
796         /* Set macaddr of this PF/VF */
797         ether_addr_copy(rsp->mac_addr, pfvf->mac_addr);
798
799         /* set SQB size info */
800         cfg = rvu_read64(rvu, blkaddr, NIX_AF_SQ_CONST);
801         rsp->sqb_size = (cfg >> 34) & 0xFFFF;
802         rsp->lso_tsov4_idx = NIX_LSO_FORMAT_IDX_TSOV4;
803         rsp->lso_tsov6_idx = NIX_LSO_FORMAT_IDX_TSOV6;
804         return rc;
805 }
806
807 int rvu_mbox_handler_NIX_LF_FREE(struct rvu *rvu, struct msg_req *req,
808                                  struct msg_rsp *rsp)
809 {
810         struct rvu_hwinfo *hw = rvu->hw;
811         u16 pcifunc = req->hdr.pcifunc;
812         struct rvu_block *block;
813         int blkaddr, nixlf, err;
814         struct rvu_pfvf *pfvf;
815
816         pfvf = rvu_get_pfvf(rvu, pcifunc);
817         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
818         if (!pfvf->nixlf || blkaddr < 0)
819                 return NIX_AF_ERR_AF_LF_INVALID;
820
821         block = &hw->block[blkaddr];
822         nixlf = rvu_get_lf(rvu, block, pcifunc, 0);
823         if (nixlf < 0)
824                 return NIX_AF_ERR_AF_LF_INVALID;
825
826         nix_interface_deinit(rvu, pcifunc, nixlf);
827
828         /* Reset this NIX LF */
829         err = rvu_lf_reset(rvu, block, nixlf);
830         if (err) {
831                 dev_err(rvu->dev, "Failed to reset NIX%d LF%d\n",
832                         block->addr - BLKADDR_NIX0, nixlf);
833                 return NIX_AF_ERR_LF_RESET;
834         }
835
836         nix_ctx_free(rvu, pfvf);
837
838         return 0;
839 }
840
841 /* Disable shaping of pkts by a scheduler queue
842  * at a given scheduler level.
843  */
844 static void nix_reset_tx_shaping(struct rvu *rvu, int blkaddr,
845                                  int lvl, int schq)
846 {
847         u64  cir_reg = 0, pir_reg = 0;
848         u64  cfg;
849
850         switch (lvl) {
851         case NIX_TXSCH_LVL_TL1:
852                 cir_reg = NIX_AF_TL1X_CIR(schq);
853                 pir_reg = 0; /* PIR not available at TL1 */
854                 break;
855         case NIX_TXSCH_LVL_TL2:
856                 cir_reg = NIX_AF_TL2X_CIR(schq);
857                 pir_reg = NIX_AF_TL2X_PIR(schq);
858                 break;
859         case NIX_TXSCH_LVL_TL3:
860                 cir_reg = NIX_AF_TL3X_CIR(schq);
861                 pir_reg = NIX_AF_TL3X_PIR(schq);
862                 break;
863         case NIX_TXSCH_LVL_TL4:
864                 cir_reg = NIX_AF_TL4X_CIR(schq);
865                 pir_reg = NIX_AF_TL4X_PIR(schq);
866                 break;
867         }
868
869         if (!cir_reg)
870                 return;
871         cfg = rvu_read64(rvu, blkaddr, cir_reg);
872         rvu_write64(rvu, blkaddr, cir_reg, cfg & ~BIT_ULL(0));
873
874         if (!pir_reg)
875                 return;
876         cfg = rvu_read64(rvu, blkaddr, pir_reg);
877         rvu_write64(rvu, blkaddr, pir_reg, cfg & ~BIT_ULL(0));
878 }
879
880 static void nix_reset_tx_linkcfg(struct rvu *rvu, int blkaddr,
881                                  int lvl, int schq)
882 {
883         struct rvu_hwinfo *hw = rvu->hw;
884         int link;
885
886         /* Reset TL4's SDP link config */
887         if (lvl == NIX_TXSCH_LVL_TL4)
888                 rvu_write64(rvu, blkaddr, NIX_AF_TL4X_SDP_LINK_CFG(schq), 0x00);
889
890         if (lvl != NIX_TXSCH_LVL_TL2)
891                 return;
892
893         /* Reset TL2's CGX or LBK link config */
894         for (link = 0; link < (hw->cgx_links + hw->lbk_links); link++)
895                 rvu_write64(rvu, blkaddr,
896                             NIX_AF_TL3_TL2X_LINKX_CFG(schq, link), 0x00);
897 }
898
899 int rvu_mbox_handler_NIX_TXSCH_ALLOC(struct rvu *rvu,
900                                      struct nix_txsch_alloc_req *req,
901                                      struct nix_txsch_alloc_rsp *rsp)
902 {
903         u16 pcifunc = req->hdr.pcifunc;
904         struct nix_txsch *txsch;
905         int lvl, idx, req_schq;
906         struct rvu_pfvf *pfvf;
907         struct nix_hw *nix_hw;
908         int blkaddr, rc = 0;
909         u16 schq;
910
911         pfvf = rvu_get_pfvf(rvu, pcifunc);
912         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
913         if (!pfvf->nixlf || blkaddr < 0)
914                 return NIX_AF_ERR_AF_LF_INVALID;
915
916         nix_hw = get_nix_hw(rvu->hw, blkaddr);
917         if (!nix_hw)
918                 return -EINVAL;
919
920         spin_lock(&rvu->rsrc_lock);
921         for (lvl = 0; lvl < NIX_TXSCH_LVL_CNT; lvl++) {
922                 txsch = &nix_hw->txsch[lvl];
923                 req_schq = req->schq_contig[lvl] + req->schq[lvl];
924
925                 /* There are only 28 TL1s */
926                 if (lvl == NIX_TXSCH_LVL_TL1 && req_schq > txsch->schq.max)
927                         goto err;
928
929                 /* Check if request is valid */
930                 if (!req_schq || req_schq > MAX_TXSCHQ_PER_FUNC)
931                         goto err;
932
933                 /* If contiguous queues are needed, check for availability */
934                 if (req->schq_contig[lvl] &&
935                     !rvu_rsrc_check_contig(&txsch->schq, req->schq_contig[lvl]))
936                         goto err;
937
938                 /* Check if full request can be accommodated */
939                 if (req_schq >= rvu_rsrc_free_count(&txsch->schq))
940                         goto err;
941         }
942
943         for (lvl = 0; lvl < NIX_TXSCH_LVL_CNT; lvl++) {
944                 txsch = &nix_hw->txsch[lvl];
945                 rsp->schq_contig[lvl] = req->schq_contig[lvl];
946                 rsp->schq[lvl] = req->schq[lvl];
947
948                 schq = 0;
949                 /* Alloc contiguous queues first */
950                 if (req->schq_contig[lvl]) {
951                         schq = rvu_alloc_rsrc_contig(&txsch->schq,
952                                                      req->schq_contig[lvl]);
953
954                         for (idx = 0; idx < req->schq_contig[lvl]; idx++) {
955                                 txsch->pfvf_map[schq] = pcifunc;
956                                 nix_reset_tx_linkcfg(rvu, blkaddr, lvl, schq);
957                                 nix_reset_tx_shaping(rvu, blkaddr, lvl, schq);
958                                 rsp->schq_contig_list[lvl][idx] = schq;
959                                 schq++;
960                         }
961                 }
962
963                 /* Alloc non-contiguous queues */
964                 for (idx = 0; idx < req->schq[lvl]; idx++) {
965                         schq = rvu_alloc_rsrc(&txsch->schq);
966                         txsch->pfvf_map[schq] = pcifunc;
967                         nix_reset_tx_linkcfg(rvu, blkaddr, lvl, schq);
968                         nix_reset_tx_shaping(rvu, blkaddr, lvl, schq);
969                         rsp->schq_list[lvl][idx] = schq;
970                 }
971         }
972         goto exit;
973 err:
974         rc = NIX_AF_ERR_TLX_ALLOC_FAIL;
975 exit:
976         spin_unlock(&rvu->rsrc_lock);
977         return rc;
978 }
979
980 static int nix_txschq_free(struct rvu *rvu, u16 pcifunc)
981 {
982         int blkaddr, nixlf, lvl, schq, err;
983         struct rvu_hwinfo *hw = rvu->hw;
984         struct nix_txsch *txsch;
985         struct nix_hw *nix_hw;
986         u64 cfg;
987
988         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
989         if (blkaddr < 0)
990                 return NIX_AF_ERR_AF_LF_INVALID;
991
992         nix_hw = get_nix_hw(rvu->hw, blkaddr);
993         if (!nix_hw)
994                 return -EINVAL;
995
996         nixlf = rvu_get_lf(rvu, &hw->block[blkaddr], pcifunc, 0);
997         if (nixlf < 0)
998                 return NIX_AF_ERR_AF_LF_INVALID;
999
1000         /* Disable TL2/3 queue links before SMQ flush*/
1001         spin_lock(&rvu->rsrc_lock);
1002         for (lvl = NIX_TXSCH_LVL_TL4; lvl < NIX_TXSCH_LVL_CNT; lvl++) {
1003                 if (lvl != NIX_TXSCH_LVL_TL2 && lvl != NIX_TXSCH_LVL_TL4)
1004                         continue;
1005
1006                 txsch = &nix_hw->txsch[lvl];
1007                 for (schq = 0; schq < txsch->schq.max; schq++) {
1008                         if (txsch->pfvf_map[schq] != pcifunc)
1009                                 continue;
1010                         nix_reset_tx_linkcfg(rvu, blkaddr, lvl, schq);
1011                 }
1012         }
1013
1014         /* Flush SMQs */
1015         txsch = &nix_hw->txsch[NIX_TXSCH_LVL_SMQ];
1016         for (schq = 0; schq < txsch->schq.max; schq++) {
1017                 if (txsch->pfvf_map[schq] != pcifunc)
1018                         continue;
1019                 cfg = rvu_read64(rvu, blkaddr, NIX_AF_SMQX_CFG(schq));
1020                 /* Do SMQ flush and set enqueue xoff */
1021                 cfg |= BIT_ULL(50) | BIT_ULL(49);
1022                 rvu_write64(rvu, blkaddr, NIX_AF_SMQX_CFG(schq), cfg);
1023
1024                 /* Wait for flush to complete */
1025                 err = rvu_poll_reg(rvu, blkaddr,
1026                                    NIX_AF_SMQX_CFG(schq), BIT_ULL(49), true);
1027                 if (err) {
1028                         dev_err(rvu->dev,
1029                                 "NIXLF%d: SMQ%d flush failed\n", nixlf, schq);
1030                 }
1031         }
1032
1033         /* Now free scheduler queues to free pool */
1034         for (lvl = 0; lvl < NIX_TXSCH_LVL_CNT; lvl++) {
1035                 txsch = &nix_hw->txsch[lvl];
1036                 for (schq = 0; schq < txsch->schq.max; schq++) {
1037                         if (txsch->pfvf_map[schq] != pcifunc)
1038                                 continue;
1039                         rvu_free_rsrc(&txsch->schq, schq);
1040                         txsch->pfvf_map[schq] = 0;
1041                 }
1042         }
1043         spin_unlock(&rvu->rsrc_lock);
1044
1045         /* Sync cached info for this LF in NDC-TX to LLC/DRAM */
1046         rvu_write64(rvu, blkaddr, NIX_AF_NDC_TX_SYNC, BIT_ULL(12) | nixlf);
1047         err = rvu_poll_reg(rvu, blkaddr, NIX_AF_NDC_TX_SYNC, BIT_ULL(12), true);
1048         if (err)
1049                 dev_err(rvu->dev, "NDC-TX sync failed for NIXLF %d\n", nixlf);
1050
1051         return 0;
1052 }
1053
1054 int rvu_mbox_handler_NIX_TXSCH_FREE(struct rvu *rvu,
1055                                     struct nix_txsch_free_req *req,
1056                                     struct msg_rsp *rsp)
1057 {
1058         return nix_txschq_free(rvu, req->hdr.pcifunc);
1059 }
1060
1061 static bool is_txschq_config_valid(struct rvu *rvu, u16 pcifunc, int blkaddr,
1062                                    int lvl, u64 reg, u64 regval)
1063 {
1064         u64 regbase = reg & 0xFFFF;
1065         u16 schq, parent;
1066
1067         if (!rvu_check_valid_reg(TXSCHQ_HWREGMAP, lvl, reg))
1068                 return false;
1069
1070         schq = TXSCHQ_IDX(reg, TXSCHQ_IDX_SHIFT);
1071         /* Check if this schq belongs to this PF/VF or not */
1072         if (!is_valid_txschq(rvu, blkaddr, lvl, pcifunc, schq))
1073                 return false;
1074
1075         parent = (regval >> 16) & 0x1FF;
1076         /* Validate MDQ's TL4 parent */
1077         if (regbase == NIX_AF_MDQX_PARENT(0) &&
1078             !is_valid_txschq(rvu, blkaddr, NIX_TXSCH_LVL_TL4, pcifunc, parent))
1079                 return false;
1080
1081         /* Validate TL4's TL3 parent */
1082         if (regbase == NIX_AF_TL4X_PARENT(0) &&
1083             !is_valid_txschq(rvu, blkaddr, NIX_TXSCH_LVL_TL3, pcifunc, parent))
1084                 return false;
1085
1086         /* Validate TL3's TL2 parent */
1087         if (regbase == NIX_AF_TL3X_PARENT(0) &&
1088             !is_valid_txschq(rvu, blkaddr, NIX_TXSCH_LVL_TL2, pcifunc, parent))
1089                 return false;
1090
1091         /* Validate TL2's TL1 parent */
1092         if (regbase == NIX_AF_TL2X_PARENT(0) &&
1093             !is_valid_txschq(rvu, blkaddr, NIX_TXSCH_LVL_TL1, pcifunc, parent))
1094                 return false;
1095
1096         return true;
1097 }
1098
1099 int rvu_mbox_handler_NIX_TXSCHQ_CFG(struct rvu *rvu,
1100                                     struct nix_txschq_config *req,
1101                                     struct msg_rsp *rsp)
1102 {
1103         struct rvu_hwinfo *hw = rvu->hw;
1104         u16 pcifunc = req->hdr.pcifunc;
1105         u64 reg, regval, schq_regbase;
1106         struct nix_txsch *txsch;
1107         struct nix_hw *nix_hw;
1108         int blkaddr, idx, err;
1109         int nixlf;
1110
1111         if (req->lvl >= NIX_TXSCH_LVL_CNT ||
1112             req->num_regs > MAX_REGS_PER_MBOX_MSG)
1113                 return NIX_AF_INVAL_TXSCHQ_CFG;
1114
1115         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
1116         if (blkaddr < 0)
1117                 return NIX_AF_ERR_AF_LF_INVALID;
1118
1119         nix_hw = get_nix_hw(rvu->hw, blkaddr);
1120         if (!nix_hw)
1121                 return -EINVAL;
1122
1123         nixlf = rvu_get_lf(rvu, &hw->block[blkaddr], pcifunc, 0);
1124         if (nixlf < 0)
1125                 return NIX_AF_ERR_AF_LF_INVALID;
1126
1127         txsch = &nix_hw->txsch[req->lvl];
1128         for (idx = 0; idx < req->num_regs; idx++) {
1129                 reg = req->reg[idx];
1130                 regval = req->regval[idx];
1131                 schq_regbase = reg & 0xFFFF;
1132
1133                 if (!is_txschq_config_valid(rvu, pcifunc, blkaddr,
1134                                             txsch->lvl, reg, regval))
1135                         return NIX_AF_INVAL_TXSCHQ_CFG;
1136
1137                 /* Replace PF/VF visible NIXLF slot with HW NIXLF id */
1138                 if (schq_regbase == NIX_AF_SMQX_CFG(0)) {
1139                         nixlf = rvu_get_lf(rvu, &hw->block[blkaddr],
1140                                            pcifunc, 0);
1141                         regval &= ~(0x7FULL << 24);
1142                         regval |= ((u64)nixlf << 24);
1143                 }
1144
1145                 rvu_write64(rvu, blkaddr, reg, regval);
1146
1147                 /* Check for SMQ flush, if so, poll for its completion */
1148                 if (schq_regbase == NIX_AF_SMQX_CFG(0) &&
1149                     (regval & BIT_ULL(49))) {
1150                         err = rvu_poll_reg(rvu, blkaddr,
1151                                            reg, BIT_ULL(49), true);
1152                         if (err)
1153                                 return NIX_AF_SMQ_FLUSH_FAILED;
1154                 }
1155         }
1156         return 0;
1157 }
1158
1159 static int nix_rx_vtag_cfg(struct rvu *rvu, int nixlf, int blkaddr,
1160                            struct nix_vtag_config *req)
1161 {
1162         u64 regval = 0;
1163
1164 #define NIX_VTAGTYPE_MAX 0x8ull
1165 #define NIX_VTAGSIZE_MASK 0x7ull
1166 #define NIX_VTAGSTRIP_CAP_MASK 0x30ull
1167
1168         if (req->rx.vtag_type >= NIX_VTAGTYPE_MAX ||
1169             req->vtag_size > VTAGSIZE_T8)
1170                 return -EINVAL;
1171
1172         regval = rvu_read64(rvu, blkaddr,
1173                             NIX_AF_LFX_RX_VTAG_TYPEX(nixlf, req->rx.vtag_type));
1174
1175         if (req->rx.strip_vtag && req->rx.capture_vtag)
1176                 regval |= BIT_ULL(4) | BIT_ULL(5);
1177         else if (req->rx.strip_vtag)
1178                 regval |= BIT_ULL(4);
1179         else
1180                 regval &= ~(BIT_ULL(4) | BIT_ULL(5));
1181
1182         regval &= ~NIX_VTAGSIZE_MASK;
1183         regval |= req->vtag_size & NIX_VTAGSIZE_MASK;
1184
1185         rvu_write64(rvu, blkaddr,
1186                     NIX_AF_LFX_RX_VTAG_TYPEX(nixlf, req->rx.vtag_type), regval);
1187         return 0;
1188 }
1189
1190 int rvu_mbox_handler_NIX_VTAG_CFG(struct rvu *rvu,
1191                                   struct nix_vtag_config *req,
1192                                   struct msg_rsp *rsp)
1193 {
1194         struct rvu_hwinfo *hw = rvu->hw;
1195         u16 pcifunc = req->hdr.pcifunc;
1196         int blkaddr, nixlf, err;
1197
1198         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
1199         if (blkaddr < 0)
1200                 return NIX_AF_ERR_AF_LF_INVALID;
1201
1202         nixlf = rvu_get_lf(rvu, &hw->block[blkaddr], pcifunc, 0);
1203         if (nixlf < 0)
1204                 return NIX_AF_ERR_AF_LF_INVALID;
1205
1206         if (req->cfg_type) {
1207                 err = nix_rx_vtag_cfg(rvu, nixlf, blkaddr, req);
1208                 if (err)
1209                         return NIX_AF_ERR_PARAM;
1210         } else {
1211                 /* TODO: handle tx vtag configuration */
1212                 return 0;
1213         }
1214
1215         return 0;
1216 }
1217
1218 static int nix_setup_mce(struct rvu *rvu, int mce, u8 op,
1219                          u16 pcifunc, int next, bool eol)
1220 {
1221         struct nix_aq_enq_req aq_req;
1222         int err;
1223
1224         aq_req.hdr.pcifunc = pcifunc;
1225         aq_req.ctype = NIX_AQ_CTYPE_MCE;
1226         aq_req.op = op;
1227         aq_req.qidx = mce;
1228
1229         /* Forward bcast pkts to RQ0, RSS not needed */
1230         aq_req.mce.op = 0;
1231         aq_req.mce.index = 0;
1232         aq_req.mce.eol = eol;
1233         aq_req.mce.pf_func = pcifunc;
1234         aq_req.mce.next = next;
1235
1236         /* All fields valid */
1237         *(u64 *)(&aq_req.mce_mask) = ~0ULL;
1238
1239         err = rvu_nix_aq_enq_inst(rvu, &aq_req, NULL);
1240         if (err) {
1241                 dev_err(rvu->dev, "Failed to setup Bcast MCE for PF%d:VF%d\n",
1242                         rvu_get_pf(pcifunc), pcifunc & RVU_PFVF_FUNC_MASK);
1243                 return err;
1244         }
1245         return 0;
1246 }
1247
1248 static int nix_update_mce_list(struct nix_mce_list *mce_list,
1249                                u16 pcifunc, int idx, bool add)
1250 {
1251         struct mce *mce, *tail = NULL;
1252         bool delete = false;
1253
1254         /* Scan through the current list */
1255         hlist_for_each_entry(mce, &mce_list->head, node) {
1256                 /* If already exists, then delete */
1257                 if (mce->pcifunc == pcifunc && !add) {
1258                         delete = true;
1259                         break;
1260                 }
1261                 tail = mce;
1262         }
1263
1264         if (delete) {
1265                 hlist_del(&mce->node);
1266                 kfree(mce);
1267                 mce_list->count--;
1268                 return 0;
1269         }
1270
1271         if (!add)
1272                 return 0;
1273
1274         /* Add a new one to the list, at the tail */
1275         mce = kzalloc(sizeof(*mce), GFP_KERNEL);
1276         if (!mce)
1277                 return -ENOMEM;
1278         mce->idx = idx;
1279         mce->pcifunc = pcifunc;
1280         if (!tail)
1281                 hlist_add_head(&mce->node, &mce_list->head);
1282         else
1283                 hlist_add_behind(&mce->node, &tail->node);
1284         mce_list->count++;
1285         return 0;
1286 }
1287
1288 static int nix_update_bcast_mce_list(struct rvu *rvu, u16 pcifunc, bool add)
1289 {
1290         int err = 0, idx, next_idx, count;
1291         struct nix_mce_list *mce_list;
1292         struct mce *mce, *next_mce;
1293         struct nix_mcast *mcast;
1294         struct nix_hw *nix_hw;
1295         struct rvu_pfvf *pfvf;
1296         int blkaddr;
1297
1298         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
1299         if (blkaddr < 0)
1300                 return 0;
1301
1302         nix_hw = get_nix_hw(rvu->hw, blkaddr);
1303         if (!nix_hw)
1304                 return 0;
1305
1306         mcast = &nix_hw->mcast;
1307
1308         /* Get this PF/VF func's MCE index */
1309         pfvf = rvu_get_pfvf(rvu, pcifunc & ~RVU_PFVF_FUNC_MASK);
1310         idx = pfvf->bcast_mce_idx + (pcifunc & RVU_PFVF_FUNC_MASK);
1311
1312         mce_list = &pfvf->bcast_mce_list;
1313         if (idx > (pfvf->bcast_mce_idx + mce_list->max)) {
1314                 dev_err(rvu->dev,
1315                         "%s: Idx %d > max MCE idx %d, for PF%d bcast list\n",
1316                         __func__, idx, mce_list->max,
1317                         pcifunc >> RVU_PFVF_PF_SHIFT);
1318                 return -EINVAL;
1319         }
1320
1321         spin_lock(&mcast->mce_lock);
1322
1323         err = nix_update_mce_list(mce_list, pcifunc, idx, add);
1324         if (err)
1325                 goto end;
1326
1327         /* Disable MCAM entry in NPC */
1328
1329         if (!mce_list->count)
1330                 goto end;
1331         count = mce_list->count;
1332
1333         /* Dump the updated list to HW */
1334         hlist_for_each_entry(mce, &mce_list->head, node) {
1335                 next_idx = 0;
1336                 count--;
1337                 if (count) {
1338                         next_mce = hlist_entry(mce->node.next,
1339                                                struct mce, node);
1340                         next_idx = next_mce->idx;
1341                 }
1342                 /* EOL should be set in last MCE */
1343                 err = nix_setup_mce(rvu, mce->idx,
1344                                     NIX_AQ_INSTOP_WRITE, mce->pcifunc,
1345                                     next_idx, count ? false : true);
1346                 if (err)
1347                         goto end;
1348         }
1349
1350 end:
1351         spin_unlock(&mcast->mce_lock);
1352         return err;
1353 }
1354
1355 static int nix_setup_bcast_tables(struct rvu *rvu, struct nix_hw *nix_hw)
1356 {
1357         struct nix_mcast *mcast = &nix_hw->mcast;
1358         int err, pf, numvfs, idx;
1359         struct rvu_pfvf *pfvf;
1360         u16 pcifunc;
1361         u64 cfg;
1362
1363         /* Skip PF0 (i.e AF) */
1364         for (pf = 1; pf < (rvu->cgx_mapped_pfs + 1); pf++) {
1365                 cfg = rvu_read64(rvu, BLKADDR_RVUM, RVU_PRIV_PFX_CFG(pf));
1366                 /* If PF is not enabled, nothing to do */
1367                 if (!((cfg >> 20) & 0x01))
1368                         continue;
1369                 /* Get numVFs attached to this PF */
1370                 numvfs = (cfg >> 12) & 0xFF;
1371
1372                 pfvf = &rvu->pf[pf];
1373                 /* Save the start MCE */
1374                 pfvf->bcast_mce_idx = nix_alloc_mce_list(mcast, numvfs + 1);
1375
1376                 nix_mce_list_init(&pfvf->bcast_mce_list, numvfs + 1);
1377
1378                 for (idx = 0; idx < (numvfs + 1); idx++) {
1379                         /* idx-0 is for PF, followed by VFs */
1380                         pcifunc = (pf << RVU_PFVF_PF_SHIFT);
1381                         pcifunc |= idx;
1382                         /* Add dummy entries now, so that we don't have to check
1383                          * for whether AQ_OP should be INIT/WRITE later on.
1384                          * Will be updated when a NIXLF is attached/detached to
1385                          * these PF/VFs.
1386                          */
1387                         err = nix_setup_mce(rvu, pfvf->bcast_mce_idx + idx,
1388                                             NIX_AQ_INSTOP_INIT,
1389                                             pcifunc, 0, true);
1390                         if (err)
1391                                 return err;
1392                 }
1393         }
1394         return 0;
1395 }
1396
1397 static int nix_setup_mcast(struct rvu *rvu, struct nix_hw *nix_hw, int blkaddr)
1398 {
1399         struct nix_mcast *mcast = &nix_hw->mcast;
1400         struct rvu_hwinfo *hw = rvu->hw;
1401         int err, size;
1402
1403         size = (rvu_read64(rvu, blkaddr, NIX_AF_CONST3) >> 16) & 0x0F;
1404         size = (1ULL << size);
1405
1406         /* Alloc memory for multicast/mirror replication entries */
1407         err = qmem_alloc(rvu->dev, &mcast->mce_ctx,
1408                          (256UL << MC_TBL_SIZE), size);
1409         if (err)
1410                 return -ENOMEM;
1411
1412         rvu_write64(rvu, blkaddr, NIX_AF_RX_MCAST_BASE,
1413                     (u64)mcast->mce_ctx->iova);
1414
1415         /* Set max list length equal to max no of VFs per PF  + PF itself */
1416         rvu_write64(rvu, blkaddr, NIX_AF_RX_MCAST_CFG,
1417                     BIT_ULL(36) | (hw->max_vfs_per_pf << 4) | MC_TBL_SIZE);
1418
1419         /* Alloc memory for multicast replication buffers */
1420         size = rvu_read64(rvu, blkaddr, NIX_AF_MC_MIRROR_CONST) & 0xFFFF;
1421         err = qmem_alloc(rvu->dev, &mcast->mcast_buf,
1422                          (8UL << MC_BUF_CNT), size);
1423         if (err)
1424                 return -ENOMEM;
1425
1426         rvu_write64(rvu, blkaddr, NIX_AF_RX_MCAST_BUF_BASE,
1427                     (u64)mcast->mcast_buf->iova);
1428
1429         /* Alloc pkind for NIX internal RX multicast/mirror replay */
1430         mcast->replay_pkind = rvu_alloc_rsrc(&hw->pkind.rsrc);
1431
1432         rvu_write64(rvu, blkaddr, NIX_AF_RX_MCAST_BUF_CFG,
1433                     BIT_ULL(63) | (mcast->replay_pkind << 24) |
1434                     BIT_ULL(20) | MC_BUF_CNT);
1435
1436         spin_lock_init(&mcast->mce_lock);
1437
1438         return nix_setup_bcast_tables(rvu, nix_hw);
1439 }
1440
1441 static int nix_setup_txschq(struct rvu *rvu, struct nix_hw *nix_hw, int blkaddr)
1442 {
1443         struct nix_txsch *txsch;
1444         u64 cfg, reg;
1445         int err, lvl;
1446
1447         /* Get scheduler queue count of each type and alloc
1448          * bitmap for each for alloc/free/attach operations.
1449          */
1450         for (lvl = 0; lvl < NIX_TXSCH_LVL_CNT; lvl++) {
1451                 txsch = &nix_hw->txsch[lvl];
1452                 txsch->lvl = lvl;
1453                 switch (lvl) {
1454                 case NIX_TXSCH_LVL_SMQ:
1455                         reg = NIX_AF_MDQ_CONST;
1456                         break;
1457                 case NIX_TXSCH_LVL_TL4:
1458                         reg = NIX_AF_TL4_CONST;
1459                         break;
1460                 case NIX_TXSCH_LVL_TL3:
1461                         reg = NIX_AF_TL3_CONST;
1462                         break;
1463                 case NIX_TXSCH_LVL_TL2:
1464                         reg = NIX_AF_TL2_CONST;
1465                         break;
1466                 case NIX_TXSCH_LVL_TL1:
1467                         reg = NIX_AF_TL1_CONST;
1468                         break;
1469                 }
1470                 cfg = rvu_read64(rvu, blkaddr, reg);
1471                 txsch->schq.max = cfg & 0xFFFF;
1472                 err = rvu_alloc_bitmap(&txsch->schq);
1473                 if (err)
1474                         return err;
1475
1476                 /* Allocate memory for scheduler queues to
1477                  * PF/VF pcifunc mapping info.
1478                  */
1479                 txsch->pfvf_map = devm_kcalloc(rvu->dev, txsch->schq.max,
1480                                                sizeof(u16), GFP_KERNEL);
1481                 if (!txsch->pfvf_map)
1482                         return -ENOMEM;
1483         }
1484         return 0;
1485 }
1486
1487 int rvu_mbox_handler_NIX_STATS_RST(struct rvu *rvu, struct msg_req *req,
1488                                    struct msg_rsp *rsp)
1489 {
1490         struct rvu_hwinfo *hw = rvu->hw;
1491         u16 pcifunc = req->hdr.pcifunc;
1492         int i, nixlf, blkaddr;
1493         u64 stats;
1494
1495         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
1496         if (blkaddr < 0)
1497                 return NIX_AF_ERR_AF_LF_INVALID;
1498
1499         nixlf = rvu_get_lf(rvu, &hw->block[blkaddr], pcifunc, 0);
1500         if (nixlf < 0)
1501                 return NIX_AF_ERR_AF_LF_INVALID;
1502
1503         /* Get stats count supported by HW */
1504         stats = rvu_read64(rvu, blkaddr, NIX_AF_CONST1);
1505
1506         /* Reset tx stats */
1507         for (i = 0; i < ((stats >> 24) & 0xFF); i++)
1508                 rvu_write64(rvu, blkaddr, NIX_AF_LFX_TX_STATX(nixlf, i), 0);
1509
1510         /* Reset rx stats */
1511         for (i = 0; i < ((stats >> 32) & 0xFF); i++)
1512                 rvu_write64(rvu, blkaddr, NIX_AF_LFX_RX_STATX(nixlf, i), 0);
1513
1514         return 0;
1515 }
1516
1517 static int nix_calibrate_x2p(struct rvu *rvu, int blkaddr)
1518 {
1519         int idx, err;
1520         u64 status;
1521
1522         /* Start X2P bus calibration */
1523         rvu_write64(rvu, blkaddr, NIX_AF_CFG,
1524                     rvu_read64(rvu, blkaddr, NIX_AF_CFG) | BIT_ULL(9));
1525         /* Wait for calibration to complete */
1526         err = rvu_poll_reg(rvu, blkaddr,
1527                            NIX_AF_STATUS, BIT_ULL(10), false);
1528         if (err) {
1529                 dev_err(rvu->dev, "NIX X2P bus calibration failed\n");
1530                 return err;
1531         }
1532
1533         status = rvu_read64(rvu, blkaddr, NIX_AF_STATUS);
1534         /* Check if CGX devices are ready */
1535         for (idx = 0; idx < cgx_get_cgx_cnt(); idx++) {
1536                 if (status & (BIT_ULL(16 + idx)))
1537                         continue;
1538                 dev_err(rvu->dev,
1539                         "CGX%d didn't respond to NIX X2P calibration\n", idx);
1540                 err = -EBUSY;
1541         }
1542
1543         /* Check if LBK is ready */
1544         if (!(status & BIT_ULL(19))) {
1545                 dev_err(rvu->dev,
1546                         "LBK didn't respond to NIX X2P calibration\n");
1547                 err = -EBUSY;
1548         }
1549
1550         /* Clear 'calibrate_x2p' bit */
1551         rvu_write64(rvu, blkaddr, NIX_AF_CFG,
1552                     rvu_read64(rvu, blkaddr, NIX_AF_CFG) & ~BIT_ULL(9));
1553         if (err || (status & 0x3FFULL))
1554                 dev_err(rvu->dev,
1555                         "NIX X2P calibration failed, status 0x%llx\n", status);
1556         if (err)
1557                 return err;
1558         return 0;
1559 }
1560
1561 static int nix_aq_init(struct rvu *rvu, struct rvu_block *block)
1562 {
1563         u64 cfg;
1564         int err;
1565
1566         /* Set admin queue endianness */
1567         cfg = rvu_read64(rvu, block->addr, NIX_AF_CFG);
1568 #ifdef __BIG_ENDIAN
1569         cfg |= BIT_ULL(1);
1570         rvu_write64(rvu, block->addr, NIX_AF_CFG, cfg);
1571 #else
1572         cfg &= ~BIT_ULL(1);
1573         rvu_write64(rvu, block->addr, NIX_AF_CFG, cfg);
1574 #endif
1575
1576         /* Do not bypass NDC cache */
1577         cfg = rvu_read64(rvu, block->addr, NIX_AF_NDC_CFG);
1578         cfg &= ~0x3FFEULL;
1579         rvu_write64(rvu, block->addr, NIX_AF_NDC_CFG, cfg);
1580
1581         /* Result structure can be followed by RQ/SQ/CQ context at
1582          * RES + 128bytes and a write mask at RES + 256 bytes, depending on
1583          * operation type. Alloc sufficient result memory for all operations.
1584          */
1585         err = rvu_aq_alloc(rvu, &block->aq,
1586                            Q_COUNT(AQ_SIZE), sizeof(struct nix_aq_inst_s),
1587                            ALIGN(sizeof(struct nix_aq_res_s), 128) + 256);
1588         if (err)
1589                 return err;
1590
1591         rvu_write64(rvu, block->addr, NIX_AF_AQ_CFG, AQ_SIZE);
1592         rvu_write64(rvu, block->addr,
1593                     NIX_AF_AQ_BASE, (u64)block->aq->inst->iova);
1594         return 0;
1595 }
1596
1597 int rvu_nix_init(struct rvu *rvu)
1598 {
1599         struct rvu_hwinfo *hw = rvu->hw;
1600         struct rvu_block *block;
1601         int blkaddr, err;
1602         u64 cfg;
1603
1604         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
1605         if (blkaddr < 0)
1606                 return 0;
1607         block = &hw->block[blkaddr];
1608
1609         /* Calibrate X2P bus to check if CGX/LBK links are fine */
1610         err = nix_calibrate_x2p(rvu, blkaddr);
1611         if (err)
1612                 return err;
1613
1614         /* Set num of links of each type */
1615         cfg = rvu_read64(rvu, blkaddr, NIX_AF_CONST);
1616         hw->cgx = (cfg >> 12) & 0xF;
1617         hw->lmac_per_cgx = (cfg >> 8) & 0xF;
1618         hw->cgx_links = hw->cgx * hw->lmac_per_cgx;
1619         hw->lbk_links = 1;
1620         hw->sdp_links = 1;
1621
1622         /* Initialize admin queue */
1623         err = nix_aq_init(rvu, block);
1624         if (err)
1625                 return err;
1626
1627         /* Restore CINT timer delay to HW reset values */
1628         rvu_write64(rvu, blkaddr, NIX_AF_CINT_DELAY, 0x0ULL);
1629
1630         /* Configure segmentation offload formats */
1631         nix_setup_lso(rvu, blkaddr);
1632
1633         if (blkaddr == BLKADDR_NIX0) {
1634                 hw->nix0 = devm_kzalloc(rvu->dev,
1635                                         sizeof(struct nix_hw), GFP_KERNEL);
1636                 if (!hw->nix0)
1637                         return -ENOMEM;
1638
1639                 err = nix_setup_txschq(rvu, hw->nix0, blkaddr);
1640                 if (err)
1641                         return err;
1642
1643                 err = nix_setup_mcast(rvu, hw->nix0, blkaddr);
1644                 if (err)
1645                         return err;
1646
1647                 /* Config Outer L2, IP, TCP and UDP's NPC layer info.
1648                  * This helps HW protocol checker to identify headers
1649                  * and validate length and checksums.
1650                  */
1651                 rvu_write64(rvu, blkaddr, NIX_AF_RX_DEF_OL2,
1652                             (NPC_LID_LA << 8) | (NPC_LT_LA_ETHER << 4) | 0x0F);
1653                 rvu_write64(rvu, blkaddr, NIX_AF_RX_DEF_OUDP,
1654                             (NPC_LID_LD << 8) | (NPC_LT_LD_UDP << 4) | 0x0F);
1655                 rvu_write64(rvu, blkaddr, NIX_AF_RX_DEF_OTCP,
1656                             (NPC_LID_LD << 8) | (NPC_LT_LD_TCP << 4) | 0x0F);
1657                 rvu_write64(rvu, blkaddr, NIX_AF_RX_DEF_OIP4,
1658                             (NPC_LID_LC << 8) | (NPC_LT_LC_IP << 4) | 0x0F);
1659         }
1660         return 0;
1661 }
1662
1663 void rvu_nix_freemem(struct rvu *rvu)
1664 {
1665         struct rvu_hwinfo *hw = rvu->hw;
1666         struct rvu_block *block;
1667         struct nix_txsch *txsch;
1668         struct nix_mcast *mcast;
1669         struct nix_hw *nix_hw;
1670         int blkaddr, lvl;
1671
1672         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, 0);
1673         if (blkaddr < 0)
1674                 return;
1675
1676         block = &hw->block[blkaddr];
1677         rvu_aq_free(rvu, block->aq);
1678
1679         if (blkaddr == BLKADDR_NIX0) {
1680                 nix_hw = get_nix_hw(rvu->hw, blkaddr);
1681                 if (!nix_hw)
1682                         return;
1683
1684                 for (lvl = 0; lvl < NIX_TXSCH_LVL_CNT; lvl++) {
1685                         txsch = &nix_hw->txsch[lvl];
1686                         kfree(txsch->schq.bmap);
1687                 }
1688
1689                 mcast = &nix_hw->mcast;
1690                 qmem_free(rvu->dev, mcast->mce_ctx);
1691                 qmem_free(rvu->dev, mcast->mcast_buf);
1692         }
1693 }