drivers/net/ethernet/marvell/octeontx2/af/rvu_npc.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 "npc_profile.h"
  19
  20 #define RSVD_MCAM_ENTRIES_PER_PF        2 /* Bcast & Promisc */
  21 #define RSVD_MCAM_ENTRIES_PER_NIXLF     1 /* Ucast for LFs */
  22
  23 #define NIXLF_UCAST_ENTRY       0
  24 #define NIXLF_BCAST_ENTRY       1
  25 #define NIXLF_PROMISC_ENTRY     2
  26
  27 #define NPC_PARSE_RESULT_DMAC_OFFSET    8
  28
  29 struct mcam_entry {
  30 #define NPC_MAX_KWS_IN_KEY      7 /* Number of keywords in max keywidth */
  31         u64     kw[NPC_MAX_KWS_IN_KEY];
  32         u64     kw_mask[NPC_MAX_KWS_IN_KEY];
  33         u64     action;
  34         u64     vtag_action;
  35 };
  36
  37 void rvu_npc_set_pkind(struct rvu *rvu, int pkind, struct rvu_pfvf *pfvf)
  38 {
  39         int blkaddr;
  40         u64 val = 0;
  41
  42         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPC, 0);
  43         if (blkaddr < 0)
  44                 return;
  45
  46         /* Config CPI base for the PKIND */
  47         val = pkind | 1ULL << 62;
  48         rvu_write64(rvu, blkaddr, NPC_AF_PKINDX_CPI_DEFX(pkind, 0), val);
  49 }
  50
  51 int rvu_npc_get_pkind(struct rvu *rvu, u16 pf)
  52 {
  53         struct npc_pkind *pkind = &rvu->hw->pkind;
  54         u32 map;
  55         int i;
  56
  57         for (i = 0; i < pkind->rsrc.max; i++) {
  58                 map = pkind->pfchan_map[i];
  59                 if (((map >> 16) & 0x3F) == pf)
  60                         return i;
  61         }
  62         return -1;
  63 }
  64
  65 static int npc_get_nixlf_mcam_index(struct npc_mcam *mcam,
  66                                     u16 pcifunc, int nixlf, int type)
  67 {
  68         int pf = rvu_get_pf(pcifunc);
  69         int index;
  70
  71         /* Check if this is for a PF */
  72         if (pf && !(pcifunc & RVU_PFVF_FUNC_MASK)) {
  73                 /* Reserved entries exclude PF0 */
  74                 pf--;
  75                 index = mcam->pf_offset + (pf * RSVD_MCAM_ENTRIES_PER_PF);
  76                 /* Broadcast address matching entry should be first so
  77                  * that the packet can be replicated to all VFs.
  78                  */
  79                 if (type == NIXLF_BCAST_ENTRY)
  80                         return index;
  81                 else if (type == NIXLF_PROMISC_ENTRY)
  82                         return index + 1;
  83         }
  84
  85         return (mcam->nixlf_offset + (nixlf * RSVD_MCAM_ENTRIES_PER_NIXLF));
  86 }
  87
  88 static int npc_get_bank(struct npc_mcam *mcam, int index)
  89 {
  90         int bank = index / mcam->banksize;
  91
  92         /* 0,1 & 2,3 banks are combined for this keysize */
  93         if (mcam->keysize == NPC_MCAM_KEY_X2)
  94                 return bank ? 2 : 0;
  95
  96         return bank;
  97 }
  98
  99 static bool is_mcam_entry_enabled(struct rvu *rvu, struct npc_mcam *mcam,
 100                                   int blkaddr, int index)
 101 {
 102         int bank = npc_get_bank(mcam, index);
 103         u64 cfg;
 104
 105         index &= (mcam->banksize - 1);
 106         cfg = rvu_read64(rvu, blkaddr, NPC_AF_MCAMEX_BANKX_CFG(index, bank));
 107         return (cfg & 1);
 108 }
 109
 110 static void npc_enable_mcam_entry(struct rvu *rvu, struct npc_mcam *mcam,
 111                                   int blkaddr, int index, bool enable)
 112 {
 113         int bank = npc_get_bank(mcam, index);
 114         int actbank = bank;
 115
 116         index &= (mcam->banksize - 1);
 117         for (; bank < (actbank + mcam->banks_per_entry); bank++) {
 118                 rvu_write64(rvu, blkaddr,
 119                             NPC_AF_MCAMEX_BANKX_CFG(index, bank),
 120                             enable ? 1 : 0);
 121         }
 122 }
 123
 124 static void npc_get_keyword(struct mcam_entry *entry, int idx,
 125                             u64 *cam0, u64 *cam1)
 126 {
 127         u64 kw_mask = 0x00;
 128
 129 #define CAM_MASK(n)     (BIT_ULL(n) - 1)
 130
 131         /* 0, 2, 4, 6 indices refer to BANKX_CAMX_W0 and
 132          * 1, 3, 5, 7 indices refer to BANKX_CAMX_W1.
 133          *
 134          * Also, only 48 bits of BANKX_CAMX_W1 are valid.
 135          */
 136         switch (idx) {
 137         case 0:
 138                 /* BANK(X)_CAM_W0<63:0> = MCAM_KEY[KW0]<63:0> */
 139                 *cam1 = entry->kw[0];
 140                 kw_mask = entry->kw_mask[0];
 141                 break;
 142         case 1:
 143                 /* BANK(X)_CAM_W1<47:0> = MCAM_KEY[KW1]<47:0> */
 144                 *cam1 = entry->kw[1] & CAM_MASK(48);
 145                 kw_mask = entry->kw_mask[1] & CAM_MASK(48);
 146                 break;
 147         case 2:
 148                 /* BANK(X + 1)_CAM_W0<15:0> = MCAM_KEY[KW1]<63:48>
 149                  * BANK(X + 1)_CAM_W0<63:16> = MCAM_KEY[KW2]<47:0>
 150                  */
 151                 *cam1 = (entry->kw[1] >> 48) & CAM_MASK(16);
 152                 *cam1 |= ((entry->kw[2] & CAM_MASK(48)) << 16);
 153                 kw_mask = (entry->kw_mask[1] >> 48) & CAM_MASK(16);
 154                 kw_mask |= ((entry->kw_mask[2] & CAM_MASK(48)) << 16);
 155                 break;
 156         case 3:
 157                 /* BANK(X + 1)_CAM_W1<15:0> = MCAM_KEY[KW2]<63:48>
 158                  * BANK(X + 1)_CAM_W1<47:16> = MCAM_KEY[KW3]<31:0>
 159                  */
 160                 *cam1 = (entry->kw[2] >> 48) & CAM_MASK(16);
 161                 *cam1 |= ((entry->kw[3] & CAM_MASK(32)) << 16);
 162                 kw_mask = (entry->kw_mask[2] >> 48) & CAM_MASK(16);
 163                 kw_mask |= ((entry->kw_mask[3] & CAM_MASK(32)) << 16);
 164                 break;
 165         case 4:
 166                 /* BANK(X + 2)_CAM_W0<31:0> = MCAM_KEY[KW3]<63:32>
 167                  * BANK(X + 2)_CAM_W0<63:32> = MCAM_KEY[KW4]<31:0>
 168                  */
 169                 *cam1 = (entry->kw[3] >> 32) & CAM_MASK(32);
 170                 *cam1 |= ((entry->kw[4] & CAM_MASK(32)) << 32);
 171                 kw_mask = (entry->kw_mask[3] >> 32) & CAM_MASK(32);
 172                 kw_mask |= ((entry->kw_mask[4] & CAM_MASK(32)) << 32);
 173                 break;
 174         case 5:
 175                 /* BANK(X + 2)_CAM_W1<31:0> = MCAM_KEY[KW4]<63:32>
 176                  * BANK(X + 2)_CAM_W1<47:32> = MCAM_KEY[KW5]<15:0>
 177                  */
 178                 *cam1 = (entry->kw[4] >> 32) & CAM_MASK(32);
 179                 *cam1 |= ((entry->kw[5] & CAM_MASK(16)) << 32);
 180                 kw_mask = (entry->kw_mask[4] >> 32) & CAM_MASK(32);
 181                 kw_mask |= ((entry->kw_mask[5] & CAM_MASK(16)) << 32);
 182                 break;
 183         case 6:
 184                 /* BANK(X + 3)_CAM_W0<47:0> = MCAM_KEY[KW5]<63:16>
 185                  * BANK(X + 3)_CAM_W0<63:48> = MCAM_KEY[KW6]<15:0>
 186                  */
 187                 *cam1 = (entry->kw[5] >> 16) & CAM_MASK(48);
 188                 *cam1 |= ((entry->kw[6] & CAM_MASK(16)) << 48);
 189                 kw_mask = (entry->kw_mask[5] >> 16) & CAM_MASK(48);
 190                 kw_mask |= ((entry->kw_mask[6] & CAM_MASK(16)) << 48);
 191                 break;
 192         case 7:
 193                 /* BANK(X + 3)_CAM_W1<47:0> = MCAM_KEY[KW6]<63:16> */
 194                 *cam1 = (entry->kw[6] >> 16) & CAM_MASK(48);
 195                 kw_mask = (entry->kw_mask[6] >> 16) & CAM_MASK(48);
 196                 break;
 197         }
 198
 199         *cam1 &= kw_mask;
 200         *cam0 = ~*cam1 & kw_mask;
 201 }
 202
 203 static void npc_config_mcam_entry(struct rvu *rvu, struct npc_mcam *mcam,
 204                                   int blkaddr, int index, u8 intf,
 205                                   struct mcam_entry *entry, bool enable)
 206 {
 207         int bank = npc_get_bank(mcam, index);
 208         int kw = 0, actbank, actindex;
 209         u64 cam0, cam1;
 210
 211         actbank = bank; /* Save bank id, to set action later on */
 212         actindex = index;
 213         index &= (mcam->banksize - 1);
 214
 215         /* CAM1 takes the comparison value and
 216          * CAM0 specifies match for a bit in key being '0' or '1' or 'dontcare'.
 217          * CAM1<n> = 0 & CAM0<n> = 1 => match if key<n> = 0
 218          * CAM1<n> = 1 & CAM0<n> = 0 => match if key<n> = 1
 219          * CAM1<n> = 0 & CAM0<n> = 0 => always match i.e dontcare.
 220          */
 221         for (; bank < (actbank + mcam->banks_per_entry); bank++, kw = kw + 2) {
 222                 /* Interface should be set in all banks */
 223                 rvu_write64(rvu, blkaddr,
 224                             NPC_AF_MCAMEX_BANKX_CAMX_INTF(index, bank, 1),
 225                             intf);
 226                 rvu_write64(rvu, blkaddr,
 227                             NPC_AF_MCAMEX_BANKX_CAMX_INTF(index, bank, 0),
 228                             ~intf & 0x3);
 229
 230                 /* Set the match key */
 231                 npc_get_keyword(entry, kw, &cam0, &cam1);
 232                 rvu_write64(rvu, blkaddr,
 233                             NPC_AF_MCAMEX_BANKX_CAMX_W0(index, bank, 1), cam1);
 234                 rvu_write64(rvu, blkaddr,
 235                             NPC_AF_MCAMEX_BANKX_CAMX_W0(index, bank, 0), cam0);
 236
 237                 npc_get_keyword(entry, kw + 1, &cam0, &cam1);
 238                 rvu_write64(rvu, blkaddr,
 239                             NPC_AF_MCAMEX_BANKX_CAMX_W1(index, bank, 1), cam1);
 240                 rvu_write64(rvu, blkaddr,
 241                             NPC_AF_MCAMEX_BANKX_CAMX_W1(index, bank, 0), cam0);
 242         }
 243
 244         /* Set 'action' */
 245         rvu_write64(rvu, blkaddr,
 246                     NPC_AF_MCAMEX_BANKX_ACTION(index, actbank), entry->action);
 247
 248         /* Set TAG 'action' */
 249         rvu_write64(rvu, blkaddr, NPC_AF_MCAMEX_BANKX_TAG_ACT(index, actbank),
 250                     entry->vtag_action);
 251
 252         /* Enable the entry */
 253         if (enable)
 254                 npc_enable_mcam_entry(rvu, mcam, blkaddr, actindex, true);
 255         else
 256                 npc_enable_mcam_entry(rvu, mcam, blkaddr, actindex, false);
 257 }
 258
 259 static u64 npc_get_mcam_action(struct rvu *rvu, struct npc_mcam *mcam,
 260                                int blkaddr, int index)
 261 {
 262         int bank = npc_get_bank(mcam, index);
 263
 264         index &= (mcam->banksize - 1);
 265         return rvu_read64(rvu, blkaddr,
 266                           NPC_AF_MCAMEX_BANKX_ACTION(index, bank));
 267 }
 268
 269 void rvu_npc_install_ucast_entry(struct rvu *rvu, u16 pcifunc,
 270                                  int nixlf, u64 chan, u8 *mac_addr)
 271 {
 272         struct npc_mcam *mcam = &rvu->hw->mcam;
 273         struct mcam_entry entry = { {0} };
 274         struct nix_rx_action action;
 275         int blkaddr, index, kwi;
 276         u64 mac = 0;
 277
 278         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPC, 0);
 279         if (blkaddr < 0)
 280                 return;
 281
 282         for (index = ETH_ALEN - 1; index >= 0; index--)
 283                 mac |= ((u64)*mac_addr++) << (8 * index);
 284
 285         index = npc_get_nixlf_mcam_index(mcam, pcifunc,
 286                                          nixlf, NIXLF_UCAST_ENTRY);
 287
 288         /* Match ingress channel and DMAC */
 289         entry.kw[0] = chan;
 290         entry.kw_mask[0] = 0xFFFULL;
 291
 292         kwi = NPC_PARSE_RESULT_DMAC_OFFSET / sizeof(u64);
 293         entry.kw[kwi] = mac;
 294         entry.kw_mask[kwi] = BIT_ULL(48) - 1;
 295
 296         /* Don't change the action if entry is already enabled
 297          * Otherwise RSS action may get overwritten.
 298          */
 299         if (is_mcam_entry_enabled(rvu, mcam, blkaddr, index)) {
 300                 *(u64 *)&action = npc_get_mcam_action(rvu, mcam,
 301                                                       blkaddr, index);
 302         } else {
 303                 *(u64 *)&action = 0x00;
 304                 action.op = NIX_RX_ACTIONOP_UCAST;
 305                 action.pf_func = pcifunc;
 306         }
 307
 308         entry.action = *(u64 *)&action;
 309         npc_config_mcam_entry(rvu, mcam, blkaddr, index,
 310                               NIX_INTF_RX, &entry, true);
 311 }
 312
 313 void rvu_npc_install_bcast_match_entry(struct rvu *rvu, u16 pcifunc,
 314                                        int nixlf, u64 chan)
 315 {
 316         struct npc_mcam *mcam = &rvu->hw->mcam;
 317         struct mcam_entry entry = { {0} };
 318         struct nix_rx_action action;
 319 #ifdef MCAST_MCE
 320         struct rvu_pfvf *pfvf;
 321 #endif
 322         int blkaddr, index;
 323
 324         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPC, 0);
 325         if (blkaddr < 0)
 326                 return;
 327
 328         /* Only PF can add a bcast match entry */
 329         if (pcifunc & RVU_PFVF_FUNC_MASK)
 330                 return;
 331 #ifdef MCAST_MCE
 332         pfvf = rvu_get_pfvf(rvu, pcifunc & ~RVU_PFVF_FUNC_MASK);
 333 #endif
 334
 335         index = npc_get_nixlf_mcam_index(mcam, pcifunc,
 336                                          nixlf, NIXLF_BCAST_ENTRY);
 337
 338         /* Check for L2B bit and LMAC channel */
 339         entry.kw[0] = BIT_ULL(25) | chan;
 340         entry.kw_mask[0] = BIT_ULL(25) | 0xFFFULL;
 341
 342         *(u64 *)&action = 0x00;
 343 #ifdef MCAST_MCE
 344         /* Early silicon doesn't support pkt replication,
 345          * so install entry with UCAST action, so that PF
 346          * receives all broadcast packets.
 347          */
 348         action.op = NIX_RX_ACTIONOP_MCAST;
 349         action.pf_func = pcifunc;
 350         action.index = pfvf->bcast_mce_idx;
 351 #else
 352         action.op = NIX_RX_ACTIONOP_UCAST;
 353         action.pf_func = pcifunc;
 354 #endif
 355
 356         entry.action = *(u64 *)&action;
 357         npc_config_mcam_entry(rvu, mcam, blkaddr, index,
 358                               NIX_INTF_RX, &entry, true);
 359 }
 360
 361 void rvu_npc_disable_mcam_entries(struct rvu *rvu, u16 pcifunc, int nixlf)
 362 {
 363         struct npc_mcam *mcam = &rvu->hw->mcam;
 364         struct nix_rx_action action;
 365         int blkaddr, index, bank;
 366
 367         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPC, 0);
 368         if (blkaddr < 0)
 369                 return;
 370
 371         /* Disable ucast MCAM match entry of this PF/VF */
 372         index = npc_get_nixlf_mcam_index(mcam, pcifunc,
 373                                          nixlf, NIXLF_UCAST_ENTRY);
 374         npc_enable_mcam_entry(rvu, mcam, blkaddr, index, false);
 375
 376         /* For PF, disable promisc and bcast MCAM match entries */
 377         if (!(pcifunc & RVU_PFVF_FUNC_MASK)) {
 378                 index = npc_get_nixlf_mcam_index(mcam, pcifunc,
 379                                                  nixlf, NIXLF_BCAST_ENTRY);
 380                 /* For bcast, disable only if it's action is not
 381                  * packet replication, incase if action is replication
 382                  * then this PF's nixlf is removed from bcast replication
 383                  * list.
 384                  */
 385                 bank = npc_get_bank(mcam, index);
 386                 index &= (mcam->banksize - 1);
 387                 *(u64 *)&action = rvu_read64(rvu, blkaddr,
 388                                      NPC_AF_MCAMEX_BANKX_ACTION(index, bank));
 389                 if (action.op != NIX_RX_ACTIONOP_MCAST)
 390                         npc_enable_mcam_entry(rvu, mcam, blkaddr, index, false);
 391         }
 392 }
 393
 394 #define LDATA_EXTRACT_CONFIG(intf, lid, ltype, ld, cfg) \
 395         rvu_write64(rvu, blkaddr,                       \
 396                 NPC_AF_INTFX_LIDX_LTX_LDX_CFG(intf, lid, ltype, ld), cfg)
 397
 398 #define LDATA_FLAGS_CONFIG(intf, ld, flags, cfg)        \
 399         rvu_write64(rvu, blkaddr,                       \
 400                 NPC_AF_INTFX_LDATAX_FLAGSX_CFG(intf, ld, flags), cfg)
 401
 402 static void npc_config_ldata_extract(struct rvu *rvu, int blkaddr)
 403 {
 404         struct npc_mcam *mcam = &rvu->hw->mcam;
 405         int lid, ltype;
 406         int lid_count;
 407         u64 cfg;
 408
 409         cfg = rvu_read64(rvu, blkaddr, NPC_AF_CONST);
 410         lid_count = (cfg >> 4) & 0xF;
 411
 412         /* First clear any existing config i.e
 413          * disable LDATA and FLAGS extraction.
 414          */
 415         for (lid = 0; lid < lid_count; lid++) {
 416                 for (ltype = 0; ltype < 16; ltype++) {
 417                         LDATA_EXTRACT_CONFIG(NIX_INTF_RX, lid, ltype, 0, 0ULL);
 418                         LDATA_EXTRACT_CONFIG(NIX_INTF_RX, lid, ltype, 1, 0ULL);
 419                         LDATA_EXTRACT_CONFIG(NIX_INTF_TX, lid, ltype, 0, 0ULL);
 420                         LDATA_EXTRACT_CONFIG(NIX_INTF_TX, lid, ltype, 1, 0ULL);
 421
 422                         LDATA_FLAGS_CONFIG(NIX_INTF_RX, 0, ltype, 0ULL);
 423                         LDATA_FLAGS_CONFIG(NIX_INTF_RX, 1, ltype, 0ULL);
 424                         LDATA_FLAGS_CONFIG(NIX_INTF_TX, 0, ltype, 0ULL);
 425                         LDATA_FLAGS_CONFIG(NIX_INTF_TX, 1, ltype, 0ULL);
 426                 }
 427         }
 428
 429         /* If we plan to extract Outer IPv4 tuple for TCP/UDP pkts
 430          * then 112bit key is not sufficient
 431          */
 432         if (mcam->keysize != NPC_MCAM_KEY_X2)
 433                 return;
 434
 435         /* Start placing extracted data/flags from 64bit onwards, for now */
 436         /* Extract DMAC from the packet */
 437         cfg = (0x05 << 16) | BIT_ULL(7) | NPC_PARSE_RESULT_DMAC_OFFSET;
 438         LDATA_EXTRACT_CONFIG(NIX_INTF_RX, NPC_LID_LA, NPC_LT_LA_ETHER, 0, cfg);
 439 }
 440
 441 static void npc_config_kpuaction(struct rvu *rvu, int blkaddr,
 442                                  struct npc_kpu_profile_action *kpuaction,
 443                                  int kpu, int entry, bool pkind)
 444 {
 445         struct npc_kpu_action0 action0 = {0};
 446         struct npc_kpu_action1 action1 = {0};
 447         u64 reg;
 448
 449         action1.errlev = kpuaction->errlev;
 450         action1.errcode = kpuaction->errcode;
 451         action1.dp0_offset = kpuaction->dp0_offset;
 452         action1.dp1_offset = kpuaction->dp1_offset;
 453         action1.dp2_offset = kpuaction->dp2_offset;
 454
 455         if (pkind)
 456                 reg = NPC_AF_PKINDX_ACTION1(entry);
 457         else
 458                 reg = NPC_AF_KPUX_ENTRYX_ACTION1(kpu, entry);
 459
 460         rvu_write64(rvu, blkaddr, reg, *(u64 *)&action1);
 461
 462         action0.byp_count = kpuaction->bypass_count;
 463         action0.capture_ena = kpuaction->cap_ena;
 464         action0.parse_done = kpuaction->parse_done;
 465         action0.next_state = kpuaction->next_state;
 466         action0.capture_lid = kpuaction->lid;
 467         action0.capture_ltype = kpuaction->ltype;
 468         action0.capture_flags = kpuaction->flags;
 469         action0.ptr_advance = kpuaction->ptr_advance;
 470         action0.var_len_offset = kpuaction->offset;
 471         action0.var_len_mask = kpuaction->mask;
 472         action0.var_len_right = kpuaction->right;
 473         action0.var_len_shift = kpuaction->shift;
 474
 475         if (pkind)
 476                 reg = NPC_AF_PKINDX_ACTION0(entry);
 477         else
 478                 reg = NPC_AF_KPUX_ENTRYX_ACTION0(kpu, entry);
 479
 480         rvu_write64(rvu, blkaddr, reg, *(u64 *)&action0);
 481 }
 482
 483 static void npc_config_kpucam(struct rvu *rvu, int blkaddr,
 484                               struct npc_kpu_profile_cam *kpucam,
 485                               int kpu, int entry)
 486 {
 487         struct npc_kpu_cam cam0 = {0};
 488         struct npc_kpu_cam cam1 = {0};
 489
 490         cam1.state = kpucam->state & kpucam->state_mask;
 491         cam1.dp0_data = kpucam->dp0 & kpucam->dp0_mask;
 492         cam1.dp1_data = kpucam->dp1 & kpucam->dp1_mask;
 493         cam1.dp2_data = kpucam->dp2 & kpucam->dp2_mask;
 494
 495         cam0.state = ~kpucam->state & kpucam->state_mask;
 496         cam0.dp0_data = ~kpucam->dp0 & kpucam->dp0_mask;
 497         cam0.dp1_data = ~kpucam->dp1 & kpucam->dp1_mask;
 498         cam0.dp2_data = ~kpucam->dp2 & kpucam->dp2_mask;
 499
 500         rvu_write64(rvu, blkaddr,
 501                     NPC_AF_KPUX_ENTRYX_CAMX(kpu, entry, 0), *(u64 *)&cam0);
 502         rvu_write64(rvu, blkaddr,
 503                     NPC_AF_KPUX_ENTRYX_CAMX(kpu, entry, 1), *(u64 *)&cam1);
 504 }
 505
 506 static inline u64 enable_mask(int count)
 507 {
 508         return (((count) < 64) ? ~(BIT_ULL(count) - 1) : (0x00ULL));
 509 }
 510
 511 static void npc_program_kpu_profile(struct rvu *rvu, int blkaddr, int kpu,
 512                                     struct npc_kpu_profile *profile)
 513 {
 514         int entry, num_entries, max_entries;
 515
 516         if (profile->cam_entries != profile->action_entries) {
 517                 dev_err(rvu->dev,
 518                         "KPU%d: CAM and action entries [%d != %d] not equal\n",
 519                         kpu, profile->cam_entries, profile->action_entries);
 520         }
 521
 522         max_entries = rvu_read64(rvu, blkaddr, NPC_AF_CONST1) & 0xFFF;
 523
 524         /* Program CAM match entries for previous KPU extracted data */
 525         num_entries = min_t(int, profile->cam_entries, max_entries);
 526         for (entry = 0; entry < num_entries; entry++)
 527                 npc_config_kpucam(rvu, blkaddr,
 528                                   &profile->cam[entry], kpu, entry);
 529
 530         /* Program this KPU's actions */
 531         num_entries = min_t(int, profile->action_entries, max_entries);
 532         for (entry = 0; entry < num_entries; entry++)
 533                 npc_config_kpuaction(rvu, blkaddr, &profile->action[entry],
 534                                      kpu, entry, false);
 535
 536         /* Enable all programmed entries */
 537         num_entries = min_t(int, profile->action_entries, profile->cam_entries);
 538         rvu_write64(rvu, blkaddr,
 539                     NPC_AF_KPUX_ENTRY_DISX(kpu, 0), enable_mask(num_entries));
 540         if (num_entries > 64) {
 541                 rvu_write64(rvu, blkaddr,
 542                             NPC_AF_KPUX_ENTRY_DISX(kpu, 1),
 543                             enable_mask(num_entries - 64));
 544         }
 545
 546         /* Enable this KPU */
 547         rvu_write64(rvu, blkaddr, NPC_AF_KPUX_CFG(kpu), 0x01);
 548 }
 549
 550 static void npc_parser_profile_init(struct rvu *rvu, int blkaddr)
 551 {
 552         struct rvu_hwinfo *hw = rvu->hw;
 553         int num_pkinds, num_kpus, idx;
 554         struct npc_pkind *pkind;
 555
 556         /* Get HW limits */
 557         hw->npc_kpus = (rvu_read64(rvu, blkaddr, NPC_AF_CONST) >> 8) & 0x1F;
 558
 559         /* Disable all KPUs and their entries */
 560         for (idx = 0; idx < hw->npc_kpus; idx++) {
 561                 rvu_write64(rvu, blkaddr,
 562                             NPC_AF_KPUX_ENTRY_DISX(idx, 0), ~0ULL);
 563                 rvu_write64(rvu, blkaddr,
 564                             NPC_AF_KPUX_ENTRY_DISX(idx, 1), ~0ULL);
 565                 rvu_write64(rvu, blkaddr, NPC_AF_KPUX_CFG(idx), 0x00);
 566         }
 567
 568         /* First program IKPU profile i.e PKIND configs.
 569          * Check HW max count to avoid configuring junk or
 570          * writing to unsupported CSR addresses.
 571          */
 572         pkind = &hw->pkind;
 573         num_pkinds = ARRAY_SIZE(ikpu_action_entries);
 574         num_pkinds = min_t(int, pkind->rsrc.max, num_pkinds);
 575
 576         for (idx = 0; idx < num_pkinds; idx++)
 577                 npc_config_kpuaction(rvu, blkaddr,
 578                                      &ikpu_action_entries[idx], 0, idx, true);
 579
 580         /* Program KPU CAM and Action profiles */
 581         num_kpus = ARRAY_SIZE(npc_kpu_profiles);
 582         num_kpus = min_t(int, hw->npc_kpus, num_kpus);
 583
 584         for (idx = 0; idx < num_kpus; idx++)
 585                 npc_program_kpu_profile(rvu, blkaddr,
 586                                         idx, &npc_kpu_profiles[idx]);
 587 }
 588
 589 static int npc_mcam_rsrcs_init(struct rvu *rvu, int blkaddr)
 590 {
 591         int nixlf_count = rvu_get_nixlf_count(rvu);
 592         struct npc_mcam *mcam = &rvu->hw->mcam;
 593         int rsvd;
 594         u64 cfg;
 595
 596         /* Get HW limits */
 597         cfg = rvu_read64(rvu, blkaddr, NPC_AF_CONST);
 598         mcam->banks = (cfg >> 44) & 0xF;
 599         mcam->banksize = (cfg >> 28) & 0xFFFF;
 600
 601         /* Actual number of MCAM entries vary by entry size */
 602         cfg = (rvu_read64(rvu, blkaddr,
 603                           NPC_AF_INTFX_KEX_CFG(0)) >> 32) & 0x07;
 604         mcam->total_entries = (mcam->banks / BIT_ULL(cfg)) * mcam->banksize;
 605         mcam->keysize = cfg;
 606
 607         /* Number of banks combined per MCAM entry */
 608         if (cfg == NPC_MCAM_KEY_X4)
 609                 mcam->banks_per_entry = 4;
 610         else if (cfg == NPC_MCAM_KEY_X2)
 611                 mcam->banks_per_entry = 2;
 612         else
 613                 mcam->banks_per_entry = 1;
 614
 615         /* Reserve one MCAM entry for each of the NIX LF to
 616          * guarantee space to install default matching DMAC rule.
 617          * Also reserve 2 MCAM entries for each PF for default
 618          * channel based matching or 'bcast & promisc' matching to
 619          * support BCAST and PROMISC modes of operation for PFs.
 620          * PF0 is excluded.
 621          */
 622         rsvd = (nixlf_count * RSVD_MCAM_ENTRIES_PER_NIXLF) +
 623                 ((rvu->hw->total_pfs - 1) * RSVD_MCAM_ENTRIES_PER_PF);
 624         if (mcam->total_entries <= rsvd) {
 625                 dev_warn(rvu->dev,
 626                          "Insufficient NPC MCAM size %d for pkt I/O, exiting\n",
 627                          mcam->total_entries);
 628                 return -ENOMEM;
 629         }
 630
 631         mcam->entries = mcam->total_entries - rsvd;
 632         mcam->nixlf_offset = mcam->entries;
 633         mcam->pf_offset = mcam->nixlf_offset + nixlf_count;
 634
 635         spin_lock_init(&mcam->lock);
 636
 637         return 0;
 638 }
 639
 640 int rvu_npc_init(struct rvu *rvu)
 641 {
 642         struct npc_pkind *pkind = &rvu->hw->pkind;
 643         u64 keyz = NPC_MCAM_KEY_X2;
 644         int blkaddr, err;
 645
 646         blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_NPC, 0);
 647         if (blkaddr < 0) {
 648                 dev_err(rvu->dev, "%s: NPC block not implemented\n", __func__);
 649                 return -ENODEV;
 650         }
 651
 652         /* Allocate resource bimap for pkind*/
 653         pkind->rsrc.max = (rvu_read64(rvu, blkaddr,
 654                                       NPC_AF_CONST1) >> 12) & 0xFF;
 655         err = rvu_alloc_bitmap(&pkind->rsrc);
 656         if (err)
 657                 return err;
 658
 659         /* Allocate mem for pkind to PF and channel mapping info */
 660         pkind->pfchan_map = devm_kcalloc(rvu->dev, pkind->rsrc.max,
 661                                          sizeof(u32), GFP_KERNEL);
 662         if (!pkind->pfchan_map)
 663                 return -ENOMEM;
 664
 665         /* Configure KPU profile */
 666         npc_parser_profile_init(rvu, blkaddr);
 667
 668         /* Config Outer L2, IPv4's NPC layer info */
 669         rvu_write64(rvu, blkaddr, NPC_AF_PCK_DEF_OL2,
 670                     (NPC_LID_LA << 8) | (NPC_LT_LA_ETHER << 4) | 0x0F);
 671         rvu_write64(rvu, blkaddr, NPC_AF_PCK_DEF_OIP4,
 672                     (NPC_LID_LC << 8) | (NPC_LT_LC_IP << 4) | 0x0F);
 673
 674         /* Enable below for Rx pkts.
 675          * - Outer IPv4 header checksum validation.
 676          * - Detect outer L2 broadcast address and set NPC_RESULT_S[L2M].
 677          */
 678         rvu_write64(rvu, blkaddr, NPC_AF_PCK_CFG,
 679                     rvu_read64(rvu, blkaddr, NPC_AF_PCK_CFG) |
 680                     BIT_ULL(6) | BIT_ULL(2));
 681
 682         /* Set RX and TX side MCAM search key size.
 683          * Also enable parse key extract nibbles suchthat except
 684          * layer E to H, rest of the key is included for MCAM search.
 685          */
 686         rvu_write64(rvu, blkaddr, NPC_AF_INTFX_KEX_CFG(NIX_INTF_RX),
 687                     ((keyz & 0x3) << 32) | ((1ULL << 20) - 1));
 688         rvu_write64(rvu, blkaddr, NPC_AF_INTFX_KEX_CFG(NIX_INTF_TX),
 689                     ((keyz & 0x3) << 32) | ((1ULL << 20) - 1));
 690
 691         err = npc_mcam_rsrcs_init(rvu, blkaddr);
 692         if (err)
 693                 return err;
 694
 695         /* Config packet data and flags extraction into PARSE result */
 696         npc_config_ldata_extract(rvu, blkaddr);
 697
 698         /* Set TX miss action to UCAST_DEFAULT i.e
 699          * transmit the packet on NIX LF SQ's default channel.
 700          */
 701         rvu_write64(rvu, blkaddr, NPC_AF_INTFX_MISS_ACT(NIX_INTF_TX),
 702                     NIX_TX_ACTIONOP_UCAST_DEFAULT);
 703
 704         /* If MCAM lookup doesn't result in a match, drop the received packet */
 705         rvu_write64(rvu, blkaddr, NPC_AF_INTFX_MISS_ACT(NIX_INTF_RX),
 706                     NIX_RX_ACTIONOP_DROP);
 707
 708         return 0;
 709 }
 710
 711 void rvu_npc_freemem(struct rvu *rvu)
 712 {
 713         struct npc_pkind *pkind = &rvu->hw->pkind;
 714
 715         kfree(pkind->rsrc.bmap);
 716 }