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