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