drivers/net/ethernet/microchip/lan966x/lan966x_vcap_impl.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2
   3 #include "lan966x_main.h"
   4 #include "lan966x_vcap_ag_api.h"
   5 #include "vcap_api.h"
   6 #include "vcap_api_client.h"
   7 #include "vcap_api_debugfs.h"
   8
   9 #define STREAMSIZE (64 * 4)
  10
  11 #define LAN966X_IS1_LOOKUPS 3
  12 #define LAN966X_IS2_LOOKUPS 2
  13 #define LAN966X_ES0_LOOKUPS 1
  14
  15 #define LAN966X_STAT_ESDX_GRN_BYTES 0x300
  16 #define LAN966X_STAT_ESDX_GRN_PKTS 0x301
  17 #define LAN966X_STAT_ESDX_YEL_BYTES 0x302
  18 #define LAN966X_STAT_ESDX_YEL_PKTS 0x303
  19
  20 static struct lan966x_vcap_inst {
  21         enum vcap_type vtype; /* type of vcap */
  22         int tgt_inst; /* hardware instance number */
  23         int lookups; /* number of lookups in this vcap type */
  24         int first_cid; /* first chain id in this vcap */
  25         int last_cid; /* last chain id in this vcap */
  26         int count; /* number of available addresses */
  27         bool ingress; /* is vcap in the ingress path */
  28 } lan966x_vcap_inst_cfg[] = {
  29         {
  30                 .vtype = VCAP_TYPE_ES0,
  31                 .tgt_inst = 0,
  32                 .lookups = LAN966X_ES0_LOOKUPS,
  33                 .first_cid = LAN966X_VCAP_CID_ES0_L0,
  34                 .last_cid = LAN966X_VCAP_CID_ES0_MAX,
  35                 .count = 64,
  36         },
  37         {
  38                 .vtype = VCAP_TYPE_IS1, /* IS1-0 */
  39                 .tgt_inst = 1,
  40                 .lookups = LAN966X_IS1_LOOKUPS,
  41                 .first_cid = LAN966X_VCAP_CID_IS1_L0,
  42                 .last_cid = LAN966X_VCAP_CID_IS1_MAX,
  43                 .count = 768,
  44                 .ingress = true,
  45         },
  46         {
  47                 .vtype = VCAP_TYPE_IS2, /* IS2-0 */
  48                 .tgt_inst = 2,
  49                 .lookups = LAN966X_IS2_LOOKUPS,
  50                 .first_cid = LAN966X_VCAP_CID_IS2_L0,
  51                 .last_cid = LAN966X_VCAP_CID_IS2_MAX,
  52                 .count = 256,
  53                 .ingress = true,
  54         },
  55 };
  56
  57 struct lan966x_vcap_cmd_cb {
  58         struct lan966x *lan966x;
  59         u32 instance;
  60 };
  61
  62 static u32 lan966x_vcap_read_update_ctrl(const struct lan966x_vcap_cmd_cb *cb)
  63 {
  64         return lan_rd(cb->lan966x, VCAP_UPDATE_CTRL(cb->instance));
  65 }
  66
  67 static void lan966x_vcap_wait_update(struct lan966x *lan966x, int instance)
  68 {
  69         const struct lan966x_vcap_cmd_cb cb = { .lan966x = lan966x,
  70                                                 .instance = instance };
  71         u32 val;
  72
  73         readx_poll_timeout(lan966x_vcap_read_update_ctrl, &cb, val,
  74                            (val & VCAP_UPDATE_CTRL_UPDATE_SHOT) == 0, 10,
  75                            100000);
  76 }
  77
  78 static void __lan966x_vcap_range_init(struct lan966x *lan966x,
  79                                       struct vcap_admin *admin,
  80                                       u32 addr,
  81                                       u32 count)
  82 {
  83         lan_wr(VCAP_MV_CFG_MV_NUM_POS_SET(0) |
  84                VCAP_MV_CFG_MV_SIZE_SET(count - 1),
  85                lan966x, VCAP_MV_CFG(admin->tgt_inst));
  86
  87         lan_wr(VCAP_UPDATE_CTRL_UPDATE_CMD_SET(VCAP_CMD_INITIALIZE) |
  88                VCAP_UPDATE_CTRL_UPDATE_ENTRY_DIS_SET(0) |
  89                VCAP_UPDATE_CTRL_UPDATE_ACTION_DIS_SET(0) |
  90                VCAP_UPDATE_CTRL_UPDATE_CNT_DIS_SET(0) |
  91                VCAP_UPDATE_CTRL_UPDATE_ADDR_SET(addr) |
  92                VCAP_UPDATE_CTRL_CLEAR_CACHE_SET(true) |
  93                VCAP_UPDATE_CTRL_UPDATE_SHOT_SET(1),
  94                lan966x, VCAP_UPDATE_CTRL(admin->tgt_inst));
  95
  96         lan966x_vcap_wait_update(lan966x, admin->tgt_inst);
  97 }
  98
  99 static int lan966x_vcap_is1_cid_to_lookup(int cid)
 100 {
 101         int lookup = 0;
 102
 103         if (cid >= LAN966X_VCAP_CID_IS1_L1 &&
 104             cid < LAN966X_VCAP_CID_IS1_L2)
 105                 lookup = 1;
 106         else if (cid >= LAN966X_VCAP_CID_IS1_L2 &&
 107                  cid < LAN966X_VCAP_CID_IS1_MAX)
 108                 lookup = 2;
 109
 110         return lookup;
 111 }
 112
 113 static int lan966x_vcap_is2_cid_to_lookup(int cid)
 114 {
 115         if (cid >= LAN966X_VCAP_CID_IS2_L1 &&
 116             cid < LAN966X_VCAP_CID_IS2_MAX)
 117                 return 1;
 118
 119         return 0;
 120 }
 121
 122 /* Return the list of keysets for the vcap port configuration */
 123 static int
 124 lan966x_vcap_is1_get_port_keysets(struct net_device *ndev, int lookup,
 125                                   struct vcap_keyset_list *keysetlist,
 126                                   u16 l3_proto)
 127 {
 128         struct lan966x_port *port = netdev_priv(ndev);
 129         struct lan966x *lan966x = port->lan966x;
 130         u32 val;
 131
 132         val = lan_rd(lan966x, ANA_VCAP_S1_CFG(port->chip_port, lookup));
 133
 134         /* Collect all keysets for the port in a list */
 135         if (l3_proto == ETH_P_ALL || l3_proto == ETH_P_IP) {
 136                 switch (ANA_VCAP_S1_CFG_KEY_IP4_CFG_GET(val)) {
 137                 case VCAP_IS1_PS_IPV4_7TUPLE:
 138                         vcap_keyset_list_add(keysetlist, VCAP_KFS_7TUPLE);
 139                         break;
 140                 case VCAP_IS1_PS_IPV4_5TUPLE_IP4:
 141                         vcap_keyset_list_add(keysetlist, VCAP_KFS_5TUPLE_IP4);
 142                         break;
 143                 case VCAP_IS1_PS_IPV4_NORMAL:
 144                         vcap_keyset_list_add(keysetlist, VCAP_KFS_NORMAL);
 145                         break;
 146                 }
 147         }
 148
 149         if (l3_proto == ETH_P_ALL || l3_proto == ETH_P_IPV6) {
 150                 switch (ANA_VCAP_S1_CFG_KEY_IP6_CFG_GET(val)) {
 151                 case VCAP_IS1_PS_IPV6_NORMAL:
 152                 case VCAP_IS1_PS_IPV6_NORMAL_IP6:
 153                         vcap_keyset_list_add(keysetlist, VCAP_KFS_NORMAL);
 154                         vcap_keyset_list_add(keysetlist, VCAP_KFS_NORMAL_IP6);
 155                         break;
 156                 case VCAP_IS1_PS_IPV6_5TUPLE_IP6:
 157                         vcap_keyset_list_add(keysetlist, VCAP_KFS_5TUPLE_IP6);
 158                         break;
 159                 case VCAP_IS1_PS_IPV6_7TUPLE:
 160                         vcap_keyset_list_add(keysetlist, VCAP_KFS_7TUPLE);
 161                         break;
 162                 case VCAP_IS1_PS_IPV6_5TUPLE_IP4:
 163                         vcap_keyset_list_add(keysetlist, VCAP_KFS_5TUPLE_IP4);
 164                         break;
 165                 case VCAP_IS1_PS_IPV6_DMAC_VID:
 166                         vcap_keyset_list_add(keysetlist, VCAP_KFS_DMAC_VID);
 167                         break;
 168                 }
 169         }
 170
 171         switch (ANA_VCAP_S1_CFG_KEY_OTHER_CFG_GET(val)) {
 172         case VCAP_IS1_PS_OTHER_7TUPLE:
 173                 vcap_keyset_list_add(keysetlist, VCAP_KFS_7TUPLE);
 174                 break;
 175         case VCAP_IS1_PS_OTHER_NORMAL:
 176                 vcap_keyset_list_add(keysetlist, VCAP_KFS_NORMAL);
 177                 break;
 178         }
 179
 180         return 0;
 181 }
 182
 183 static int
 184 lan966x_vcap_is2_get_port_keysets(struct net_device *dev, int lookup,
 185                                   struct vcap_keyset_list *keysetlist,
 186                                   u16 l3_proto)
 187 {
 188         struct lan966x_port *port = netdev_priv(dev);
 189         struct lan966x *lan966x = port->lan966x;
 190         bool found = false;
 191         u32 val;
 192
 193         val = lan_rd(lan966x, ANA_VCAP_S2_CFG(port->chip_port));
 194
 195         /* Collect all keysets for the port in a list */
 196         if (l3_proto == ETH_P_ALL)
 197                 vcap_keyset_list_add(keysetlist, VCAP_KFS_MAC_ETYPE);
 198
 199         if (l3_proto == ETH_P_ALL || l3_proto == ETH_P_SNAP) {
 200                 if (ANA_VCAP_S2_CFG_SNAP_DIS_GET(val) & (BIT(0) << lookup))
 201                         vcap_keyset_list_add(keysetlist, VCAP_KFS_MAC_LLC);
 202                 else
 203                         vcap_keyset_list_add(keysetlist, VCAP_KFS_MAC_SNAP);
 204
 205                 found = true;
 206         }
 207
 208         if (l3_proto == ETH_P_ALL || l3_proto == ETH_P_CFM) {
 209                 if (ANA_VCAP_S2_CFG_OAM_DIS_GET(val) & (BIT(0) << lookup))
 210                         vcap_keyset_list_add(keysetlist, VCAP_KFS_MAC_ETYPE);
 211                 else
 212                         vcap_keyset_list_add(keysetlist, VCAP_KFS_OAM);
 213
 214                 found = true;
 215         }
 216
 217         if (l3_proto == ETH_P_ALL || l3_proto == ETH_P_ARP) {
 218                 if (ANA_VCAP_S2_CFG_ARP_DIS_GET(val) & (BIT(0) << lookup))
 219                         vcap_keyset_list_add(keysetlist, VCAP_KFS_MAC_ETYPE);
 220                 else
 221                         vcap_keyset_list_add(keysetlist, VCAP_KFS_ARP);
 222
 223                 found = true;
 224         }
 225
 226         if (l3_proto == ETH_P_ALL || l3_proto == ETH_P_IP) {
 227                 if (ANA_VCAP_S2_CFG_IP_OTHER_DIS_GET(val) & (BIT(0) << lookup))
 228                         vcap_keyset_list_add(keysetlist, VCAP_KFS_MAC_ETYPE);
 229                 else
 230                         vcap_keyset_list_add(keysetlist, VCAP_KFS_IP4_OTHER);
 231
 232                 if (ANA_VCAP_S2_CFG_IP_TCPUDP_DIS_GET(val) & (BIT(0) << lookup))
 233                         vcap_keyset_list_add(keysetlist, VCAP_KFS_MAC_ETYPE);
 234                 else
 235                         vcap_keyset_list_add(keysetlist, VCAP_KFS_IP4_TCP_UDP);
 236
 237                 found = true;
 238         }
 239
 240         if (l3_proto == ETH_P_ALL || l3_proto == ETH_P_IPV6) {
 241                 switch (ANA_VCAP_S2_CFG_IP6_CFG_GET(val) & (0x3 << lookup)) {
 242                 case VCAP_IS2_PS_IPV6_TCPUDP_OTHER:
 243                         vcap_keyset_list_add(keysetlist, VCAP_KFS_IP6_OTHER);
 244                         vcap_keyset_list_add(keysetlist, VCAP_KFS_IP6_TCP_UDP);
 245                         break;
 246                 case VCAP_IS2_PS_IPV6_STD:
 247                         vcap_keyset_list_add(keysetlist, VCAP_KFS_IP6_STD);
 248                         break;
 249                 case VCAP_IS2_PS_IPV6_IP4_TCPUDP_IP4_OTHER:
 250                         vcap_keyset_list_add(keysetlist, VCAP_KFS_IP4_OTHER);
 251                         vcap_keyset_list_add(keysetlist, VCAP_KFS_IP4_TCP_UDP);
 252                         break;
 253                 case VCAP_IS2_PS_IPV6_MAC_ETYPE:
 254                         vcap_keyset_list_add(keysetlist, VCAP_KFS_MAC_ETYPE);
 255                         break;
 256                 }
 257
 258                 found = true;
 259         }
 260
 261         if (!found)
 262                 vcap_keyset_list_add(keysetlist, VCAP_KFS_MAC_ETYPE);
 263
 264         return 0;
 265 }
 266
 267 static enum vcap_keyfield_set
 268 lan966x_vcap_validate_keyset(struct net_device *dev,
 269                              struct vcap_admin *admin,
 270                              struct vcap_rule *rule,
 271                              struct vcap_keyset_list *kslist,
 272                              u16 l3_proto)
 273 {
 274         struct vcap_keyset_list keysetlist = {};
 275         enum vcap_keyfield_set keysets[10] = {};
 276         int lookup;
 277         int err;
 278
 279         if (!kslist || kslist->cnt == 0)
 280                 return VCAP_KFS_NO_VALUE;
 281
 282         keysetlist.max = ARRAY_SIZE(keysets);
 283         keysetlist.keysets = keysets;
 284
 285         switch (admin->vtype) {
 286         case VCAP_TYPE_IS1:
 287                 lookup = lan966x_vcap_is1_cid_to_lookup(rule->vcap_chain_id);
 288                 err = lan966x_vcap_is1_get_port_keysets(dev, lookup, &keysetlist,
 289                                                         l3_proto);
 290                 break;
 291         case VCAP_TYPE_IS2:
 292                 lookup = lan966x_vcap_is2_cid_to_lookup(rule->vcap_chain_id);
 293                 err = lan966x_vcap_is2_get_port_keysets(dev, lookup, &keysetlist,
 294                                                         l3_proto);
 295                 break;
 296         case VCAP_TYPE_ES0:
 297                 return kslist->keysets[0];
 298         default:
 299                 pr_err("vcap type: %s not supported\n",
 300                        lan966x_vcaps[admin->vtype].name);
 301                 return VCAP_KFS_NO_VALUE;
 302         }
 303
 304         if (err)
 305                 return VCAP_KFS_NO_VALUE;
 306
 307         /* Check if there is a match and return the match */
 308         for (int i = 0; i < kslist->cnt; ++i)
 309                 for (int j = 0; j < keysetlist.cnt; ++j)
 310                         if (kslist->keysets[i] == keysets[j])
 311                                 return kslist->keysets[i];
 312
 313         return VCAP_KFS_NO_VALUE;
 314 }
 315
 316 static bool lan966x_vcap_is2_is_first_chain(struct vcap_rule *rule)
 317 {
 318         return (rule->vcap_chain_id >= LAN966X_VCAP_CID_IS2_L0 &&
 319                 rule->vcap_chain_id < LAN966X_VCAP_CID_IS2_L1);
 320 }
 321
 322 static void lan966x_vcap_is1_add_default_fields(struct lan966x_port *port,
 323                                                 struct vcap_admin *admin,
 324                                                 struct vcap_rule *rule)
 325 {
 326         u32 value, mask;
 327         u32 lookup;
 328
 329         if (vcap_rule_get_key_u32(rule, VCAP_KF_IF_IGR_PORT_MASK,
 330                                   &value, &mask))
 331                 vcap_rule_add_key_u32(rule, VCAP_KF_IF_IGR_PORT_MASK, 0,
 332                                       ~BIT(port->chip_port));
 333
 334         lookup = lan966x_vcap_is1_cid_to_lookup(rule->vcap_chain_id);
 335         vcap_rule_add_key_u32(rule, VCAP_KF_LOOKUP_INDEX, lookup, 0x3);
 336 }
 337
 338 static void lan966x_vcap_is2_add_default_fields(struct lan966x_port *port,
 339                                                 struct vcap_admin *admin,
 340                                                 struct vcap_rule *rule)
 341 {
 342         u32 value, mask;
 343
 344         if (vcap_rule_get_key_u32(rule, VCAP_KF_IF_IGR_PORT_MASK,
 345                                   &value, &mask))
 346                 vcap_rule_add_key_u32(rule, VCAP_KF_IF_IGR_PORT_MASK, 0,
 347                                       ~BIT(port->chip_port));
 348
 349         if (lan966x_vcap_is2_is_first_chain(rule))
 350                 vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS,
 351                                       VCAP_BIT_1);
 352         else
 353                 vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS,
 354                                       VCAP_BIT_0);
 355 }
 356
 357 static void lan966x_vcap_es0_add_default_fields(struct lan966x_port *port,
 358                                                 struct vcap_admin *admin,
 359                                                 struct vcap_rule *rule)
 360 {
 361         vcap_rule_add_key_u32(rule, VCAP_KF_IF_EGR_PORT_NO,
 362                               port->chip_port, GENMASK(4, 0));
 363 }
 364
 365 static void lan966x_vcap_add_default_fields(struct net_device *dev,
 366                                             struct vcap_admin *admin,
 367                                             struct vcap_rule *rule)
 368 {
 369         struct lan966x_port *port = netdev_priv(dev);
 370
 371         switch (admin->vtype) {
 372         case VCAP_TYPE_IS1:
 373                 lan966x_vcap_is1_add_default_fields(port, admin, rule);
 374                 break;
 375         case VCAP_TYPE_IS2:
 376                 lan966x_vcap_is2_add_default_fields(port, admin, rule);
 377                 break;
 378         case VCAP_TYPE_ES0:
 379                 lan966x_vcap_es0_add_default_fields(port, admin, rule);
 380                 break;
 381         default:
 382                 pr_err("vcap type: %s not supported\n",
 383                        lan966x_vcaps[admin->vtype].name);
 384                 break;
 385         }
 386 }
 387
 388 static void lan966x_vcap_cache_erase(struct vcap_admin *admin)
 389 {
 390         memset(admin->cache.keystream, 0, STREAMSIZE);
 391         memset(admin->cache.maskstream, 0, STREAMSIZE);
 392         memset(admin->cache.actionstream, 0, STREAMSIZE);
 393         memset(&admin->cache.counter, 0, sizeof(admin->cache.counter));
 394 }
 395
 396 /* The ESDX counter is only used/incremented if the frame has been classified
 397  * with an ISDX > 0 (e.g by a rule in IS0).  This is not mentioned in the
 398  * datasheet.
 399  */
 400 static void lan966x_es0_read_esdx_counter(struct lan966x *lan966x,
 401                                           struct vcap_admin *admin, u32 id)
 402 {
 403         u32 counter;
 404
 405         id = id & 0xff; /* counter limit */
 406         mutex_lock(&lan966x->stats_lock);
 407         lan_wr(SYS_STAT_CFG_STAT_VIEW_SET(id), lan966x, SYS_STAT_CFG);
 408         counter = lan_rd(lan966x, SYS_CNT(LAN966X_STAT_ESDX_GRN_PKTS)) +
 409                   lan_rd(lan966x, SYS_CNT(LAN966X_STAT_ESDX_YEL_PKTS));
 410         mutex_unlock(&lan966x->stats_lock);
 411         if (counter)
 412                 admin->cache.counter = counter;
 413 }
 414
 415 static void lan966x_es0_write_esdx_counter(struct lan966x *lan966x,
 416                                            struct vcap_admin *admin, u32 id)
 417 {
 418         id = id & 0xff; /* counter limit */
 419
 420         mutex_lock(&lan966x->stats_lock);
 421         lan_wr(SYS_STAT_CFG_STAT_VIEW_SET(id), lan966x, SYS_STAT_CFG);
 422         lan_wr(0, lan966x, SYS_CNT(LAN966X_STAT_ESDX_GRN_BYTES));
 423         lan_wr(admin->cache.counter, lan966x,
 424                SYS_CNT(LAN966X_STAT_ESDX_GRN_PKTS));
 425         lan_wr(0, lan966x, SYS_CNT(LAN966X_STAT_ESDX_YEL_BYTES));
 426         lan_wr(0, lan966x, SYS_CNT(LAN966X_STAT_ESDX_YEL_PKTS));
 427         mutex_unlock(&lan966x->stats_lock);
 428 }
 429
 430 static void lan966x_vcap_cache_write(struct net_device *dev,
 431                                      struct vcap_admin *admin,
 432                                      enum vcap_selection sel,
 433                                      u32 start,
 434                                      u32 count)
 435 {
 436         struct lan966x_port *port = netdev_priv(dev);
 437         struct lan966x *lan966x = port->lan966x;
 438         u32 *keystr, *mskstr, *actstr;
 439
 440         keystr = &admin->cache.keystream[start];
 441         mskstr = &admin->cache.maskstream[start];
 442         actstr = &admin->cache.actionstream[start];
 443
 444         switch (sel) {
 445         case VCAP_SEL_ENTRY:
 446                 for (int i = 0; i < count; ++i) {
 447                         lan_wr(keystr[i] & mskstr[i], lan966x,
 448                                VCAP_ENTRY_DAT(admin->tgt_inst, i));
 449                         lan_wr(~mskstr[i], lan966x,
 450                                VCAP_MASK_DAT(admin->tgt_inst, i));
 451                 }
 452                 break;
 453         case VCAP_SEL_ACTION:
 454                 for (int i = 0; i < count; ++i)
 455                         lan_wr(actstr[i], lan966x,
 456                                VCAP_ACTION_DAT(admin->tgt_inst, i));
 457                 break;
 458         case VCAP_SEL_COUNTER:
 459                 admin->cache.sticky = admin->cache.counter > 0;
 460                 lan_wr(admin->cache.counter, lan966x,
 461                        VCAP_CNT_DAT(admin->tgt_inst, 0));
 462
 463                 if (admin->vtype == VCAP_TYPE_ES0)
 464                         lan966x_es0_write_esdx_counter(lan966x, admin, start);
 465                 break;
 466         default:
 467                 break;
 468         }
 469 }
 470
 471 static void lan966x_vcap_cache_read(struct net_device *dev,
 472                                     struct vcap_admin *admin,
 473                                     enum vcap_selection sel,
 474                                     u32 start,
 475                                     u32 count)
 476 {
 477         struct lan966x_port *port = netdev_priv(dev);
 478         struct lan966x *lan966x = port->lan966x;
 479         int instance = admin->tgt_inst;
 480         u32 *keystr, *mskstr, *actstr;
 481
 482         keystr = &admin->cache.keystream[start];
 483         mskstr = &admin->cache.maskstream[start];
 484         actstr = &admin->cache.actionstream[start];
 485
 486         if (sel & VCAP_SEL_ENTRY) {
 487                 for (int i = 0; i < count; ++i) {
 488                         keystr[i] =
 489                                 lan_rd(lan966x, VCAP_ENTRY_DAT(instance, i));
 490                         mskstr[i] =
 491                                 ~lan_rd(lan966x, VCAP_MASK_DAT(instance, i));
 492                 }
 493         }
 494
 495         if (sel & VCAP_SEL_ACTION)
 496                 for (int i = 0; i < count; ++i)
 497                         actstr[i] =
 498                                 lan_rd(lan966x, VCAP_ACTION_DAT(instance, i));
 499
 500         if (sel & VCAP_SEL_COUNTER) {
 501                 admin->cache.counter =
 502                         lan_rd(lan966x, VCAP_CNT_DAT(instance, 0));
 503                 admin->cache.sticky = admin->cache.counter > 0;
 504
 505                 if (admin->vtype == VCAP_TYPE_ES0)
 506                         lan966x_es0_read_esdx_counter(lan966x, admin, start);
 507         }
 508 }
 509
 510 static void lan966x_vcap_range_init(struct net_device *dev,
 511                                     struct vcap_admin *admin,
 512                                     u32 addr,
 513                                     u32 count)
 514 {
 515         struct lan966x_port *port = netdev_priv(dev);
 516         struct lan966x *lan966x = port->lan966x;
 517
 518         __lan966x_vcap_range_init(lan966x, admin, addr, count);
 519 }
 520
 521 static void lan966x_vcap_update(struct net_device *dev,
 522                                 struct vcap_admin *admin,
 523                                 enum vcap_command cmd,
 524                                 enum vcap_selection sel,
 525                                 u32 addr)
 526 {
 527         struct lan966x_port *port = netdev_priv(dev);
 528         struct lan966x *lan966x = port->lan966x;
 529         bool clear;
 530
 531         clear = (cmd == VCAP_CMD_INITIALIZE);
 532
 533         lan_wr(VCAP_MV_CFG_MV_NUM_POS_SET(0) |
 534                VCAP_MV_CFG_MV_SIZE_SET(0),
 535                lan966x, VCAP_MV_CFG(admin->tgt_inst));
 536
 537         lan_wr(VCAP_UPDATE_CTRL_UPDATE_CMD_SET(cmd) |
 538                VCAP_UPDATE_CTRL_UPDATE_ENTRY_DIS_SET((VCAP_SEL_ENTRY & sel) == 0) |
 539                VCAP_UPDATE_CTRL_UPDATE_ACTION_DIS_SET((VCAP_SEL_ACTION & sel) == 0) |
 540                VCAP_UPDATE_CTRL_UPDATE_CNT_DIS_SET((VCAP_SEL_COUNTER & sel) == 0) |
 541                VCAP_UPDATE_CTRL_UPDATE_ADDR_SET(addr) |
 542                VCAP_UPDATE_CTRL_CLEAR_CACHE_SET(clear) |
 543                VCAP_UPDATE_CTRL_UPDATE_SHOT,
 544                lan966x, VCAP_UPDATE_CTRL(admin->tgt_inst));
 545
 546         lan966x_vcap_wait_update(lan966x, admin->tgt_inst);
 547 }
 548
 549 static void lan966x_vcap_move(struct net_device *dev,
 550                               struct vcap_admin *admin,
 551                               u32 addr, int offset, int count)
 552 {
 553         struct lan966x_port *port = netdev_priv(dev);
 554         struct lan966x *lan966x = port->lan966x;
 555         enum vcap_command cmd;
 556         u16 mv_num_pos;
 557         u16 mv_size;
 558
 559         mv_size = count - 1;
 560         if (offset > 0) {
 561                 mv_num_pos = offset - 1;
 562                 cmd = VCAP_CMD_MOVE_DOWN;
 563         } else {
 564                 mv_num_pos = -offset - 1;
 565                 cmd = VCAP_CMD_MOVE_UP;
 566         }
 567
 568         lan_wr(VCAP_MV_CFG_MV_NUM_POS_SET(mv_num_pos) |
 569                VCAP_MV_CFG_MV_SIZE_SET(mv_size),
 570                lan966x, VCAP_MV_CFG(admin->tgt_inst));
 571
 572         lan_wr(VCAP_UPDATE_CTRL_UPDATE_CMD_SET(cmd) |
 573                VCAP_UPDATE_CTRL_UPDATE_ENTRY_DIS_SET(0) |
 574                VCAP_UPDATE_CTRL_UPDATE_ACTION_DIS_SET(0) |
 575                VCAP_UPDATE_CTRL_UPDATE_CNT_DIS_SET(0) |
 576                VCAP_UPDATE_CTRL_UPDATE_ADDR_SET(addr) |
 577                VCAP_UPDATE_CTRL_CLEAR_CACHE_SET(false) |
 578                VCAP_UPDATE_CTRL_UPDATE_SHOT,
 579                lan966x, VCAP_UPDATE_CTRL(admin->tgt_inst));
 580
 581         lan966x_vcap_wait_update(lan966x, admin->tgt_inst);
 582 }
 583
 584 static const struct vcap_operations lan966x_vcap_ops = {
 585         .validate_keyset = lan966x_vcap_validate_keyset,
 586         .add_default_fields = lan966x_vcap_add_default_fields,
 587         .cache_erase = lan966x_vcap_cache_erase,
 588         .cache_write = lan966x_vcap_cache_write,
 589         .cache_read = lan966x_vcap_cache_read,
 590         .init = lan966x_vcap_range_init,
 591         .update = lan966x_vcap_update,
 592         .move = lan966x_vcap_move,
 593         .port_info = lan966x_vcap_port_info,
 594 };
 595
 596 static void lan966x_vcap_admin_free(struct vcap_admin *admin)
 597 {
 598         if (!admin)
 599                 return;
 600
 601         kfree(admin->cache.keystream);
 602         kfree(admin->cache.maskstream);
 603         kfree(admin->cache.actionstream);
 604         mutex_destroy(&admin->lock);
 605         kfree(admin);
 606 }
 607
 608 static struct vcap_admin *
 609 lan966x_vcap_admin_alloc(struct lan966x *lan966x, struct vcap_control *ctrl,
 610                          const struct lan966x_vcap_inst *cfg)
 611 {
 612         struct vcap_admin *admin;
 613
 614         admin = kzalloc(sizeof(*admin), GFP_KERNEL);
 615         if (!admin)
 616                 return ERR_PTR(-ENOMEM);
 617
 618         mutex_init(&admin->lock);
 619         INIT_LIST_HEAD(&admin->list);
 620         INIT_LIST_HEAD(&admin->rules);
 621         INIT_LIST_HEAD(&admin->enabled);
 622
 623         admin->vtype = cfg->vtype;
 624         admin->vinst = 0;
 625         admin->ingress = cfg->ingress;
 626         admin->w32be = true;
 627         admin->tgt_inst = cfg->tgt_inst;
 628
 629         admin->lookups = cfg->lookups;
 630         admin->lookups_per_instance = cfg->lookups;
 631
 632         admin->first_cid = cfg->first_cid;
 633         admin->last_cid = cfg->last_cid;
 634
 635         admin->cache.keystream = kzalloc(STREAMSIZE, GFP_KERNEL);
 636         admin->cache.maskstream = kzalloc(STREAMSIZE, GFP_KERNEL);
 637         admin->cache.actionstream = kzalloc(STREAMSIZE, GFP_KERNEL);
 638         if (!admin->cache.keystream ||
 639             !admin->cache.maskstream ||
 640             !admin->cache.actionstream) {
 641                 lan966x_vcap_admin_free(admin);
 642                 return ERR_PTR(-ENOMEM);
 643         }
 644
 645         return admin;
 646 }
 647
 648 static void lan966x_vcap_block_init(struct lan966x *lan966x,
 649                                     struct vcap_admin *admin,
 650                                     struct lan966x_vcap_inst *cfg)
 651 {
 652         admin->first_valid_addr = 0;
 653         admin->last_used_addr = cfg->count;
 654         admin->last_valid_addr = cfg->count - 1;
 655
 656         lan_wr(VCAP_CORE_IDX_CORE_IDX_SET(0),
 657                lan966x, VCAP_CORE_IDX(admin->tgt_inst));
 658         lan_wr(VCAP_CORE_MAP_CORE_MAP_SET(1),
 659                lan966x, VCAP_CORE_MAP(admin->tgt_inst));
 660
 661         __lan966x_vcap_range_init(lan966x, admin, admin->first_valid_addr,
 662                                   admin->last_valid_addr -
 663                                         admin->first_valid_addr);
 664 }
 665
 666 static void lan966x_vcap_port_key_deselection(struct lan966x *lan966x,
 667                                               struct vcap_admin *admin)
 668 {
 669         u32 val;
 670
 671         switch (admin->vtype) {
 672         case VCAP_TYPE_IS1:
 673                 val = ANA_VCAP_S1_CFG_KEY_IP6_CFG_SET(VCAP_IS1_PS_IPV6_5TUPLE_IP6) |
 674                       ANA_VCAP_S1_CFG_KEY_IP4_CFG_SET(VCAP_IS1_PS_IPV4_5TUPLE_IP4) |
 675                       ANA_VCAP_S1_CFG_KEY_OTHER_CFG_SET(VCAP_IS1_PS_OTHER_NORMAL);
 676
 677                 for (int p = 0; p < lan966x->num_phys_ports; ++p) {
 678                         if (!lan966x->ports[p])
 679                                 continue;
 680
 681                         for (int l = 0; l < LAN966X_IS1_LOOKUPS; ++l)
 682                                 lan_wr(val, lan966x, ANA_VCAP_S1_CFG(p, l));
 683
 684                         lan_rmw(ANA_VCAP_CFG_S1_ENA_SET(true),
 685                                 ANA_VCAP_CFG_S1_ENA, lan966x,
 686                                 ANA_VCAP_CFG(p));
 687                 }
 688
 689                 break;
 690         case VCAP_TYPE_IS2:
 691                 for (int p = 0; p < lan966x->num_phys_ports; ++p)
 692                         lan_wr(0, lan966x, ANA_VCAP_S2_CFG(p));
 693
 694                 break;
 695         case VCAP_TYPE_ES0:
 696                 for (int p = 0; p < lan966x->num_phys_ports; ++p)
 697                         lan_rmw(REW_PORT_CFG_ES0_EN_SET(false),
 698                                 REW_PORT_CFG_ES0_EN, lan966x,
 699                                 REW_PORT_CFG(p));
 700                 break;
 701         default:
 702                 pr_err("vcap type: %s not supported\n",
 703                        lan966x_vcaps[admin->vtype].name);
 704                 break;
 705         }
 706 }
 707
 708 int lan966x_vcap_init(struct lan966x *lan966x)
 709 {
 710         struct lan966x_vcap_inst *cfg;
 711         struct vcap_control *ctrl;
 712         struct vcap_admin *admin;
 713         struct dentry *dir;
 714
 715         ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);
 716         if (!ctrl)
 717                 return -ENOMEM;
 718
 719         ctrl->vcaps = lan966x_vcaps;
 720         ctrl->stats = &lan966x_vcap_stats;
 721         ctrl->ops = &lan966x_vcap_ops;
 722
 723         INIT_LIST_HEAD(&ctrl->list);
 724         for (int i = 0; i < ARRAY_SIZE(lan966x_vcap_inst_cfg); ++i) {
 725                 cfg = &lan966x_vcap_inst_cfg[i];
 726
 727                 admin = lan966x_vcap_admin_alloc(lan966x, ctrl, cfg);
 728                 if (IS_ERR(admin))
 729                         return PTR_ERR(admin);
 730
 731                 lan966x_vcap_block_init(lan966x, admin, cfg);
 732                 lan966x_vcap_port_key_deselection(lan966x, admin);
 733
 734                 list_add_tail(&admin->list, &ctrl->list);
 735         }
 736
 737         dir = vcap_debugfs(lan966x->dev, lan966x->debugfs_root, ctrl);
 738         for (int p = 0; p < lan966x->num_phys_ports; ++p) {
 739                 if (lan966x->ports[p]) {
 740                         vcap_port_debugfs(lan966x->dev, dir, ctrl,
 741                                           lan966x->ports[p]->dev);
 742
 743                         lan_rmw(ANA_VCAP_S2_CFG_ENA_SET(true),
 744                                 ANA_VCAP_S2_CFG_ENA, lan966x,
 745                                 ANA_VCAP_S2_CFG(lan966x->ports[p]->chip_port));
 746
 747                         lan_rmw(ANA_VCAP_CFG_S1_ENA_SET(true),
 748                                 ANA_VCAP_CFG_S1_ENA, lan966x,
 749                                 ANA_VCAP_CFG(lan966x->ports[p]->chip_port));
 750
 751                         lan_rmw(REW_PORT_CFG_ES0_EN_SET(true),
 752                                 REW_PORT_CFG_ES0_EN, lan966x,
 753                                 REW_PORT_CFG(lan966x->ports[p]->chip_port));
 754                 }
 755         }
 756
 757         /* Statistics: Use ESDX from ES0 if hit, otherwise no counting */
 758         lan_rmw(REW_STAT_CFG_STAT_MODE_SET(1),
 759                 REW_STAT_CFG_STAT_MODE, lan966x,
 760                 REW_STAT_CFG);
 761
 762         lan966x->vcap_ctrl = ctrl;
 763
 764         return 0;
 765 }
 766
 767 void lan966x_vcap_deinit(struct lan966x *lan966x)
 768 {
 769         struct vcap_admin *admin, *admin_next;
 770         struct vcap_control *ctrl;
 771
 772         ctrl = lan966x->vcap_ctrl;
 773         if (!ctrl)
 774                 return;
 775
 776         list_for_each_entry_safe(admin, admin_next, &ctrl->list, list) {
 777                 lan966x_vcap_port_key_deselection(lan966x, admin);
 778                 vcap_del_rules(ctrl, admin);
 779                 list_del(&admin->list);
 780                 lan966x_vcap_admin_free(admin);
 781         }
 782
 783         kfree(ctrl);
 784 }