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