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