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 rvu_nix_get_bpid(struct rvu *rvu, struct nix_bp_cfg_req *req,
  21                             int type, int chan_id);
  22
  23 enum mc_tbl_sz {
  24         MC_TBL_SZ_256,
  25         MC_TBL_SZ_512,
  26         MC_TBL_SZ_1K,
  27         MC_TBL_SZ_2K,
  28         MC_TBL_SZ_4K,
  29         MC_TBL_SZ_8K,
  30         MC_TBL_SZ_16K,
  31         MC_TBL_SZ_32K,
  32         MC_TBL_SZ_64K,
  33 };
  34
  35 enum mc_buf_cnt {
  36         MC_BUF_CNT_8,
  37         MC_BUF_CNT_16,
  38         MC_BUF_CNT_32,
  39         MC_BUF_CNT_64,
  40         MC_BUF_CNT_128,
  41         MC_BUF_CNT_256,
  42         MC_BUF_CNT_512,
  43         MC_BUF_CNT_1024,
  44         MC_BUF_CNT_2048,
  45 };
  46
  47 enum nix_makr_fmt_indexes {
  48         NIX_MARK_CFG_IP_DSCP_RED,
  49         NIX_MARK_CFG_IP_DSCP_YELLOW,
  50         NIX_MARK_CFG_IP_DSCP_YELLOW_RED,
  51         NIX_MARK_CFG_IP_ECN_RED,
  52         NIX_MARK_CFG_IP_ECN_YELLOW,
  53         NIX_MARK_CFG_IP_ECN_YELLOW_RED,
  54         NIX_MARK_CFG_VLAN_DEI_RED,
  55         NIX_MARK_CFG_VLAN_DEI_YELLOW,
  56         NIX_MARK_CFG_VLAN_DEI_YELLOW_RED,
  57         NIX_MARK_CFG_MAX,
  58 };
  59
  60 /* For now considering MC resources needed for broadcast
  61  * pkt replication only. i.e 256 HWVFs + 12 PFs.
  62  */
  63 #define MC_TBL_SIZE     MC_TBL_SZ_512
  64 #define MC_BUF_CNT      MC_BUF_CNT_128
  65
  66 struct mce {
  67         struct hlist_node       node;
  68         u16                     pcifunc;
  69 };
  70
  71 int rvu_get_next_nix_blkaddr(struct rvu *rvu, int blkaddr)
  72 {
  73         int i = 0;
  74
  75         /*If blkaddr is 0, return the first nix block address*/
  76         if (blkaddr == 0)
  77                 return rvu->nix_blkaddr[blkaddr];
  78
  79         while (i + 1 < MAX_NIX_BLKS) {
  80                 if (rvu->nix_blkaddr[i] == blkaddr)
  81                         return rvu->nix_blkaddr[i + 1];
  82                 i++;
  83         }
  84
  85         return 0;
  86 }
  87
  88 bool is_nixlf_attached(struct rvu *rvu, u16 pcifunc)
  89 {
  90         struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, pcifunc);
  91         int blkaddr;
  92
  93         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
  94         if (!pfvf->nixlf || blkaddr < 0)
  95                 return false;
  96         return true;
  97 }
  98
  99 int rvu_get_nixlf_count(struct rvu *rvu)
 100 {
 101         int blkaddr = 0, max = 0;
 102         struct rvu_block *block;
 103
 104         blkaddr = rvu_get_next_nix_blkaddr(rvu, blkaddr);
 105         while (blkaddr) {
 106                 block = &rvu->hw->block[blkaddr];
 107                 max += block->lf.max;
 108                 blkaddr = rvu_get_next_nix_blkaddr(rvu, blkaddr);
 109         }
 110         return max;
 111 }
 112
 113 int nix_get_nixlf(struct rvu *rvu, u16 pcifunc, int *nixlf, int *nix_blkaddr)
 114 {
 115         struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, pcifunc);
 116         struct rvu_hwinfo *hw = rvu->hw;
 117         int blkaddr;
 118
 119         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
 120         if (!pfvf->nixlf || blkaddr < 0)
 121                 return NIX_AF_ERR_AF_LF_INVALID;
 122
 123         *nixlf = rvu_get_lf(rvu, &hw->block[blkaddr], pcifunc, 0);
 124         if (*nixlf < 0)
 125                 return NIX_AF_ERR_AF_LF_INVALID;
 126
 127         if (nix_blkaddr)
 128                 *nix_blkaddr = blkaddr;
 129
 130         return 0;
 131 }
 132
 133 static void nix_mce_list_init(struct nix_mce_list *list, int max)
 134 {
 135         INIT_HLIST_HEAD(&list->head);
 136         list->count = 0;
 137         list->max = max;
 138 }
 139
 140 static u16 nix_alloc_mce_list(struct nix_mcast *mcast, int count)
 141 {
 142         int idx;
 143
 144         if (!mcast)
 145                 return 0;
 146
 147         idx = mcast->next_free_mce;
 148         mcast->next_free_mce += count;
 149         return idx;
 150 }
 151
 152 struct nix_hw *get_nix_hw(struct rvu_hwinfo *hw, int blkaddr)
 153 {
 154         int nix_blkaddr = 0, i = 0;
 155         struct rvu *rvu = hw->rvu;
 156
 157         nix_blkaddr = rvu_get_next_nix_blkaddr(rvu, nix_blkaddr);
 158         while (nix_blkaddr) {
 159                 if (blkaddr == nix_blkaddr && hw->nix)
 160                         return &hw->nix[i];
 161                 nix_blkaddr = rvu_get_next_nix_blkaddr(rvu, nix_blkaddr);
 162                 i++;
 163         }
 164         return NULL;
 165 }
 166
 167 static void nix_rx_sync(struct rvu *rvu, int blkaddr)
 168 {
 169         int err;
 170
 171         /*Sync all in flight RX packets to LLC/DRAM */
 172         rvu_write64(rvu, blkaddr, NIX_AF_RX_SW_SYNC, BIT_ULL(0));
 173         err = rvu_poll_reg(rvu, blkaddr, NIX_AF_RX_SW_SYNC, BIT_ULL(0), true);
 174         if (err)
 175                 dev_err(rvu->dev, "NIX RX software sync failed\n");
 176 }
 177
 178 static bool is_valid_txschq(struct rvu *rvu, int blkaddr,
 179                             int lvl, u16 pcifunc, u16 schq)
 180 {
 181         struct rvu_hwinfo *hw = rvu->hw;
 182         struct nix_txsch *txsch;
 183         struct nix_hw *nix_hw;
 184         u16 map_func;
 185
 186         nix_hw = get_nix_hw(rvu->hw, blkaddr);
 187         if (!nix_hw)
 188                 return false;
 189
 190         txsch = &nix_hw->txsch[lvl];
 191         /* Check out of bounds */
 192         if (schq >= txsch->schq.max)
 193                 return false;
 194
 195         mutex_lock(&rvu->rsrc_lock);
 196         map_func = TXSCH_MAP_FUNC(txsch->pfvf_map[schq]);
 197         mutex_unlock(&rvu->rsrc_lock);
 198
 199         /* TLs aggegating traffic are shared across PF and VFs */
 200         if (lvl >= hw->cap.nix_tx_aggr_lvl) {
 201                 if (rvu_get_pf(map_func) != rvu_get_pf(pcifunc))
 202                         return false;
 203                 else
 204                         return true;
 205         }
 206
 207         if (map_func != pcifunc)
 208                 return false;
 209
 210         return true;
 211 }
 212
 213 static int nix_interface_init(struct rvu *rvu, u16 pcifunc, int type, int nixlf)
 214 {
 215         struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, pcifunc);
 216         int pkind, pf, vf, lbkid;
 217         u8 cgx_id, lmac_id;
 218         int err;
 219
 220         pf = rvu_get_pf(pcifunc);
 221         if (!is_pf_cgxmapped(rvu, pf) && type != NIX_INTF_TYPE_LBK)
 222                 return 0;
 223
 224         switch (type) {
 225         case NIX_INTF_TYPE_CGX:
 226                 pfvf->cgx_lmac = rvu->pf2cgxlmac_map[pf];
 227                 rvu_get_cgx_lmac_id(pfvf->cgx_lmac, &cgx_id, &lmac_id);
 228
 229                 pkind = rvu_npc_get_pkind(rvu, pf);
 230                 if (pkind < 0) {
 231                         dev_err(rvu->dev,
 232                                 "PF_Func 0x%x: Invalid pkind\n", pcifunc);
 233                         return -EINVAL;
 234                 }
 235                 pfvf->rx_chan_base = NIX_CHAN_CGX_LMAC_CHX(cgx_id, lmac_id, 0);
 236                 pfvf->tx_chan_base = pfvf->rx_chan_base;
 237                 pfvf->rx_chan_cnt = 1;
 238                 pfvf->tx_chan_cnt = 1;
 239                 cgx_set_pkind(rvu_cgx_pdata(cgx_id, rvu), lmac_id, pkind);
 240                 rvu_npc_set_pkind(rvu, pkind, pfvf);
 241
 242                 /* By default we enable pause frames */
 243                 if ((pcifunc & RVU_PFVF_FUNC_MASK) == 0)
 244                         cgx_lmac_set_pause_frm(rvu_cgx_pdata(cgx_id, rvu),
 245                                                lmac_id, true, true);
 246                 break;
 247         case NIX_INTF_TYPE_LBK:
 248                 vf = (pcifunc & RVU_PFVF_FUNC_MASK) - 1;
 249
 250                 /* If NIX1 block is present on the silicon then NIXes are
 251                  * assigned alternatively for lbk interfaces. NIX0 should
 252                  * send packets on lbk link 1 channels and NIX1 should send
 253                  * on lbk link 0 channels for the communication between
 254                  * NIX0 and NIX1.
 255                  */
 256                 lbkid = 0;
 257                 if (rvu->hw->lbk_links > 1)
 258                         lbkid = vf & 0x1 ? 0 : 1;
 259
 260                 /* Note that AF's VFs work in pairs and talk over consecutive
 261                  * loopback channels.Therefore if odd number of AF VFs are
 262                  * enabled then the last VF remains with no pair.
 263                  */
 264                 pfvf->rx_chan_base = NIX_CHAN_LBK_CHX(lbkid, vf);
 265                 pfvf->tx_chan_base = vf & 0x1 ?
 266                                         NIX_CHAN_LBK_CHX(lbkid, vf - 1) :
 267                                         NIX_CHAN_LBK_CHX(lbkid, vf + 1);
 268                 pfvf->rx_chan_cnt = 1;
 269                 pfvf->tx_chan_cnt = 1;
 270                 rvu_npc_install_promisc_entry(rvu, pcifunc, nixlf,
 271                                               pfvf->rx_chan_base, false);
 272                 break;
 273         }
 274
 275         /* Add a UCAST forwarding rule in MCAM with this NIXLF attached
 276          * RVU PF/VF's MAC address.
 277          */
 278         rvu_npc_install_ucast_entry(rvu, pcifunc, nixlf,
 279                                     pfvf->rx_chan_base, pfvf->mac_addr);
 280
 281         /* Add this PF_FUNC to bcast pkt replication list */
 282         err = nix_update_bcast_mce_list(rvu, pcifunc, true);
 283         if (err) {
 284                 dev_err(rvu->dev,
 285                         "Bcast list, failed to enable PF_FUNC 0x%x\n",
 286                         pcifunc);
 287                 return err;
 288         }
 289
 290         rvu_npc_install_bcast_match_entry(rvu, pcifunc,
 291                                           nixlf, pfvf->rx_chan_base);
 292         pfvf->maxlen = NIC_HW_MIN_FRS;
 293         pfvf->minlen = NIC_HW_MIN_FRS;
 294
 295         return 0;
 296 }
 297
 298 static void nix_interface_deinit(struct rvu *rvu, u16 pcifunc, u8 nixlf)
 299 {
 300         struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, pcifunc);
 301         int err;
 302
 303         pfvf->maxlen = 0;
 304         pfvf->minlen = 0;
 305         pfvf->rxvlan = false;
 306
 307         /* Remove this PF_FUNC from bcast pkt replication list */
 308         err = nix_update_bcast_mce_list(rvu, pcifunc, false);
 309         if (err) {
 310                 dev_err(rvu->dev,
 311                         "Bcast list, failed to disable PF_FUNC 0x%x\n",
 312                         pcifunc);
 313         }
 314
 315         /* Free and disable any MCAM entries used by this NIX LF */
 316         rvu_npc_disable_mcam_entries(rvu, pcifunc, nixlf);
 317 }
 318
 319 int rvu_mbox_handler_nix_bp_disable(struct rvu *rvu,
 320                                     struct nix_bp_cfg_req *req,
 321                                     struct msg_rsp *rsp)
 322 {
 323         u16 pcifunc = req->hdr.pcifunc;
 324         struct rvu_pfvf *pfvf;
 325         int blkaddr, pf, type;
 326         u16 chan_base, chan;
 327         u64 cfg;
 328
 329         pf = rvu_get_pf(pcifunc);
 330         type = is_afvf(pcifunc) ? NIX_INTF_TYPE_LBK : NIX_INTF_TYPE_CGX;
 331         if (!is_pf_cgxmapped(rvu, pf) && type != NIX_INTF_TYPE_LBK)
 332                 return 0;
 333
 334         pfvf = rvu_get_pfvf(rvu, pcifunc);
 335         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
 336
 337         chan_base = pfvf->rx_chan_base + req->chan_base;
 338         for (chan = chan_base; chan < (chan_base + req->chan_cnt); chan++) {
 339                 cfg = rvu_read64(rvu, blkaddr, NIX_AF_RX_CHANX_CFG(chan));
 340                 rvu_write64(rvu, blkaddr, NIX_AF_RX_CHANX_CFG(chan),
 341                             cfg & ~BIT_ULL(16));
 342         }
 343         return 0;
 344 }
 345
 346 static int rvu_nix_get_bpid(struct rvu *rvu, struct nix_bp_cfg_req *req,
 347                             int type, int chan_id)
 348 {
 349         int bpid, blkaddr, lmac_chan_cnt;
 350         struct rvu_hwinfo *hw = rvu->hw;
 351         u16 cgx_bpid_cnt, lbk_bpid_cnt;
 352         struct rvu_pfvf *pfvf;
 353         u8 cgx_id, lmac_id;
 354         u64 cfg;
 355
 356         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, req->hdr.pcifunc);
 357         cfg = rvu_read64(rvu, blkaddr, NIX_AF_CONST);
 358         lmac_chan_cnt = cfg & 0xFF;
 359
 360         cgx_bpid_cnt = hw->cgx_links * lmac_chan_cnt;
 361         lbk_bpid_cnt = hw->lbk_links * ((cfg >> 16) & 0xFF);
 362
 363         pfvf = rvu_get_pfvf(rvu, req->hdr.pcifunc);
 364
 365         /* Backpressure IDs range division
 366          * CGX channles are mapped to (0 - 191) BPIDs
 367          * LBK channles are mapped to (192 - 255) BPIDs
 368          * SDP channles are mapped to (256 - 511) BPIDs
 369          *
 370          * Lmac channles and bpids mapped as follows
 371          * cgx(0)_lmac(0)_chan(0 - 15) = bpid(0 - 15)
 372          * cgx(0)_lmac(1)_chan(0 - 15) = bpid(16 - 31) ....
 373          * cgx(1)_lmac(0)_chan(0 - 15) = bpid(64 - 79) ....
 374          */
 375         switch (type) {
 376         case NIX_INTF_TYPE_CGX:
 377                 if ((req->chan_base + req->chan_cnt) > 15)
 378                         return -EINVAL;
 379                 rvu_get_cgx_lmac_id(pfvf->cgx_lmac, &cgx_id, &lmac_id);
 380                 /* Assign bpid based on cgx, lmac and chan id */
 381                 bpid = (cgx_id * hw->lmac_per_cgx * lmac_chan_cnt) +
 382                         (lmac_id * lmac_chan_cnt) + req->chan_base;
 383
 384                 if (req->bpid_per_chan)
 385                         bpid += chan_id;
 386                 if (bpid > cgx_bpid_cnt)
 387                         return -EINVAL;
 388                 break;
 389
 390         case NIX_INTF_TYPE_LBK:
 391                 if ((req->chan_base + req->chan_cnt) > 63)
 392                         return -EINVAL;
 393                 bpid = cgx_bpid_cnt + req->chan_base;
 394                 if (req->bpid_per_chan)
 395                         bpid += chan_id;
 396                 if (bpid > (cgx_bpid_cnt + lbk_bpid_cnt))
 397                         return -EINVAL;
 398                 break;
 399         default:
 400                 return -EINVAL;
 401         }
 402         return bpid;
 403 }
 404
 405 int rvu_mbox_handler_nix_bp_enable(struct rvu *rvu,
 406                                    struct nix_bp_cfg_req *req,
 407                                    struct nix_bp_cfg_rsp *rsp)
 408 {
 409         int blkaddr, pf, type, chan_id = 0;
 410         u16 pcifunc = req->hdr.pcifunc;
 411         struct rvu_pfvf *pfvf;
 412         u16 chan_base, chan;
 413         s16 bpid, bpid_base;
 414         u64 cfg;
 415
 416         pf = rvu_get_pf(pcifunc);
 417         type = is_afvf(pcifunc) ? NIX_INTF_TYPE_LBK : NIX_INTF_TYPE_CGX;
 418
 419         /* Enable backpressure only for CGX mapped PFs and LBK interface */
 420         if (!is_pf_cgxmapped(rvu, pf) && type != NIX_INTF_TYPE_LBK)
 421                 return 0;
 422
 423         pfvf = rvu_get_pfvf(rvu, pcifunc);
 424         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
 425
 426         bpid_base = rvu_nix_get_bpid(rvu, req, type, chan_id);
 427         chan_base = pfvf->rx_chan_base + req->chan_base;
 428         bpid = bpid_base;
 429
 430         for (chan = chan_base; chan < (chan_base + req->chan_cnt); chan++) {
 431                 if (bpid < 0) {
 432                         dev_warn(rvu->dev, "Fail to enable backpressure\n");
 433                         return -EINVAL;
 434                 }
 435
 436                 cfg = rvu_read64(rvu, blkaddr, NIX_AF_RX_CHANX_CFG(chan));
 437                 rvu_write64(rvu, blkaddr, NIX_AF_RX_CHANX_CFG(chan),
 438                             cfg | (bpid & 0xFF) | BIT_ULL(16));
 439                 chan_id++;
 440                 bpid = rvu_nix_get_bpid(rvu, req, type, chan_id);
 441         }
 442
 443         for (chan = 0; chan < req->chan_cnt; chan++) {
 444                 /* Map channel and bpid assign to it */
 445                 rsp->chan_bpid[chan] = ((req->chan_base + chan) & 0x7F) << 10 |
 446                                         (bpid_base & 0x3FF);
 447                 if (req->bpid_per_chan)
 448                         bpid_base++;
 449         }
 450         rsp->chan_cnt = req->chan_cnt;
 451
 452         return 0;
 453 }
 454
 455 static void nix_setup_lso_tso_l3(struct rvu *rvu, int blkaddr,
 456                                  u64 format, bool v4, u64 *fidx)
 457 {
 458         struct nix_lso_format field = {0};
 459
 460         /* IP's Length field */
 461         field.layer = NIX_TXLAYER_OL3;
 462         /* In ipv4, length field is at offset 2 bytes, for ipv6 it's 4 */
 463         field.offset = v4 ? 2 : 4;
 464         field.sizem1 = 1; /* i.e 2 bytes */
 465         field.alg = NIX_LSOALG_ADD_PAYLEN;
 466         rvu_write64(rvu, blkaddr,
 467                     NIX_AF_LSO_FORMATX_FIELDX(format, (*fidx)++),
 468                     *(u64 *)&field);
 469
 470         /* No ID field in IPv6 header */
 471         if (!v4)
 472                 return;
 473
 474         /* IP's ID field */
 475         field.layer = NIX_TXLAYER_OL3;
 476         field.offset = 4;
 477         field.sizem1 = 1; /* i.e 2 bytes */
 478         field.alg = NIX_LSOALG_ADD_SEGNUM;
 479         rvu_write64(rvu, blkaddr,
 480                     NIX_AF_LSO_FORMATX_FIELDX(format, (*fidx)++),
 481                     *(u64 *)&field);
 482 }
 483
 484 static void nix_setup_lso_tso_l4(struct rvu *rvu, int blkaddr,
 485                                  u64 format, u64 *fidx)
 486 {
 487         struct nix_lso_format field = {0};
 488
 489         /* TCP's sequence number field */
 490         field.layer = NIX_TXLAYER_OL4;
 491         field.offset = 4;
 492         field.sizem1 = 3; /* i.e 4 bytes */
 493         field.alg = NIX_LSOALG_ADD_OFFSET;
 494         rvu_write64(rvu, blkaddr,
 495                     NIX_AF_LSO_FORMATX_FIELDX(format, (*fidx)++),
 496                     *(u64 *)&field);
 497
 498         /* TCP's flags field */
 499         field.layer = NIX_TXLAYER_OL4;
 500         field.offset = 12;
 501         field.sizem1 = 1; /* 2 bytes */
 502         field.alg = NIX_LSOALG_TCP_FLAGS;
 503         rvu_write64(rvu, blkaddr,
 504                     NIX_AF_LSO_FORMATX_FIELDX(format, (*fidx)++),
 505                     *(u64 *)&field);
 506 }
 507
 508 static void nix_setup_lso(struct rvu *rvu, struct nix_hw *nix_hw, int blkaddr)
 509 {
 510         u64 cfg, idx, fidx = 0;
 511
 512         /* Get max HW supported format indices */
 513         cfg = (rvu_read64(rvu, blkaddr, NIX_AF_CONST1) >> 48) & 0xFF;
 514         nix_hw->lso.total = cfg;
 515
 516         /* Enable LSO */
 517         cfg = rvu_read64(rvu, blkaddr, NIX_AF_LSO_CFG);
 518         /* For TSO, set first and middle segment flags to
 519          * mask out PSH, RST & FIN flags in TCP packet
 520          */
 521         cfg &= ~((0xFFFFULL << 32) | (0xFFFFULL << 16));
 522         cfg |= (0xFFF2ULL << 32) | (0xFFF2ULL << 16);
 523         rvu_write64(rvu, blkaddr, NIX_AF_LSO_CFG, cfg | BIT_ULL(63));
 524
 525         /* Setup default static LSO formats
 526          *
 527          * Configure format fields for TCPv4 segmentation offload
 528          */
 529         idx = NIX_LSO_FORMAT_IDX_TSOV4;
 530         nix_setup_lso_tso_l3(rvu, blkaddr, idx, true, &fidx);
 531         nix_setup_lso_tso_l4(rvu, blkaddr, idx, &fidx);
 532
 533         /* Set rest of the fields to NOP */
 534         for (; fidx < 8; fidx++) {
 535                 rvu_write64(rvu, blkaddr,
 536                             NIX_AF_LSO_FORMATX_FIELDX(idx, fidx), 0x0ULL);
 537         }
 538         nix_hw->lso.in_use++;
 539
 540         /* Configure format fields for TCPv6 segmentation offload */
 541         idx = NIX_LSO_FORMAT_IDX_TSOV6;
 542         fidx = 0;
 543         nix_setup_lso_tso_l3(rvu, blkaddr, idx, false, &fidx);
 544         nix_setup_lso_tso_l4(rvu, blkaddr, idx, &fidx);
 545
 546         /* Set rest of the fields to NOP */
 547         for (; fidx < 8; fidx++) {
 548                 rvu_write64(rvu, blkaddr,
 549                             NIX_AF_LSO_FORMATX_FIELDX(idx, fidx), 0x0ULL);
 550         }
 551         nix_hw->lso.in_use++;
 552 }
 553
 554 static void nix_ctx_free(struct rvu *rvu, struct rvu_pfvf *pfvf)
 555 {
 556         kfree(pfvf->rq_bmap);
 557         kfree(pfvf->sq_bmap);
 558         kfree(pfvf->cq_bmap);
 559         if (pfvf->rq_ctx)
 560                 qmem_free(rvu->dev, pfvf->rq_ctx);
 561         if (pfvf->sq_ctx)
 562                 qmem_free(rvu->dev, pfvf->sq_ctx);
 563         if (pfvf->cq_ctx)
 564                 qmem_free(rvu->dev, pfvf->cq_ctx);
 565         if (pfvf->rss_ctx)
 566                 qmem_free(rvu->dev, pfvf->rss_ctx);
 567         if (pfvf->nix_qints_ctx)
 568                 qmem_free(rvu->dev, pfvf->nix_qints_ctx);
 569         if (pfvf->cq_ints_ctx)
 570                 qmem_free(rvu->dev, pfvf->cq_ints_ctx);
 571
 572         pfvf->rq_bmap = NULL;
 573         pfvf->cq_bmap = NULL;
 574         pfvf->sq_bmap = NULL;
 575         pfvf->rq_ctx = NULL;
 576         pfvf->sq_ctx = NULL;
 577         pfvf->cq_ctx = NULL;
 578         pfvf->rss_ctx = NULL;
 579         pfvf->nix_qints_ctx = NULL;
 580         pfvf->cq_ints_ctx = NULL;
 581 }
 582
 583 static int nixlf_rss_ctx_init(struct rvu *rvu, int blkaddr,
 584                               struct rvu_pfvf *pfvf, int nixlf,
 585                               int rss_sz, int rss_grps, int hwctx_size,
 586                               u64 way_mask)
 587 {
 588         int err, grp, num_indices;
 589
 590         /* RSS is not requested for this NIXLF */
 591         if (!rss_sz)
 592                 return 0;
 593         num_indices = rss_sz * rss_grps;
 594
 595         /* Alloc NIX RSS HW context memory and config the base */
 596         err = qmem_alloc(rvu->dev, &pfvf->rss_ctx, num_indices, hwctx_size);
 597         if (err)
 598                 return err;
 599
 600         rvu_write64(rvu, blkaddr, NIX_AF_LFX_RSS_BASE(nixlf),
 601                     (u64)pfvf->rss_ctx->iova);
 602
 603         /* Config full RSS table size, enable RSS and caching */
 604         rvu_write64(rvu, blkaddr, NIX_AF_LFX_RSS_CFG(nixlf),
 605                     BIT_ULL(36) | BIT_ULL(4) |
 606                     ilog2(num_indices / MAX_RSS_INDIR_TBL_SIZE) |
 607                     way_mask << 20);
 608         /* Config RSS group offset and sizes */
 609         for (grp = 0; grp < rss_grps; grp++)
 610                 rvu_write64(rvu, blkaddr, NIX_AF_LFX_RSS_GRPX(nixlf, grp),
 611                             ((ilog2(rss_sz) - 1) << 16) | (rss_sz * grp));
 612         return 0;
 613 }
 614
 615 static int nix_aq_enqueue_wait(struct rvu *rvu, struct rvu_block *block,
 616                                struct nix_aq_inst_s *inst)
 617 {
 618         struct admin_queue *aq = block->aq;
 619         struct nix_aq_res_s *result;
 620         int timeout = 1000;
 621         u64 reg, head;
 622
 623         result = (struct nix_aq_res_s *)aq->res->base;
 624
 625         /* Get current head pointer where to append this instruction */
 626         reg = rvu_read64(rvu, block->addr, NIX_AF_AQ_STATUS);
 627         head = (reg >> 4) & AQ_PTR_MASK;
 628
 629         memcpy((void *)(aq->inst->base + (head * aq->inst->entry_sz)),
 630                (void *)inst, aq->inst->entry_sz);
 631         memset(result, 0, sizeof(*result));
 632         /* sync into memory */
 633         wmb();
 634
 635         /* Ring the doorbell and wait for result */
 636         rvu_write64(rvu, block->addr, NIX_AF_AQ_DOOR, 1);
 637         while (result->compcode == NIX_AQ_COMP_NOTDONE) {
 638                 cpu_relax();
 639                 udelay(1);
 640                 timeout--;
 641                 if (!timeout)
 642                         return -EBUSY;
 643         }
 644
 645         if (result->compcode != NIX_AQ_COMP_GOOD)
 646                 /* TODO: Replace this with some error code */
 647                 return -EBUSY;
 648
 649         return 0;
 650 }
 651
 652 static int rvu_nix_blk_aq_enq_inst(struct rvu *rvu, struct nix_hw *nix_hw,
 653                                    struct nix_aq_enq_req *req,
 654                                    struct nix_aq_enq_rsp *rsp)
 655 {
 656         struct rvu_hwinfo *hw = rvu->hw;
 657         u16 pcifunc = req->hdr.pcifunc;
 658         int nixlf, blkaddr, rc = 0;
 659         struct nix_aq_inst_s inst;
 660         struct rvu_block *block;
 661         struct admin_queue *aq;
 662         struct rvu_pfvf *pfvf;
 663         void *ctx, *mask;
 664         bool ena;
 665         u64 cfg;
 666
 667         blkaddr = nix_hw->blkaddr;
 668         block = &hw->block[blkaddr];
 669         aq = block->aq;
 670         if (!aq) {
 671                 dev_warn(rvu->dev, "%s: NIX AQ not initialized\n", __func__);
 672                 return NIX_AF_ERR_AQ_ENQUEUE;
 673         }
 674
 675         pfvf = rvu_get_pfvf(rvu, pcifunc);
 676         nixlf = rvu_get_lf(rvu, block, pcifunc, 0);
 677
 678         /* Skip NIXLF check for broadcast MCE entry init */
 679         if (!(!rsp && req->ctype == NIX_AQ_CTYPE_MCE)) {
 680                 if (!pfvf->nixlf || nixlf < 0)
 681                         return NIX_AF_ERR_AF_LF_INVALID;
 682         }
 683
 684         switch (req->ctype) {
 685         case NIX_AQ_CTYPE_RQ:
 686                 /* Check if index exceeds max no of queues */
 687                 if (!pfvf->rq_ctx || req->qidx >= pfvf->rq_ctx->qsize)
 688                         rc = NIX_AF_ERR_AQ_ENQUEUE;
 689                 break;
 690         case NIX_AQ_CTYPE_SQ:
 691                 if (!pfvf->sq_ctx || req->qidx >= pfvf->sq_ctx->qsize)
 692                         rc = NIX_AF_ERR_AQ_ENQUEUE;
 693                 break;
 694         case NIX_AQ_CTYPE_CQ:
 695                 if (!pfvf->cq_ctx || req->qidx >= pfvf->cq_ctx->qsize)
 696                         rc = NIX_AF_ERR_AQ_ENQUEUE;
 697                 break;
 698         case NIX_AQ_CTYPE_RSS:
 699                 /* Check if RSS is enabled and qidx is within range */
 700                 cfg = rvu_read64(rvu, blkaddr, NIX_AF_LFX_RSS_CFG(nixlf));
 701                 if (!(cfg & BIT_ULL(4)) || !pfvf->rss_ctx ||
 702                     (req->qidx >= (256UL << (cfg & 0xF))))
 703                         rc = NIX_AF_ERR_AQ_ENQUEUE;
 704                 break;
 705         case NIX_AQ_CTYPE_MCE:
 706                 cfg = rvu_read64(rvu, blkaddr, NIX_AF_RX_MCAST_CFG);
 707
 708                 /* Check if index exceeds MCE list length */
 709                 if (!nix_hw->mcast.mce_ctx ||
 710                     (req->qidx >= (256UL << (cfg & 0xF))))
 711                         rc = NIX_AF_ERR_AQ_ENQUEUE;
 712
 713                 /* Adding multicast lists for requests from PF/VFs is not
 714                  * yet supported, so ignore this.
 715                  */
 716                 if (rsp)
 717                         rc = NIX_AF_ERR_AQ_ENQUEUE;
 718                 break;
 719         default:
 720                 rc = NIX_AF_ERR_AQ_ENQUEUE;
 721         }
 722
 723         if (rc)
 724                 return rc;
 725
 726         /* Check if SQ pointed SMQ belongs to this PF/VF or not */
 727         if (req->ctype == NIX_AQ_CTYPE_SQ &&
 728             ((req->op == NIX_AQ_INSTOP_INIT && req->sq.ena) ||
 729              (req->op == NIX_AQ_INSTOP_WRITE &&
 730               req->sq_mask.ena && req->sq_mask.smq && req->sq.ena))) {
 731                 if (!is_valid_txschq(rvu, blkaddr, NIX_TXSCH_LVL_SMQ,
 732                                      pcifunc, req->sq.smq))
 733                         return NIX_AF_ERR_AQ_ENQUEUE;
 734         }
 735
 736         memset(&inst, 0, sizeof(struct nix_aq_inst_s));
 737         inst.lf = nixlf;
 738         inst.cindex = req->qidx;
 739         inst.ctype = req->ctype;
 740         inst.op = req->op;
 741         /* Currently we are not supporting enqueuing multiple instructions,
 742          * so always choose first entry in result memory.
 743          */
 744         inst.res_addr = (u64)aq->res->iova;
 745
 746         /* Hardware uses same aq->res->base for updating result of
 747          * previous instruction hence wait here till it is done.
 748          */
 749         spin_lock(&aq->lock);
 750
 751         /* Clean result + context memory */
 752         memset(aq->res->base, 0, aq->res->entry_sz);
 753         /* Context needs to be written at RES_ADDR + 128 */
 754         ctx = aq->res->base + 128;
 755         /* Mask needs to be written at RES_ADDR + 256 */
 756         mask = aq->res->base + 256;
 757
 758         switch (req->op) {
 759         case NIX_AQ_INSTOP_WRITE:
 760                 if (req->ctype == NIX_AQ_CTYPE_RQ)
 761                         memcpy(mask, &req->rq_mask,
 762                                sizeof(struct nix_rq_ctx_s));
 763                 else if (req->ctype == NIX_AQ_CTYPE_SQ)
 764                         memcpy(mask, &req->sq_mask,
 765                                sizeof(struct nix_sq_ctx_s));
 766                 else if (req->ctype == NIX_AQ_CTYPE_CQ)
 767                         memcpy(mask, &req->cq_mask,
 768                                sizeof(struct nix_cq_ctx_s));
 769                 else if (req->ctype == NIX_AQ_CTYPE_RSS)
 770                         memcpy(mask, &req->rss_mask,
 771                                sizeof(struct nix_rsse_s));
 772                 else if (req->ctype == NIX_AQ_CTYPE_MCE)
 773                         memcpy(mask, &req->mce_mask,
 774                                sizeof(struct nix_rx_mce_s));
 775                 fallthrough;
 776         case NIX_AQ_INSTOP_INIT:
 777                 if (req->ctype == NIX_AQ_CTYPE_RQ)
 778                         memcpy(ctx, &req->rq, sizeof(struct nix_rq_ctx_s));
 779                 else if (req->ctype == NIX_AQ_CTYPE_SQ)
 780                         memcpy(ctx, &req->sq, sizeof(struct nix_sq_ctx_s));
 781                 else if (req->ctype == NIX_AQ_CTYPE_CQ)
 782                         memcpy(ctx, &req->cq, sizeof(struct nix_cq_ctx_s));
 783                 else if (req->ctype == NIX_AQ_CTYPE_RSS)
 784                         memcpy(ctx, &req->rss, sizeof(struct nix_rsse_s));
 785                 else if (req->ctype == NIX_AQ_CTYPE_MCE)
 786                         memcpy(ctx, &req->mce, sizeof(struct nix_rx_mce_s));
 787                 break;
 788         case NIX_AQ_INSTOP_NOP:
 789         case NIX_AQ_INSTOP_READ:
 790         case NIX_AQ_INSTOP_LOCK:
 791         case NIX_AQ_INSTOP_UNLOCK:
 792                 break;
 793         default:
 794                 rc = NIX_AF_ERR_AQ_ENQUEUE;
 795                 spin_unlock(&aq->lock);
 796                 return rc;
 797         }
 798
 799         /* Submit the instruction to AQ */
 800         rc = nix_aq_enqueue_wait(rvu, block, &inst);
 801         if (rc) {
 802                 spin_unlock(&aq->lock);
 803                 return rc;
 804         }
 805
 806         /* Set RQ/SQ/CQ bitmap if respective queue hw context is enabled */
 807         if (req->op == NIX_AQ_INSTOP_INIT) {
 808                 if (req->ctype == NIX_AQ_CTYPE_RQ && req->rq.ena)
 809                         __set_bit(req->qidx, pfvf->rq_bmap);
 810                 if (req->ctype == NIX_AQ_CTYPE_SQ && req->sq.ena)
 811                         __set_bit(req->qidx, pfvf->sq_bmap);
 812                 if (req->ctype == NIX_AQ_CTYPE_CQ && req->cq.ena)
 813                         __set_bit(req->qidx, pfvf->cq_bmap);
 814         }
 815
 816         if (req->op == NIX_AQ_INSTOP_WRITE) {
 817                 if (req->ctype == NIX_AQ_CTYPE_RQ) {
 818                         ena = (req->rq.ena & req->rq_mask.ena) |
 819                                 (test_bit(req->qidx, pfvf->rq_bmap) &
 820                                 ~req->rq_mask.ena);
 821                         if (ena)
 822                                 __set_bit(req->qidx, pfvf->rq_bmap);
 823                         else
 824                                 __clear_bit(req->qidx, pfvf->rq_bmap);
 825                 }
 826                 if (req->ctype == NIX_AQ_CTYPE_SQ) {
 827                         ena = (req->rq.ena & req->sq_mask.ena) |
 828                                 (test_bit(req->qidx, pfvf->sq_bmap) &
 829                                 ~req->sq_mask.ena);
 830                         if (ena)
 831                                 __set_bit(req->qidx, pfvf->sq_bmap);
 832                         else
 833                                 __clear_bit(req->qidx, pfvf->sq_bmap);
 834                 }
 835                 if (req->ctype == NIX_AQ_CTYPE_CQ) {
 836                         ena = (req->rq.ena & req->cq_mask.ena) |
 837                                 (test_bit(req->qidx, pfvf->cq_bmap) &
 838                                 ~req->cq_mask.ena);
 839                         if (ena)
 840                                 __set_bit(req->qidx, pfvf->cq_bmap);
 841                         else
 842                                 __clear_bit(req->qidx, pfvf->cq_bmap);
 843                 }
 844         }
 845
 846         if (rsp) {
 847                 /* Copy read context into mailbox */
 848                 if (req->op == NIX_AQ_INSTOP_READ) {
 849                         if (req->ctype == NIX_AQ_CTYPE_RQ)
 850                                 memcpy(&rsp->rq, ctx,
 851                                        sizeof(struct nix_rq_ctx_s));
 852                         else if (req->ctype == NIX_AQ_CTYPE_SQ)
 853                                 memcpy(&rsp->sq, ctx,
 854                                        sizeof(struct nix_sq_ctx_s));
 855                         else if (req->ctype == NIX_AQ_CTYPE_CQ)
 856                                 memcpy(&rsp->cq, ctx,
 857                                        sizeof(struct nix_cq_ctx_s));
 858                         else if (req->ctype == NIX_AQ_CTYPE_RSS)
 859                                 memcpy(&rsp->rss, ctx,
 860                                        sizeof(struct nix_rsse_s));
 861                         else if (req->ctype == NIX_AQ_CTYPE_MCE)
 862                                 memcpy(&rsp->mce, ctx,
 863                                        sizeof(struct nix_rx_mce_s));
 864                 }
 865         }
 866
 867         spin_unlock(&aq->lock);
 868         return 0;
 869 }
 870
 871 static int rvu_nix_aq_enq_inst(struct rvu *rvu, struct nix_aq_enq_req *req,
 872                                struct nix_aq_enq_rsp *rsp)
 873 {
 874         struct nix_hw *nix_hw;
 875         int blkaddr;
 876
 877         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, req->hdr.pcifunc);
 878         if (blkaddr < 0)
 879                 return NIX_AF_ERR_AF_LF_INVALID;
 880
 881         nix_hw =  get_nix_hw(rvu->hw, blkaddr);
 882         if (!nix_hw)
 883                 return -EINVAL;
 884
 885         return rvu_nix_blk_aq_enq_inst(rvu, nix_hw, req, rsp);
 886 }
 887
 888 static const char *nix_get_ctx_name(int ctype)
 889 {
 890         switch (ctype) {
 891         case NIX_AQ_CTYPE_CQ:
 892                 return "CQ";
 893         case NIX_AQ_CTYPE_SQ:
 894                 return "SQ";
 895         case NIX_AQ_CTYPE_RQ:
 896                 return "RQ";
 897         case NIX_AQ_CTYPE_RSS:
 898                 return "RSS";
 899         }
 900         return "";
 901 }
 902
 903 static int nix_lf_hwctx_disable(struct rvu *rvu, struct hwctx_disable_req *req)
 904 {
 905         struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, req->hdr.pcifunc);
 906         struct nix_aq_enq_req aq_req;
 907         unsigned long *bmap;
 908         int qidx, q_cnt = 0;
 909         int err = 0, rc;
 910
 911         if (!pfvf->cq_ctx || !pfvf->sq_ctx || !pfvf->rq_ctx)
 912                 return NIX_AF_ERR_AQ_ENQUEUE;
 913
 914         memset(&aq_req, 0, sizeof(struct nix_aq_enq_req));
 915         aq_req.hdr.pcifunc = req->hdr.pcifunc;
 916
 917         if (req->ctype == NIX_AQ_CTYPE_CQ) {
 918                 aq_req.cq.ena = 0;
 919                 aq_req.cq_mask.ena = 1;
 920                 aq_req.cq.bp_ena = 0;
 921                 aq_req.cq_mask.bp_ena = 1;
 922                 q_cnt = pfvf->cq_ctx->qsize;
 923                 bmap = pfvf->cq_bmap;
 924         }
 925         if (req->ctype == NIX_AQ_CTYPE_SQ) {
 926                 aq_req.sq.ena = 0;
 927                 aq_req.sq_mask.ena = 1;
 928                 q_cnt = pfvf->sq_ctx->qsize;
 929                 bmap = pfvf->sq_bmap;
 930         }
 931         if (req->ctype == NIX_AQ_CTYPE_RQ) {
 932                 aq_req.rq.ena = 0;
 933                 aq_req.rq_mask.ena = 1;
 934                 q_cnt = pfvf->rq_ctx->qsize;
 935                 bmap = pfvf->rq_bmap;
 936         }
 937
 938         aq_req.ctype = req->ctype;
 939         aq_req.op = NIX_AQ_INSTOP_WRITE;
 940
 941         for (qidx = 0; qidx < q_cnt; qidx++) {
 942                 if (!test_bit(qidx, bmap))
 943                         continue;
 944                 aq_req.qidx = qidx;
 945                 rc = rvu_nix_aq_enq_inst(rvu, &aq_req, NULL);
 946                 if (rc) {
 947                         err = rc;
 948                         dev_err(rvu->dev, "Failed to disable %s:%d context\n",
 949                                 nix_get_ctx_name(req->ctype), qidx);
 950                 }
 951         }
 952
 953         return err;
 954 }
 955
 956 #ifdef CONFIG_NDC_DIS_DYNAMIC_CACHING
 957 static int nix_lf_hwctx_lockdown(struct rvu *rvu, struct nix_aq_enq_req *req)
 958 {
 959         struct nix_aq_enq_req lock_ctx_req;
 960         int err;
 961
 962         if (req->op != NIX_AQ_INSTOP_INIT)
 963                 return 0;
 964
 965         if (req->ctype == NIX_AQ_CTYPE_MCE ||
 966             req->ctype == NIX_AQ_CTYPE_DYNO)
 967                 return 0;
 968
 969         memset(&lock_ctx_req, 0, sizeof(struct nix_aq_enq_req));
 970         lock_ctx_req.hdr.pcifunc = req->hdr.pcifunc;
 971         lock_ctx_req.ctype = req->ctype;
 972         lock_ctx_req.op = NIX_AQ_INSTOP_LOCK;
 973         lock_ctx_req.qidx = req->qidx;
 974         err = rvu_nix_aq_enq_inst(rvu, &lock_ctx_req, NULL);
 975         if (err)
 976                 dev_err(rvu->dev,
 977                         "PFUNC 0x%x: Failed to lock NIX %s:%d context\n",
 978                         req->hdr.pcifunc,
 979                         nix_get_ctx_name(req->ctype), req->qidx);
 980         return err;
 981 }
 982
 983 int rvu_mbox_handler_nix_aq_enq(struct rvu *rvu,
 984                                 struct nix_aq_enq_req *req,
 985                                 struct nix_aq_enq_rsp *rsp)
 986 {
 987         int err;
 988
 989         err = rvu_nix_aq_enq_inst(rvu, req, rsp);
 990         if (!err)
 991                 err = nix_lf_hwctx_lockdown(rvu, req);
 992         return err;
 993 }
 994 #else
 995
 996 int rvu_mbox_handler_nix_aq_enq(struct rvu *rvu,
 997                                 struct nix_aq_enq_req *req,
 998                                 struct nix_aq_enq_rsp *rsp)
 999 {
1000         return rvu_nix_aq_enq_inst(rvu, req, rsp);
1001 }
1002 #endif
1003
1004 int rvu_mbox_handler_nix_hwctx_disable(struct rvu *rvu,
1005                                        struct hwctx_disable_req *req,
1006                                        struct msg_rsp *rsp)
1007 {
1008         return nix_lf_hwctx_disable(rvu, req);
1009 }
1010
1011 int rvu_mbox_handler_nix_lf_alloc(struct rvu *rvu,
1012                                   struct nix_lf_alloc_req *req,
1013                                   struct nix_lf_alloc_rsp *rsp)
1014 {
1015         int nixlf, qints, hwctx_size, intf, err, rc = 0;
1016         struct rvu_hwinfo *hw = rvu->hw;
1017         u16 pcifunc = req->hdr.pcifunc;
1018         struct rvu_block *block;
1019         struct rvu_pfvf *pfvf;
1020         u64 cfg, ctx_cfg;
1021         int blkaddr;
1022
1023         if (!req->rq_cnt || !req->sq_cnt || !req->cq_cnt)
1024                 return NIX_AF_ERR_PARAM;
1025
1026         if (req->way_mask)
1027                 req->way_mask &= 0xFFFF;
1028
1029         pfvf = rvu_get_pfvf(rvu, pcifunc);
1030         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
1031         if (!pfvf->nixlf || blkaddr < 0)
1032                 return NIX_AF_ERR_AF_LF_INVALID;
1033
1034         block = &hw->block[blkaddr];
1035         nixlf = rvu_get_lf(rvu, block, pcifunc, 0);
1036         if (nixlf < 0)
1037                 return NIX_AF_ERR_AF_LF_INVALID;
1038
1039         /* Check if requested 'NIXLF <=> NPALF' mapping is valid */
1040         if (req->npa_func) {
1041                 /* If default, use 'this' NIXLF's PFFUNC */
1042                 if (req->npa_func == RVU_DEFAULT_PF_FUNC)
1043                         req->npa_func = pcifunc;
1044                 if (!is_pffunc_map_valid(rvu, req->npa_func, BLKTYPE_NPA))
1045                         return NIX_AF_INVAL_NPA_PF_FUNC;
1046         }
1047
1048         /* Check if requested 'NIXLF <=> SSOLF' mapping is valid */
1049         if (req->sso_func) {
1050                 /* If default, use 'this' NIXLF's PFFUNC */
1051                 if (req->sso_func == RVU_DEFAULT_PF_FUNC)
1052                         req->sso_func = pcifunc;
1053                 if (!is_pffunc_map_valid(rvu, req->sso_func, BLKTYPE_SSO))
1054                         return NIX_AF_INVAL_SSO_PF_FUNC;
1055         }
1056
1057         /* If RSS is being enabled, check if requested config is valid.
1058          * RSS table size should be power of two, otherwise
1059          * RSS_GRP::OFFSET + adder might go beyond that group or
1060          * won't be able to use entire table.
1061          */
1062         if (req->rss_sz && (req->rss_sz > MAX_RSS_INDIR_TBL_SIZE ||
1063                             !is_power_of_2(req->rss_sz)))
1064                 return NIX_AF_ERR_RSS_SIZE_INVALID;
1065
1066         if (req->rss_sz &&
1067             (!req->rss_grps || req->rss_grps > MAX_RSS_GROUPS))
1068                 return NIX_AF_ERR_RSS_GRPS_INVALID;
1069
1070         /* Reset this NIX LF */
1071         err = rvu_lf_reset(rvu, block, nixlf);
1072         if (err) {
1073                 dev_err(rvu->dev, "Failed to reset NIX%d LF%d\n",
1074                         block->addr - BLKADDR_NIX0, nixlf);
1075                 return NIX_AF_ERR_LF_RESET;
1076         }
1077
1078         ctx_cfg = rvu_read64(rvu, blkaddr, NIX_AF_CONST3);
1079
1080         /* Alloc NIX RQ HW context memory and config the base */
1081         hwctx_size = 1UL << ((ctx_cfg >> 4) & 0xF);
1082         err = qmem_alloc(rvu->dev, &pfvf->rq_ctx, req->rq_cnt, hwctx_size);
1083         if (err)
1084                 goto free_mem;
1085
1086         pfvf->rq_bmap = kcalloc(req->rq_cnt, sizeof(long), GFP_KERNEL);
1087         if (!pfvf->rq_bmap)
1088                 goto free_mem;
1089
1090         rvu_write64(rvu, blkaddr, NIX_AF_LFX_RQS_BASE(nixlf),
1091                     (u64)pfvf->rq_ctx->iova);
1092
1093         /* Set caching and queue count in HW */
1094         cfg = BIT_ULL(36) | (req->rq_cnt - 1) | req->way_mask << 20;
1095         rvu_write64(rvu, blkaddr, NIX_AF_LFX_RQS_CFG(nixlf), cfg);
1096
1097         /* Alloc NIX SQ HW context memory and config the base */
1098         hwctx_size = 1UL << (ctx_cfg & 0xF);
1099         err = qmem_alloc(rvu->dev, &pfvf->sq_ctx, req->sq_cnt, hwctx_size);
1100         if (err)
1101                 goto free_mem;
1102
1103         pfvf->sq_bmap = kcalloc(req->sq_cnt, sizeof(long), GFP_KERNEL);
1104         if (!pfvf->sq_bmap)
1105                 goto free_mem;
1106
1107         rvu_write64(rvu, blkaddr, NIX_AF_LFX_SQS_BASE(nixlf),
1108                     (u64)pfvf->sq_ctx->iova);
1109
1110         cfg = BIT_ULL(36) | (req->sq_cnt - 1) | req->way_mask << 20;
1111         rvu_write64(rvu, blkaddr, NIX_AF_LFX_SQS_CFG(nixlf), cfg);
1112
1113         /* Alloc NIX CQ HW context memory and config the base */
1114         hwctx_size = 1UL << ((ctx_cfg >> 8) & 0xF);
1115         err = qmem_alloc(rvu->dev, &pfvf->cq_ctx, req->cq_cnt, hwctx_size);
1116         if (err)
1117                 goto free_mem;
1118
1119         pfvf->cq_bmap = kcalloc(req->cq_cnt, sizeof(long), GFP_KERNEL);
1120         if (!pfvf->cq_bmap)
1121                 goto free_mem;
1122
1123         rvu_write64(rvu, blkaddr, NIX_AF_LFX_CQS_BASE(nixlf),
1124                     (u64)pfvf->cq_ctx->iova);
1125
1126         cfg = BIT_ULL(36) | (req->cq_cnt - 1) | req->way_mask << 20;
1127         rvu_write64(rvu, blkaddr, NIX_AF_LFX_CQS_CFG(nixlf), cfg);
1128
1129         /* Initialize receive side scaling (RSS) */
1130         hwctx_size = 1UL << ((ctx_cfg >> 12) & 0xF);
1131         err = nixlf_rss_ctx_init(rvu, blkaddr, pfvf, nixlf, req->rss_sz,
1132                                  req->rss_grps, hwctx_size, req->way_mask);
1133         if (err)
1134                 goto free_mem;
1135
1136         /* Alloc memory for CQINT's HW contexts */
1137         cfg = rvu_read64(rvu, blkaddr, NIX_AF_CONST2);
1138         qints = (cfg >> 24) & 0xFFF;
1139         hwctx_size = 1UL << ((ctx_cfg >> 24) & 0xF);
1140         err = qmem_alloc(rvu->dev, &pfvf->cq_ints_ctx, qints, hwctx_size);
1141         if (err)
1142                 goto free_mem;
1143
1144         rvu_write64(rvu, blkaddr, NIX_AF_LFX_CINTS_BASE(nixlf),
1145                     (u64)pfvf->cq_ints_ctx->iova);
1146
1147         rvu_write64(rvu, blkaddr, NIX_AF_LFX_CINTS_CFG(nixlf),
1148                     BIT_ULL(36) | req->way_mask << 20);
1149
1150         /* Alloc memory for QINT's HW contexts */
1151         cfg = rvu_read64(rvu, blkaddr, NIX_AF_CONST2);
1152         qints = (cfg >> 12) & 0xFFF;
1153         hwctx_size = 1UL << ((ctx_cfg >> 20) & 0xF);
1154         err = qmem_alloc(rvu->dev, &pfvf->nix_qints_ctx, qints, hwctx_size);
1155         if (err)
1156                 goto free_mem;
1157
1158         rvu_write64(rvu, blkaddr, NIX_AF_LFX_QINTS_BASE(nixlf),
1159                     (u64)pfvf->nix_qints_ctx->iova);
1160         rvu_write64(rvu, blkaddr, NIX_AF_LFX_QINTS_CFG(nixlf),
1161                     BIT_ULL(36) | req->way_mask << 20);
1162
1163         /* Setup VLANX TPID's.
1164          * Use VLAN1 for 802.1Q
1165          * and VLAN0 for 802.1AD.
1166          */
1167         cfg = (0x8100ULL << 16) | 0x88A8ULL;
1168         rvu_write64(rvu, blkaddr, NIX_AF_LFX_TX_CFG(nixlf), cfg);
1169
1170         /* Enable LMTST for this NIX LF */
1171         rvu_write64(rvu, blkaddr, NIX_AF_LFX_TX_CFG2(nixlf), BIT_ULL(0));
1172
1173         /* Set CQE/WQE size, NPA_PF_FUNC for SQBs and also SSO_PF_FUNC */
1174         if (req->npa_func)
1175                 cfg = req->npa_func;
1176         if (req->sso_func)
1177                 cfg |= (u64)req->sso_func << 16;
1178
1179         cfg |= (u64)req->xqe_sz << 33;
1180         rvu_write64(rvu, blkaddr, NIX_AF_LFX_CFG(nixlf), cfg);
1181
1182         /* Config Rx pkt length, csum checks and apad  enable / disable */
1183         rvu_write64(rvu, blkaddr, NIX_AF_LFX_RX_CFG(nixlf), req->rx_cfg);
1184
1185         /* Configure pkind for TX parse config */
1186         cfg = NPC_TX_DEF_PKIND;
1187         rvu_write64(rvu, blkaddr, NIX_AF_LFX_TX_PARSE_CFG(nixlf), cfg);
1188
1189         intf = is_afvf(pcifunc) ? NIX_INTF_TYPE_LBK : NIX_INTF_TYPE_CGX;
1190         err = nix_interface_init(rvu, pcifunc, intf, nixlf);
1191         if (err)
1192                 goto free_mem;
1193
1194         /* Disable NPC entries as NIXLF's contexts are not initialized yet */
1195         rvu_npc_disable_default_entries(rvu, pcifunc, nixlf);
1196
1197         goto exit;
1198
1199 free_mem:
1200         nix_ctx_free(rvu, pfvf);
1201         rc = -ENOMEM;
1202
1203 exit:
1204         /* Set macaddr of this PF/VF */
1205         ether_addr_copy(rsp->mac_addr, pfvf->mac_addr);
1206
1207         /* set SQB size info */
1208         cfg = rvu_read64(rvu, blkaddr, NIX_AF_SQ_CONST);
1209         rsp->sqb_size = (cfg >> 34) & 0xFFFF;
1210         rsp->rx_chan_base = pfvf->rx_chan_base;
1211         rsp->tx_chan_base = pfvf->tx_chan_base;
1212         rsp->rx_chan_cnt = pfvf->rx_chan_cnt;
1213         rsp->tx_chan_cnt = pfvf->tx_chan_cnt;
1214         rsp->lso_tsov4_idx = NIX_LSO_FORMAT_IDX_TSOV4;
1215         rsp->lso_tsov6_idx = NIX_LSO_FORMAT_IDX_TSOV6;
1216         /* Get HW supported stat count */
1217         cfg = rvu_read64(rvu, blkaddr, NIX_AF_CONST1);
1218         rsp->lf_rx_stats = ((cfg >> 32) & 0xFF);
1219         rsp->lf_tx_stats = ((cfg >> 24) & 0xFF);
1220         /* Get count of CQ IRQs and error IRQs supported per LF */
1221         cfg = rvu_read64(rvu, blkaddr, NIX_AF_CONST2);
1222         rsp->qints = ((cfg >> 12) & 0xFFF);
1223         rsp->cints = ((cfg >> 24) & 0xFFF);
1224         rsp->cgx_links = hw->cgx_links;
1225         rsp->lbk_links = hw->lbk_links;
1226         rsp->sdp_links = hw->sdp_links;
1227
1228         return rc;
1229 }
1230
1231 int rvu_mbox_handler_nix_lf_free(struct rvu *rvu, struct msg_req *req,
1232                                  struct msg_rsp *rsp)
1233 {
1234         struct rvu_hwinfo *hw = rvu->hw;
1235         u16 pcifunc = req->hdr.pcifunc;
1236         struct rvu_block *block;
1237         int blkaddr, nixlf, err;
1238         struct rvu_pfvf *pfvf;
1239
1240         pfvf = rvu_get_pfvf(rvu, pcifunc);
1241         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
1242         if (!pfvf->nixlf || blkaddr < 0)
1243                 return NIX_AF_ERR_AF_LF_INVALID;
1244
1245         block = &hw->block[blkaddr];
1246         nixlf = rvu_get_lf(rvu, block, pcifunc, 0);
1247         if (nixlf < 0)
1248                 return NIX_AF_ERR_AF_LF_INVALID;
1249
1250         nix_interface_deinit(rvu, pcifunc, nixlf);
1251
1252         /* Reset this NIX LF */
1253         err = rvu_lf_reset(rvu, block, nixlf);
1254         if (err) {
1255                 dev_err(rvu->dev, "Failed to reset NIX%d LF%d\n",
1256                         block->addr - BLKADDR_NIX0, nixlf);
1257                 return NIX_AF_ERR_LF_RESET;
1258         }
1259
1260         nix_ctx_free(rvu, pfvf);
1261
1262         return 0;
1263 }
1264
1265 int rvu_mbox_handler_nix_mark_format_cfg(struct rvu *rvu,
1266                                          struct nix_mark_format_cfg  *req,
1267                                          struct nix_mark_format_cfg_rsp *rsp)
1268 {
1269         u16 pcifunc = req->hdr.pcifunc;
1270         struct nix_hw *nix_hw;
1271         struct rvu_pfvf *pfvf;
1272         int blkaddr, rc;
1273         u32 cfg;
1274
1275         pfvf = rvu_get_pfvf(rvu, pcifunc);
1276         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
1277         if (!pfvf->nixlf || blkaddr < 0)
1278                 return NIX_AF_ERR_AF_LF_INVALID;
1279
1280         nix_hw = get_nix_hw(rvu->hw, blkaddr);
1281         if (!nix_hw)
1282                 return -EINVAL;
1283
1284         cfg = (((u32)req->offset & 0x7) << 16) |
1285               (((u32)req->y_mask & 0xF) << 12) |
1286               (((u32)req->y_val & 0xF) << 8) |
1287               (((u32)req->r_mask & 0xF) << 4) | ((u32)req->r_val & 0xF);
1288
1289         rc = rvu_nix_reserve_mark_format(rvu, nix_hw, blkaddr, cfg);
1290         if (rc < 0) {
1291                 dev_err(rvu->dev, "No mark_format_ctl for (pf:%d, vf:%d)",
1292                         rvu_get_pf(pcifunc), pcifunc & RVU_PFVF_FUNC_MASK);
1293                 return NIX_AF_ERR_MARK_CFG_FAIL;
1294         }
1295
1296         rsp->mark_format_idx = rc;
1297         return 0;
1298 }
1299
1300 /* Disable shaping of pkts by a scheduler queue
1301  * at a given scheduler level.
1302  */
1303 static void nix_reset_tx_shaping(struct rvu *rvu, int blkaddr,
1304                                  int lvl, int schq)
1305 {
1306         u64  cir_reg = 0, pir_reg = 0;
1307         u64  cfg;
1308
1309         switch (lvl) {
1310         case NIX_TXSCH_LVL_TL1:
1311                 cir_reg = NIX_AF_TL1X_CIR(schq);
1312                 pir_reg = 0; /* PIR not available at TL1 */
1313                 break;
1314         case NIX_TXSCH_LVL_TL2:
1315                 cir_reg = NIX_AF_TL2X_CIR(schq);
1316                 pir_reg = NIX_AF_TL2X_PIR(schq);
1317                 break;
1318         case NIX_TXSCH_LVL_TL3:
1319                 cir_reg = NIX_AF_TL3X_CIR(schq);
1320                 pir_reg = NIX_AF_TL3X_PIR(schq);
1321                 break;
1322         case NIX_TXSCH_LVL_TL4:
1323                 cir_reg = NIX_AF_TL4X_CIR(schq);
1324                 pir_reg = NIX_AF_TL4X_PIR(schq);
1325                 break;
1326         }
1327
1328         if (!cir_reg)
1329                 return;
1330         cfg = rvu_read64(rvu, blkaddr, cir_reg);
1331         rvu_write64(rvu, blkaddr, cir_reg, cfg & ~BIT_ULL(0));
1332
1333         if (!pir_reg)
1334                 return;
1335         cfg = rvu_read64(rvu, blkaddr, pir_reg);
1336         rvu_write64(rvu, blkaddr, pir_reg, cfg & ~BIT_ULL(0));
1337 }
1338
1339 static void nix_reset_tx_linkcfg(struct rvu *rvu, int blkaddr,
1340                                  int lvl, int schq)
1341 {
1342         struct rvu_hwinfo *hw = rvu->hw;
1343         int link;
1344
1345         if (lvl >= hw->cap.nix_tx_aggr_lvl)
1346                 return;
1347
1348         /* Reset TL4's SDP link config */
1349         if (lvl == NIX_TXSCH_LVL_TL4)
1350                 rvu_write64(rvu, blkaddr, NIX_AF_TL4X_SDP_LINK_CFG(schq), 0x00);
1351
1352         if (lvl != NIX_TXSCH_LVL_TL2)
1353                 return;
1354
1355         /* Reset TL2's CGX or LBK link config */
1356         for (link = 0; link < (hw->cgx_links + hw->lbk_links); link++)
1357                 rvu_write64(rvu, blkaddr,
1358                             NIX_AF_TL3_TL2X_LINKX_CFG(schq, link), 0x00);
1359 }
1360
1361 static int nix_get_tx_link(struct rvu *rvu, u16 pcifunc)
1362 {
1363         struct rvu_hwinfo *hw = rvu->hw;
1364         int pf = rvu_get_pf(pcifunc);
1365         u8 cgx_id = 0, lmac_id = 0;
1366
1367         if (is_afvf(pcifunc)) {/* LBK links */
1368                 return hw->cgx_links;
1369         } else if (is_pf_cgxmapped(rvu, pf)) {
1370                 rvu_get_cgx_lmac_id(rvu->pf2cgxlmac_map[pf], &cgx_id, &lmac_id);
1371                 return (cgx_id * hw->lmac_per_cgx) + lmac_id;
1372         }
1373
1374         /* SDP link */
1375         return hw->cgx_links + hw->lbk_links;
1376 }
1377
1378 static void nix_get_txschq_range(struct rvu *rvu, u16 pcifunc,
1379                                  int link, int *start, int *end)
1380 {
1381         struct rvu_hwinfo *hw = rvu->hw;
1382         int pf = rvu_get_pf(pcifunc);
1383
1384         if (is_afvf(pcifunc)) { /* LBK links */
1385                 *start = hw->cap.nix_txsch_per_cgx_lmac * link;
1386                 *end = *start + hw->cap.nix_txsch_per_lbk_lmac;
1387         } else if (is_pf_cgxmapped(rvu, pf)) { /* CGX links */
1388                 *start = hw->cap.nix_txsch_per_cgx_lmac * link;
1389                 *end = *start + hw->cap.nix_txsch_per_cgx_lmac;
1390         } else { /* SDP link */
1391                 *start = (hw->cap.nix_txsch_per_cgx_lmac * hw->cgx_links) +
1392                         (hw->cap.nix_txsch_per_lbk_lmac * hw->lbk_links);
1393                 *end = *start + hw->cap.nix_txsch_per_sdp_lmac;
1394         }
1395 }
1396
1397 static int nix_check_txschq_alloc_req(struct rvu *rvu, int lvl, u16 pcifunc,
1398                                       struct nix_hw *nix_hw,
1399                                       struct nix_txsch_alloc_req *req)
1400 {
1401         struct rvu_hwinfo *hw = rvu->hw;
1402         int schq, req_schq, free_cnt;
1403         struct nix_txsch *txsch;
1404         int link, start, end;
1405
1406         txsch = &nix_hw->txsch[lvl];
1407         req_schq = req->schq_contig[lvl] + req->schq[lvl];
1408
1409         if (!req_schq)
1410                 return 0;
1411
1412         link = nix_get_tx_link(rvu, pcifunc);
1413
1414         /* For traffic aggregating scheduler level, one queue is enough */
1415         if (lvl >= hw->cap.nix_tx_aggr_lvl) {
1416                 if (req_schq != 1)
1417                         return NIX_AF_ERR_TLX_ALLOC_FAIL;
1418                 return 0;
1419         }
1420
1421         /* Get free SCHQ count and check if request can be accomodated */
1422         if (hw->cap.nix_fixed_txschq_mapping) {
1423                 nix_get_txschq_range(rvu, pcifunc, link, &start, &end);
1424                 schq = start + (pcifunc & RVU_PFVF_FUNC_MASK);
1425                 if (end <= txsch->schq.max && schq < end &&
1426                     !test_bit(schq, txsch->schq.bmap))
1427                         free_cnt = 1;
1428                 else
1429                         free_cnt = 0;
1430         } else {
1431                 free_cnt = rvu_rsrc_free_count(&txsch->schq);
1432         }
1433
1434         if (free_cnt < req_schq || req_schq > MAX_TXSCHQ_PER_FUNC)
1435                 return NIX_AF_ERR_TLX_ALLOC_FAIL;
1436
1437         /* If contiguous queues are needed, check for availability */
1438         if (!hw->cap.nix_fixed_txschq_mapping && req->schq_contig[lvl] &&
1439             !rvu_rsrc_check_contig(&txsch->schq, req->schq_contig[lvl]))
1440                 return NIX_AF_ERR_TLX_ALLOC_FAIL;
1441
1442         return 0;
1443 }
1444
1445 static void nix_txsch_alloc(struct rvu *rvu, struct nix_txsch *txsch,
1446                             struct nix_txsch_alloc_rsp *rsp,
1447                             int lvl, int start, int end)
1448 {
1449         struct rvu_hwinfo *hw = rvu->hw;
1450         u16 pcifunc = rsp->hdr.pcifunc;
1451         int idx, schq;
1452
1453         /* For traffic aggregating levels, queue alloc is based
1454          * on transmit link to which PF_FUNC is mapped to.
1455          */
1456         if (lvl >= hw->cap.nix_tx_aggr_lvl) {
1457                 /* A single TL queue is allocated */
1458                 if (rsp->schq_contig[lvl]) {
1459                         rsp->schq_contig[lvl] = 1;
1460                         rsp->schq_contig_list[lvl][0] = start;
1461                 }
1462
1463                 /* Both contig and non-contig reqs doesn't make sense here */
1464                 if (rsp->schq_contig[lvl])
1465                         rsp->schq[lvl] = 0;
1466
1467                 if (rsp->schq[lvl]) {
1468                         rsp->schq[lvl] = 1;
1469                         rsp->schq_list[lvl][0] = start;
1470                 }
1471                 return;
1472         }
1473
1474         /* Adjust the queue request count if HW supports
1475          * only one queue per level configuration.
1476          */
1477         if (hw->cap.nix_fixed_txschq_mapping) {
1478                 idx = pcifunc & RVU_PFVF_FUNC_MASK;
1479                 schq = start + idx;
1480                 if (idx >= (end - start) || test_bit(schq, txsch->schq.bmap)) {
1481                         rsp->schq_contig[lvl] = 0;
1482                         rsp->schq[lvl] = 0;
1483                         return;
1484                 }
1485
1486                 if (rsp->schq_contig[lvl]) {
1487                         rsp->schq_contig[lvl] = 1;
1488                         set_bit(schq, txsch->schq.bmap);
1489                         rsp->schq_contig_list[lvl][0] = schq;
1490                         rsp->schq[lvl] = 0;
1491                 } else if (rsp->schq[lvl]) {
1492                         rsp->schq[lvl] = 1;
1493                         set_bit(schq, txsch->schq.bmap);
1494                         rsp->schq_list[lvl][0] = schq;
1495                 }
1496                 return;
1497         }
1498
1499         /* Allocate contiguous queue indices requesty first */
1500         if (rsp->schq_contig[lvl]) {
1501                 schq = bitmap_find_next_zero_area(txsch->schq.bmap,
1502                                                   txsch->schq.max, start,
1503                                                   rsp->schq_contig[lvl], 0);
1504                 if (schq >= end)
1505                         rsp->schq_contig[lvl] = 0;
1506                 for (idx = 0; idx < rsp->schq_contig[lvl]; idx++) {
1507                         set_bit(schq, txsch->schq.bmap);
1508                         rsp->schq_contig_list[lvl][idx] = schq;
1509                         schq++;
1510                 }
1511         }
1512
1513         /* Allocate non-contiguous queue indices */
1514         if (rsp->schq[lvl]) {
1515                 idx = 0;
1516                 for (schq = start; schq < end; schq++) {
1517                         if (!test_bit(schq, txsch->schq.bmap)) {
1518                                 set_bit(schq, txsch->schq.bmap);
1519                                 rsp->schq_list[lvl][idx++] = schq;
1520                         }
1521                         if (idx == rsp->schq[lvl])
1522                                 break;
1523                 }
1524                 /* Update how many were allocated */
1525                 rsp->schq[lvl] = idx;
1526         }
1527 }
1528
1529 int rvu_mbox_handler_nix_txsch_alloc(struct rvu *rvu,
1530                                      struct nix_txsch_alloc_req *req,
1531                                      struct nix_txsch_alloc_rsp *rsp)
1532 {
1533         struct rvu_hwinfo *hw = rvu->hw;
1534         u16 pcifunc = req->hdr.pcifunc;
1535         int link, blkaddr, rc = 0;
1536         int lvl, idx, start, end;
1537         struct nix_txsch *txsch;
1538         struct rvu_pfvf *pfvf;
1539         struct nix_hw *nix_hw;
1540         u32 *pfvf_map;
1541         u16 schq;
1542
1543         pfvf = rvu_get_pfvf(rvu, pcifunc);
1544         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
1545         if (!pfvf->nixlf || blkaddr < 0)
1546                 return NIX_AF_ERR_AF_LF_INVALID;
1547
1548         nix_hw = get_nix_hw(rvu->hw, blkaddr);
1549         if (!nix_hw)
1550                 return -EINVAL;
1551
1552         mutex_lock(&rvu->rsrc_lock);
1553
1554         /* Check if request is valid as per HW capabilities
1555          * and can be accomodated.
1556          */
1557         for (lvl = 0; lvl < NIX_TXSCH_LVL_CNT; lvl++) {
1558                 rc = nix_check_txschq_alloc_req(rvu, lvl, pcifunc, nix_hw, req);
1559                 if (rc)
1560                         goto err;
1561         }
1562
1563         /* Allocate requested Tx scheduler queues */
1564         for (lvl = 0; lvl < NIX_TXSCH_LVL_CNT; lvl++) {
1565                 txsch = &nix_hw->txsch[lvl];
1566                 pfvf_map = txsch->pfvf_map;
1567
1568                 if (!req->schq[lvl] && !req->schq_contig[lvl])
1569                         continue;
1570
1571                 rsp->schq[lvl] = req->schq[lvl];
1572                 rsp->schq_contig[lvl] = req->schq_contig[lvl];
1573
1574                 link = nix_get_tx_link(rvu, pcifunc);
1575
1576                 if (lvl >= hw->cap.nix_tx_aggr_lvl) {
1577                         start = link;
1578                         end = link;
1579                 } else if (hw->cap.nix_fixed_txschq_mapping) {
1580                         nix_get_txschq_range(rvu, pcifunc, link, &start, &end);
1581                 } else {
1582                         start = 0;
1583                         end = txsch->schq.max;
1584                 }
1585
1586                 nix_txsch_alloc(rvu, txsch, rsp, lvl, start, end);
1587
1588                 /* Reset queue config */
1589                 for (idx = 0; idx < req->schq_contig[lvl]; idx++) {
1590                         schq = rsp->schq_contig_list[lvl][idx];
1591                         if (!(TXSCH_MAP_FLAGS(pfvf_map[schq]) &
1592                             NIX_TXSCHQ_CFG_DONE))
1593                                 pfvf_map[schq] = TXSCH_MAP(pcifunc, 0);
1594                         nix_reset_tx_linkcfg(rvu, blkaddr, lvl, schq);
1595                         nix_reset_tx_shaping(rvu, blkaddr, lvl, schq);
1596                 }
1597
1598                 for (idx = 0; idx < req->schq[lvl]; idx++) {
1599                         schq = rsp->schq_list[lvl][idx];
1600                         if (!(TXSCH_MAP_FLAGS(pfvf_map[schq]) &
1601                             NIX_TXSCHQ_CFG_DONE))
1602                                 pfvf_map[schq] = TXSCH_MAP(pcifunc, 0);
1603                         nix_reset_tx_linkcfg(rvu, blkaddr, lvl, schq);
1604                         nix_reset_tx_shaping(rvu, blkaddr, lvl, schq);
1605                 }
1606         }
1607
1608         rsp->aggr_level = hw->cap.nix_tx_aggr_lvl;
1609         rsp->aggr_lvl_rr_prio = TXSCH_TL1_DFLT_RR_PRIO;
1610         rsp->link_cfg_lvl = rvu_read64(rvu, blkaddr,
1611                                        NIX_AF_PSE_CHANNEL_LEVEL) & 0x01 ?
1612                                        NIX_TXSCH_LVL_TL3 : NIX_TXSCH_LVL_TL2;
1613         goto exit;
1614 err:
1615         rc = NIX_AF_ERR_TLX_ALLOC_FAIL;
1616 exit:
1617         mutex_unlock(&rvu->rsrc_lock);
1618         return rc;
1619 }
1620
1621 static void nix_smq_flush(struct rvu *rvu, int blkaddr,
1622                           int smq, u16 pcifunc, int nixlf)
1623 {
1624         int pf = rvu_get_pf(pcifunc);
1625         u8 cgx_id = 0, lmac_id = 0;
1626         int err, restore_tx_en = 0;
1627         u64 cfg;
1628
1629         /* enable cgx tx if disabled */
1630         if (is_pf_cgxmapped(rvu, pf)) {
1631                 rvu_get_cgx_lmac_id(rvu->pf2cgxlmac_map[pf], &cgx_id, &lmac_id);
1632                 restore_tx_en = !cgx_lmac_tx_enable(rvu_cgx_pdata(cgx_id, rvu),
1633                                                     lmac_id, true);
1634         }
1635
1636         cfg = rvu_read64(rvu, blkaddr, NIX_AF_SMQX_CFG(smq));
1637         /* Do SMQ flush and set enqueue xoff */
1638         cfg |= BIT_ULL(50) | BIT_ULL(49);
1639         rvu_write64(rvu, blkaddr, NIX_AF_SMQX_CFG(smq), cfg);
1640
1641         /* Disable backpressure from physical link,
1642          * otherwise SMQ flush may stall.
1643          */
1644         rvu_cgx_enadis_rx_bp(rvu, pf, false);
1645
1646         /* Wait for flush to complete */
1647         err = rvu_poll_reg(rvu, blkaddr,
1648                            NIX_AF_SMQX_CFG(smq), BIT_ULL(49), true);
1649         if (err)
1650                 dev_err(rvu->dev,
1651                         "NIXLF%d: SMQ%d flush failed\n", nixlf, smq);
1652
1653         rvu_cgx_enadis_rx_bp(rvu, pf, true);
1654         /* restore cgx tx state */
1655         if (restore_tx_en)
1656                 cgx_lmac_tx_enable(rvu_cgx_pdata(cgx_id, rvu), lmac_id, false);
1657 }
1658
1659 static int nix_txschq_free(struct rvu *rvu, u16 pcifunc)
1660 {
1661         int blkaddr, nixlf, lvl, schq, err;
1662         struct rvu_hwinfo *hw = rvu->hw;
1663         struct nix_txsch *txsch;
1664         struct nix_hw *nix_hw;
1665
1666         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
1667         if (blkaddr < 0)
1668                 return NIX_AF_ERR_AF_LF_INVALID;
1669
1670         nix_hw = get_nix_hw(rvu->hw, blkaddr);
1671         if (!nix_hw)
1672                 return -EINVAL;
1673
1674         nixlf = rvu_get_lf(rvu, &hw->block[blkaddr], pcifunc, 0);
1675         if (nixlf < 0)
1676                 return NIX_AF_ERR_AF_LF_INVALID;
1677
1678         /* Disable TL2/3 queue links before SMQ flush*/
1679         mutex_lock(&rvu->rsrc_lock);
1680         for (lvl = NIX_TXSCH_LVL_TL4; lvl < NIX_TXSCH_LVL_CNT; lvl++) {
1681                 if (lvl != NIX_TXSCH_LVL_TL2 && lvl != NIX_TXSCH_LVL_TL4)
1682                         continue;
1683
1684                 txsch = &nix_hw->txsch[lvl];
1685                 for (schq = 0; schq < txsch->schq.max; schq++) {
1686                         if (TXSCH_MAP_FUNC(txsch->pfvf_map[schq]) != pcifunc)
1687                                 continue;
1688                         nix_reset_tx_linkcfg(rvu, blkaddr, lvl, schq);
1689                 }
1690         }
1691
1692         /* Flush SMQs */
1693         txsch = &nix_hw->txsch[NIX_TXSCH_LVL_SMQ];
1694         for (schq = 0; schq < txsch->schq.max; schq++) {
1695                 if (TXSCH_MAP_FUNC(txsch->pfvf_map[schq]) != pcifunc)
1696                         continue;
1697                 nix_smq_flush(rvu, blkaddr, schq, pcifunc, nixlf);
1698         }
1699
1700         /* Now free scheduler queues to free pool */
1701         for (lvl = 0; lvl < NIX_TXSCH_LVL_CNT; lvl++) {
1702                  /* TLs above aggregation level are shared across all PF
1703                   * and it's VFs, hence skip freeing them.
1704                   */
1705                 if (lvl >= hw->cap.nix_tx_aggr_lvl)
1706                         continue;
1707
1708                 txsch = &nix_hw->txsch[lvl];
1709                 for (schq = 0; schq < txsch->schq.max; schq++) {
1710                         if (TXSCH_MAP_FUNC(txsch->pfvf_map[schq]) != pcifunc)
1711                                 continue;
1712                         rvu_free_rsrc(&txsch->schq, schq);
1713                         txsch->pfvf_map[schq] = TXSCH_MAP(0, NIX_TXSCHQ_FREE);
1714                 }
1715         }
1716         mutex_unlock(&rvu->rsrc_lock);
1717
1718         /* Sync cached info for this LF in NDC-TX to LLC/DRAM */
1719         rvu_write64(rvu, blkaddr, NIX_AF_NDC_TX_SYNC, BIT_ULL(12) | nixlf);
1720         err = rvu_poll_reg(rvu, blkaddr, NIX_AF_NDC_TX_SYNC, BIT_ULL(12), true);
1721         if (err)
1722                 dev_err(rvu->dev, "NDC-TX sync failed for NIXLF %d\n", nixlf);
1723
1724         return 0;
1725 }
1726
1727 static int nix_txschq_free_one(struct rvu *rvu,
1728                                struct nix_txsch_free_req *req)
1729 {
1730         struct rvu_hwinfo *hw = rvu->hw;
1731         u16 pcifunc = req->hdr.pcifunc;
1732         int lvl, schq, nixlf, blkaddr;
1733         struct nix_txsch *txsch;
1734         struct nix_hw *nix_hw;
1735         u32 *pfvf_map;
1736
1737         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
1738         if (blkaddr < 0)
1739                 return NIX_AF_ERR_AF_LF_INVALID;
1740
1741         nix_hw = get_nix_hw(rvu->hw, blkaddr);
1742         if (!nix_hw)
1743                 return -EINVAL;
1744
1745         nixlf = rvu_get_lf(rvu, &hw->block[blkaddr], pcifunc, 0);
1746         if (nixlf < 0)
1747                 return NIX_AF_ERR_AF_LF_INVALID;
1748
1749         lvl = req->schq_lvl;
1750         schq = req->schq;
1751         txsch = &nix_hw->txsch[lvl];
1752
1753         if (lvl >= hw->cap.nix_tx_aggr_lvl || schq >= txsch->schq.max)
1754                 return 0;
1755
1756         pfvf_map = txsch->pfvf_map;
1757         mutex_lock(&rvu->rsrc_lock);
1758
1759         if (TXSCH_MAP_FUNC(pfvf_map[schq]) != pcifunc) {
1760                 mutex_unlock(&rvu->rsrc_lock);
1761                 goto err;
1762         }
1763
1764         /* Flush if it is a SMQ. Onus of disabling
1765          * TL2/3 queue links before SMQ flush is on user
1766          */
1767         if (lvl == NIX_TXSCH_LVL_SMQ)
1768                 nix_smq_flush(rvu, blkaddr, schq, pcifunc, nixlf);
1769
1770         /* Free the resource */
1771         rvu_free_rsrc(&txsch->schq, schq);
1772         txsch->pfvf_map[schq] = TXSCH_MAP(0, NIX_TXSCHQ_FREE);
1773         mutex_unlock(&rvu->rsrc_lock);
1774         return 0;
1775 err:
1776         return NIX_AF_ERR_TLX_INVALID;
1777 }
1778
1779 int rvu_mbox_handler_nix_txsch_free(struct rvu *rvu,
1780                                     struct nix_txsch_free_req *req,
1781                                     struct msg_rsp *rsp)
1782 {
1783         if (req->flags & TXSCHQ_FREE_ALL)
1784                 return nix_txschq_free(rvu, req->hdr.pcifunc);
1785         else
1786                 return nix_txschq_free_one(rvu, req);
1787 }
1788
1789 static bool is_txschq_hierarchy_valid(struct rvu *rvu, u16 pcifunc, int blkaddr,
1790                                       int lvl, u64 reg, u64 regval)
1791 {
1792         u64 regbase = reg & 0xFFFF;
1793         u16 schq, parent;
1794
1795         if (!rvu_check_valid_reg(TXSCHQ_HWREGMAP, lvl, reg))
1796                 return false;
1797
1798         schq = TXSCHQ_IDX(reg, TXSCHQ_IDX_SHIFT);
1799         /* Check if this schq belongs to this PF/VF or not */
1800         if (!is_valid_txschq(rvu, blkaddr, lvl, pcifunc, schq))
1801                 return false;
1802
1803         parent = (regval >> 16) & 0x1FF;
1804         /* Validate MDQ's TL4 parent */
1805         if (regbase == NIX_AF_MDQX_PARENT(0) &&
1806             !is_valid_txschq(rvu, blkaddr, NIX_TXSCH_LVL_TL4, pcifunc, parent))
1807                 return false;
1808
1809         /* Validate TL4's TL3 parent */
1810         if (regbase == NIX_AF_TL4X_PARENT(0) &&
1811             !is_valid_txschq(rvu, blkaddr, NIX_TXSCH_LVL_TL3, pcifunc, parent))
1812                 return false;
1813
1814         /* Validate TL3's TL2 parent */
1815         if (regbase == NIX_AF_TL3X_PARENT(0) &&
1816             !is_valid_txschq(rvu, blkaddr, NIX_TXSCH_LVL_TL2, pcifunc, parent))
1817                 return false;
1818
1819         /* Validate TL2's TL1 parent */
1820         if (regbase == NIX_AF_TL2X_PARENT(0) &&
1821             !is_valid_txschq(rvu, blkaddr, NIX_TXSCH_LVL_TL1, pcifunc, parent))
1822                 return false;
1823
1824         return true;
1825 }
1826
1827 static bool is_txschq_shaping_valid(struct rvu_hwinfo *hw, int lvl, u64 reg)
1828 {
1829         u64 regbase;
1830
1831         if (hw->cap.nix_shaping)
1832                 return true;
1833
1834         /* If shaping and coloring is not supported, then
1835          * *_CIR and *_PIR registers should not be configured.
1836          */
1837         regbase = reg & 0xFFFF;
1838
1839         switch (lvl) {
1840         case NIX_TXSCH_LVL_TL1:
1841                 if (regbase == NIX_AF_TL1X_CIR(0))
1842                         return false;
1843                 break;
1844         case NIX_TXSCH_LVL_TL2:
1845                 if (regbase == NIX_AF_TL2X_CIR(0) ||
1846                     regbase == NIX_AF_TL2X_PIR(0))
1847                         return false;
1848                 break;
1849         case NIX_TXSCH_LVL_TL3:
1850                 if (regbase == NIX_AF_TL3X_CIR(0) ||
1851                     regbase == NIX_AF_TL3X_PIR(0))
1852                         return false;
1853                 break;
1854         case NIX_TXSCH_LVL_TL4:
1855                 if (regbase == NIX_AF_TL4X_CIR(0) ||
1856                     regbase == NIX_AF_TL4X_PIR(0))
1857                         return false;
1858                 break;
1859         }
1860         return true;
1861 }
1862
1863 static void nix_tl1_default_cfg(struct rvu *rvu, struct nix_hw *nix_hw,
1864                                 u16 pcifunc, int blkaddr)
1865 {
1866         u32 *pfvf_map;
1867         int schq;
1868
1869         schq = nix_get_tx_link(rvu, pcifunc);
1870         pfvf_map = nix_hw->txsch[NIX_TXSCH_LVL_TL1].pfvf_map;
1871         /* Skip if PF has already done the config */
1872         if (TXSCH_MAP_FLAGS(pfvf_map[schq]) & NIX_TXSCHQ_CFG_DONE)
1873                 return;
1874         rvu_write64(rvu, blkaddr, NIX_AF_TL1X_TOPOLOGY(schq),
1875                     (TXSCH_TL1_DFLT_RR_PRIO << 1));
1876         rvu_write64(rvu, blkaddr, NIX_AF_TL1X_SCHEDULE(schq),
1877                     TXSCH_TL1_DFLT_RR_QTM);
1878         rvu_write64(rvu, blkaddr, NIX_AF_TL1X_CIR(schq), 0x00);
1879         pfvf_map[schq] = TXSCH_SET_FLAG(pfvf_map[schq], NIX_TXSCHQ_CFG_DONE);
1880 }
1881
1882 int rvu_mbox_handler_nix_txschq_cfg(struct rvu *rvu,
1883                                     struct nix_txschq_config *req,
1884                                     struct msg_rsp *rsp)
1885 {
1886         struct rvu_hwinfo *hw = rvu->hw;
1887         u16 pcifunc = req->hdr.pcifunc;
1888         u64 reg, regval, schq_regbase;
1889         struct nix_txsch *txsch;
1890         struct nix_hw *nix_hw;
1891         int blkaddr, idx, err;
1892         int nixlf, schq;
1893         u32 *pfvf_map;
1894
1895         if (req->lvl >= NIX_TXSCH_LVL_CNT ||
1896             req->num_regs > MAX_REGS_PER_MBOX_MSG)
1897                 return NIX_AF_INVAL_TXSCHQ_CFG;
1898
1899         err = nix_get_nixlf(rvu, pcifunc, &nixlf, &blkaddr);
1900         if (err)
1901                 return err;
1902
1903         nix_hw = get_nix_hw(rvu->hw, blkaddr);
1904         if (!nix_hw)
1905                 return -EINVAL;
1906
1907         txsch = &nix_hw->txsch[req->lvl];
1908         pfvf_map = txsch->pfvf_map;
1909
1910         if (req->lvl >= hw->cap.nix_tx_aggr_lvl &&
1911             pcifunc & RVU_PFVF_FUNC_MASK) {
1912                 mutex_lock(&rvu->rsrc_lock);
1913                 if (req->lvl == NIX_TXSCH_LVL_TL1)
1914                         nix_tl1_default_cfg(rvu, nix_hw, pcifunc, blkaddr);
1915                 mutex_unlock(&rvu->rsrc_lock);
1916                 return 0;
1917         }
1918
1919         for (idx = 0; idx < req->num_regs; idx++) {
1920                 reg = req->reg[idx];
1921                 regval = req->regval[idx];
1922                 schq_regbase = reg & 0xFFFF;
1923
1924                 if (!is_txschq_hierarchy_valid(rvu, pcifunc, blkaddr,
1925                                                txsch->lvl, reg, regval))
1926                         return NIX_AF_INVAL_TXSCHQ_CFG;
1927
1928                 /* Check if shaping and coloring is supported */
1929                 if (!is_txschq_shaping_valid(hw, req->lvl, reg))
1930                         continue;
1931
1932                 /* Replace PF/VF visible NIXLF slot with HW NIXLF id */
1933                 if (schq_regbase == NIX_AF_SMQX_CFG(0)) {
1934                         nixlf = rvu_get_lf(rvu, &hw->block[blkaddr],
1935                                            pcifunc, 0);
1936                         regval &= ~(0x7FULL << 24);
1937                         regval |= ((u64)nixlf << 24);
1938                 }
1939
1940                 /* Clear 'BP_ENA' config, if it's not allowed */
1941                 if (!hw->cap.nix_tx_link_bp) {
1942                         if (schq_regbase == NIX_AF_TL4X_SDP_LINK_CFG(0) ||
1943                             (schq_regbase & 0xFF00) ==
1944                             NIX_AF_TL3_TL2X_LINKX_CFG(0, 0))
1945                                 regval &= ~BIT_ULL(13);
1946                 }
1947
1948                 /* Mark config as done for TL1 by PF */
1949                 if (schq_regbase >= NIX_AF_TL1X_SCHEDULE(0) &&
1950                     schq_regbase <= NIX_AF_TL1X_GREEN_BYTES(0)) {
1951                         schq = TXSCHQ_IDX(reg, TXSCHQ_IDX_SHIFT);
1952                         mutex_lock(&rvu->rsrc_lock);
1953                         pfvf_map[schq] = TXSCH_SET_FLAG(pfvf_map[schq],
1954                                                         NIX_TXSCHQ_CFG_DONE);
1955                         mutex_unlock(&rvu->rsrc_lock);
1956                 }
1957
1958                 /* SMQ flush is special hence split register writes such
1959                  * that flush first and write rest of the bits later.
1960                  */
1961                 if (schq_regbase == NIX_AF_SMQX_CFG(0) &&
1962                     (regval & BIT_ULL(49))) {
1963                         schq = TXSCHQ_IDX(reg, TXSCHQ_IDX_SHIFT);
1964                         nix_smq_flush(rvu, blkaddr, schq, pcifunc, nixlf);
1965                         regval &= ~BIT_ULL(49);
1966                 }
1967                 rvu_write64(rvu, blkaddr, reg, regval);
1968         }
1969
1970         return 0;
1971 }
1972
1973 static int nix_rx_vtag_cfg(struct rvu *rvu, int nixlf, int blkaddr,
1974                            struct nix_vtag_config *req)
1975 {
1976         u64 regval = req->vtag_size;
1977
1978         if (req->rx.vtag_type > 7 || req->vtag_size > VTAGSIZE_T8)
1979                 return -EINVAL;
1980
1981         if (req->rx.capture_vtag)
1982                 regval |= BIT_ULL(5);
1983         if (req->rx.strip_vtag)
1984                 regval |= BIT_ULL(4);
1985
1986         rvu_write64(rvu, blkaddr,
1987                     NIX_AF_LFX_RX_VTAG_TYPEX(nixlf, req->rx.vtag_type), regval);
1988         return 0;
1989 }
1990
1991 int rvu_mbox_handler_nix_vtag_cfg(struct rvu *rvu,
1992                                   struct nix_vtag_config *req,
1993                                   struct msg_rsp *rsp)
1994 {
1995         u16 pcifunc = req->hdr.pcifunc;
1996         int blkaddr, nixlf, err;
1997
1998         err = nix_get_nixlf(rvu, pcifunc, &nixlf, &blkaddr);
1999         if (err)
2000                 return err;
2001
2002         if (req->cfg_type) {
2003                 err = nix_rx_vtag_cfg(rvu, nixlf, blkaddr, req);
2004                 if (err)
2005                         return NIX_AF_ERR_PARAM;
2006         } else {
2007                 /* TODO: handle tx vtag configuration */
2008                 return 0;
2009         }
2010
2011         return 0;
2012 }
2013
2014 static int nix_blk_setup_mce(struct rvu *rvu, struct nix_hw *nix_hw,
2015                              int mce, u8 op, u16 pcifunc, int next, bool eol)
2016 {
2017         struct nix_aq_enq_req aq_req;
2018         int err;
2019
2020         aq_req.hdr.pcifunc = 0;
2021         aq_req.ctype = NIX_AQ_CTYPE_MCE;
2022         aq_req.op = op;
2023         aq_req.qidx = mce;
2024
2025         /* Forward bcast pkts to RQ0, RSS not needed */
2026         aq_req.mce.op = 0;
2027         aq_req.mce.index = 0;
2028         aq_req.mce.eol = eol;
2029         aq_req.mce.pf_func = pcifunc;
2030         aq_req.mce.next = next;
2031
2032         /* All fields valid */
2033         *(u64 *)(&aq_req.mce_mask) = ~0ULL;
2034
2035         err = rvu_nix_blk_aq_enq_inst(rvu, nix_hw, &aq_req, NULL);
2036         if (err) {
2037                 dev_err(rvu->dev, "Failed to setup Bcast MCE for PF%d:VF%d\n",
2038                         rvu_get_pf(pcifunc), pcifunc & RVU_PFVF_FUNC_MASK);
2039                 return err;
2040         }
2041         return 0;
2042 }
2043
2044 static int nix_update_mce_list(struct nix_mce_list *mce_list,
2045                                u16 pcifunc, bool add)
2046 {
2047         struct mce *mce, *tail = NULL;
2048         bool delete = false;
2049
2050         /* Scan through the current list */
2051         hlist_for_each_entry(mce, &mce_list->head, node) {
2052                 /* If already exists, then delete */
2053                 if (mce->pcifunc == pcifunc && !add) {
2054                         delete = true;
2055                         break;
2056                 }
2057                 tail = mce;
2058         }
2059
2060         if (delete) {
2061                 hlist_del(&mce->node);
2062                 kfree(mce);
2063                 mce_list->count--;
2064                 return 0;
2065         }
2066
2067         if (!add)
2068                 return 0;
2069
2070         /* Add a new one to the list, at the tail */
2071         mce = kzalloc(sizeof(*mce), GFP_KERNEL);
2072         if (!mce)
2073                 return -ENOMEM;
2074         mce->pcifunc = pcifunc;
2075         if (!tail)
2076                 hlist_add_head(&mce->node, &mce_list->head);
2077         else
2078                 hlist_add_behind(&mce->node, &tail->node);
2079         mce_list->count++;
2080         return 0;
2081 }
2082
2083 int nix_update_bcast_mce_list(struct rvu *rvu, u16 pcifunc, bool add)
2084 {
2085         int err = 0, idx, next_idx, last_idx;
2086         struct nix_mce_list *mce_list;
2087         struct nix_mcast *mcast;
2088         struct nix_hw *nix_hw;
2089         struct rvu_pfvf *pfvf;
2090         struct mce *mce;
2091         int blkaddr;
2092
2093         /* Broadcast pkt replication is not needed for AF's VFs, hence skip */
2094         if (is_afvf(pcifunc))
2095                 return 0;
2096
2097         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
2098         if (blkaddr < 0)
2099                 return 0;
2100
2101         nix_hw = get_nix_hw(rvu->hw, blkaddr);
2102         if (!nix_hw)
2103                 return 0;
2104
2105         mcast = &nix_hw->mcast;
2106
2107         /* Get this PF/VF func's MCE index */
2108         pfvf = rvu_get_pfvf(rvu, pcifunc & ~RVU_PFVF_FUNC_MASK);
2109         idx = pfvf->bcast_mce_idx + (pcifunc & RVU_PFVF_FUNC_MASK);
2110
2111         mce_list = &pfvf->bcast_mce_list;
2112         if (idx > (pfvf->bcast_mce_idx + mce_list->max)) {
2113                 dev_err(rvu->dev,
2114                         "%s: Idx %d > max MCE idx %d, for PF%d bcast list\n",
2115                         __func__, idx, mce_list->max,
2116                         pcifunc >> RVU_PFVF_PF_SHIFT);
2117                 return -EINVAL;
2118         }
2119
2120         mutex_lock(&mcast->mce_lock);
2121
2122         err = nix_update_mce_list(mce_list, pcifunc, add);
2123         if (err)
2124                 goto end;
2125
2126         /* Disable MCAM entry in NPC */
2127         if (!mce_list->count) {
2128                 rvu_npc_enable_bcast_entry(rvu, pcifunc, false);
2129                 goto end;
2130         }
2131
2132         /* Dump the updated list to HW */
2133         idx = pfvf->bcast_mce_idx;
2134         last_idx = idx + mce_list->count - 1;
2135         hlist_for_each_entry(mce, &mce_list->head, node) {
2136                 if (idx > last_idx)
2137                         break;
2138
2139                 next_idx = idx + 1;
2140                 /* EOL should be set in last MCE */
2141                 err = nix_blk_setup_mce(rvu, nix_hw, idx, NIX_AQ_INSTOP_WRITE,
2142                                         mce->pcifunc, next_idx,
2143                                         (next_idx > last_idx) ? true : false);
2144                 if (err)
2145                         goto end;
2146                 idx++;
2147         }
2148
2149 end:
2150         mutex_unlock(&mcast->mce_lock);
2151         return err;
2152 }
2153
2154 static int nix_setup_bcast_tables(struct rvu *rvu, struct nix_hw *nix_hw)
2155 {
2156         struct nix_mcast *mcast = &nix_hw->mcast;
2157         int err, pf, numvfs, idx;
2158         struct rvu_pfvf *pfvf;
2159         u16 pcifunc;
2160         u64 cfg;
2161
2162         /* Skip PF0 (i.e AF) */
2163         for (pf = 1; pf < (rvu->cgx_mapped_pfs + 1); pf++) {
2164                 cfg = rvu_read64(rvu, BLKADDR_RVUM, RVU_PRIV_PFX_CFG(pf));
2165                 /* If PF is not enabled, nothing to do */
2166                 if (!((cfg >> 20) & 0x01))
2167                         continue;
2168                 /* Get numVFs attached to this PF */
2169                 numvfs = (cfg >> 12) & 0xFF;
2170
2171                 pfvf = &rvu->pf[pf];
2172
2173                 /* This NIX0/1 block mapped to PF ? */
2174                 if (pfvf->nix_blkaddr != nix_hw->blkaddr)
2175                         continue;
2176
2177                 /* Save the start MCE */
2178                 pfvf->bcast_mce_idx = nix_alloc_mce_list(mcast, numvfs + 1);
2179
2180                 nix_mce_list_init(&pfvf->bcast_mce_list, numvfs + 1);
2181
2182                 for (idx = 0; idx < (numvfs + 1); idx++) {
2183                         /* idx-0 is for PF, followed by VFs */
2184                         pcifunc = (pf << RVU_PFVF_PF_SHIFT);
2185                         pcifunc |= idx;
2186                         /* Add dummy entries now, so that we don't have to check
2187                          * for whether AQ_OP should be INIT/WRITE later on.
2188                          * Will be updated when a NIXLF is attached/detached to
2189                          * these PF/VFs.
2190                          */
2191                         err = nix_blk_setup_mce(rvu, nix_hw,
2192                                                 pfvf->bcast_mce_idx + idx,
2193                                                 NIX_AQ_INSTOP_INIT,
2194                                                 pcifunc, 0, true);
2195                         if (err)
2196                                 return err;
2197                 }
2198         }
2199         return 0;
2200 }
2201
2202 static int nix_setup_mcast(struct rvu *rvu, struct nix_hw *nix_hw, int blkaddr)
2203 {
2204         struct nix_mcast *mcast = &nix_hw->mcast;
2205         struct rvu_hwinfo *hw = rvu->hw;
2206         int err, size;
2207
2208         size = (rvu_read64(rvu, blkaddr, NIX_AF_CONST3) >> 16) & 0x0F;
2209         size = (1ULL << size);
2210
2211         /* Alloc memory for multicast/mirror replication entries */
2212         err = qmem_alloc(rvu->dev, &mcast->mce_ctx,
2213                          (256UL << MC_TBL_SIZE), size);
2214         if (err)
2215                 return -ENOMEM;
2216
2217         rvu_write64(rvu, blkaddr, NIX_AF_RX_MCAST_BASE,
2218                     (u64)mcast->mce_ctx->iova);
2219
2220         /* Set max list length equal to max no of VFs per PF  + PF itself */
2221         rvu_write64(rvu, blkaddr, NIX_AF_RX_MCAST_CFG,
2222                     BIT_ULL(36) | (hw->max_vfs_per_pf << 4) | MC_TBL_SIZE);
2223
2224         /* Alloc memory for multicast replication buffers */
2225         size = rvu_read64(rvu, blkaddr, NIX_AF_MC_MIRROR_CONST) & 0xFFFF;
2226         err = qmem_alloc(rvu->dev, &mcast->mcast_buf,
2227                          (8UL << MC_BUF_CNT), size);
2228         if (err)
2229                 return -ENOMEM;
2230
2231         rvu_write64(rvu, blkaddr, NIX_AF_RX_MCAST_BUF_BASE,
2232                     (u64)mcast->mcast_buf->iova);
2233
2234         /* Alloc pkind for NIX internal RX multicast/mirror replay */
2235         mcast->replay_pkind = rvu_alloc_rsrc(&hw->pkind.rsrc);
2236
2237         rvu_write64(rvu, blkaddr, NIX_AF_RX_MCAST_BUF_CFG,
2238                     BIT_ULL(63) | (mcast->replay_pkind << 24) |
2239                     BIT_ULL(20) | MC_BUF_CNT);
2240
2241         mutex_init(&mcast->mce_lock);
2242
2243         return nix_setup_bcast_tables(rvu, nix_hw);
2244 }
2245
2246 static int nix_setup_txschq(struct rvu *rvu, struct nix_hw *nix_hw, int blkaddr)
2247 {
2248         struct nix_txsch *txsch;
2249         int err, lvl, schq;
2250         u64 cfg, reg;
2251
2252         /* Get scheduler queue count of each type and alloc
2253          * bitmap for each for alloc/free/attach operations.
2254          */
2255         for (lvl = 0; lvl < NIX_TXSCH_LVL_CNT; lvl++) {
2256                 txsch = &nix_hw->txsch[lvl];
2257                 txsch->lvl = lvl;
2258                 switch (lvl) {
2259                 case NIX_TXSCH_LVL_SMQ:
2260                         reg = NIX_AF_MDQ_CONST;
2261                         break;
2262                 case NIX_TXSCH_LVL_TL4:
2263                         reg = NIX_AF_TL4_CONST;
2264                         break;
2265                 case NIX_TXSCH_LVL_TL3:
2266                         reg = NIX_AF_TL3_CONST;
2267                         break;
2268                 case NIX_TXSCH_LVL_TL2:
2269                         reg = NIX_AF_TL2_CONST;
2270                         break;
2271                 case NIX_TXSCH_LVL_TL1:
2272                         reg = NIX_AF_TL1_CONST;
2273                         break;
2274                 }
2275                 cfg = rvu_read64(rvu, blkaddr, reg);
2276                 txsch->schq.max = cfg & 0xFFFF;
2277                 err = rvu_alloc_bitmap(&txsch->schq);
2278                 if (err)
2279                         return err;
2280
2281                 /* Allocate memory for scheduler queues to
2282                  * PF/VF pcifunc mapping info.
2283                  */
2284                 txsch->pfvf_map = devm_kcalloc(rvu->dev, txsch->schq.max,
2285                                                sizeof(u32), GFP_KERNEL);
2286                 if (!txsch->pfvf_map)
2287                         return -ENOMEM;
2288                 for (schq = 0; schq < txsch->schq.max; schq++)
2289                         txsch->pfvf_map[schq] = TXSCH_MAP(0, NIX_TXSCHQ_FREE);
2290         }
2291         return 0;
2292 }
2293
2294 int rvu_nix_reserve_mark_format(struct rvu *rvu, struct nix_hw *nix_hw,
2295                                 int blkaddr, u32 cfg)
2296 {
2297         int fmt_idx;
2298
2299         for (fmt_idx = 0; fmt_idx < nix_hw->mark_format.in_use; fmt_idx++) {
2300                 if (nix_hw->mark_format.cfg[fmt_idx] == cfg)
2301                         return fmt_idx;
2302         }
2303         if (fmt_idx >= nix_hw->mark_format.total)
2304                 return -ERANGE;
2305
2306         rvu_write64(rvu, blkaddr, NIX_AF_MARK_FORMATX_CTL(fmt_idx), cfg);
2307         nix_hw->mark_format.cfg[fmt_idx] = cfg;
2308         nix_hw->mark_format.in_use++;
2309         return fmt_idx;
2310 }
2311
2312 static int nix_af_mark_format_setup(struct rvu *rvu, struct nix_hw *nix_hw,
2313                                     int blkaddr)
2314 {
2315         u64 cfgs[] = {
2316                 [NIX_MARK_CFG_IP_DSCP_RED]         = 0x10003,
2317                 [NIX_MARK_CFG_IP_DSCP_YELLOW]      = 0x11200,
2318                 [NIX_MARK_CFG_IP_DSCP_YELLOW_RED]  = 0x11203,
2319                 [NIX_MARK_CFG_IP_ECN_RED]          = 0x6000c,
2320                 [NIX_MARK_CFG_IP_ECN_YELLOW]       = 0x60c00,
2321                 [NIX_MARK_CFG_IP_ECN_YELLOW_RED]   = 0x60c0c,
2322                 [NIX_MARK_CFG_VLAN_DEI_RED]        = 0x30008,
2323                 [NIX_MARK_CFG_VLAN_DEI_YELLOW]     = 0x30800,
2324                 [NIX_MARK_CFG_VLAN_DEI_YELLOW_RED] = 0x30808,
2325         };
2326         int i, rc;
2327         u64 total;
2328
2329         total = (rvu_read64(rvu, blkaddr, NIX_AF_PSE_CONST) & 0xFF00) >> 8;
2330         nix_hw->mark_format.total = (u8)total;
2331         nix_hw->mark_format.cfg = devm_kcalloc(rvu->dev, total, sizeof(u32),
2332                                                GFP_KERNEL);
2333         if (!nix_hw->mark_format.cfg)
2334                 return -ENOMEM;
2335         for (i = 0; i < NIX_MARK_CFG_MAX; i++) {
2336                 rc = rvu_nix_reserve_mark_format(rvu, nix_hw, blkaddr, cfgs[i]);
2337                 if (rc < 0)
2338                         dev_err(rvu->dev, "Err %d in setup mark format %d\n",
2339                                 i, rc);
2340         }
2341
2342         return 0;
2343 }
2344
2345 int rvu_mbox_handler_nix_stats_rst(struct rvu *rvu, struct msg_req *req,
2346                                    struct msg_rsp *rsp)
2347 {
2348         u16 pcifunc = req->hdr.pcifunc;
2349         int i, nixlf, blkaddr, err;
2350         u64 stats;
2351
2352         err = nix_get_nixlf(rvu, pcifunc, &nixlf, &blkaddr);
2353         if (err)
2354                 return err;
2355
2356         /* Get stats count supported by HW */
2357         stats = rvu_read64(rvu, blkaddr, NIX_AF_CONST1);
2358
2359         /* Reset tx stats */
2360         for (i = 0; i < ((stats >> 24) & 0xFF); i++)
2361                 rvu_write64(rvu, blkaddr, NIX_AF_LFX_TX_STATX(nixlf, i), 0);
2362
2363         /* Reset rx stats */
2364         for (i = 0; i < ((stats >> 32) & 0xFF); i++)
2365                 rvu_write64(rvu, blkaddr, NIX_AF_LFX_RX_STATX(nixlf, i), 0);
2366
2367         return 0;
2368 }
2369
2370 /* Returns the ALG index to be set into NPC_RX_ACTION */
2371 static int get_flowkey_alg_idx(struct nix_hw *nix_hw, u32 flow_cfg)
2372 {
2373         int i;
2374
2375         /* Scan over exiting algo entries to find a match */
2376         for (i = 0; i < nix_hw->flowkey.in_use; i++)
2377                 if (nix_hw->flowkey.flowkey[i] == flow_cfg)
2378                         return i;
2379
2380         return -ERANGE;
2381 }
2382
2383 static int set_flowkey_fields(struct nix_rx_flowkey_alg *alg, u32 flow_cfg)
2384 {
2385         int idx, nr_field, key_off, field_marker, keyoff_marker;
2386         int max_key_off, max_bit_pos, group_member;
2387         struct nix_rx_flowkey_alg *field;
2388         struct nix_rx_flowkey_alg tmp;
2389         u32 key_type, valid_key;
2390
2391         if (!alg)
2392                 return -EINVAL;
2393
2394 #define FIELDS_PER_ALG  5
2395 #define MAX_KEY_OFF     40
2396         /* Clear all fields */
2397         memset(alg, 0, sizeof(uint64_t) * FIELDS_PER_ALG);
2398
2399         /* Each of the 32 possible flow key algorithm definitions should
2400          * fall into above incremental config (except ALG0). Otherwise a
2401          * single NPC MCAM entry is not sufficient for supporting RSS.
2402          *
2403          * If a different definition or combination needed then NPC MCAM
2404          * has to be programmed to filter such pkts and it's action should
2405          * point to this definition to calculate flowtag or hash.
2406          *
2407          * The `for loop` goes over _all_ protocol field and the following
2408          * variables depicts the state machine forward progress logic.
2409          *
2410          * keyoff_marker - Enabled when hash byte length needs to be accounted
2411          * in field->key_offset update.
2412          * field_marker - Enabled when a new field needs to be selected.
2413          * group_member - Enabled when protocol is part of a group.
2414          */
2415
2416         keyoff_marker = 0; max_key_off = 0; group_member = 0;
2417         nr_field = 0; key_off = 0; field_marker = 1;
2418         field = &tmp; max_bit_pos = fls(flow_cfg);
2419         for (idx = 0;
2420              idx < max_bit_pos && nr_field < FIELDS_PER_ALG &&
2421              key_off < MAX_KEY_OFF; idx++) {
2422                 key_type = BIT(idx);
2423                 valid_key = flow_cfg & key_type;
2424                 /* Found a field marker, reset the field values */
2425                 if (field_marker)
2426                         memset(&tmp, 0, sizeof(tmp));
2427
2428                 field_marker = true;
2429                 keyoff_marker = true;
2430                 switch (key_type) {
2431                 case NIX_FLOW_KEY_TYPE_PORT:
2432                         field->sel_chan = true;
2433                         /* This should be set to 1, when SEL_CHAN is set */
2434                         field->bytesm1 = 1;
2435                         break;
2436                 case NIX_FLOW_KEY_TYPE_IPV4:
2437                 case NIX_FLOW_KEY_TYPE_INNR_IPV4:
2438                         field->lid = NPC_LID_LC;
2439                         field->ltype_match = NPC_LT_LC_IP;
2440                         if (key_type == NIX_FLOW_KEY_TYPE_INNR_IPV4) {
2441                                 field->lid = NPC_LID_LG;
2442                                 field->ltype_match = NPC_LT_LG_TU_IP;
2443                         }
2444                         field->hdr_offset = 12; /* SIP offset */
2445                         field->bytesm1 = 7; /* SIP + DIP, 8 bytes */
2446                         field->ltype_mask = 0xF; /* Match only IPv4 */
2447                         keyoff_marker = false;
2448                         break;
2449                 case NIX_FLOW_KEY_TYPE_IPV6:
2450                 case NIX_FLOW_KEY_TYPE_INNR_IPV6:
2451                         field->lid = NPC_LID_LC;
2452                         field->ltype_match = NPC_LT_LC_IP6;
2453                         if (key_type == NIX_FLOW_KEY_TYPE_INNR_IPV6) {
2454                                 field->lid = NPC_LID_LG;
2455                                 field->ltype_match = NPC_LT_LG_TU_IP6;
2456                         }
2457                         field->hdr_offset = 8; /* SIP offset */
2458                         field->bytesm1 = 31; /* SIP + DIP, 32 bytes */
2459                         field->ltype_mask = 0xF; /* Match only IPv6 */
2460                         break;
2461                 case NIX_FLOW_KEY_TYPE_TCP:
2462                 case NIX_FLOW_KEY_TYPE_UDP:
2463                 case NIX_FLOW_KEY_TYPE_SCTP:
2464                 case NIX_FLOW_KEY_TYPE_INNR_TCP:
2465                 case NIX_FLOW_KEY_TYPE_INNR_UDP:
2466                 case NIX_FLOW_KEY_TYPE_INNR_SCTP:
2467                         field->lid = NPC_LID_LD;
2468                         if (key_type == NIX_FLOW_KEY_TYPE_INNR_TCP ||
2469                             key_type == NIX_FLOW_KEY_TYPE_INNR_UDP ||
2470                             key_type == NIX_FLOW_KEY_TYPE_INNR_SCTP)
2471                                 field->lid = NPC_LID_LH;
2472                         field->bytesm1 = 3; /* Sport + Dport, 4 bytes */
2473
2474                         /* Enum values for NPC_LID_LD and NPC_LID_LG are same,
2475                          * so no need to change the ltype_match, just change
2476                          * the lid for inner protocols
2477                          */
2478                         BUILD_BUG_ON((int)NPC_LT_LD_TCP !=
2479                                      (int)NPC_LT_LH_TU_TCP);
2480                         BUILD_BUG_ON((int)NPC_LT_LD_UDP !=
2481                                      (int)NPC_LT_LH_TU_UDP);
2482                         BUILD_BUG_ON((int)NPC_LT_LD_SCTP !=
2483                                      (int)NPC_LT_LH_TU_SCTP);
2484
2485                         if ((key_type == NIX_FLOW_KEY_TYPE_TCP ||
2486                              key_type == NIX_FLOW_KEY_TYPE_INNR_TCP) &&
2487                             valid_key) {
2488                                 field->ltype_match |= NPC_LT_LD_TCP;
2489                                 group_member = true;
2490                         } else if ((key_type == NIX_FLOW_KEY_TYPE_UDP ||
2491                                     key_type == NIX_FLOW_KEY_TYPE_INNR_UDP) &&
2492                                    valid_key) {
2493                                 field->ltype_match |= NPC_LT_LD_UDP;
2494                                 group_member = true;
2495                         } else if ((key_type == NIX_FLOW_KEY_TYPE_SCTP ||
2496                                     key_type == NIX_FLOW_KEY_TYPE_INNR_SCTP) &&
2497                                    valid_key) {
2498                                 field->ltype_match |= NPC_LT_LD_SCTP;
2499                                 group_member = true;
2500                         }
2501                         field->ltype_mask = ~field->ltype_match;
2502                         if (key_type == NIX_FLOW_KEY_TYPE_SCTP ||
2503                             key_type == NIX_FLOW_KEY_TYPE_INNR_SCTP) {
2504                                 /* Handle the case where any of the group item
2505                                  * is enabled in the group but not the final one
2506                                  */
2507                                 if (group_member) {
2508                                         valid_key = true;
2509                                         group_member = false;
2510                                 }
2511                         } else {
2512                                 field_marker = false;
2513                                 keyoff_marker = false;
2514                         }
2515                         break;
2516                 case NIX_FLOW_KEY_TYPE_NVGRE:
2517                         field->lid = NPC_LID_LD;
2518                         field->hdr_offset = 4; /* VSID offset */
2519                         field->bytesm1 = 2;
2520                         field->ltype_match = NPC_LT_LD_NVGRE;
2521                         field->ltype_mask = 0xF;
2522                         break;
2523                 case NIX_FLOW_KEY_TYPE_VXLAN:
2524                 case NIX_FLOW_KEY_TYPE_GENEVE:
2525                         field->lid = NPC_LID_LE;
2526                         field->bytesm1 = 2;
2527                         field->hdr_offset = 4;
2528                         field->ltype_mask = 0xF;
2529                         field_marker = false;
2530                         keyoff_marker = false;
2531
2532                         if (key_type == NIX_FLOW_KEY_TYPE_VXLAN && valid_key) {
2533                                 field->ltype_match |= NPC_LT_LE_VXLAN;
2534                                 group_member = true;
2535                         }
2536
2537                         if (key_type == NIX_FLOW_KEY_TYPE_GENEVE && valid_key) {
2538                                 field->ltype_match |= NPC_LT_LE_GENEVE;
2539                                 group_member = true;
2540                         }
2541
2542                         if (key_type == NIX_FLOW_KEY_TYPE_GENEVE) {
2543                                 if (group_member) {
2544                                         field->ltype_mask = ~field->ltype_match;
2545                                         field_marker = true;
2546                                         keyoff_marker = true;
2547                                         valid_key = true;
2548                                         group_member = false;
2549                                 }
2550                         }
2551                         break;
2552                 case NIX_FLOW_KEY_TYPE_ETH_DMAC:
2553                 case NIX_FLOW_KEY_TYPE_INNR_ETH_DMAC:
2554                         field->lid = NPC_LID_LA;
2555                         field->ltype_match = NPC_LT_LA_ETHER;
2556                         if (key_type == NIX_FLOW_KEY_TYPE_INNR_ETH_DMAC) {
2557                                 field->lid = NPC_LID_LF;
2558                                 field->ltype_match = NPC_LT_LF_TU_ETHER;
2559                         }
2560                         field->hdr_offset = 0;
2561                         field->bytesm1 = 5; /* DMAC 6 Byte */
2562                         field->ltype_mask = 0xF;
2563                         break;
2564                 case NIX_FLOW_KEY_TYPE_IPV6_EXT:
2565                         field->lid = NPC_LID_LC;
2566                         field->hdr_offset = 40; /* IPV6 hdr */
2567                         field->bytesm1 = 0; /* 1 Byte ext hdr*/
2568                         field->ltype_match = NPC_LT_LC_IP6_EXT;
2569                         field->ltype_mask = 0xF;
2570                         break;
2571                 case NIX_FLOW_KEY_TYPE_GTPU:
2572                         field->lid = NPC_LID_LE;
2573                         field->hdr_offset = 4;
2574                         field->bytesm1 = 3; /* 4 bytes TID*/
2575                         field->ltype_match = NPC_LT_LE_GTPU;
2576                         field->ltype_mask = 0xF;
2577                         break;
2578                 case NIX_FLOW_KEY_TYPE_VLAN:
2579                         field->lid = NPC_LID_LB;
2580                         field->hdr_offset = 2; /* Skip TPID (2-bytes) */
2581                         field->bytesm1 = 1; /* 2 Bytes (Actually 12 bits) */
2582                         field->ltype_match = NPC_LT_LB_CTAG;
2583                         field->ltype_mask = 0xF;
2584                         field->fn_mask = 1; /* Mask out the first nibble */
2585                         break;
2586                 }
2587                 field->ena = 1;
2588
2589                 /* Found a valid flow key type */
2590                 if (valid_key) {
2591                         field->key_offset = key_off;
2592                         memcpy(&alg[nr_field], field, sizeof(*field));
2593                         max_key_off = max(max_key_off, field->bytesm1 + 1);
2594
2595                         /* Found a field marker, get the next field */
2596                         if (field_marker)
2597                                 nr_field++;
2598                 }
2599
2600                 /* Found a keyoff marker, update the new key_off */
2601                 if (keyoff_marker) {
2602                         key_off += max_key_off;
2603                         max_key_off = 0;
2604                 }
2605         }
2606         /* Processed all the flow key types */
2607         if (idx == max_bit_pos && key_off <= MAX_KEY_OFF)
2608                 return 0;
2609         else
2610                 return NIX_AF_ERR_RSS_NOSPC_FIELD;
2611 }
2612
2613 static int reserve_flowkey_alg_idx(struct rvu *rvu, int blkaddr, u32 flow_cfg)
2614 {
2615         u64 field[FIELDS_PER_ALG];
2616         struct nix_hw *hw;
2617         int fid, rc;
2618
2619         hw = get_nix_hw(rvu->hw, blkaddr);
2620         if (!hw)
2621                 return -EINVAL;
2622
2623         /* No room to add new flow hash algoritham */
2624         if (hw->flowkey.in_use >= NIX_FLOW_KEY_ALG_MAX)
2625                 return NIX_AF_ERR_RSS_NOSPC_ALGO;
2626
2627         /* Generate algo fields for the given flow_cfg */
2628         rc = set_flowkey_fields((struct nix_rx_flowkey_alg *)field, flow_cfg);
2629         if (rc)
2630                 return rc;
2631
2632         /* Update ALGX_FIELDX register with generated fields */
2633         for (fid = 0; fid < FIELDS_PER_ALG; fid++)
2634                 rvu_write64(rvu, blkaddr,
2635                             NIX_AF_RX_FLOW_KEY_ALGX_FIELDX(hw->flowkey.in_use,
2636                                                            fid), field[fid]);
2637
2638         /* Store the flow_cfg for futher lookup */
2639         rc = hw->flowkey.in_use;
2640         hw->flowkey.flowkey[rc] = flow_cfg;
2641         hw->flowkey.in_use++;
2642
2643         return rc;
2644 }
2645
2646 int rvu_mbox_handler_nix_rss_flowkey_cfg(struct rvu *rvu,
2647                                          struct nix_rss_flowkey_cfg *req,
2648                                          struct nix_rss_flowkey_cfg_rsp *rsp)
2649 {
2650         u16 pcifunc = req->hdr.pcifunc;
2651         int alg_idx, nixlf, blkaddr;
2652         struct nix_hw *nix_hw;
2653         int err;
2654
2655         err = nix_get_nixlf(rvu, pcifunc, &nixlf, &blkaddr);
2656         if (err)
2657                 return err;
2658
2659         nix_hw = get_nix_hw(rvu->hw, blkaddr);
2660         if (!nix_hw)
2661                 return -EINVAL;
2662
2663         alg_idx = get_flowkey_alg_idx(nix_hw, req->flowkey_cfg);
2664         /* Failed to get algo index from the exiting list, reserve new  */
2665         if (alg_idx < 0) {
2666                 alg_idx = reserve_flowkey_alg_idx(rvu, blkaddr,
2667                                                   req->flowkey_cfg);
2668                 if (alg_idx < 0)
2669                         return alg_idx;
2670         }
2671         rsp->alg_idx = alg_idx;
2672         rvu_npc_update_flowkey_alg_idx(rvu, pcifunc, nixlf, req->group,
2673                                        alg_idx, req->mcam_index);
2674         return 0;
2675 }
2676
2677 static int nix_rx_flowkey_alg_cfg(struct rvu *rvu, int blkaddr)
2678 {
2679         u32 flowkey_cfg, minkey_cfg;
2680         int alg, fid, rc;
2681
2682         /* Disable all flow key algx fieldx */
2683         for (alg = 0; alg < NIX_FLOW_KEY_ALG_MAX; alg++) {
2684                 for (fid = 0; fid < FIELDS_PER_ALG; fid++)
2685                         rvu_write64(rvu, blkaddr,
2686                                     NIX_AF_RX_FLOW_KEY_ALGX_FIELDX(alg, fid),
2687                                     0);
2688         }
2689
2690         /* IPv4/IPv6 SIP/DIPs */
2691         flowkey_cfg = NIX_FLOW_KEY_TYPE_IPV4 | NIX_FLOW_KEY_TYPE_IPV6;
2692         rc = reserve_flowkey_alg_idx(rvu, blkaddr, flowkey_cfg);
2693         if (rc < 0)
2694                 return rc;
2695
2696         /* TCPv4/v6 4-tuple, SIP, DIP, Sport, Dport */
2697         minkey_cfg = flowkey_cfg;
2698         flowkey_cfg = minkey_cfg | NIX_FLOW_KEY_TYPE_TCP;
2699         rc = reserve_flowkey_alg_idx(rvu, blkaddr, flowkey_cfg);
2700         if (rc < 0)
2701                 return rc;
2702
2703         /* UDPv4/v6 4-tuple, SIP, DIP, Sport, Dport */
2704         flowkey_cfg = minkey_cfg | NIX_FLOW_KEY_TYPE_UDP;
2705         rc = reserve_flowkey_alg_idx(rvu, blkaddr, flowkey_cfg);
2706         if (rc < 0)
2707                 return rc;
2708
2709         /* SCTPv4/v6 4-tuple, SIP, DIP, Sport, Dport */
2710         flowkey_cfg = minkey_cfg | NIX_FLOW_KEY_TYPE_SCTP;
2711         rc = reserve_flowkey_alg_idx(rvu, blkaddr, flowkey_cfg);
2712         if (rc < 0)
2713                 return rc;
2714
2715         /* TCP/UDP v4/v6 4-tuple, rest IP pkts 2-tuple */
2716         flowkey_cfg = minkey_cfg | NIX_FLOW_KEY_TYPE_TCP |
2717                         NIX_FLOW_KEY_TYPE_UDP;
2718         rc = reserve_flowkey_alg_idx(rvu, blkaddr, flowkey_cfg);
2719         if (rc < 0)
2720                 return rc;
2721
2722         /* TCP/SCTP v4/v6 4-tuple, rest IP pkts 2-tuple */
2723         flowkey_cfg = minkey_cfg | NIX_FLOW_KEY_TYPE_TCP |
2724                         NIX_FLOW_KEY_TYPE_SCTP;
2725         rc = reserve_flowkey_alg_idx(rvu, blkaddr, flowkey_cfg);
2726         if (rc < 0)
2727                 return rc;
2728
2729         /* UDP/SCTP v4/v6 4-tuple, rest IP pkts 2-tuple */
2730         flowkey_cfg = minkey_cfg | NIX_FLOW_KEY_TYPE_UDP |
2731                         NIX_FLOW_KEY_TYPE_SCTP;
2732         rc = reserve_flowkey_alg_idx(rvu, blkaddr, flowkey_cfg);
2733         if (rc < 0)
2734                 return rc;
2735
2736         /* TCP/UDP/SCTP v4/v6 4-tuple, rest IP pkts 2-tuple */
2737         flowkey_cfg = minkey_cfg | NIX_FLOW_KEY_TYPE_TCP |
2738                       NIX_FLOW_KEY_TYPE_UDP | NIX_FLOW_KEY_TYPE_SCTP;
2739         rc = reserve_flowkey_alg_idx(rvu, blkaddr, flowkey_cfg);
2740         if (rc < 0)
2741                 return rc;
2742
2743         return 0;
2744 }
2745
2746 int rvu_mbox_handler_nix_set_mac_addr(struct rvu *rvu,
2747                                       struct nix_set_mac_addr *req,
2748                                       struct msg_rsp *rsp)
2749 {
2750         u16 pcifunc = req->hdr.pcifunc;
2751         int blkaddr, nixlf, err;
2752         struct rvu_pfvf *pfvf;
2753
2754         err = nix_get_nixlf(rvu, pcifunc, &nixlf, &blkaddr);
2755         if (err)
2756                 return err;
2757
2758         pfvf = rvu_get_pfvf(rvu, pcifunc);
2759
2760         ether_addr_copy(pfvf->mac_addr, req->mac_addr);
2761
2762         rvu_npc_install_ucast_entry(rvu, pcifunc, nixlf,
2763                                     pfvf->rx_chan_base, req->mac_addr);
2764
2765         rvu_npc_update_rxvlan(rvu, pcifunc, nixlf);
2766
2767         return 0;
2768 }
2769
2770 int rvu_mbox_handler_nix_get_mac_addr(struct rvu *rvu,
2771                                       struct msg_req *req,
2772                                       struct nix_get_mac_addr_rsp *rsp)
2773 {
2774         u16 pcifunc = req->hdr.pcifunc;
2775         struct rvu_pfvf *pfvf;
2776
2777         if (!is_nixlf_attached(rvu, pcifunc))
2778                 return NIX_AF_ERR_AF_LF_INVALID;
2779
2780         pfvf = rvu_get_pfvf(rvu, pcifunc);
2781
2782         ether_addr_copy(rsp->mac_addr, pfvf->mac_addr);
2783
2784         return 0;
2785 }
2786
2787 int rvu_mbox_handler_nix_set_rx_mode(struct rvu *rvu, struct nix_rx_mode *req,
2788                                      struct msg_rsp *rsp)
2789 {
2790         bool allmulti = false, disable_promisc = false;
2791         u16 pcifunc = req->hdr.pcifunc;
2792         int blkaddr, nixlf, err;
2793         struct rvu_pfvf *pfvf;
2794
2795         err = nix_get_nixlf(rvu, pcifunc, &nixlf, &blkaddr);
2796         if (err)
2797                 return err;
2798
2799         pfvf = rvu_get_pfvf(rvu, pcifunc);
2800
2801         if (req->mode & NIX_RX_MODE_PROMISC)
2802                 allmulti = false;
2803         else if (req->mode & NIX_RX_MODE_ALLMULTI)
2804                 allmulti = true;
2805         else
2806                 disable_promisc = true;
2807
2808         if (disable_promisc)
2809                 rvu_npc_disable_promisc_entry(rvu, pcifunc, nixlf);
2810         else
2811                 rvu_npc_install_promisc_entry(rvu, pcifunc, nixlf,
2812                                               pfvf->rx_chan_base, allmulti);
2813
2814         rvu_npc_update_rxvlan(rvu, pcifunc, nixlf);
2815
2816         return 0;
2817 }
2818
2819 static void nix_find_link_frs(struct rvu *rvu,
2820                               struct nix_frs_cfg *req, u16 pcifunc)
2821 {
2822         int pf = rvu_get_pf(pcifunc);
2823         struct rvu_pfvf *pfvf;
2824         int maxlen, minlen;
2825         int numvfs, hwvf;
2826         int vf;
2827
2828         /* Update with requester's min/max lengths */
2829         pfvf = rvu_get_pfvf(rvu, pcifunc);
2830         pfvf->maxlen = req->maxlen;
2831         if (req->update_minlen)
2832                 pfvf->minlen = req->minlen;
2833
2834         maxlen = req->maxlen;
2835         minlen = req->update_minlen ? req->minlen : 0;
2836
2837         /* Get this PF's numVFs and starting hwvf */
2838         rvu_get_pf_numvfs(rvu, pf, &numvfs, &hwvf);
2839
2840         /* For each VF, compare requested max/minlen */
2841         for (vf = 0; vf < numvfs; vf++) {
2842                 pfvf =  &rvu->hwvf[hwvf + vf];
2843                 if (pfvf->maxlen > maxlen)
2844                         maxlen = pfvf->maxlen;
2845                 if (req->update_minlen &&
2846                     pfvf->minlen && pfvf->minlen < minlen)
2847                         minlen = pfvf->minlen;
2848         }
2849
2850         /* Compare requested max/minlen with PF's max/minlen */
2851         pfvf = &rvu->pf[pf];
2852         if (pfvf->maxlen > maxlen)
2853                 maxlen = pfvf->maxlen;
2854         if (req->update_minlen &&
2855             pfvf->minlen && pfvf->minlen < minlen)
2856                 minlen = pfvf->minlen;
2857
2858         /* Update the request with max/min PF's and it's VF's max/min */
2859         req->maxlen = maxlen;
2860         if (req->update_minlen)
2861                 req->minlen = minlen;
2862 }
2863
2864 int rvu_mbox_handler_nix_set_hw_frs(struct rvu *rvu, struct nix_frs_cfg *req,
2865                                     struct msg_rsp *rsp)
2866 {
2867         struct rvu_hwinfo *hw = rvu->hw;
2868         u16 pcifunc = req->hdr.pcifunc;
2869         int pf = rvu_get_pf(pcifunc);
2870         int blkaddr, schq, link = -1;
2871         struct nix_txsch *txsch;
2872         u64 cfg, lmac_fifo_len;
2873         struct nix_hw *nix_hw;
2874         u8 cgx = 0, lmac = 0;
2875
2876         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
2877         if (blkaddr < 0)
2878                 return NIX_AF_ERR_AF_LF_INVALID;
2879
2880         nix_hw = get_nix_hw(rvu->hw, blkaddr);
2881         if (!nix_hw)
2882                 return -EINVAL;
2883
2884         if (!req->sdp_link && req->maxlen > NIC_HW_MAX_FRS)
2885                 return NIX_AF_ERR_FRS_INVALID;
2886
2887         if (req->update_minlen && req->minlen < NIC_HW_MIN_FRS)
2888                 return NIX_AF_ERR_FRS_INVALID;
2889
2890         /* Check if requester wants to update SMQ's */
2891         if (!req->update_smq)
2892                 goto rx_frscfg;
2893
2894         /* Update min/maxlen in each of the SMQ attached to this PF/VF */
2895         txsch = &nix_hw->txsch[NIX_TXSCH_LVL_SMQ];
2896         mutex_lock(&rvu->rsrc_lock);
2897         for (schq = 0; schq < txsch->schq.max; schq++) {
2898                 if (TXSCH_MAP_FUNC(txsch->pfvf_map[schq]) != pcifunc)
2899                         continue;
2900                 cfg = rvu_read64(rvu, blkaddr, NIX_AF_SMQX_CFG(schq));
2901                 cfg = (cfg & ~(0xFFFFULL << 8)) | ((u64)req->maxlen << 8);
2902                 if (req->update_minlen)
2903                         cfg = (cfg & ~0x7FULL) | ((u64)req->minlen & 0x7F);
2904                 rvu_write64(rvu, blkaddr, NIX_AF_SMQX_CFG(schq), cfg);
2905         }
2906         mutex_unlock(&rvu->rsrc_lock);
2907
2908 rx_frscfg:
2909         /* Check if config is for SDP link */
2910         if (req->sdp_link) {
2911                 if (!hw->sdp_links)
2912                         return NIX_AF_ERR_RX_LINK_INVALID;
2913                 link = hw->cgx_links + hw->lbk_links;
2914                 goto linkcfg;
2915         }
2916
2917         /* Check if the request is from CGX mapped RVU PF */
2918         if (is_pf_cgxmapped(rvu, pf)) {
2919                 /* Get CGX and LMAC to which this PF is mapped and find link */
2920                 rvu_get_cgx_lmac_id(rvu->pf2cgxlmac_map[pf], &cgx, &lmac);
2921                 link = (cgx * hw->lmac_per_cgx) + lmac;
2922         } else if (pf == 0) {
2923                 /* For VFs of PF0 ingress is LBK port, so config LBK link */
2924                 link = hw->cgx_links;
2925         }
2926
2927         if (link < 0)
2928                 return NIX_AF_ERR_RX_LINK_INVALID;
2929
2930         nix_find_link_frs(rvu, req, pcifunc);
2931
2932 linkcfg:
2933         cfg = rvu_read64(rvu, blkaddr, NIX_AF_RX_LINKX_CFG(link));
2934         cfg = (cfg & ~(0xFFFFULL << 16)) | ((u64)req->maxlen << 16);
2935         if (req->update_minlen)
2936                 cfg = (cfg & ~0xFFFFULL) | req->minlen;
2937         rvu_write64(rvu, blkaddr, NIX_AF_RX_LINKX_CFG(link), cfg);
2938
2939         if (req->sdp_link || pf == 0)
2940                 return 0;
2941
2942         /* Update transmit credits for CGX links */
2943         lmac_fifo_len =
2944                 CGX_FIFO_LEN / cgx_get_lmac_cnt(rvu_cgx_pdata(cgx, rvu));
2945         cfg = rvu_read64(rvu, blkaddr, NIX_AF_TX_LINKX_NORM_CREDIT(link));
2946         cfg &= ~(0xFFFFFULL << 12);
2947         cfg |=  ((lmac_fifo_len - req->maxlen) / 16) << 12;
2948         rvu_write64(rvu, blkaddr, NIX_AF_TX_LINKX_NORM_CREDIT(link), cfg);
2949         return 0;
2950 }
2951
2952 int rvu_mbox_handler_nix_rxvlan_alloc(struct rvu *rvu, struct msg_req *req,
2953                                       struct msg_rsp *rsp)
2954 {
2955         struct npc_mcam_alloc_entry_req alloc_req = { };
2956         struct npc_mcam_alloc_entry_rsp alloc_rsp = { };
2957         struct npc_mcam_free_entry_req free_req = { };
2958         u16 pcifunc = req->hdr.pcifunc;
2959         int blkaddr, nixlf, err;
2960         struct rvu_pfvf *pfvf;
2961
2962         /* LBK VFs do not have separate MCAM UCAST entry hence
2963          * skip allocating rxvlan for them
2964          */
2965         if (is_afvf(pcifunc))
2966                 return 0;
2967
2968         pfvf = rvu_get_pfvf(rvu, pcifunc);
2969         if (pfvf->rxvlan)
2970                 return 0;
2971
2972         /* alloc new mcam entry */
2973         alloc_req.hdr.pcifunc = pcifunc;
2974         alloc_req.count = 1;
2975
2976         err = rvu_mbox_handler_npc_mcam_alloc_entry(rvu, &alloc_req,
2977                                                     &alloc_rsp);
2978         if (err)
2979                 return err;
2980
2981         /* update entry to enable rxvlan offload */
2982         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
2983         if (blkaddr < 0) {
2984                 err = NIX_AF_ERR_AF_LF_INVALID;
2985                 goto free_entry;
2986         }
2987
2988         nixlf = rvu_get_lf(rvu, &rvu->hw->block[blkaddr], pcifunc, 0);
2989         if (nixlf < 0) {
2990                 err = NIX_AF_ERR_AF_LF_INVALID;
2991                 goto free_entry;
2992         }
2993
2994         pfvf->rxvlan_index = alloc_rsp.entry_list[0];
2995         /* all it means is that rxvlan_index is valid */
2996         pfvf->rxvlan = true;
2997
2998         err = rvu_npc_update_rxvlan(rvu, pcifunc, nixlf);
2999         if (err)
3000                 goto free_entry;
3001
3002         return 0;
3003 free_entry:
3004         free_req.hdr.pcifunc = pcifunc;
3005         free_req.entry = alloc_rsp.entry_list[0];
3006         rvu_mbox_handler_npc_mcam_free_entry(rvu, &free_req, rsp);
3007         pfvf->rxvlan = false;
3008         return err;
3009 }
3010
3011 int rvu_mbox_handler_nix_set_rx_cfg(struct rvu *rvu, struct nix_rx_cfg *req,
3012                                     struct msg_rsp *rsp)
3013 {
3014         int nixlf, blkaddr, err;
3015         u64 cfg;
3016
3017         err = nix_get_nixlf(rvu, req->hdr.pcifunc, &nixlf, &blkaddr);
3018         if (err)
3019                 return err;
3020
3021         cfg = rvu_read64(rvu, blkaddr, NIX_AF_LFX_RX_CFG(nixlf));
3022         /* Set the interface configuration */
3023         if (req->len_verify & BIT(0))
3024                 cfg |= BIT_ULL(41);
3025         else
3026                 cfg &= ~BIT_ULL(41);
3027
3028         if (req->len_verify & BIT(1))
3029                 cfg |= BIT_ULL(40);
3030         else
3031                 cfg &= ~BIT_ULL(40);
3032
3033         if (req->csum_verify & BIT(0))
3034                 cfg |= BIT_ULL(37);
3035         else
3036                 cfg &= ~BIT_ULL(37);
3037
3038         rvu_write64(rvu, blkaddr, NIX_AF_LFX_RX_CFG(nixlf), cfg);
3039
3040         return 0;
3041 }
3042
3043 static void nix_link_config(struct rvu *rvu, int blkaddr)
3044 {
3045         struct rvu_hwinfo *hw = rvu->hw;
3046         int cgx, lmac_cnt, slink, link;
3047         u64 tx_credits;
3048
3049         /* Set default min/max packet lengths allowed on NIX Rx links.
3050          *
3051          * With HW reset minlen value of 60byte, HW will treat ARP pkts
3052          * as undersize and report them to SW as error pkts, hence
3053          * setting it to 40 bytes.
3054          */
3055         for (link = 0; link < (hw->cgx_links + hw->lbk_links); link++) {
3056                 rvu_write64(rvu, blkaddr, NIX_AF_RX_LINKX_CFG(link),
3057                             NIC_HW_MAX_FRS << 16 | NIC_HW_MIN_FRS);
3058         }
3059
3060         if (hw->sdp_links) {
3061                 link = hw->cgx_links + hw->lbk_links;
3062                 rvu_write64(rvu, blkaddr, NIX_AF_RX_LINKX_CFG(link),
3063                             SDP_HW_MAX_FRS << 16 | NIC_HW_MIN_FRS);
3064         }
3065
3066         /* Set credits for Tx links assuming max packet length allowed.
3067          * This will be reconfigured based on MTU set for PF/VF.
3068          */
3069         for (cgx = 0; cgx < hw->cgx; cgx++) {
3070                 lmac_cnt = cgx_get_lmac_cnt(rvu_cgx_pdata(cgx, rvu));
3071                 tx_credits = ((CGX_FIFO_LEN / lmac_cnt) - NIC_HW_MAX_FRS) / 16;
3072                 /* Enable credits and set credit pkt count to max allowed */
3073                 tx_credits =  (tx_credits << 12) | (0x1FF << 2) | BIT_ULL(1);
3074                 slink = cgx * hw->lmac_per_cgx;
3075                 for (link = slink; link < (slink + lmac_cnt); link++) {
3076                         rvu_write64(rvu, blkaddr,
3077                                     NIX_AF_TX_LINKX_NORM_CREDIT(link),
3078                                     tx_credits);
3079                 }
3080         }
3081
3082         /* Set Tx credits for LBK link */
3083         slink = hw->cgx_links;
3084         for (link = slink; link < (slink + hw->lbk_links); link++) {
3085                 tx_credits = 1000; /* 10 * max LBK datarate = 10 * 100Gbps */
3086                 /* Enable credits and set credit pkt count to max allowed */
3087                 tx_credits =  (tx_credits << 12) | (0x1FF << 2) | BIT_ULL(1);
3088                 rvu_write64(rvu, blkaddr,
3089                             NIX_AF_TX_LINKX_NORM_CREDIT(link), tx_credits);
3090         }
3091 }
3092
3093 static int nix_calibrate_x2p(struct rvu *rvu, int blkaddr)
3094 {
3095         int idx, err;
3096         u64 status;
3097
3098         /* Start X2P bus calibration */
3099         rvu_write64(rvu, blkaddr, NIX_AF_CFG,
3100                     rvu_read64(rvu, blkaddr, NIX_AF_CFG) | BIT_ULL(9));
3101         /* Wait for calibration to complete */
3102         err = rvu_poll_reg(rvu, blkaddr,
3103                            NIX_AF_STATUS, BIT_ULL(10), false);
3104         if (err) {
3105                 dev_err(rvu->dev, "NIX X2P bus calibration failed\n");
3106                 return err;
3107         }
3108
3109         status = rvu_read64(rvu, blkaddr, NIX_AF_STATUS);
3110         /* Check if CGX devices are ready */
3111         for (idx = 0; idx < rvu->cgx_cnt_max; idx++) {
3112                 /* Skip when cgx port is not available */
3113                 if (!rvu_cgx_pdata(idx, rvu) ||
3114                     (status & (BIT_ULL(16 + idx))))
3115                         continue;
3116                 dev_err(rvu->dev,
3117                         "CGX%d didn't respond to NIX X2P calibration\n", idx);
3118                 err = -EBUSY;
3119         }
3120
3121         /* Check if LBK is ready */
3122         if (!(status & BIT_ULL(19))) {
3123                 dev_err(rvu->dev,
3124                         "LBK didn't respond to NIX X2P calibration\n");
3125                 err = -EBUSY;
3126         }
3127
3128         /* Clear 'calibrate_x2p' bit */
3129         rvu_write64(rvu, blkaddr, NIX_AF_CFG,
3130                     rvu_read64(rvu, blkaddr, NIX_AF_CFG) & ~BIT_ULL(9));
3131         if (err || (status & 0x3FFULL))
3132                 dev_err(rvu->dev,
3133                         "NIX X2P calibration failed, status 0x%llx\n", status);
3134         if (err)
3135                 return err;
3136         return 0;
3137 }
3138
3139 static int nix_aq_init(struct rvu *rvu, struct rvu_block *block)
3140 {
3141         u64 cfg;
3142         int err;
3143
3144         /* Set admin queue endianness */
3145         cfg = rvu_read64(rvu, block->addr, NIX_AF_CFG);
3146 #ifdef __BIG_ENDIAN
3147         cfg |= BIT_ULL(8);
3148         rvu_write64(rvu, block->addr, NIX_AF_CFG, cfg);
3149 #else
3150         cfg &= ~BIT_ULL(8);
3151         rvu_write64(rvu, block->addr, NIX_AF_CFG, cfg);
3152 #endif
3153
3154         /* Do not bypass NDC cache */
3155         cfg = rvu_read64(rvu, block->addr, NIX_AF_NDC_CFG);
3156         cfg &= ~0x3FFEULL;
3157 #ifdef CONFIG_NDC_DIS_DYNAMIC_CACHING
3158         /* Disable caching of SQB aka SQEs */
3159         cfg |= 0x04ULL;
3160 #endif
3161         rvu_write64(rvu, block->addr, NIX_AF_NDC_CFG, cfg);
3162
3163         /* Result structure can be followed by RQ/SQ/CQ context at
3164          * RES + 128bytes and a write mask at RES + 256 bytes, depending on
3165          * operation type. Alloc sufficient result memory for all operations.
3166          */
3167         err = rvu_aq_alloc(rvu, &block->aq,
3168                            Q_COUNT(AQ_SIZE), sizeof(struct nix_aq_inst_s),
3169                            ALIGN(sizeof(struct nix_aq_res_s), 128) + 256);
3170         if (err)
3171                 return err;
3172
3173         rvu_write64(rvu, block->addr, NIX_AF_AQ_CFG, AQ_SIZE);
3174         rvu_write64(rvu, block->addr,
3175                     NIX_AF_AQ_BASE, (u64)block->aq->inst->iova);
3176         return 0;
3177 }
3178
3179 static int rvu_nix_block_init(struct rvu *rvu, struct nix_hw *nix_hw)
3180 {
3181         const struct npc_lt_def_cfg *ltdefs;
3182         struct rvu_hwinfo *hw = rvu->hw;
3183         int blkaddr = nix_hw->blkaddr;
3184         struct rvu_block *block;
3185         int err;
3186         u64 cfg;
3187
3188         block = &hw->block[blkaddr];
3189
3190         if (is_rvu_96xx_B0(rvu)) {
3191                 /* As per a HW errata in 96xx A0/B0 silicon, NIX may corrupt
3192                  * internal state when conditional clocks are turned off.
3193                  * Hence enable them.
3194                  */
3195                 rvu_write64(rvu, blkaddr, NIX_AF_CFG,
3196                             rvu_read64(rvu, blkaddr, NIX_AF_CFG) | 0x40ULL);
3197
3198                 /* Set chan/link to backpressure TL3 instead of TL2 */
3199                 rvu_write64(rvu, blkaddr, NIX_AF_PSE_CHANNEL_LEVEL, 0x01);
3200
3201                 /* Disable SQ manager's sticky mode operation (set TM6 = 0)
3202                  * This sticky mode is known to cause SQ stalls when multiple
3203                  * SQs are mapped to same SMQ and transmitting pkts at a time.
3204                  */
3205                 cfg = rvu_read64(rvu, blkaddr, NIX_AF_SQM_DBG_CTL_STATUS);
3206                 cfg &= ~BIT_ULL(15);
3207                 rvu_write64(rvu, blkaddr, NIX_AF_SQM_DBG_CTL_STATUS, cfg);
3208         }
3209
3210         ltdefs = rvu->kpu.lt_def;
3211         /* Calibrate X2P bus to check if CGX/LBK links are fine */
3212         err = nix_calibrate_x2p(rvu, blkaddr);
3213         if (err)
3214                 return err;
3215
3216         /* Set num of links of each type */
3217         cfg = rvu_read64(rvu, blkaddr, NIX_AF_CONST);
3218         hw->cgx = (cfg >> 12) & 0xF;
3219         hw->lmac_per_cgx = (cfg >> 8) & 0xF;
3220         hw->cgx_links = hw->cgx * hw->lmac_per_cgx;
3221         hw->lbk_links = (cfg >> 24) & 0xF;
3222         hw->sdp_links = 1;
3223
3224         /* Initialize admin queue */
3225         err = nix_aq_init(rvu, block);
3226         if (err)
3227                 return err;
3228
3229         /* Restore CINT timer delay to HW reset values */
3230         rvu_write64(rvu, blkaddr, NIX_AF_CINT_DELAY, 0x0ULL);
3231
3232         if (is_block_implemented(hw, blkaddr)) {
3233                 err = nix_setup_txschq(rvu, nix_hw, blkaddr);
3234                 if (err)
3235                         return err;
3236
3237                 err = nix_af_mark_format_setup(rvu, nix_hw, blkaddr);
3238                 if (err)
3239                         return err;
3240
3241                 err = nix_setup_mcast(rvu, nix_hw, blkaddr);
3242                 if (err)
3243                         return err;
3244
3245                 /* Configure segmentation offload formats */
3246                 nix_setup_lso(rvu, nix_hw, blkaddr);
3247
3248                 /* Config Outer/Inner L2, IP, TCP, UDP and SCTP NPC layer info.
3249                  * This helps HW protocol checker to identify headers
3250                  * and validate length and checksums.
3251                  */
3252                 rvu_write64(rvu, blkaddr, NIX_AF_RX_DEF_OL2,
3253                             (ltdefs->rx_ol2.lid << 8) | (ltdefs->rx_ol2.ltype_match << 4) |
3254                             ltdefs->rx_ol2.ltype_mask);
3255                 rvu_write64(rvu, blkaddr, NIX_AF_RX_DEF_OIP4,
3256                             (ltdefs->rx_oip4.lid << 8) | (ltdefs->rx_oip4.ltype_match << 4) |
3257                             ltdefs->rx_oip4.ltype_mask);
3258                 rvu_write64(rvu, blkaddr, NIX_AF_RX_DEF_IIP4,
3259                             (ltdefs->rx_iip4.lid << 8) | (ltdefs->rx_iip4.ltype_match << 4) |
3260                             ltdefs->rx_iip4.ltype_mask);
3261                 rvu_write64(rvu, blkaddr, NIX_AF_RX_DEF_OIP6,
3262                             (ltdefs->rx_oip6.lid << 8) | (ltdefs->rx_oip6.ltype_match << 4) |
3263                             ltdefs->rx_oip6.ltype_mask);
3264                 rvu_write64(rvu, blkaddr, NIX_AF_RX_DEF_IIP6,
3265                             (ltdefs->rx_iip6.lid << 8) | (ltdefs->rx_iip6.ltype_match << 4) |
3266                             ltdefs->rx_iip6.ltype_mask);
3267                 rvu_write64(rvu, blkaddr, NIX_AF_RX_DEF_OTCP,
3268                             (ltdefs->rx_otcp.lid << 8) | (ltdefs->rx_otcp.ltype_match << 4) |
3269                             ltdefs->rx_otcp.ltype_mask);
3270                 rvu_write64(rvu, blkaddr, NIX_AF_RX_DEF_ITCP,
3271                             (ltdefs->rx_itcp.lid << 8) | (ltdefs->rx_itcp.ltype_match << 4) |
3272                             ltdefs->rx_itcp.ltype_mask);
3273                 rvu_write64(rvu, blkaddr, NIX_AF_RX_DEF_OUDP,
3274                             (ltdefs->rx_oudp.lid << 8) | (ltdefs->rx_oudp.ltype_match << 4) |
3275                             ltdefs->rx_oudp.ltype_mask);
3276                 rvu_write64(rvu, blkaddr, NIX_AF_RX_DEF_IUDP,
3277                             (ltdefs->rx_iudp.lid << 8) | (ltdefs->rx_iudp.ltype_match << 4) |
3278                             ltdefs->rx_iudp.ltype_mask);
3279                 rvu_write64(rvu, blkaddr, NIX_AF_RX_DEF_OSCTP,
3280                             (ltdefs->rx_osctp.lid << 8) | (ltdefs->rx_osctp.ltype_match << 4) |
3281                             ltdefs->rx_osctp.ltype_mask);
3282                 rvu_write64(rvu, blkaddr, NIX_AF_RX_DEF_ISCTP,
3283                             (ltdefs->rx_isctp.lid << 8) | (ltdefs->rx_isctp.ltype_match << 4) |
3284                             ltdefs->rx_isctp.ltype_mask);
3285
3286                 err = nix_rx_flowkey_alg_cfg(rvu, blkaddr);
3287                 if (err)
3288                         return err;
3289
3290                 /* Initialize CGX/LBK/SDP link credits, min/max pkt lengths */
3291                 nix_link_config(rvu, blkaddr);
3292
3293                 /* Enable Channel backpressure */
3294                 rvu_write64(rvu, blkaddr, NIX_AF_RX_CFG, BIT_ULL(0));
3295         }
3296         return 0;
3297 }
3298
3299 int rvu_nix_init(struct rvu *rvu)
3300 {
3301         struct rvu_hwinfo *hw = rvu->hw;
3302         struct nix_hw *nix_hw;
3303         int blkaddr = 0, err;
3304         int i = 0;
3305
3306         hw->nix = devm_kcalloc(rvu->dev, MAX_NIX_BLKS, sizeof(struct nix_hw),
3307                                GFP_KERNEL);
3308         if (!hw->nix)
3309                 return -ENOMEM;
3310
3311         blkaddr = rvu_get_next_nix_blkaddr(rvu, blkaddr);
3312         while (blkaddr) {
3313                 nix_hw = &hw->nix[i];
3314                 nix_hw->rvu = rvu;
3315                 nix_hw->blkaddr = blkaddr;
3316                 err = rvu_nix_block_init(rvu, nix_hw);
3317                 if (err)
3318                         return err;
3319                 blkaddr = rvu_get_next_nix_blkaddr(rvu, blkaddr);
3320                 i++;
3321         }
3322
3323         return 0;
3324 }
3325
3326 static void rvu_nix_block_freemem(struct rvu *rvu, int blkaddr,
3327                                   struct rvu_block *block)
3328 {
3329         struct nix_txsch *txsch;
3330         struct nix_mcast *mcast;
3331         struct nix_hw *nix_hw;
3332         int lvl;
3333
3334         rvu_aq_free(rvu, block->aq);
3335
3336         if (is_block_implemented(rvu->hw, blkaddr)) {
3337                 nix_hw = get_nix_hw(rvu->hw, blkaddr);
3338                 if (!nix_hw)
3339                         return;
3340
3341                 for (lvl = 0; lvl < NIX_TXSCH_LVL_CNT; lvl++) {
3342                         txsch = &nix_hw->txsch[lvl];
3343                         kfree(txsch->schq.bmap);
3344                 }
3345
3346                 mcast = &nix_hw->mcast;
3347                 qmem_free(rvu->dev, mcast->mce_ctx);
3348                 qmem_free(rvu->dev, mcast->mcast_buf);
3349                 mutex_destroy(&mcast->mce_lock);
3350         }
3351 }
3352
3353 void rvu_nix_freemem(struct rvu *rvu)
3354 {
3355         struct rvu_hwinfo *hw = rvu->hw;
3356         struct rvu_block *block;
3357         int blkaddr = 0;
3358
3359         blkaddr = rvu_get_next_nix_blkaddr(rvu, blkaddr);
3360         while (blkaddr) {
3361                 block = &hw->block[blkaddr];
3362                 rvu_nix_block_freemem(rvu, blkaddr, block);
3363                 blkaddr = rvu_get_next_nix_blkaddr(rvu, blkaddr);
3364         }
3365 }
3366
3367 int rvu_mbox_handler_nix_lf_start_rx(struct rvu *rvu, struct msg_req *req,
3368                                      struct msg_rsp *rsp)
3369 {
3370         u16 pcifunc = req->hdr.pcifunc;
3371         int nixlf, err;
3372
3373         err = nix_get_nixlf(rvu, pcifunc, &nixlf, NULL);
3374         if (err)
3375                 return err;
3376
3377         rvu_npc_enable_default_entries(rvu, pcifunc, nixlf);
3378
3379         return rvu_cgx_start_stop_io(rvu, pcifunc, true);
3380 }
3381
3382 int rvu_mbox_handler_nix_lf_stop_rx(struct rvu *rvu, struct msg_req *req,
3383                                     struct msg_rsp *rsp)
3384 {
3385         u16 pcifunc = req->hdr.pcifunc;
3386         int nixlf, err;
3387
3388         err = nix_get_nixlf(rvu, pcifunc, &nixlf, NULL);
3389         if (err)
3390                 return err;
3391
3392         rvu_npc_disable_default_entries(rvu, pcifunc, nixlf);
3393
3394         return rvu_cgx_start_stop_io(rvu, pcifunc, false);
3395 }
3396
3397 void rvu_nix_lf_teardown(struct rvu *rvu, u16 pcifunc, int blkaddr, int nixlf)
3398 {
3399         struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, pcifunc);
3400         struct hwctx_disable_req ctx_req;
3401         int err;
3402
3403         ctx_req.hdr.pcifunc = pcifunc;
3404
3405         /* Cleanup NPC MCAM entries, free Tx scheduler queues being used */
3406         nix_interface_deinit(rvu, pcifunc, nixlf);
3407         nix_rx_sync(rvu, blkaddr);
3408         nix_txschq_free(rvu, pcifunc);
3409
3410         rvu_cgx_start_stop_io(rvu, pcifunc, false);
3411
3412         if (pfvf->sq_ctx) {
3413                 ctx_req.ctype = NIX_AQ_CTYPE_SQ;
3414                 err = nix_lf_hwctx_disable(rvu, &ctx_req);
3415                 if (err)
3416                         dev_err(rvu->dev, "SQ ctx disable failed\n");
3417         }
3418
3419         if (pfvf->rq_ctx) {
3420                 ctx_req.ctype = NIX_AQ_CTYPE_RQ;
3421                 err = nix_lf_hwctx_disable(rvu, &ctx_req);
3422                 if (err)
3423                         dev_err(rvu->dev, "RQ ctx disable failed\n");
3424         }
3425
3426         if (pfvf->cq_ctx) {
3427                 ctx_req.ctype = NIX_AQ_CTYPE_CQ;
3428                 err = nix_lf_hwctx_disable(rvu, &ctx_req);
3429                 if (err)
3430                         dev_err(rvu->dev, "CQ ctx disable failed\n");
3431         }
3432
3433         nix_ctx_free(rvu, pfvf);
3434 }
3435
3436 #define NIX_AF_LFX_TX_CFG_PTP_EN        BIT_ULL(32)
3437
3438 static int rvu_nix_lf_ptp_tx_cfg(struct rvu *rvu, u16 pcifunc, bool enable)
3439 {
3440         struct rvu_hwinfo *hw = rvu->hw;
3441         struct rvu_block *block;
3442         int blkaddr;
3443         int nixlf;
3444         u64 cfg;
3445
3446         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
3447         if (blkaddr < 0)
3448                 return NIX_AF_ERR_AF_LF_INVALID;
3449
3450         block = &hw->block[blkaddr];
3451         nixlf = rvu_get_lf(rvu, block, pcifunc, 0);
3452         if (nixlf < 0)
3453                 return NIX_AF_ERR_AF_LF_INVALID;
3454
3455         cfg = rvu_read64(rvu, blkaddr, NIX_AF_LFX_TX_CFG(nixlf));
3456
3457         if (enable)
3458                 cfg |= NIX_AF_LFX_TX_CFG_PTP_EN;
3459         else
3460                 cfg &= ~NIX_AF_LFX_TX_CFG_PTP_EN;
3461
3462         rvu_write64(rvu, blkaddr, NIX_AF_LFX_TX_CFG(nixlf), cfg);
3463
3464         return 0;
3465 }
3466
3467 int rvu_mbox_handler_nix_lf_ptp_tx_enable(struct rvu *rvu, struct msg_req *req,
3468                                           struct msg_rsp *rsp)
3469 {
3470         return rvu_nix_lf_ptp_tx_cfg(rvu, req->hdr.pcifunc, true);
3471 }
3472
3473 int rvu_mbox_handler_nix_lf_ptp_tx_disable(struct rvu *rvu, struct msg_req *req,
3474                                            struct msg_rsp *rsp)
3475 {
3476         return rvu_nix_lf_ptp_tx_cfg(rvu, req->hdr.pcifunc, false);
3477 }
3478
3479 int rvu_mbox_handler_nix_lso_format_cfg(struct rvu *rvu,
3480                                         struct nix_lso_format_cfg *req,
3481                                         struct nix_lso_format_cfg_rsp *rsp)
3482 {
3483         u16 pcifunc = req->hdr.pcifunc;
3484         struct nix_hw *nix_hw;
3485         struct rvu_pfvf *pfvf;
3486         int blkaddr, idx, f;
3487         u64 reg;
3488
3489         pfvf = rvu_get_pfvf(rvu, pcifunc);
3490         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
3491         if (!pfvf->nixlf || blkaddr < 0)
3492                 return NIX_AF_ERR_AF_LF_INVALID;
3493
3494         nix_hw = get_nix_hw(rvu->hw, blkaddr);
3495         if (!nix_hw)
3496                 return -EINVAL;
3497
3498         /* Find existing matching LSO format, if any */
3499         for (idx = 0; idx < nix_hw->lso.in_use; idx++) {
3500                 for (f = 0; f < NIX_LSO_FIELD_MAX; f++) {
3501                         reg = rvu_read64(rvu, blkaddr,
3502                                          NIX_AF_LSO_FORMATX_FIELDX(idx, f));
3503                         if (req->fields[f] != (reg & req->field_mask))
3504                                 break;
3505                 }
3506
3507                 if (f == NIX_LSO_FIELD_MAX)
3508                         break;
3509         }
3510
3511         if (idx < nix_hw->lso.in_use) {
3512                 /* Match found */
3513                 rsp->lso_format_idx = idx;
3514                 return 0;
3515         }
3516
3517         if (nix_hw->lso.in_use == nix_hw->lso.total)
3518                 return NIX_AF_ERR_LSO_CFG_FAIL;
3519
3520         rsp->lso_format_idx = nix_hw->lso.in_use++;
3521
3522         for (f = 0; f < NIX_LSO_FIELD_MAX; f++)
3523                 rvu_write64(rvu, blkaddr,
3524                             NIX_AF_LSO_FORMATX_FIELDX(rsp->lso_format_idx, f),
3525                             req->fields[f]);
3526
3527         return 0;
3528 }