drivers/net/ethernet/marvell/octeontx2/af/mcs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Marvell MCS driver
   3  *
   4  * Copyright (C) 2022 Marvell.
   5  */
   6
   7 #include <linux/bitfield.h>
   8 #include <linux/delay.h>
   9 #include <linux/device.h>
  10 #include <linux/module.h>
  11 #include <linux/pci.h>
  12
  13 #include "mcs.h"
  14 #include "mcs_reg.h"
  15
  16 #define DRV_NAME        "Marvell MCS Driver"
  17
  18 #define PCI_CFG_REG_BAR_NUM     0
  19
  20 static const struct pci_device_id mcs_id_table[] = {
  21         { PCI_DEVICE(PCI_VENDOR_ID_CAVIUM, PCI_DEVID_CN10K_MCS) },
  22         { 0, }  /* end of table */
  23 };
  24
  25 static LIST_HEAD(mcs_list);
  26
  27 void mcs_get_tx_secy_stats(struct mcs *mcs, struct mcs_secy_stats *stats, int id)
  28 {
  29         u64 reg;
  30
  31         reg = MCSX_CSE_TX_MEM_SLAVE_IFOUTCTLBCPKTSX(id);
  32         stats->ctl_pkt_bcast_cnt = mcs_reg_read(mcs, reg);
  33
  34         reg = MCSX_CSE_TX_MEM_SLAVE_IFOUTCTLMCPKTSX(id);
  35         stats->ctl_pkt_mcast_cnt = mcs_reg_read(mcs, reg);
  36
  37         reg = MCSX_CSE_TX_MEM_SLAVE_IFOUTCTLOCTETSX(id);
  38         stats->ctl_octet_cnt = mcs_reg_read(mcs, reg);
  39
  40         reg = MCSX_CSE_TX_MEM_SLAVE_IFOUTCTLUCPKTSX(id);
  41         stats->ctl_pkt_ucast_cnt = mcs_reg_read(mcs, reg);
  42
  43         reg = MCSX_CSE_TX_MEM_SLAVE_IFOUTUNCTLBCPKTSX(id);
  44         stats->unctl_pkt_bcast_cnt = mcs_reg_read(mcs, reg);
  45
  46         reg = MCSX_CSE_TX_MEM_SLAVE_IFOUTUNCTLMCPKTSX(id);
  47         stats->unctl_pkt_mcast_cnt = mcs_reg_read(mcs, reg);
  48
  49         reg = MCSX_CSE_TX_MEM_SLAVE_IFOUTUNCTLOCTETSX(id);
  50         stats->unctl_octet_cnt = mcs_reg_read(mcs, reg);
  51
  52         reg = MCSX_CSE_TX_MEM_SLAVE_IFOUTUNCTLUCPKTSX(id);
  53         stats->unctl_pkt_ucast_cnt = mcs_reg_read(mcs, reg);
  54
  55         reg = MCSX_CSE_TX_MEM_SLAVE_OUTOCTETSSECYENCRYPTEDX(id);
  56         stats->octet_encrypted_cnt =  mcs_reg_read(mcs, reg);
  57
  58         reg = MCSX_CSE_TX_MEM_SLAVE_OUTOCTETSSECYPROTECTEDX(id);
  59         stats->octet_protected_cnt =  mcs_reg_read(mcs, reg);
  60
  61         reg = MCSX_CSE_TX_MEM_SLAVE_OUTPKTSSECYNOACTIVESAX(id);
  62         stats->pkt_noactivesa_cnt =  mcs_reg_read(mcs, reg);
  63
  64         reg = MCSX_CSE_TX_MEM_SLAVE_OUTPKTSSECYTOOLONGX(id);
  65         stats->pkt_toolong_cnt =  mcs_reg_read(mcs, reg);
  66
  67         reg = MCSX_CSE_TX_MEM_SLAVE_OUTPKTSSECYUNTAGGEDX(id);
  68         stats->pkt_untagged_cnt =  mcs_reg_read(mcs, reg);
  69 }
  70
  71 void mcs_get_rx_secy_stats(struct mcs *mcs, struct mcs_secy_stats *stats, int id)
  72 {
  73         u64 reg;
  74
  75         reg = MCSX_CSE_RX_MEM_SLAVE_IFINCTLBCPKTSX(id);
  76         stats->ctl_pkt_bcast_cnt = mcs_reg_read(mcs, reg);
  77
  78         reg = MCSX_CSE_RX_MEM_SLAVE_IFINCTLMCPKTSX(id);
  79         stats->ctl_pkt_mcast_cnt = mcs_reg_read(mcs, reg);
  80
  81         reg = MCSX_CSE_RX_MEM_SLAVE_IFINCTLOCTETSX(id);
  82         stats->ctl_octet_cnt = mcs_reg_read(mcs, reg);
  83
  84         reg = MCSX_CSE_RX_MEM_SLAVE_IFINCTLUCPKTSX(id);
  85         stats->ctl_pkt_ucast_cnt = mcs_reg_read(mcs, reg);
  86
  87         reg = MCSX_CSE_RX_MEM_SLAVE_IFINUNCTLBCPKTSX(id);
  88         stats->unctl_pkt_bcast_cnt = mcs_reg_read(mcs, reg);
  89
  90         reg = MCSX_CSE_RX_MEM_SLAVE_IFINUNCTLMCPKTSX(id);
  91         stats->unctl_pkt_mcast_cnt = mcs_reg_read(mcs, reg);
  92
  93         reg = MCSX_CSE_RX_MEM_SLAVE_IFINUNCTLOCTETSX(id);
  94         stats->unctl_octet_cnt = mcs_reg_read(mcs, reg);
  95
  96         reg = MCSX_CSE_RX_MEM_SLAVE_IFINUNCTLUCPKTSX(id);
  97         stats->unctl_pkt_ucast_cnt = mcs_reg_read(mcs, reg);
  98
  99         reg = MCSX_CSE_RX_MEM_SLAVE_INOCTETSSECYDECRYPTEDX(id);
 100         stats->octet_decrypted_cnt =  mcs_reg_read(mcs, reg);
 101
 102         reg = MCSX_CSE_RX_MEM_SLAVE_INOCTETSSECYVALIDATEX(id);
 103         stats->octet_validated_cnt =  mcs_reg_read(mcs, reg);
 104
 105         reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSCTRLPORTDISABLEDX(id);
 106         stats->pkt_port_disabled_cnt =  mcs_reg_read(mcs, reg);
 107
 108         reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSECYBADTAGX(id);
 109         stats->pkt_badtag_cnt =  mcs_reg_read(mcs, reg);
 110
 111         reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSECYNOSAX(id);
 112         stats->pkt_nosa_cnt = mcs_reg_read(mcs, reg);
 113
 114         reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSECYNOSAERRORX(id);
 115         stats->pkt_nosaerror_cnt = mcs_reg_read(mcs, reg);
 116
 117         reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSECYTAGGEDCTLX(id);
 118         stats->pkt_tagged_ctl_cnt = mcs_reg_read(mcs, reg);
 119
 120         reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSECYUNTAGGEDORNOTAGX(id);
 121         stats->pkt_untaged_cnt = mcs_reg_read(mcs, reg);
 122
 123         reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSECYCTLX(id);
 124         stats->pkt_ctl_cnt = mcs_reg_read(mcs, reg);
 125
 126         if (mcs->hw->mcs_blks > 1) {
 127                 reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSECYNOTAGX(id);
 128                 stats->pkt_notag_cnt = mcs_reg_read(mcs, reg);
 129         }
 130 }
 131
 132 void mcs_get_flowid_stats(struct mcs *mcs, struct mcs_flowid_stats *stats,
 133                           int id, int dir)
 134 {
 135         u64 reg;
 136
 137         if (dir == MCS_RX)
 138                 reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSFLOWIDTCAMHITX(id);
 139         else
 140                 reg = MCSX_CSE_TX_MEM_SLAVE_OUTPKTSFLOWIDTCAMHITX(id);
 141
 142         stats->tcam_hit_cnt = mcs_reg_read(mcs, reg);
 143 }
 144
 145 void mcs_get_port_stats(struct mcs *mcs, struct mcs_port_stats *stats,
 146                         int id, int dir)
 147 {
 148         u64 reg;
 149
 150         if (dir == MCS_RX) {
 151                 reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSFLOWIDTCAMMISSX(id);
 152                 stats->tcam_miss_cnt = mcs_reg_read(mcs, reg);
 153
 154                 reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSPARSEERRX(id);
 155                 stats->parser_err_cnt = mcs_reg_read(mcs, reg);
 156                 if (mcs->hw->mcs_blks > 1) {
 157                         reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSEARLYPREEMPTERRX(id);
 158                         stats->preempt_err_cnt = mcs_reg_read(mcs, reg);
 159                 }
 160         } else {
 161                 reg = MCSX_CSE_TX_MEM_SLAVE_OUTPKTSFLOWIDTCAMMISSX(id);
 162                 stats->tcam_miss_cnt = mcs_reg_read(mcs, reg);
 163
 164                 reg = MCSX_CSE_TX_MEM_SLAVE_OUTPKTSPARSEERRX(id);
 165                 stats->parser_err_cnt = mcs_reg_read(mcs, reg);
 166
 167                 reg = MCSX_CSE_TX_MEM_SLAVE_OUTPKTSSECTAGINSERTIONERRX(id);
 168                 stats->sectag_insert_err_cnt = mcs_reg_read(mcs, reg);
 169         }
 170 }
 171
 172 void mcs_get_sa_stats(struct mcs *mcs, struct mcs_sa_stats *stats, int id, int dir)
 173 {
 174         u64 reg;
 175
 176         if (dir == MCS_RX) {
 177                 reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSAINVALIDX(id);
 178                 stats->pkt_invalid_cnt = mcs_reg_read(mcs, reg);
 179
 180                 reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSANOTUSINGSAERRORX(id);
 181                 stats->pkt_nosaerror_cnt = mcs_reg_read(mcs, reg);
 182
 183                 reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSANOTVALIDX(id);
 184                 stats->pkt_notvalid_cnt = mcs_reg_read(mcs, reg);
 185
 186                 reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSAOKX(id);
 187                 stats->pkt_ok_cnt = mcs_reg_read(mcs, reg);
 188
 189                 reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSAUNUSEDSAX(id);
 190                 stats->pkt_nosa_cnt = mcs_reg_read(mcs, reg);
 191         } else {
 192                 reg = MCSX_CSE_TX_MEM_SLAVE_OUTPKTSSAENCRYPTEDX(id);
 193                 stats->pkt_encrypt_cnt = mcs_reg_read(mcs, reg);
 194
 195                 reg = MCSX_CSE_TX_MEM_SLAVE_OUTPKTSSAPROTECTEDX(id);
 196                 stats->pkt_protected_cnt = mcs_reg_read(mcs, reg);
 197         }
 198 }
 199
 200 void mcs_get_sc_stats(struct mcs *mcs, struct mcs_sc_stats *stats,
 201                       int id, int dir)
 202 {
 203         u64 reg;
 204
 205         if (dir == MCS_RX) {
 206                 reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSCCAMHITX(id);
 207                 stats->hit_cnt = mcs_reg_read(mcs, reg);
 208
 209                 reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSCINVALIDX(id);
 210                 stats->pkt_invalid_cnt = mcs_reg_read(mcs, reg);
 211
 212                 reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSCLATEORDELAYEDX(id);
 213                 stats->pkt_late_cnt = mcs_reg_read(mcs, reg);
 214
 215                 reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSCNOTVALIDX(id);
 216                 stats->pkt_notvalid_cnt = mcs_reg_read(mcs, reg);
 217
 218                 reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSCUNCHECKEDOROKX(id);
 219                 stats->pkt_unchecked_cnt = mcs_reg_read(mcs, reg);
 220
 221                 if (mcs->hw->mcs_blks > 1) {
 222                         reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSCDELAYEDX(id);
 223                         stats->pkt_delay_cnt = mcs_reg_read(mcs, reg);
 224
 225                         reg = MCSX_CSE_RX_MEM_SLAVE_INPKTSSCOKX(id);
 226                         stats->pkt_ok_cnt = mcs_reg_read(mcs, reg);
 227                 }
 228                 if (mcs->hw->mcs_blks == 1) {
 229                         reg = MCSX_CSE_RX_MEM_SLAVE_INOCTETSSCDECRYPTEDX(id);
 230                         stats->octet_decrypt_cnt = mcs_reg_read(mcs, reg);
 231
 232                         reg = MCSX_CSE_RX_MEM_SLAVE_INOCTETSSCVALIDATEX(id);
 233                         stats->octet_validate_cnt = mcs_reg_read(mcs, reg);
 234                 }
 235         } else {
 236                 reg = MCSX_CSE_TX_MEM_SLAVE_OUTPKTSSCENCRYPTEDX(id);
 237                 stats->pkt_encrypt_cnt = mcs_reg_read(mcs, reg);
 238
 239                 reg = MCSX_CSE_TX_MEM_SLAVE_OUTPKTSSCPROTECTEDX(id);
 240                 stats->pkt_protected_cnt = mcs_reg_read(mcs, reg);
 241
 242                 if (mcs->hw->mcs_blks == 1) {
 243                         reg = MCSX_CSE_TX_MEM_SLAVE_OUTOCTETSSCENCRYPTEDX(id);
 244                         stats->octet_encrypt_cnt = mcs_reg_read(mcs, reg);
 245
 246                         reg = MCSX_CSE_TX_MEM_SLAVE_OUTOCTETSSCPROTECTEDX(id);
 247                         stats->octet_protected_cnt = mcs_reg_read(mcs, reg);
 248                 }
 249         }
 250 }
 251
 252 void mcs_clear_stats(struct mcs *mcs, u8 type, u8 id, int dir)
 253 {
 254         struct mcs_flowid_stats flowid_st;
 255         struct mcs_port_stats port_st;
 256         struct mcs_secy_stats secy_st;
 257         struct mcs_sc_stats sc_st;
 258         struct mcs_sa_stats sa_st;
 259         u64 reg;
 260
 261         if (dir == MCS_RX)
 262                 reg = MCSX_CSE_RX_SLAVE_CTRL;
 263         else
 264                 reg = MCSX_CSE_TX_SLAVE_CTRL;
 265
 266         mcs_reg_write(mcs, reg, BIT_ULL(0));
 267
 268         switch (type) {
 269         case MCS_FLOWID_STATS:
 270                 mcs_get_flowid_stats(mcs, &flowid_st, id, dir);
 271                 break;
 272         case MCS_SECY_STATS:
 273                 if (dir == MCS_RX)
 274                         mcs_get_rx_secy_stats(mcs, &secy_st, id);
 275                 else
 276                         mcs_get_tx_secy_stats(mcs, &secy_st, id);
 277                 break;
 278         case MCS_SC_STATS:
 279                 mcs_get_sc_stats(mcs, &sc_st, id, dir);
 280                 break;
 281         case MCS_SA_STATS:
 282                 mcs_get_sa_stats(mcs, &sa_st, id, dir);
 283                 break;
 284         case MCS_PORT_STATS:
 285                 mcs_get_port_stats(mcs, &port_st, id, dir);
 286                 break;
 287         }
 288
 289         mcs_reg_write(mcs, reg, 0x0);
 290 }
 291
 292 int mcs_clear_all_stats(struct mcs *mcs, u16 pcifunc, int dir)
 293 {
 294         struct mcs_rsrc_map *map;
 295         int id;
 296
 297         if (dir == MCS_RX)
 298                 map = &mcs->rx;
 299         else
 300                 map = &mcs->tx;
 301
 302         /* Clear FLOWID stats */
 303         for (id = 0; id < map->flow_ids.max; id++) {
 304                 if (map->flowid2pf_map[id] != pcifunc)
 305                         continue;
 306                 mcs_clear_stats(mcs, MCS_FLOWID_STATS, id, dir);
 307         }
 308
 309         /* Clear SECY stats */
 310         for (id = 0; id < map->secy.max; id++) {
 311                 if (map->secy2pf_map[id] != pcifunc)
 312                         continue;
 313                 mcs_clear_stats(mcs, MCS_SECY_STATS, id, dir);
 314         }
 315
 316         /* Clear SC stats */
 317         for (id = 0; id < map->secy.max; id++) {
 318                 if (map->sc2pf_map[id] != pcifunc)
 319                         continue;
 320                 mcs_clear_stats(mcs, MCS_SC_STATS, id, dir);
 321         }
 322
 323         /* Clear SA stats */
 324         for (id = 0; id < map->sa.max; id++) {
 325                 if (map->sa2pf_map[id] != pcifunc)
 326                         continue;
 327                 mcs_clear_stats(mcs, MCS_SA_STATS, id, dir);
 328         }
 329         return 0;
 330 }
 331
 332 void mcs_pn_table_write(struct mcs *mcs, u8 pn_id, u64 next_pn, u8 dir)
 333 {
 334         u64 reg;
 335
 336         if (dir == MCS_RX)
 337                 reg = MCSX_CPM_RX_SLAVE_SA_PN_TABLE_MEMX(pn_id);
 338         else
 339                 reg = MCSX_CPM_TX_SLAVE_SA_PN_TABLE_MEMX(pn_id);
 340         mcs_reg_write(mcs, reg, next_pn);
 341 }
 342
 343 void cn10kb_mcs_tx_sa_mem_map_write(struct mcs *mcs, struct mcs_tx_sc_sa_map *map)
 344 {
 345         u64 reg, val;
 346
 347         val = (map->sa_index0 & 0xFF) |
 348               (map->sa_index1 & 0xFF) << 9 |
 349               (map->rekey_ena & 0x1) << 18 |
 350               (map->sa_index0_vld & 0x1) << 19 |
 351               (map->sa_index1_vld & 0x1) << 20 |
 352               (map->tx_sa_active & 0x1) << 21 |
 353               map->sectag_sci << 22;
 354         reg = MCSX_CPM_TX_SLAVE_SA_MAP_MEM_0X(map->sc_id);
 355         mcs_reg_write(mcs, reg, val);
 356
 357         val = map->sectag_sci >> 42;
 358         reg = MCSX_CPM_TX_SLAVE_SA_MAP_MEM_1X(map->sc_id);
 359         mcs_reg_write(mcs, reg, val);
 360 }
 361
 362 void cn10kb_mcs_rx_sa_mem_map_write(struct mcs *mcs, struct mcs_rx_sc_sa_map *map)
 363 {
 364         u64 val, reg;
 365
 366         val = (map->sa_index & 0xFF) | map->sa_in_use << 9;
 367
 368         reg = MCSX_CPM_RX_SLAVE_SA_MAP_MEMX((4 * map->sc_id) + map->an);
 369         mcs_reg_write(mcs, reg, val);
 370 }
 371
 372 void mcs_sa_plcy_write(struct mcs *mcs, u64 *plcy, int sa_id, int dir)
 373 {
 374         int reg_id;
 375         u64 reg;
 376
 377         if (dir == MCS_RX) {
 378                 for (reg_id = 0; reg_id < 8; reg_id++) {
 379                         reg =  MCSX_CPM_RX_SLAVE_SA_PLCY_MEMX(reg_id, sa_id);
 380                         mcs_reg_write(mcs, reg, plcy[reg_id]);
 381                 }
 382         } else {
 383                 for (reg_id = 0; reg_id < 9; reg_id++) {
 384                         reg =  MCSX_CPM_TX_SLAVE_SA_PLCY_MEMX(reg_id, sa_id);
 385                         mcs_reg_write(mcs, reg, plcy[reg_id]);
 386                 }
 387         }
 388 }
 389
 390 void mcs_ena_dis_sc_cam_entry(struct mcs *mcs, int sc_id, int ena)
 391 {
 392         u64 reg, val;
 393
 394         reg = MCSX_CPM_RX_SLAVE_SC_CAM_ENA(0);
 395         if (sc_id > 63)
 396                 reg = MCSX_CPM_RX_SLAVE_SC_CAM_ENA(1);
 397
 398         if (ena)
 399                 val = mcs_reg_read(mcs, reg) | BIT_ULL(sc_id);
 400         else
 401                 val = mcs_reg_read(mcs, reg) & ~BIT_ULL(sc_id);
 402
 403         mcs_reg_write(mcs, reg, val);
 404 }
 405
 406 void mcs_rx_sc_cam_write(struct mcs *mcs, u64 sci, u64 secy, int sc_id)
 407 {
 408         mcs_reg_write(mcs, MCSX_CPM_RX_SLAVE_SC_CAMX(0, sc_id), sci);
 409         mcs_reg_write(mcs, MCSX_CPM_RX_SLAVE_SC_CAMX(1, sc_id), secy);
 410         /* Enable SC CAM */
 411         mcs_ena_dis_sc_cam_entry(mcs, sc_id, true);
 412 }
 413
 414 void mcs_secy_plcy_write(struct mcs *mcs, u64 plcy, int secy_id, int dir)
 415 {
 416         u64 reg;
 417
 418         if (dir == MCS_RX)
 419                 reg = MCSX_CPM_RX_SLAVE_SECY_PLCY_MEM_0X(secy_id);
 420         else
 421                 reg = MCSX_CPM_TX_SLAVE_SECY_PLCY_MEMX(secy_id);
 422
 423         mcs_reg_write(mcs, reg, plcy);
 424
 425         if (mcs->hw->mcs_blks == 1 && dir == MCS_RX)
 426                 mcs_reg_write(mcs, MCSX_CPM_RX_SLAVE_SECY_PLCY_MEM_1X(secy_id), 0x0ull);
 427 }
 428
 429 void cn10kb_mcs_flowid_secy_map(struct mcs *mcs, struct secy_mem_map *map, int dir)
 430 {
 431         u64 reg, val;
 432
 433         val = (map->secy & 0x7F) | (map->ctrl_pkt & 0x1) << 8;
 434         if (dir == MCS_RX) {
 435                 reg = MCSX_CPM_RX_SLAVE_SECY_MAP_MEMX(map->flow_id);
 436         } else {
 437                 val |= (map->sc & 0x7F) << 9;
 438                 reg = MCSX_CPM_TX_SLAVE_SECY_MAP_MEM_0X(map->flow_id);
 439         }
 440
 441         mcs_reg_write(mcs, reg, val);
 442 }
 443
 444 void mcs_ena_dis_flowid_entry(struct mcs *mcs, int flow_id, int dir, int ena)
 445 {
 446         u64 reg, val;
 447
 448         if (dir == MCS_RX) {
 449                 reg = MCSX_CPM_RX_SLAVE_FLOWID_TCAM_ENA_0;
 450                 if (flow_id > 63)
 451                         reg = MCSX_CPM_RX_SLAVE_FLOWID_TCAM_ENA_1;
 452         } else {
 453                 reg = MCSX_CPM_TX_SLAVE_FLOWID_TCAM_ENA_0;
 454                 if (flow_id > 63)
 455                         reg = MCSX_CPM_TX_SLAVE_FLOWID_TCAM_ENA_1;
 456         }
 457
 458         /* Enable/Disable the tcam entry */
 459         if (ena)
 460                 val = mcs_reg_read(mcs, reg) | BIT_ULL(flow_id);
 461         else
 462                 val = mcs_reg_read(mcs, reg) & ~BIT_ULL(flow_id);
 463
 464         mcs_reg_write(mcs, reg, val);
 465 }
 466
 467 void mcs_flowid_entry_write(struct mcs *mcs, u64 *data, u64 *mask, int flow_id, int dir)
 468 {
 469         int reg_id;
 470         u64 reg;
 471
 472         if (dir == MCS_RX) {
 473                 for (reg_id = 0; reg_id < 4; reg_id++) {
 474                         reg = MCSX_CPM_RX_SLAVE_FLOWID_TCAM_DATAX(reg_id, flow_id);
 475                         mcs_reg_write(mcs, reg, data[reg_id]);
 476                 }
 477                 for (reg_id = 0; reg_id < 4; reg_id++) {
 478                         reg = MCSX_CPM_RX_SLAVE_FLOWID_TCAM_MASKX(reg_id, flow_id);
 479                         mcs_reg_write(mcs, reg, mask[reg_id]);
 480                 }
 481         } else {
 482                 for (reg_id = 0; reg_id < 4; reg_id++) {
 483                         reg = MCSX_CPM_TX_SLAVE_FLOWID_TCAM_DATAX(reg_id, flow_id);
 484                         mcs_reg_write(mcs, reg, data[reg_id]);
 485                 }
 486                 for (reg_id = 0; reg_id < 4; reg_id++) {
 487                         reg = MCSX_CPM_TX_SLAVE_FLOWID_TCAM_MASKX(reg_id, flow_id);
 488                         mcs_reg_write(mcs, reg, mask[reg_id]);
 489                 }
 490         }
 491 }
 492
 493 int mcs_install_flowid_bypass_entry(struct mcs *mcs)
 494 {
 495         int flow_id, secy_id, reg_id;
 496         struct secy_mem_map map;
 497         u64 reg, plcy = 0;
 498
 499         /* Flow entry */
 500         flow_id = mcs->hw->tcam_entries - MCS_RSRC_RSVD_CNT;
 501         __set_bit(flow_id, mcs->rx.flow_ids.bmap);
 502         __set_bit(flow_id, mcs->tx.flow_ids.bmap);
 503
 504         for (reg_id = 0; reg_id < 4; reg_id++) {
 505                 reg = MCSX_CPM_RX_SLAVE_FLOWID_TCAM_MASKX(reg_id, flow_id);
 506                 mcs_reg_write(mcs, reg, GENMASK_ULL(63, 0));
 507         }
 508         for (reg_id = 0; reg_id < 4; reg_id++) {
 509                 reg = MCSX_CPM_TX_SLAVE_FLOWID_TCAM_MASKX(reg_id, flow_id);
 510                 mcs_reg_write(mcs, reg, GENMASK_ULL(63, 0));
 511         }
 512         /* secy */
 513         secy_id = mcs->hw->secy_entries - MCS_RSRC_RSVD_CNT;
 514         __set_bit(secy_id, mcs->rx.secy.bmap);
 515         __set_bit(secy_id, mcs->tx.secy.bmap);
 516
 517         /* Set validate frames to NULL and enable control port */
 518         plcy = 0x7ull;
 519         if (mcs->hw->mcs_blks > 1)
 520                 plcy = BIT_ULL(0) | 0x3ull << 4;
 521         mcs_secy_plcy_write(mcs, plcy, secy_id, MCS_RX);
 522
 523         /* Enable control port and set mtu to max */
 524         plcy = BIT_ULL(0) | GENMASK_ULL(43, 28);
 525         if (mcs->hw->mcs_blks > 1)
 526                 plcy = BIT_ULL(0) | GENMASK_ULL(63, 48);
 527         mcs_secy_plcy_write(mcs, plcy, secy_id, MCS_TX);
 528
 529         /* Map flowid to secy */
 530         map.secy = secy_id;
 531         map.ctrl_pkt = 0;
 532         map.flow_id = flow_id;
 533         mcs->mcs_ops->mcs_flowid_secy_map(mcs, &map, MCS_RX);
 534         map.sc = secy_id;
 535         mcs->mcs_ops->mcs_flowid_secy_map(mcs, &map, MCS_TX);
 536
 537         /* Enable Flowid entry */
 538         mcs_ena_dis_flowid_entry(mcs, flow_id, MCS_RX, true);
 539         mcs_ena_dis_flowid_entry(mcs, flow_id, MCS_TX, true);
 540
 541         return 0;
 542 }
 543
 544 void mcs_clear_secy_plcy(struct mcs *mcs, int secy_id, int dir)
 545 {
 546         struct mcs_rsrc_map *map;
 547         int flow_id;
 548
 549         if (dir == MCS_RX)
 550                 map = &mcs->rx;
 551         else
 552                 map = &mcs->tx;
 553
 554         /* Clear secy memory to zero */
 555         mcs_secy_plcy_write(mcs, 0, secy_id, dir);
 556
 557         /* Disable the tcam entry using this secy */
 558         for (flow_id = 0; flow_id < map->flow_ids.max; flow_id++) {
 559                 if (map->flowid2secy_map[flow_id] != secy_id)
 560                         continue;
 561                 mcs_ena_dis_flowid_entry(mcs, flow_id, dir, false);
 562         }
 563 }
 564
 565 int mcs_alloc_ctrlpktrule(struct rsrc_bmap *rsrc, u16 *pf_map, u16 offset, u16 pcifunc)
 566 {
 567         int rsrc_id;
 568
 569         if (!rsrc->bmap)
 570                 return -EINVAL;
 571
 572         rsrc_id = bitmap_find_next_zero_area(rsrc->bmap, rsrc->max, offset, 1, 0);
 573         if (rsrc_id >= rsrc->max)
 574                 return -ENOSPC;
 575
 576         bitmap_set(rsrc->bmap, rsrc_id, 1);
 577         pf_map[rsrc_id] = pcifunc;
 578
 579         return rsrc_id;
 580 }
 581
 582 int mcs_free_ctrlpktrule(struct mcs *mcs, struct mcs_free_ctrl_pkt_rule_req *req)
 583 {
 584         u16 pcifunc = req->hdr.pcifunc;
 585         struct mcs_rsrc_map *map;
 586         u64 dis, reg;
 587         int id, rc;
 588
 589         reg = (req->dir == MCS_RX) ? MCSX_PEX_RX_SLAVE_RULE_ENABLE : MCSX_PEX_TX_SLAVE_RULE_ENABLE;
 590         map = (req->dir == MCS_RX) ? &mcs->rx : &mcs->tx;
 591
 592         if (req->all) {
 593                 for (id = 0; id < map->ctrlpktrule.max; id++) {
 594                         if (map->ctrlpktrule2pf_map[id] != pcifunc)
 595                                 continue;
 596                         mcs_free_rsrc(&map->ctrlpktrule, map->ctrlpktrule2pf_map, id, pcifunc);
 597                         dis = mcs_reg_read(mcs, reg);
 598                         dis &= ~BIT_ULL(id);
 599                         mcs_reg_write(mcs, reg, dis);
 600                 }
 601                 return 0;
 602         }
 603
 604         rc = mcs_free_rsrc(&map->ctrlpktrule, map->ctrlpktrule2pf_map, req->rule_idx, pcifunc);
 605         dis = mcs_reg_read(mcs, reg);
 606         dis &= ~BIT_ULL(req->rule_idx);
 607         mcs_reg_write(mcs, reg, dis);
 608
 609         return rc;
 610 }
 611
 612 int mcs_ctrlpktrule_write(struct mcs *mcs, struct mcs_ctrl_pkt_rule_write_req *req)
 613 {
 614         u64 reg, enb;
 615         u64 idx;
 616
 617         switch (req->rule_type) {
 618         case MCS_CTRL_PKT_RULE_TYPE_ETH:
 619                 req->data0 &= GENMASK(15, 0);
 620                 if (req->data0 != ETH_P_PAE)
 621                         return -EINVAL;
 622
 623                 idx = req->rule_idx - MCS_CTRLPKT_ETYPE_RULE_OFFSET;
 624                 reg = (req->dir == MCS_RX) ? MCSX_PEX_RX_SLAVE_RULE_ETYPE_CFGX(idx) :
 625                       MCSX_PEX_TX_SLAVE_RULE_ETYPE_CFGX(idx);
 626
 627                 mcs_reg_write(mcs, reg, req->data0);
 628                 break;
 629         case MCS_CTRL_PKT_RULE_TYPE_DA:
 630                 if (!(req->data0 & BIT_ULL(40)))
 631                         return -EINVAL;
 632
 633                 idx = req->rule_idx - MCS_CTRLPKT_DA_RULE_OFFSET;
 634                 reg = (req->dir == MCS_RX) ? MCSX_PEX_RX_SLAVE_RULE_DAX(idx) :
 635                       MCSX_PEX_TX_SLAVE_RULE_DAX(idx);
 636
 637                 mcs_reg_write(mcs, reg, req->data0 & GENMASK_ULL(47, 0));
 638                 break;
 639         case MCS_CTRL_PKT_RULE_TYPE_RANGE:
 640                 if (!(req->data0 & BIT_ULL(40)) || !(req->data1 & BIT_ULL(40)))
 641                         return -EINVAL;
 642
 643                 idx = req->rule_idx - MCS_CTRLPKT_DA_RANGE_RULE_OFFSET;
 644                 if (req->dir == MCS_RX) {
 645                         reg = MCSX_PEX_RX_SLAVE_RULE_DA_RANGE_MINX(idx);
 646                         mcs_reg_write(mcs, reg, req->data0 & GENMASK_ULL(47, 0));
 647                         reg = MCSX_PEX_RX_SLAVE_RULE_DA_RANGE_MAXX(idx);
 648                         mcs_reg_write(mcs, reg, req->data1 & GENMASK_ULL(47, 0));
 649                 } else {
 650                         reg = MCSX_PEX_TX_SLAVE_RULE_DA_RANGE_MINX(idx);
 651                         mcs_reg_write(mcs, reg, req->data0 & GENMASK_ULL(47, 0));
 652                         reg = MCSX_PEX_TX_SLAVE_RULE_DA_RANGE_MAXX(idx);
 653                         mcs_reg_write(mcs, reg, req->data1 & GENMASK_ULL(47, 0));
 654                 }
 655                 break;
 656         case MCS_CTRL_PKT_RULE_TYPE_COMBO:
 657                 req->data2 &= GENMASK(15, 0);
 658                 if (req->data2 != ETH_P_PAE || !(req->data0 & BIT_ULL(40)) ||
 659                     !(req->data1 & BIT_ULL(40)))
 660                         return -EINVAL;
 661
 662                 idx = req->rule_idx - MCS_CTRLPKT_COMBO_RULE_OFFSET;
 663                 if (req->dir == MCS_RX) {
 664                         reg = MCSX_PEX_RX_SLAVE_RULE_COMBO_MINX(idx);
 665                         mcs_reg_write(mcs, reg, req->data0 & GENMASK_ULL(47, 0));
 666                         reg = MCSX_PEX_RX_SLAVE_RULE_COMBO_MAXX(idx);
 667                         mcs_reg_write(mcs, reg, req->data1 & GENMASK_ULL(47, 0));
 668                         reg = MCSX_PEX_RX_SLAVE_RULE_COMBO_ETX(idx);
 669                         mcs_reg_write(mcs, reg, req->data2);
 670                 } else {
 671                         reg = MCSX_PEX_TX_SLAVE_RULE_COMBO_MINX(idx);
 672                         mcs_reg_write(mcs, reg, req->data0 & GENMASK_ULL(47, 0));
 673                         reg = MCSX_PEX_TX_SLAVE_RULE_COMBO_MAXX(idx);
 674                         mcs_reg_write(mcs, reg, req->data1 & GENMASK_ULL(47, 0));
 675                         reg = MCSX_PEX_TX_SLAVE_RULE_COMBO_ETX(idx);
 676                         mcs_reg_write(mcs, reg, req->data2);
 677                 }
 678                 break;
 679         case MCS_CTRL_PKT_RULE_TYPE_MAC:
 680                 if (!(req->data0 & BIT_ULL(40)))
 681                         return -EINVAL;
 682
 683                 idx = req->rule_idx - MCS_CTRLPKT_MAC_EN_RULE_OFFSET;
 684                 reg = (req->dir == MCS_RX) ? MCSX_PEX_RX_SLAVE_RULE_MAC :
 685                       MCSX_PEX_TX_SLAVE_RULE_MAC;
 686
 687                 mcs_reg_write(mcs, reg, req->data0 & GENMASK_ULL(47, 0));
 688                 break;
 689         }
 690
 691         reg = (req->dir == MCS_RX) ? MCSX_PEX_RX_SLAVE_RULE_ENABLE : MCSX_PEX_TX_SLAVE_RULE_ENABLE;
 692
 693         enb = mcs_reg_read(mcs, reg);
 694         enb |= BIT_ULL(req->rule_idx);
 695         mcs_reg_write(mcs, reg, enb);
 696
 697         return 0;
 698 }
 699
 700 int mcs_free_rsrc(struct rsrc_bmap *rsrc, u16 *pf_map, int rsrc_id, u16 pcifunc)
 701 {
 702         /* Check if the rsrc_id is mapped to PF/VF */
 703         if (pf_map[rsrc_id] != pcifunc)
 704                 return -EINVAL;
 705
 706         rvu_free_rsrc(rsrc, rsrc_id);
 707         pf_map[rsrc_id] = 0;
 708         return 0;
 709 }
 710
 711 /* Free all the cam resources mapped to pf */
 712 int mcs_free_all_rsrc(struct mcs *mcs, int dir, u16 pcifunc)
 713 {
 714         struct mcs_rsrc_map *map;
 715         int id;
 716
 717         if (dir == MCS_RX)
 718                 map = &mcs->rx;
 719         else
 720                 map = &mcs->tx;
 721
 722         /* free tcam entries */
 723         for (id = 0; id < map->flow_ids.max; id++) {
 724                 if (map->flowid2pf_map[id] != pcifunc)
 725                         continue;
 726                 mcs_free_rsrc(&map->flow_ids, map->flowid2pf_map,
 727                               id, pcifunc);
 728                 mcs_ena_dis_flowid_entry(mcs, id, dir, false);
 729         }
 730
 731         /* free secy entries */
 732         for (id = 0; id < map->secy.max; id++) {
 733                 if (map->secy2pf_map[id] != pcifunc)
 734                         continue;
 735                 mcs_free_rsrc(&map->secy, map->secy2pf_map,
 736                               id, pcifunc);
 737                 mcs_clear_secy_plcy(mcs, id, dir);
 738         }
 739
 740         /* free sc entries */
 741         for (id = 0; id < map->secy.max; id++) {
 742                 if (map->sc2pf_map[id] != pcifunc)
 743                         continue;
 744                 mcs_free_rsrc(&map->sc, map->sc2pf_map, id, pcifunc);
 745
 746                 /* Disable SC CAM only on RX side */
 747                 if (dir == MCS_RX)
 748                         mcs_ena_dis_sc_cam_entry(mcs, id, false);
 749         }
 750
 751         /* free sa entries */
 752         for (id = 0; id < map->sa.max; id++) {
 753                 if (map->sa2pf_map[id] != pcifunc)
 754                         continue;
 755                 mcs_free_rsrc(&map->sa, map->sa2pf_map, id, pcifunc);
 756         }
 757         return 0;
 758 }
 759
 760 int mcs_alloc_rsrc(struct rsrc_bmap *rsrc, u16 *pf_map, u16 pcifunc)
 761 {
 762         int rsrc_id;
 763
 764         rsrc_id = rvu_alloc_rsrc(rsrc);
 765         if (rsrc_id < 0)
 766                 return -ENOMEM;
 767         pf_map[rsrc_id] = pcifunc;
 768         return rsrc_id;
 769 }
 770
 771 int mcs_alloc_all_rsrc(struct mcs *mcs, u8 *flow_id, u8 *secy_id,
 772                        u8 *sc_id, u8 *sa1_id, u8 *sa2_id, u16 pcifunc, int dir)
 773 {
 774         struct mcs_rsrc_map *map;
 775         int id;
 776
 777         if (dir == MCS_RX)
 778                 map = &mcs->rx;
 779         else
 780                 map = &mcs->tx;
 781
 782         id = mcs_alloc_rsrc(&map->flow_ids, map->flowid2pf_map, pcifunc);
 783         if (id < 0)
 784                 return -ENOMEM;
 785         *flow_id = id;
 786
 787         id = mcs_alloc_rsrc(&map->secy, map->secy2pf_map, pcifunc);
 788         if (id < 0)
 789                 return -ENOMEM;
 790         *secy_id = id;
 791
 792         id = mcs_alloc_rsrc(&map->sc, map->sc2pf_map, pcifunc);
 793         if (id < 0)
 794                 return -ENOMEM;
 795         *sc_id = id;
 796
 797         id =  mcs_alloc_rsrc(&map->sa, map->sa2pf_map, pcifunc);
 798         if (id < 0)
 799                 return -ENOMEM;
 800         *sa1_id = id;
 801
 802         id =  mcs_alloc_rsrc(&map->sa, map->sa2pf_map, pcifunc);
 803         if (id < 0)
 804                 return -ENOMEM;
 805         *sa2_id = id;
 806
 807         return 0;
 808 }
 809
 810 static void cn10kb_mcs_tx_pn_wrapped_handler(struct mcs *mcs)
 811 {
 812         struct mcs_intr_event event = { 0 };
 813         struct rsrc_bmap *sc_bmap;
 814         u64 val;
 815         int sc;
 816
 817         sc_bmap = &mcs->tx.sc;
 818
 819         event.mcs_id = mcs->mcs_id;
 820         event.intr_mask = MCS_CPM_TX_PACKET_XPN_EQ0_INT;
 821
 822         for_each_set_bit(sc, sc_bmap->bmap, mcs->hw->sc_entries) {
 823                 val = mcs_reg_read(mcs, MCSX_CPM_TX_SLAVE_SA_MAP_MEM_0X(sc));
 824
 825                 if (mcs->tx_sa_active[sc])
 826                         /* SA_index1 was used and got expired */
 827                         event.sa_id = (val >> 9) & 0xFF;
 828                 else
 829                         /* SA_index0 was used and got expired */
 830                         event.sa_id = val & 0xFF;
 831
 832                 event.pcifunc = mcs->tx.sa2pf_map[event.sa_id];
 833                 mcs_add_intr_wq_entry(mcs, &event);
 834         }
 835 }
 836
 837 static void cn10kb_mcs_tx_pn_thresh_reached_handler(struct mcs *mcs)
 838 {
 839         struct mcs_intr_event event = { 0 };
 840         struct rsrc_bmap *sc_bmap;
 841         u64 val, status;
 842         int sc;
 843
 844         sc_bmap = &mcs->tx.sc;
 845
 846         event.mcs_id = mcs->mcs_id;
 847         event.intr_mask = MCS_CPM_TX_PN_THRESH_REACHED_INT;
 848
 849         /* TX SA interrupt is raised only if autorekey is enabled.
 850          * MCS_CPM_TX_SLAVE_SA_MAP_MEM_0X[sc].tx_sa_active bit gets toggled if
 851          * one of two SAs mapped to SC gets expired. If tx_sa_active=0 implies
 852          * SA in SA_index1 got expired else SA in SA_index0 got expired.
 853          */
 854         for_each_set_bit(sc, sc_bmap->bmap, mcs->hw->sc_entries) {
 855                 val = mcs_reg_read(mcs, MCSX_CPM_TX_SLAVE_SA_MAP_MEM_0X(sc));
 856                 /* Auto rekey is enable */
 857                 if (!((val >> 18) & 0x1))
 858                         continue;
 859
 860                 status = (val >> 21) & 0x1;
 861
 862                 /* Check if tx_sa_active status had changed */
 863                 if (status == mcs->tx_sa_active[sc])
 864                         continue;
 865                 /* SA_index0 is expired */
 866                 if (status)
 867                         event.sa_id = val & 0xFF;
 868                 else
 869                         event.sa_id = (val >> 9) & 0xFF;
 870
 871                 event.pcifunc = mcs->tx.sa2pf_map[event.sa_id];
 872                 mcs_add_intr_wq_entry(mcs, &event);
 873         }
 874 }
 875
 876 static void mcs_rx_pn_thresh_reached_handler(struct mcs *mcs)
 877 {
 878         struct mcs_intr_event event = { 0 };
 879         int sa, reg;
 880         u64 intr;
 881
 882         /* Check expired SAs */
 883         for (reg = 0; reg < (mcs->hw->sa_entries / 64); reg++) {
 884                 /* Bit high in *PN_THRESH_REACHEDX implies
 885                  * corresponding SAs are expired.
 886                  */
 887                 intr = mcs_reg_read(mcs, MCSX_CPM_RX_SLAVE_PN_THRESH_REACHEDX(reg));
 888                 for (sa = 0; sa < 64; sa++) {
 889                         if (!(intr & BIT_ULL(sa)))
 890                                 continue;
 891
 892                         event.mcs_id = mcs->mcs_id;
 893                         event.intr_mask = MCS_CPM_RX_PN_THRESH_REACHED_INT;
 894                         event.sa_id = sa + (reg * 64);
 895                         event.pcifunc = mcs->rx.sa2pf_map[event.sa_id];
 896                         mcs_add_intr_wq_entry(mcs, &event);
 897                 }
 898         }
 899 }
 900
 901 static void mcs_rx_misc_intr_handler(struct mcs *mcs, u64 intr)
 902 {
 903         struct mcs_intr_event event = { 0 };
 904
 905         event.mcs_id = mcs->mcs_id;
 906         event.pcifunc = mcs->pf_map[0];
 907
 908         if (intr & MCS_CPM_RX_INT_SECTAG_V_EQ1)
 909                 event.intr_mask = MCS_CPM_RX_SECTAG_V_EQ1_INT;
 910         if (intr & MCS_CPM_RX_INT_SECTAG_E_EQ0_C_EQ1)
 911                 event.intr_mask |= MCS_CPM_RX_SECTAG_E_EQ0_C_EQ1_INT;
 912         if (intr & MCS_CPM_RX_INT_SL_GTE48)
 913                 event.intr_mask |= MCS_CPM_RX_SECTAG_SL_GTE48_INT;
 914         if (intr & MCS_CPM_RX_INT_ES_EQ1_SC_EQ1)
 915                 event.intr_mask |= MCS_CPM_RX_SECTAG_ES_EQ1_SC_EQ1_INT;
 916         if (intr & MCS_CPM_RX_INT_SC_EQ1_SCB_EQ1)
 917                 event.intr_mask |= MCS_CPM_RX_SECTAG_SC_EQ1_SCB_EQ1_INT;
 918         if (intr & MCS_CPM_RX_INT_PACKET_XPN_EQ0)
 919                 event.intr_mask |= MCS_CPM_RX_PACKET_XPN_EQ0_INT;
 920
 921         mcs_add_intr_wq_entry(mcs, &event);
 922 }
 923
 924 static void mcs_tx_misc_intr_handler(struct mcs *mcs, u64 intr)
 925 {
 926         struct mcs_intr_event event = { 0 };
 927
 928         if (!(intr & MCS_CPM_TX_INT_SA_NOT_VALID))
 929                 return;
 930
 931         event.mcs_id = mcs->mcs_id;
 932         event.pcifunc = mcs->pf_map[0];
 933
 934         event.intr_mask = MCS_CPM_TX_SA_NOT_VALID_INT;
 935
 936         mcs_add_intr_wq_entry(mcs, &event);
 937 }
 938
 939 void cn10kb_mcs_bbe_intr_handler(struct mcs *mcs, u64 intr,
 940                                  enum mcs_direction dir)
 941 {
 942         u64 val, reg;
 943         int lmac;
 944
 945         if (!(intr & 0x6ULL))
 946                 return;
 947
 948         if (intr & BIT_ULL(1))
 949                 reg = (dir == MCS_RX) ? MCSX_BBE_RX_SLAVE_DFIFO_OVERFLOW_0 :
 950                                         MCSX_BBE_TX_SLAVE_DFIFO_OVERFLOW_0;
 951         else
 952                 reg = (dir == MCS_RX) ? MCSX_BBE_RX_SLAVE_PLFIFO_OVERFLOW_0 :
 953                                         MCSX_BBE_TX_SLAVE_PLFIFO_OVERFLOW_0;
 954         val = mcs_reg_read(mcs, reg);
 955
 956         /* policy/data over flow occurred */
 957         for (lmac = 0; lmac < mcs->hw->lmac_cnt; lmac++) {
 958                 if (!(val & BIT_ULL(lmac)))
 959                         continue;
 960                 dev_warn(mcs->dev, "BEE:Policy or data overflow occurred on lmac:%d\n", lmac);
 961         }
 962 }
 963
 964 void cn10kb_mcs_pab_intr_handler(struct mcs *mcs, u64 intr,
 965                                  enum mcs_direction dir)
 966 {
 967         int lmac;
 968
 969         if (!(intr & 0xFFFFFULL))
 970                 return;
 971
 972         for (lmac = 0; lmac < mcs->hw->lmac_cnt; lmac++) {
 973                 if (intr & BIT_ULL(lmac))
 974                         dev_warn(mcs->dev, "PAB: overflow occurred on lmac:%d\n", lmac);
 975         }
 976 }
 977
 978 static irqreturn_t mcs_ip_intr_handler(int irq, void *mcs_irq)
 979 {
 980         struct mcs *mcs = (struct mcs *)mcs_irq;
 981         u64 intr, cpm_intr, bbe_intr, pab_intr;
 982
 983         /* Disable  the interrupt */
 984         mcs_reg_write(mcs, MCSX_IP_INT_ENA_W1C, BIT_ULL(0));
 985
 986         /* Check which block has interrupt*/
 987         intr = mcs_reg_read(mcs, MCSX_TOP_SLAVE_INT_SUM);
 988
 989         /* CPM RX */
 990         if (intr & MCS_CPM_RX_INT_ENA) {
 991                 /* Check for PN thresh interrupt bit */
 992                 cpm_intr = mcs_reg_read(mcs, MCSX_CPM_RX_SLAVE_RX_INT);
 993
 994                 if (cpm_intr & MCS_CPM_RX_INT_PN_THRESH_REACHED)
 995                         mcs_rx_pn_thresh_reached_handler(mcs);
 996
 997                 if (cpm_intr & MCS_CPM_RX_INT_ALL)
 998                         mcs_rx_misc_intr_handler(mcs, cpm_intr);
 999
1000                 /* Clear the interrupt */
1001                 mcs_reg_write(mcs, MCSX_CPM_RX_SLAVE_RX_INT, cpm_intr);
1002         }
1003
1004         /* CPM TX */
1005         if (intr & MCS_CPM_TX_INT_ENA) {
1006                 cpm_intr = mcs_reg_read(mcs, MCSX_CPM_TX_SLAVE_TX_INT);
1007
1008                 if (cpm_intr & MCS_CPM_TX_INT_PN_THRESH_REACHED) {
1009                         if (mcs->hw->mcs_blks > 1)
1010                                 cnf10kb_mcs_tx_pn_thresh_reached_handler(mcs);
1011                         else
1012                                 cn10kb_mcs_tx_pn_thresh_reached_handler(mcs);
1013                 }
1014
1015                 if (cpm_intr & MCS_CPM_TX_INT_SA_NOT_VALID)
1016                         mcs_tx_misc_intr_handler(mcs, cpm_intr);
1017
1018                 if (cpm_intr & MCS_CPM_TX_INT_PACKET_XPN_EQ0) {
1019                         if (mcs->hw->mcs_blks > 1)
1020                                 cnf10kb_mcs_tx_pn_wrapped_handler(mcs);
1021                         else
1022                                 cn10kb_mcs_tx_pn_wrapped_handler(mcs);
1023                 }
1024                 /* Clear the interrupt */
1025                 mcs_reg_write(mcs, MCSX_CPM_TX_SLAVE_TX_INT, cpm_intr);
1026         }
1027
1028         /* BBE RX */
1029         if (intr & MCS_BBE_RX_INT_ENA) {
1030                 bbe_intr = mcs_reg_read(mcs, MCSX_BBE_RX_SLAVE_BBE_INT);
1031                 mcs->mcs_ops->mcs_bbe_intr_handler(mcs, bbe_intr, MCS_RX);
1032
1033                 /* Clear the interrupt */
1034                 mcs_reg_write(mcs, MCSX_BBE_RX_SLAVE_BBE_INT_INTR_RW, 0);
1035                 mcs_reg_write(mcs, MCSX_BBE_RX_SLAVE_BBE_INT, bbe_intr);
1036         }
1037
1038         /* BBE TX */
1039         if (intr & MCS_BBE_TX_INT_ENA) {
1040                 bbe_intr = mcs_reg_read(mcs, MCSX_BBE_TX_SLAVE_BBE_INT);
1041                 mcs->mcs_ops->mcs_bbe_intr_handler(mcs, bbe_intr, MCS_TX);
1042
1043                 /* Clear the interrupt */
1044                 mcs_reg_write(mcs, MCSX_BBE_TX_SLAVE_BBE_INT_INTR_RW, 0);
1045                 mcs_reg_write(mcs, MCSX_BBE_TX_SLAVE_BBE_INT, bbe_intr);
1046         }
1047
1048         /* PAB RX */
1049         if (intr & MCS_PAB_RX_INT_ENA) {
1050                 pab_intr = mcs_reg_read(mcs, MCSX_PAB_RX_SLAVE_PAB_INT);
1051                 mcs->mcs_ops->mcs_pab_intr_handler(mcs, pab_intr, MCS_RX);
1052
1053                 /* Clear the interrupt */
1054                 mcs_reg_write(mcs, MCSX_PAB_RX_SLAVE_PAB_INT_INTR_RW, 0);
1055                 mcs_reg_write(mcs, MCSX_PAB_RX_SLAVE_PAB_INT, pab_intr);
1056         }
1057
1058         /* PAB TX */
1059         if (intr & MCS_PAB_TX_INT_ENA) {
1060                 pab_intr = mcs_reg_read(mcs, MCSX_PAB_TX_SLAVE_PAB_INT);
1061                 mcs->mcs_ops->mcs_pab_intr_handler(mcs, pab_intr, MCS_TX);
1062
1063                 /* Clear the interrupt */
1064                 mcs_reg_write(mcs, MCSX_PAB_TX_SLAVE_PAB_INT_INTR_RW, 0);
1065                 mcs_reg_write(mcs, MCSX_PAB_TX_SLAVE_PAB_INT, pab_intr);
1066         }
1067
1068         /* Clear and enable the interrupt */
1069         mcs_reg_write(mcs, MCSX_IP_INT, BIT_ULL(0));
1070         mcs_reg_write(mcs, MCSX_IP_INT_ENA_W1S, BIT_ULL(0));
1071
1072         return IRQ_HANDLED;
1073 }
1074
1075 static void *alloc_mem(struct mcs *mcs, int n)
1076 {
1077         return devm_kcalloc(mcs->dev, n, sizeof(u16), GFP_KERNEL);
1078 }
1079
1080 static int mcs_alloc_struct_mem(struct mcs *mcs, struct mcs_rsrc_map *res)
1081 {
1082         struct hwinfo *hw = mcs->hw;
1083         int err;
1084
1085         res->flowid2pf_map = alloc_mem(mcs, hw->tcam_entries);
1086         if (!res->flowid2pf_map)
1087                 return -ENOMEM;
1088
1089         res->secy2pf_map = alloc_mem(mcs, hw->secy_entries);
1090         if (!res->secy2pf_map)
1091                 return -ENOMEM;
1092
1093         res->sc2pf_map = alloc_mem(mcs, hw->sc_entries);
1094         if (!res->sc2pf_map)
1095                 return -ENOMEM;
1096
1097         res->sa2pf_map = alloc_mem(mcs, hw->sa_entries);
1098         if (!res->sa2pf_map)
1099                 return -ENOMEM;
1100
1101         res->flowid2secy_map = alloc_mem(mcs, hw->tcam_entries);
1102         if (!res->flowid2secy_map)
1103                 return -ENOMEM;
1104
1105         res->ctrlpktrule2pf_map = alloc_mem(mcs, MCS_MAX_CTRLPKT_RULES);
1106         if (!res->ctrlpktrule2pf_map)
1107                 return -ENOMEM;
1108
1109         res->flow_ids.max = hw->tcam_entries - MCS_RSRC_RSVD_CNT;
1110         err = rvu_alloc_bitmap(&res->flow_ids);
1111         if (err)
1112                 return err;
1113
1114         res->secy.max = hw->secy_entries - MCS_RSRC_RSVD_CNT;
1115         err = rvu_alloc_bitmap(&res->secy);
1116         if (err)
1117                 return err;
1118
1119         res->sc.max = hw->sc_entries;
1120         err = rvu_alloc_bitmap(&res->sc);
1121         if (err)
1122                 return err;
1123
1124         res->sa.max = hw->sa_entries;
1125         err = rvu_alloc_bitmap(&res->sa);
1126         if (err)
1127                 return err;
1128
1129         res->ctrlpktrule.max = MCS_MAX_CTRLPKT_RULES;
1130         err = rvu_alloc_bitmap(&res->ctrlpktrule);
1131         if (err)
1132                 return err;
1133
1134         return 0;
1135 }
1136
1137 static int mcs_register_interrupts(struct mcs *mcs)
1138 {
1139         int ret = 0;
1140
1141         mcs->num_vec = pci_msix_vec_count(mcs->pdev);
1142
1143         ret = pci_alloc_irq_vectors(mcs->pdev, mcs->num_vec,
1144                                     mcs->num_vec, PCI_IRQ_MSIX);
1145         if (ret < 0) {
1146                 dev_err(mcs->dev, "MCS Request for %d msix vector failed err:%d\n",
1147                         mcs->num_vec, ret);
1148                 return ret;
1149         }
1150
1151         ret = request_irq(pci_irq_vector(mcs->pdev, mcs->hw->ip_vec),
1152                           mcs_ip_intr_handler, 0, "MCS_IP", mcs);
1153         if (ret) {
1154                 dev_err(mcs->dev, "MCS IP irq registration failed\n");
1155                 goto exit;
1156         }
1157
1158         /* MCS enable IP interrupts */
1159         mcs_reg_write(mcs, MCSX_IP_INT_ENA_W1S, BIT_ULL(0));
1160
1161         /* Enable CPM Rx/Tx interrupts */
1162         mcs_reg_write(mcs, MCSX_TOP_SLAVE_INT_SUM_ENB,
1163                       MCS_CPM_RX_INT_ENA | MCS_CPM_TX_INT_ENA |
1164                       MCS_BBE_RX_INT_ENA | MCS_BBE_TX_INT_ENA |
1165                       MCS_PAB_RX_INT_ENA | MCS_PAB_TX_INT_ENA);
1166
1167         mcs_reg_write(mcs, MCSX_CPM_TX_SLAVE_TX_INT_ENB, 0x7ULL);
1168         mcs_reg_write(mcs, MCSX_CPM_RX_SLAVE_RX_INT_ENB, 0x7FULL);
1169
1170         mcs_reg_write(mcs, MCSX_BBE_RX_SLAVE_BBE_INT_ENB, 0xFFULL);
1171         mcs_reg_write(mcs, MCSX_BBE_TX_SLAVE_BBE_INT_ENB, 0xFFULL);
1172
1173         mcs_reg_write(mcs, MCSX_PAB_RX_SLAVE_PAB_INT_ENB, 0xFFFFFULL);
1174         mcs_reg_write(mcs, MCSX_PAB_TX_SLAVE_PAB_INT_ENB, 0xFFFFFULL);
1175
1176         mcs->tx_sa_active = alloc_mem(mcs, mcs->hw->sc_entries);
1177         if (!mcs->tx_sa_active) {
1178                 ret = -ENOMEM;
1179                 goto free_irq;
1180         }
1181
1182         return ret;
1183
1184 free_irq:
1185         free_irq(pci_irq_vector(mcs->pdev, mcs->hw->ip_vec), mcs);
1186 exit:
1187         pci_free_irq_vectors(mcs->pdev);
1188         mcs->num_vec = 0;
1189         return ret;
1190 }
1191
1192 int mcs_get_blkcnt(void)
1193 {
1194         struct mcs *mcs;
1195         int idmax = -ENODEV;
1196
1197         /* Check MCS block is present in hardware */
1198         if (!pci_dev_present(mcs_id_table))
1199                 return 0;
1200
1201         list_for_each_entry(mcs, &mcs_list, mcs_list)
1202                 if (mcs->mcs_id > idmax)
1203                         idmax = mcs->mcs_id;
1204
1205         if (idmax < 0)
1206                 return 0;
1207
1208         return idmax + 1;
1209 }
1210
1211 struct mcs *mcs_get_pdata(int mcs_id)
1212 {
1213         struct mcs *mcs_dev;
1214
1215         list_for_each_entry(mcs_dev, &mcs_list, mcs_list) {
1216                 if (mcs_dev->mcs_id == mcs_id)
1217                         return mcs_dev;
1218         }
1219         return NULL;
1220 }
1221
1222 bool is_mcs_bypass(int mcs_id)
1223 {
1224         struct mcs *mcs_dev;
1225
1226         list_for_each_entry(mcs_dev, &mcs_list, mcs_list) {
1227                 if (mcs_dev->mcs_id == mcs_id)
1228                         return mcs_dev->bypass;
1229         }
1230         return true;
1231 }
1232
1233 void mcs_set_port_cfg(struct mcs *mcs, struct mcs_port_cfg_set_req *req)
1234 {
1235         u64 val = 0;
1236
1237         mcs_reg_write(mcs, MCSX_PAB_RX_SLAVE_PORT_CFGX(req->port_id),
1238                       req->port_mode & MCS_PORT_MODE_MASK);
1239
1240         req->cstm_tag_rel_mode_sel &= 0x3;
1241
1242         if (mcs->hw->mcs_blks > 1) {
1243                 req->fifo_skid &= MCS_PORT_FIFO_SKID_MASK;
1244                 val = (u32)req->fifo_skid << 0x10;
1245                 val |= req->fifo_skid;
1246                 mcs_reg_write(mcs, MCSX_PAB_RX_SLAVE_FIFO_SKID_CFGX(req->port_id), val);
1247                 mcs_reg_write(mcs, MCSX_PEX_TX_SLAVE_CUSTOM_TAG_REL_MODE_SEL(req->port_id),
1248                               req->cstm_tag_rel_mode_sel);
1249                 val = mcs_reg_read(mcs, MCSX_PEX_RX_SLAVE_PEX_CONFIGURATION);
1250
1251                 if (req->custom_hdr_enb)
1252                         val |= BIT_ULL(req->port_id);
1253                 else
1254                         val &= ~BIT_ULL(req->port_id);
1255
1256                 mcs_reg_write(mcs, MCSX_PEX_RX_SLAVE_PEX_CONFIGURATION, val);
1257         } else {
1258                 val = mcs_reg_read(mcs, MCSX_PEX_TX_SLAVE_PORT_CONFIG(req->port_id));
1259                 val |= (req->cstm_tag_rel_mode_sel << 2);
1260                 mcs_reg_write(mcs, MCSX_PEX_TX_SLAVE_PORT_CONFIG(req->port_id), val);
1261         }
1262 }
1263
1264 void mcs_get_port_cfg(struct mcs *mcs, struct mcs_port_cfg_get_req *req,
1265                       struct mcs_port_cfg_get_rsp *rsp)
1266 {
1267         u64 reg = 0;
1268
1269         rsp->port_mode = mcs_reg_read(mcs, MCSX_PAB_RX_SLAVE_PORT_CFGX(req->port_id)) &
1270                          MCS_PORT_MODE_MASK;
1271
1272         if (mcs->hw->mcs_blks > 1) {
1273                 reg = MCSX_PAB_RX_SLAVE_FIFO_SKID_CFGX(req->port_id);
1274                 rsp->fifo_skid = mcs_reg_read(mcs, reg) & MCS_PORT_FIFO_SKID_MASK;
1275                 reg = MCSX_PEX_TX_SLAVE_CUSTOM_TAG_REL_MODE_SEL(req->port_id);
1276                 rsp->cstm_tag_rel_mode_sel = mcs_reg_read(mcs, reg) & 0x3;
1277                 if (mcs_reg_read(mcs, MCSX_PEX_RX_SLAVE_PEX_CONFIGURATION) & BIT_ULL(req->port_id))
1278                         rsp->custom_hdr_enb = 1;
1279         } else {
1280                 reg = MCSX_PEX_TX_SLAVE_PORT_CONFIG(req->port_id);
1281                 rsp->cstm_tag_rel_mode_sel = mcs_reg_read(mcs, reg) >> 2;
1282         }
1283
1284         rsp->port_id = req->port_id;
1285         rsp->mcs_id = req->mcs_id;
1286 }
1287
1288 void mcs_get_custom_tag_cfg(struct mcs *mcs, struct mcs_custom_tag_cfg_get_req *req,
1289                             struct mcs_custom_tag_cfg_get_rsp *rsp)
1290 {
1291         u64 reg = 0, val = 0;
1292         u8 idx;
1293
1294         for (idx = 0; idx < MCS_MAX_CUSTOM_TAGS; idx++) {
1295                 if (mcs->hw->mcs_blks > 1)
1296                         reg  = (req->dir == MCS_RX) ? MCSX_PEX_RX_SLAVE_CUSTOM_TAGX(idx) :
1297                                 MCSX_PEX_TX_SLAVE_CUSTOM_TAGX(idx);
1298                 else
1299                         reg = (req->dir == MCS_RX) ? MCSX_PEX_RX_SLAVE_VLAN_CFGX(idx) :
1300                                 MCSX_PEX_TX_SLAVE_VLAN_CFGX(idx);
1301
1302                 val = mcs_reg_read(mcs, reg);
1303                 if (mcs->hw->mcs_blks > 1) {
1304                         rsp->cstm_etype[idx] = val & GENMASK(15, 0);
1305                         rsp->cstm_indx[idx] = (val >> 0x16) & 0x3;
1306                         reg = (req->dir == MCS_RX) ? MCSX_PEX_RX_SLAVE_ETYPE_ENABLE :
1307                                 MCSX_PEX_TX_SLAVE_ETYPE_ENABLE;
1308                         rsp->cstm_etype_en = mcs_reg_read(mcs, reg) & 0xFF;
1309                 } else {
1310                         rsp->cstm_etype[idx] = (val >> 0x1) & GENMASK(15, 0);
1311                         rsp->cstm_indx[idx] = (val >> 0x11) & 0x3;
1312                         rsp->cstm_etype_en |= (val & 0x1) << idx;
1313                 }
1314         }
1315
1316         rsp->mcs_id = req->mcs_id;
1317         rsp->dir = req->dir;
1318 }
1319
1320 void mcs_reset_port(struct mcs *mcs, u8 port_id, u8 reset)
1321 {
1322         u64 reg = MCSX_MCS_TOP_SLAVE_PORT_RESET(port_id);
1323
1324         mcs_reg_write(mcs, reg, reset & 0x1);
1325 }
1326
1327 /* Set lmac to bypass/operational mode */
1328 void mcs_set_lmac_mode(struct mcs *mcs, int lmac_id, u8 mode)
1329 {
1330         u64 reg;
1331         int id = lmac_id * 2;
1332
1333         reg = MCSX_MCS_TOP_SLAVE_CHANNEL_CFG(id);
1334         mcs_reg_write(mcs, reg, (u64)mode);
1335         reg = MCSX_MCS_TOP_SLAVE_CHANNEL_CFG((id + 1));
1336         mcs_reg_write(mcs, reg, (u64)mode);
1337 }
1338
1339 void mcs_pn_threshold_set(struct mcs *mcs, struct mcs_set_pn_threshold *pn)
1340 {
1341         u64 reg;
1342
1343         if (pn->dir == MCS_RX)
1344                 reg = pn->xpn ? MCSX_CPM_RX_SLAVE_XPN_THRESHOLD : MCSX_CPM_RX_SLAVE_PN_THRESHOLD;
1345         else
1346                 reg = pn->xpn ? MCSX_CPM_TX_SLAVE_XPN_THRESHOLD : MCSX_CPM_TX_SLAVE_PN_THRESHOLD;
1347
1348         mcs_reg_write(mcs, reg, pn->threshold);
1349 }
1350
1351 void cn10kb_mcs_parser_cfg(struct mcs *mcs)
1352 {
1353         u64 reg, val;
1354
1355         /* VLAN CTag */
1356         val = BIT_ULL(0) | (0x8100ull & 0xFFFF) << 1 | BIT_ULL(17);
1357         /* RX */
1358         reg = MCSX_PEX_RX_SLAVE_VLAN_CFGX(0);
1359         mcs_reg_write(mcs, reg, val);
1360
1361         /* TX */
1362         reg = MCSX_PEX_TX_SLAVE_VLAN_CFGX(0);
1363         mcs_reg_write(mcs, reg, val);
1364
1365         /* VLAN STag */
1366         val = BIT_ULL(0) | (0x88a8ull & 0xFFFF) << 1 | BIT_ULL(18);
1367         /* RX */
1368         reg = MCSX_PEX_RX_SLAVE_VLAN_CFGX(1);
1369         mcs_reg_write(mcs, reg, val);
1370
1371         /* TX */
1372         reg = MCSX_PEX_TX_SLAVE_VLAN_CFGX(1);
1373         mcs_reg_write(mcs, reg, val);
1374 }
1375
1376 static void mcs_lmac_init(struct mcs *mcs, int lmac_id)
1377 {
1378         u64 reg;
1379
1380         /* Port mode 25GB */
1381         reg = MCSX_PAB_RX_SLAVE_PORT_CFGX(lmac_id);
1382         mcs_reg_write(mcs, reg, 0);
1383
1384         if (mcs->hw->mcs_blks > 1) {
1385                 reg = MCSX_PAB_RX_SLAVE_FIFO_SKID_CFGX(lmac_id);
1386                 mcs_reg_write(mcs, reg, 0xe000e);
1387                 return;
1388         }
1389
1390         reg = MCSX_PAB_TX_SLAVE_PORT_CFGX(lmac_id);
1391         mcs_reg_write(mcs, reg, 0);
1392 }
1393
1394 int mcs_set_lmac_channels(int mcs_id, u16 base)
1395 {
1396         struct mcs *mcs;
1397         int lmac;
1398         u64 cfg;
1399
1400         mcs = mcs_get_pdata(mcs_id);
1401         if (!mcs)
1402                 return -ENODEV;
1403         for (lmac = 0; lmac < mcs->hw->lmac_cnt; lmac++) {
1404                 cfg = mcs_reg_read(mcs, MCSX_LINK_LMACX_CFG(lmac));
1405                 cfg &= ~(MCSX_LINK_LMAC_BASE_MASK | MCSX_LINK_LMAC_RANGE_MASK);
1406                 cfg |=  FIELD_PREP(MCSX_LINK_LMAC_RANGE_MASK, ilog2(16));
1407                 cfg |=  FIELD_PREP(MCSX_LINK_LMAC_BASE_MASK, base);
1408                 mcs_reg_write(mcs, MCSX_LINK_LMACX_CFG(lmac), cfg);
1409                 base += 16;
1410         }
1411         return 0;
1412 }
1413
1414 static int mcs_x2p_calibration(struct mcs *mcs)
1415 {
1416         unsigned long timeout = jiffies + usecs_to_jiffies(20000);
1417         int i, err = 0;
1418         u64 val;
1419
1420         /* set X2P calibration */
1421         val = mcs_reg_read(mcs, MCSX_MIL_GLOBAL);
1422         val |= BIT_ULL(5);
1423         mcs_reg_write(mcs, MCSX_MIL_GLOBAL, val);
1424
1425         /* Wait for calibration to complete */
1426         while (!(mcs_reg_read(mcs, MCSX_MIL_RX_GBL_STATUS) & BIT_ULL(0))) {
1427                 if (time_before(jiffies, timeout)) {
1428                         usleep_range(80, 100);
1429                         continue;
1430                 } else {
1431                         err = -EBUSY;
1432                         dev_err(mcs->dev, "MCS X2P calibration failed..ignoring\n");
1433                         return err;
1434                 }
1435         }
1436
1437         val = mcs_reg_read(mcs, MCSX_MIL_RX_GBL_STATUS);
1438         for (i = 0; i < mcs->hw->mcs_x2p_intf; i++) {
1439                 if (val & BIT_ULL(1 + i))
1440                         continue;
1441                 err = -EBUSY;
1442                 dev_err(mcs->dev, "MCS:%d didn't respond to X2P calibration\n", i);
1443         }
1444         /* Clear X2P calibrate */
1445         mcs_reg_write(mcs, MCSX_MIL_GLOBAL, mcs_reg_read(mcs, MCSX_MIL_GLOBAL) & ~BIT_ULL(5));
1446
1447         return err;
1448 }
1449
1450 static void mcs_set_external_bypass(struct mcs *mcs, bool bypass)
1451 {
1452         u64 val;
1453
1454         /* Set MCS to external bypass */
1455         val = mcs_reg_read(mcs, MCSX_MIL_GLOBAL);
1456         if (bypass)
1457                 val |= BIT_ULL(6);
1458         else
1459                 val &= ~BIT_ULL(6);
1460         mcs_reg_write(mcs, MCSX_MIL_GLOBAL, val);
1461         mcs->bypass = bypass;
1462 }
1463
1464 static void mcs_global_cfg(struct mcs *mcs)
1465 {
1466         /* Disable external bypass */
1467         mcs_set_external_bypass(mcs, false);
1468
1469         /* Reset TX/RX stats memory */
1470         mcs_reg_write(mcs, MCSX_CSE_RX_SLAVE_STATS_CLEAR, 0x1F);
1471         mcs_reg_write(mcs, MCSX_CSE_TX_SLAVE_STATS_CLEAR, 0x1F);
1472
1473         /* Set MCS to perform standard IEEE802.1AE macsec processing */
1474         if (mcs->hw->mcs_blks == 1) {
1475                 mcs_reg_write(mcs, MCSX_IP_MODE, BIT_ULL(3));
1476                 return;
1477         }
1478
1479         mcs_reg_write(mcs, MCSX_BBE_RX_SLAVE_CAL_ENTRY, 0xe4);
1480         mcs_reg_write(mcs, MCSX_BBE_RX_SLAVE_CAL_LEN, 4);
1481 }
1482
1483 void cn10kb_mcs_set_hw_capabilities(struct mcs *mcs)
1484 {
1485         struct hwinfo *hw = mcs->hw;
1486
1487         hw->tcam_entries = 128;         /* TCAM entries */
1488         hw->secy_entries  = 128;        /* SecY entries */
1489         hw->sc_entries = 128;           /* SC CAM entries */
1490         hw->sa_entries = 256;           /* SA entries */
1491         hw->lmac_cnt = 20;              /* lmacs/ports per mcs block */
1492         hw->mcs_x2p_intf = 5;           /* x2p clabration intf */
1493         hw->mcs_blks = 1;               /* MCS blocks */
1494         hw->ip_vec = MCS_CN10KB_INT_VEC_IP; /* IP vector */
1495 }
1496
1497 static struct mcs_ops cn10kb_mcs_ops = {
1498         .mcs_set_hw_capabilities        = cn10kb_mcs_set_hw_capabilities,
1499         .mcs_parser_cfg                 = cn10kb_mcs_parser_cfg,
1500         .mcs_tx_sa_mem_map_write        = cn10kb_mcs_tx_sa_mem_map_write,
1501         .mcs_rx_sa_mem_map_write        = cn10kb_mcs_rx_sa_mem_map_write,
1502         .mcs_flowid_secy_map            = cn10kb_mcs_flowid_secy_map,
1503         .mcs_bbe_intr_handler           = cn10kb_mcs_bbe_intr_handler,
1504         .mcs_pab_intr_handler           = cn10kb_mcs_pab_intr_handler,
1505 };
1506
1507 static int mcs_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1508 {
1509         struct device *dev = &pdev->dev;
1510         int lmac, err = 0;
1511         struct mcs *mcs;
1512
1513         mcs = devm_kzalloc(dev, sizeof(*mcs), GFP_KERNEL);
1514         if (!mcs)
1515                 return -ENOMEM;
1516
1517         mcs->hw = devm_kzalloc(dev, sizeof(struct hwinfo), GFP_KERNEL);
1518         if (!mcs->hw)
1519                 return -ENOMEM;
1520
1521         err = pci_enable_device(pdev);
1522         if (err) {
1523                 dev_err(dev, "Failed to enable PCI device\n");
1524                 pci_set_drvdata(pdev, NULL);
1525                 return err;
1526         }
1527
1528         err = pci_request_regions(pdev, DRV_NAME);
1529         if (err) {
1530                 dev_err(dev, "PCI request regions failed 0x%x\n", err);
1531                 goto exit;
1532         }
1533
1534         mcs->reg_base = pcim_iomap(pdev, PCI_CFG_REG_BAR_NUM, 0);
1535         if (!mcs->reg_base) {
1536                 dev_err(dev, "mcs: Cannot map CSR memory space, aborting\n");
1537                 err = -ENOMEM;
1538                 goto exit;
1539         }
1540
1541         pci_set_drvdata(pdev, mcs);
1542         mcs->pdev = pdev;
1543         mcs->dev = &pdev->dev;
1544
1545         if (pdev->subsystem_device == PCI_SUBSYS_DEVID_CN10K_B)
1546                 mcs->mcs_ops = &cn10kb_mcs_ops;
1547         else
1548                 mcs->mcs_ops = cnf10kb_get_mac_ops();
1549
1550         /* Set hardware capabilities */
1551         mcs->mcs_ops->mcs_set_hw_capabilities(mcs);
1552
1553         mcs_global_cfg(mcs);
1554
1555         /* Perform X2P clibration */
1556         err = mcs_x2p_calibration(mcs);
1557         if (err)
1558                 goto err_x2p;
1559
1560         mcs->mcs_id = (pci_resource_start(pdev, PCI_CFG_REG_BAR_NUM) >> 24)
1561                         & MCS_ID_MASK;
1562
1563         /* Set mcs tx side resources */
1564         err = mcs_alloc_struct_mem(mcs, &mcs->tx);
1565         if (err)
1566                 goto err_x2p;
1567
1568         /* Set mcs rx side resources */
1569         err = mcs_alloc_struct_mem(mcs, &mcs->rx);
1570         if (err)
1571                 goto err_x2p;
1572
1573         /* per port config */
1574         for (lmac = 0; lmac < mcs->hw->lmac_cnt; lmac++)
1575                 mcs_lmac_init(mcs, lmac);
1576
1577         /* Parser configuration */
1578         mcs->mcs_ops->mcs_parser_cfg(mcs);
1579
1580         err = mcs_register_interrupts(mcs);
1581         if (err)
1582                 goto exit;
1583
1584         list_add(&mcs->mcs_list, &mcs_list);
1585         mutex_init(&mcs->stats_lock);
1586
1587         return 0;
1588
1589 err_x2p:
1590         /* Enable external bypass */
1591         mcs_set_external_bypass(mcs, true);
1592 exit:
1593         pci_release_regions(pdev);
1594         pci_disable_device(pdev);
1595         pci_set_drvdata(pdev, NULL);
1596         return err;
1597 }
1598
1599 static void mcs_remove(struct pci_dev *pdev)
1600 {
1601         struct mcs *mcs = pci_get_drvdata(pdev);
1602
1603         /* Set MCS to external bypass */
1604         mcs_set_external_bypass(mcs, true);
1605         free_irq(pci_irq_vector(pdev, mcs->hw->ip_vec), mcs);
1606         pci_free_irq_vectors(pdev);
1607         pci_release_regions(pdev);
1608         pci_disable_device(pdev);
1609         pci_set_drvdata(pdev, NULL);
1610 }
1611
1612 struct pci_driver mcs_driver = {
1613         .name = DRV_NAME,
1614         .id_table = mcs_id_table,
1615         .probe = mcs_probe,
1616         .remove = mcs_remove,
1617 };