drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Marvell RVU Ethernet driver
   3  *
   4  * Copyright (C) 2020 Marvell.
   5  *
   6  */
   7
   8 #include <net/ipv6.h>
   9 #include <linux/sort.h>
  10
  11 #include "otx2_common.h"
  12
  13 #define OTX2_DEFAULT_ACTION     0x1
  14
  15 static int otx2_mcam_entry_init(struct otx2_nic *pfvf);
  16
  17 struct otx2_flow {
  18         struct ethtool_rx_flow_spec flow_spec;
  19         struct list_head list;
  20         u32 location;
  21         u32 entry;
  22         bool is_vf;
  23         u8 rss_ctx_id;
  24 #define DMAC_FILTER_RULE                BIT(0)
  25 #define PFC_FLOWCTRL_RULE               BIT(1)
  26         u16 rule_type;
  27         int vf;
  28 };
  29
  30 enum dmac_req {
  31         DMAC_ADDR_UPDATE,
  32         DMAC_ADDR_DEL
  33 };
  34
  35 static void otx2_clear_ntuple_flow_info(struct otx2_nic *pfvf, struct otx2_flow_config *flow_cfg)
  36 {
  37         devm_kfree(pfvf->dev, flow_cfg->flow_ent);
  38         flow_cfg->flow_ent = NULL;
  39         flow_cfg->max_flows = 0;
  40 }
  41
  42 static int otx2_free_ntuple_mcam_entries(struct otx2_nic *pfvf)
  43 {
  44         struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
  45         struct npc_mcam_free_entry_req *req;
  46         int ent, err;
  47
  48         if (!flow_cfg->max_flows)
  49                 return 0;
  50
  51         mutex_lock(&pfvf->mbox.lock);
  52         for (ent = 0; ent < flow_cfg->max_flows; ent++) {
  53                 req = otx2_mbox_alloc_msg_npc_mcam_free_entry(&pfvf->mbox);
  54                 if (!req)
  55                         break;
  56
  57                 req->entry = flow_cfg->flow_ent[ent];
  58
  59                 /* Send message to AF to free MCAM entries */
  60                 err = otx2_sync_mbox_msg(&pfvf->mbox);
  61                 if (err)
  62                         break;
  63         }
  64         mutex_unlock(&pfvf->mbox.lock);
  65         otx2_clear_ntuple_flow_info(pfvf, flow_cfg);
  66         return 0;
  67 }
  68
  69 static int mcam_entry_cmp(const void *a, const void *b)
  70 {
  71         return *(u16 *)a - *(u16 *)b;
  72 }
  73
  74 int otx2_alloc_mcam_entries(struct otx2_nic *pfvf, u16 count)
  75 {
  76         struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
  77         struct npc_mcam_alloc_entry_req *req;
  78         struct npc_mcam_alloc_entry_rsp *rsp;
  79         int ent, allocated = 0;
  80
  81         /* Free current ones and allocate new ones with requested count */
  82         otx2_free_ntuple_mcam_entries(pfvf);
  83
  84         if (!count)
  85                 return 0;
  86
  87         flow_cfg->flow_ent = devm_kmalloc_array(pfvf->dev, count,
  88                                                 sizeof(u16), GFP_KERNEL);
  89         if (!flow_cfg->flow_ent) {
  90                 netdev_err(pfvf->netdev,
  91                            "%s: Unable to allocate memory for flow entries\n",
  92                             __func__);
  93                 return -ENOMEM;
  94         }
  95
  96         mutex_lock(&pfvf->mbox.lock);
  97
  98         /* In a single request a max of NPC_MAX_NONCONTIG_ENTRIES MCAM entries
  99          * can only be allocated.
 100          */
 101         while (allocated < count) {
 102                 req = otx2_mbox_alloc_msg_npc_mcam_alloc_entry(&pfvf->mbox);
 103                 if (!req)
 104                         goto exit;
 105
 106                 req->contig = false;
 107                 req->count = (count - allocated) > NPC_MAX_NONCONTIG_ENTRIES ?
 108                                 NPC_MAX_NONCONTIG_ENTRIES : count - allocated;
 109
 110                 /* Allocate higher priority entries for PFs, so that VF's entries
 111                  * will be on top of PF.
 112                  */
 113                 if (!is_otx2_vf(pfvf->pcifunc)) {
 114                         req->priority = NPC_MCAM_HIGHER_PRIO;
 115                         req->ref_entry = flow_cfg->def_ent[0];
 116                 }
 117
 118                 /* Send message to AF */
 119                 if (otx2_sync_mbox_msg(&pfvf->mbox))
 120                         goto exit;
 121
 122                 rsp = (struct npc_mcam_alloc_entry_rsp *)otx2_mbox_get_rsp
 123                         (&pfvf->mbox.mbox, 0, &req->hdr);
 124
 125                 for (ent = 0; ent < rsp->count; ent++)
 126                         flow_cfg->flow_ent[ent + allocated] = rsp->entry_list[ent];
 127
 128                 allocated += rsp->count;
 129
 130                 /* If this request is not fulfilled, no need to send
 131                  * further requests.
 132                  */
 133                 if (rsp->count != req->count)
 134                         break;
 135         }
 136
 137         /* Multiple MCAM entry alloc requests could result in non-sequential
 138          * MCAM entries in the flow_ent[] array. Sort them in an ascending order,
 139          * otherwise user installed ntuple filter index and MCAM entry index will
 140          * not be in sync.
 141          */
 142         if (allocated)
 143                 sort(&flow_cfg->flow_ent[0], allocated,
 144                      sizeof(flow_cfg->flow_ent[0]), mcam_entry_cmp, NULL);
 145
 146 exit:
 147         mutex_unlock(&pfvf->mbox.lock);
 148
 149         flow_cfg->max_flows = allocated;
 150
 151         if (allocated) {
 152                 pfvf->flags |= OTX2_FLAG_MCAM_ENTRIES_ALLOC;
 153                 pfvf->flags |= OTX2_FLAG_NTUPLE_SUPPORT;
 154         }
 155
 156         if (allocated != count)
 157                 netdev_info(pfvf->netdev,
 158                             "Unable to allocate %d MCAM entries, got only %d\n",
 159                             count, allocated);
 160         return allocated;
 161 }
 162 EXPORT_SYMBOL(otx2_alloc_mcam_entries);
 163
 164 static int otx2_mcam_entry_init(struct otx2_nic *pfvf)
 165 {
 166         struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
 167         struct npc_get_field_status_req *freq;
 168         struct npc_get_field_status_rsp *frsp;
 169         struct npc_mcam_alloc_entry_req *req;
 170         struct npc_mcam_alloc_entry_rsp *rsp;
 171         int vf_vlan_max_flows;
 172         int ent, count;
 173
 174         vf_vlan_max_flows = pfvf->total_vfs * OTX2_PER_VF_VLAN_FLOWS;
 175         count = OTX2_MAX_UNICAST_FLOWS +
 176                         OTX2_MAX_VLAN_FLOWS + vf_vlan_max_flows;
 177
 178         flow_cfg->def_ent = devm_kmalloc_array(pfvf->dev, count,
 179                                                sizeof(u16), GFP_KERNEL);
 180         if (!flow_cfg->def_ent)
 181                 return -ENOMEM;
 182
 183         mutex_lock(&pfvf->mbox.lock);
 184
 185         req = otx2_mbox_alloc_msg_npc_mcam_alloc_entry(&pfvf->mbox);
 186         if (!req) {
 187                 mutex_unlock(&pfvf->mbox.lock);
 188                 return -ENOMEM;
 189         }
 190
 191         req->contig = false;
 192         req->count = count;
 193
 194         /* Send message to AF */
 195         if (otx2_sync_mbox_msg(&pfvf->mbox)) {
 196                 mutex_unlock(&pfvf->mbox.lock);
 197                 return -EINVAL;
 198         }
 199
 200         rsp = (struct npc_mcam_alloc_entry_rsp *)otx2_mbox_get_rsp
 201                (&pfvf->mbox.mbox, 0, &req->hdr);
 202
 203         if (rsp->count != req->count) {
 204                 netdev_info(pfvf->netdev,
 205                             "Unable to allocate MCAM entries for ucast, vlan and vf_vlan\n");
 206                 mutex_unlock(&pfvf->mbox.lock);
 207                 devm_kfree(pfvf->dev, flow_cfg->def_ent);
 208                 return 0;
 209         }
 210
 211         for (ent = 0; ent < rsp->count; ent++)
 212                 flow_cfg->def_ent[ent] = rsp->entry_list[ent];
 213
 214         flow_cfg->vf_vlan_offset = 0;
 215         flow_cfg->unicast_offset = vf_vlan_max_flows;
 216         flow_cfg->rx_vlan_offset = flow_cfg->unicast_offset +
 217                                         OTX2_MAX_UNICAST_FLOWS;
 218         pfvf->flags |= OTX2_FLAG_UCAST_FLTR_SUPPORT;
 219
 220         /* Check if NPC_DMAC field is supported
 221          * by the mkex profile before setting VLAN support flag.
 222          */
 223         freq = otx2_mbox_alloc_msg_npc_get_field_status(&pfvf->mbox);
 224         if (!freq) {
 225                 mutex_unlock(&pfvf->mbox.lock);
 226                 return -ENOMEM;
 227         }
 228
 229         freq->field = NPC_DMAC;
 230         if (otx2_sync_mbox_msg(&pfvf->mbox)) {
 231                 mutex_unlock(&pfvf->mbox.lock);
 232                 return -EINVAL;
 233         }
 234
 235         frsp = (struct npc_get_field_status_rsp *)otx2_mbox_get_rsp
 236                (&pfvf->mbox.mbox, 0, &freq->hdr);
 237
 238         if (frsp->enable) {
 239                 pfvf->flags |= OTX2_FLAG_RX_VLAN_SUPPORT;
 240                 pfvf->flags |= OTX2_FLAG_VF_VLAN_SUPPORT;
 241         }
 242
 243         pfvf->flags |= OTX2_FLAG_MCAM_ENTRIES_ALLOC;
 244         mutex_unlock(&pfvf->mbox.lock);
 245
 246         /* Allocate entries for Ntuple filters */
 247         count = otx2_alloc_mcam_entries(pfvf, OTX2_DEFAULT_FLOWCOUNT);
 248         if (count <= 0) {
 249                 otx2_clear_ntuple_flow_info(pfvf, flow_cfg);
 250                 return 0;
 251         }
 252
 253         pfvf->flags |= OTX2_FLAG_TC_FLOWER_SUPPORT;
 254
 255         return 0;
 256 }
 257
 258 /* TODO : revisit on size */
 259 #define OTX2_DMAC_FLTR_BITMAP_SZ (4 * 2048 + 32)
 260
 261 int otx2vf_mcam_flow_init(struct otx2_nic *pfvf)
 262 {
 263         struct otx2_flow_config *flow_cfg;
 264
 265         pfvf->flow_cfg = devm_kzalloc(pfvf->dev,
 266                                       sizeof(struct otx2_flow_config),
 267                                       GFP_KERNEL);
 268         if (!pfvf->flow_cfg)
 269                 return -ENOMEM;
 270
 271         pfvf->flow_cfg->dmacflt_bmap = devm_kcalloc(pfvf->dev,
 272                                                     BITS_TO_LONGS(OTX2_DMAC_FLTR_BITMAP_SZ),
 273                                                     sizeof(long), GFP_KERNEL);
 274         if (!pfvf->flow_cfg->dmacflt_bmap)
 275                 return -ENOMEM;
 276
 277         flow_cfg = pfvf->flow_cfg;
 278         INIT_LIST_HEAD(&flow_cfg->flow_list);
 279         INIT_LIST_HEAD(&flow_cfg->flow_list_tc);
 280         flow_cfg->max_flows = 0;
 281
 282         return 0;
 283 }
 284 EXPORT_SYMBOL(otx2vf_mcam_flow_init);
 285
 286 int otx2_mcam_flow_init(struct otx2_nic *pf)
 287 {
 288         int err;
 289
 290         pf->flow_cfg = devm_kzalloc(pf->dev, sizeof(struct otx2_flow_config),
 291                                     GFP_KERNEL);
 292         if (!pf->flow_cfg)
 293                 return -ENOMEM;
 294
 295         pf->flow_cfg->dmacflt_bmap = devm_kcalloc(pf->dev,
 296                                                   BITS_TO_LONGS(OTX2_DMAC_FLTR_BITMAP_SZ),
 297                                                   sizeof(long), GFP_KERNEL);
 298         if (!pf->flow_cfg->dmacflt_bmap)
 299                 return -ENOMEM;
 300
 301         INIT_LIST_HEAD(&pf->flow_cfg->flow_list);
 302         INIT_LIST_HEAD(&pf->flow_cfg->flow_list_tc);
 303
 304         /* Allocate bare minimum number of MCAM entries needed for
 305          * unicast and ntuple filters.
 306          */
 307         err = otx2_mcam_entry_init(pf);
 308         if (err)
 309                 return err;
 310
 311         /* Check if MCAM entries are allocate or not */
 312         if (!(pf->flags & OTX2_FLAG_UCAST_FLTR_SUPPORT))
 313                 return 0;
 314
 315         pf->mac_table = devm_kzalloc(pf->dev, sizeof(struct otx2_mac_table)
 316                                         * OTX2_MAX_UNICAST_FLOWS, GFP_KERNEL);
 317         if (!pf->mac_table)
 318                 return -ENOMEM;
 319
 320         otx2_dmacflt_get_max_cnt(pf);
 321
 322         /* DMAC filters are not allocated */
 323         if (!pf->flow_cfg->dmacflt_max_flows)
 324                 return 0;
 325
 326         pf->flow_cfg->bmap_to_dmacindex =
 327                         devm_kzalloc(pf->dev, sizeof(u32) *
 328                                      pf->flow_cfg->dmacflt_max_flows,
 329                                      GFP_KERNEL);
 330
 331         if (!pf->flow_cfg->bmap_to_dmacindex)
 332                 return -ENOMEM;
 333
 334         pf->flags |= OTX2_FLAG_DMACFLTR_SUPPORT;
 335
 336         return 0;
 337 }
 338
 339 void otx2_mcam_flow_del(struct otx2_nic *pf)
 340 {
 341         otx2_destroy_mcam_flows(pf);
 342 }
 343 EXPORT_SYMBOL(otx2_mcam_flow_del);
 344
 345 /*  On success adds mcam entry
 346  *  On failure enable promisous mode
 347  */
 348 static int otx2_do_add_macfilter(struct otx2_nic *pf, const u8 *mac)
 349 {
 350         struct otx2_flow_config *flow_cfg = pf->flow_cfg;
 351         struct npc_install_flow_req *req;
 352         int err, i;
 353
 354         if (!(pf->flags & OTX2_FLAG_UCAST_FLTR_SUPPORT))
 355                 return -ENOMEM;
 356
 357         /* dont have free mcam entries or uc list is greater than alloted */
 358         if (netdev_uc_count(pf->netdev) > OTX2_MAX_UNICAST_FLOWS)
 359                 return -ENOMEM;
 360
 361         mutex_lock(&pf->mbox.lock);
 362         req = otx2_mbox_alloc_msg_npc_install_flow(&pf->mbox);
 363         if (!req) {
 364                 mutex_unlock(&pf->mbox.lock);
 365                 return -ENOMEM;
 366         }
 367
 368         /* unicast offset starts with 32 0..31 for ntuple */
 369         for (i = 0; i <  OTX2_MAX_UNICAST_FLOWS; i++) {
 370                 if (pf->mac_table[i].inuse)
 371                         continue;
 372                 ether_addr_copy(pf->mac_table[i].addr, mac);
 373                 pf->mac_table[i].inuse = true;
 374                 pf->mac_table[i].mcam_entry =
 375                         flow_cfg->def_ent[i + flow_cfg->unicast_offset];
 376                 req->entry =  pf->mac_table[i].mcam_entry;
 377                 break;
 378         }
 379
 380         ether_addr_copy(req->packet.dmac, mac);
 381         eth_broadcast_addr((u8 *)&req->mask.dmac);
 382         req->features = BIT_ULL(NPC_DMAC);
 383         req->channel = pf->hw.rx_chan_base;
 384         req->intf = NIX_INTF_RX;
 385         req->op = NIX_RX_ACTION_DEFAULT;
 386         req->set_cntr = 1;
 387
 388         err = otx2_sync_mbox_msg(&pf->mbox);
 389         mutex_unlock(&pf->mbox.lock);
 390
 391         return err;
 392 }
 393
 394 int otx2_add_macfilter(struct net_device *netdev, const u8 *mac)
 395 {
 396         struct otx2_nic *pf = netdev_priv(netdev);
 397
 398         if (!bitmap_empty(pf->flow_cfg->dmacflt_bmap,
 399                           pf->flow_cfg->dmacflt_max_flows))
 400                 netdev_warn(netdev,
 401                             "Add %pM to CGX/RPM DMAC filters list as well\n",
 402                             mac);
 403
 404         return otx2_do_add_macfilter(pf, mac);
 405 }
 406
 407 static bool otx2_get_mcamentry_for_mac(struct otx2_nic *pf, const u8 *mac,
 408                                        int *mcam_entry)
 409 {
 410         int i;
 411
 412         for (i = 0; i < OTX2_MAX_UNICAST_FLOWS; i++) {
 413                 if (!pf->mac_table[i].inuse)
 414                         continue;
 415
 416                 if (ether_addr_equal(pf->mac_table[i].addr, mac)) {
 417                         *mcam_entry = pf->mac_table[i].mcam_entry;
 418                         pf->mac_table[i].inuse = false;
 419                         return true;
 420                 }
 421         }
 422         return false;
 423 }
 424
 425 int otx2_del_macfilter(struct net_device *netdev, const u8 *mac)
 426 {
 427         struct otx2_nic *pf = netdev_priv(netdev);
 428         struct npc_delete_flow_req *req;
 429         int err, mcam_entry;
 430
 431         /* check does mcam entry exists for given mac */
 432         if (!otx2_get_mcamentry_for_mac(pf, mac, &mcam_entry))
 433                 return 0;
 434
 435         mutex_lock(&pf->mbox.lock);
 436         req = otx2_mbox_alloc_msg_npc_delete_flow(&pf->mbox);
 437         if (!req) {
 438                 mutex_unlock(&pf->mbox.lock);
 439                 return -ENOMEM;
 440         }
 441         req->entry = mcam_entry;
 442         /* Send message to AF */
 443         err = otx2_sync_mbox_msg(&pf->mbox);
 444         mutex_unlock(&pf->mbox.lock);
 445
 446         return err;
 447 }
 448
 449 static struct otx2_flow *otx2_find_flow(struct otx2_nic *pfvf, u32 location)
 450 {
 451         struct otx2_flow *iter;
 452
 453         list_for_each_entry(iter, &pfvf->flow_cfg->flow_list, list) {
 454                 if (iter->location == location)
 455                         return iter;
 456         }
 457
 458         return NULL;
 459 }
 460
 461 static void otx2_add_flow_to_list(struct otx2_nic *pfvf, struct otx2_flow *flow)
 462 {
 463         struct list_head *head = &pfvf->flow_cfg->flow_list;
 464         struct otx2_flow *iter;
 465
 466         list_for_each_entry(iter, &pfvf->flow_cfg->flow_list, list) {
 467                 if (iter->location > flow->location)
 468                         break;
 469                 head = &iter->list;
 470         }
 471
 472         list_add(&flow->list, head);
 473 }
 474
 475 int otx2_get_maxflows(struct otx2_flow_config *flow_cfg)
 476 {
 477         if (!flow_cfg)
 478                 return 0;
 479
 480         if (flow_cfg->nr_flows == flow_cfg->max_flows ||
 481             !bitmap_empty(flow_cfg->dmacflt_bmap,
 482                           flow_cfg->dmacflt_max_flows))
 483                 return flow_cfg->max_flows + flow_cfg->dmacflt_max_flows;
 484         else
 485                 return flow_cfg->max_flows;
 486 }
 487 EXPORT_SYMBOL(otx2_get_maxflows);
 488
 489 int otx2_get_flow(struct otx2_nic *pfvf, struct ethtool_rxnfc *nfc,
 490                   u32 location)
 491 {
 492         struct otx2_flow *iter;
 493
 494         if (location >= otx2_get_maxflows(pfvf->flow_cfg))
 495                 return -EINVAL;
 496
 497         list_for_each_entry(iter, &pfvf->flow_cfg->flow_list, list) {
 498                 if (iter->location == location) {
 499                         nfc->fs = iter->flow_spec;
 500                         nfc->rss_context = iter->rss_ctx_id;
 501                         return 0;
 502                 }
 503         }
 504
 505         return -ENOENT;
 506 }
 507
 508 int otx2_get_all_flows(struct otx2_nic *pfvf, struct ethtool_rxnfc *nfc,
 509                        u32 *rule_locs)
 510 {
 511         u32 rule_cnt = nfc->rule_cnt;
 512         u32 location = 0;
 513         int idx = 0;
 514         int err = 0;
 515
 516         nfc->data = otx2_get_maxflows(pfvf->flow_cfg);
 517         while ((!err || err == -ENOENT) && idx < rule_cnt) {
 518                 err = otx2_get_flow(pfvf, nfc, location);
 519                 if (!err)
 520                         rule_locs[idx++] = location;
 521                 location++;
 522         }
 523         nfc->rule_cnt = rule_cnt;
 524
 525         return err;
 526 }
 527
 528 static int otx2_prepare_ipv4_flow(struct ethtool_rx_flow_spec *fsp,
 529                                   struct npc_install_flow_req *req,
 530                                   u32 flow_type)
 531 {
 532         struct ethtool_usrip4_spec *ipv4_usr_mask = &fsp->m_u.usr_ip4_spec;
 533         struct ethtool_usrip4_spec *ipv4_usr_hdr = &fsp->h_u.usr_ip4_spec;
 534         struct ethtool_tcpip4_spec *ipv4_l4_mask = &fsp->m_u.tcp_ip4_spec;
 535         struct ethtool_tcpip4_spec *ipv4_l4_hdr = &fsp->h_u.tcp_ip4_spec;
 536         struct ethtool_ah_espip4_spec *ah_esp_hdr = &fsp->h_u.ah_ip4_spec;
 537         struct ethtool_ah_espip4_spec *ah_esp_mask = &fsp->m_u.ah_ip4_spec;
 538         struct flow_msg *pmask = &req->mask;
 539         struct flow_msg *pkt = &req->packet;
 540
 541         switch (flow_type) {
 542         case IP_USER_FLOW:
 543                 if (ipv4_usr_mask->ip4src) {
 544                         memcpy(&pkt->ip4src, &ipv4_usr_hdr->ip4src,
 545                                sizeof(pkt->ip4src));
 546                         memcpy(&pmask->ip4src, &ipv4_usr_mask->ip4src,
 547                                sizeof(pmask->ip4src));
 548                         req->features |= BIT_ULL(NPC_SIP_IPV4);
 549                 }
 550                 if (ipv4_usr_mask->ip4dst) {
 551                         memcpy(&pkt->ip4dst, &ipv4_usr_hdr->ip4dst,
 552                                sizeof(pkt->ip4dst));
 553                         memcpy(&pmask->ip4dst, &ipv4_usr_mask->ip4dst,
 554                                sizeof(pmask->ip4dst));
 555                         req->features |= BIT_ULL(NPC_DIP_IPV4);
 556                 }
 557                 if (ipv4_usr_mask->tos) {
 558                         pkt->tos = ipv4_usr_hdr->tos;
 559                         pmask->tos = ipv4_usr_mask->tos;
 560                         req->features |= BIT_ULL(NPC_TOS);
 561                 }
 562                 if (ipv4_usr_mask->proto) {
 563                         switch (ipv4_usr_hdr->proto) {
 564                         case IPPROTO_ICMP:
 565                                 req->features |= BIT_ULL(NPC_IPPROTO_ICMP);
 566                                 break;
 567                         case IPPROTO_TCP:
 568                                 req->features |= BIT_ULL(NPC_IPPROTO_TCP);
 569                                 break;
 570                         case IPPROTO_UDP:
 571                                 req->features |= BIT_ULL(NPC_IPPROTO_UDP);
 572                                 break;
 573                         case IPPROTO_SCTP:
 574                                 req->features |= BIT_ULL(NPC_IPPROTO_SCTP);
 575                                 break;
 576                         case IPPROTO_AH:
 577                                 req->features |= BIT_ULL(NPC_IPPROTO_AH);
 578                                 break;
 579                         case IPPROTO_ESP:
 580                                 req->features |= BIT_ULL(NPC_IPPROTO_ESP);
 581                                 break;
 582                         default:
 583                                 return -EOPNOTSUPP;
 584                         }
 585                 }
 586                 pkt->etype = cpu_to_be16(ETH_P_IP);
 587                 pmask->etype = cpu_to_be16(0xFFFF);
 588                 req->features |= BIT_ULL(NPC_ETYPE);
 589                 break;
 590         case TCP_V4_FLOW:
 591         case UDP_V4_FLOW:
 592         case SCTP_V4_FLOW:
 593                 pkt->etype = cpu_to_be16(ETH_P_IP);
 594                 pmask->etype = cpu_to_be16(0xFFFF);
 595                 req->features |= BIT_ULL(NPC_ETYPE);
 596                 if (ipv4_l4_mask->ip4src) {
 597                         memcpy(&pkt->ip4src, &ipv4_l4_hdr->ip4src,
 598                                sizeof(pkt->ip4src));
 599                         memcpy(&pmask->ip4src, &ipv4_l4_mask->ip4src,
 600                                sizeof(pmask->ip4src));
 601                         req->features |= BIT_ULL(NPC_SIP_IPV4);
 602                 }
 603                 if (ipv4_l4_mask->ip4dst) {
 604                         memcpy(&pkt->ip4dst, &ipv4_l4_hdr->ip4dst,
 605                                sizeof(pkt->ip4dst));
 606                         memcpy(&pmask->ip4dst, &ipv4_l4_mask->ip4dst,
 607                                sizeof(pmask->ip4dst));
 608                         req->features |= BIT_ULL(NPC_DIP_IPV4);
 609                 }
 610                 if (ipv4_l4_mask->tos) {
 611                         pkt->tos = ipv4_l4_hdr->tos;
 612                         pmask->tos = ipv4_l4_mask->tos;
 613                         req->features |= BIT_ULL(NPC_TOS);
 614                 }
 615                 if (ipv4_l4_mask->psrc) {
 616                         memcpy(&pkt->sport, &ipv4_l4_hdr->psrc,
 617                                sizeof(pkt->sport));
 618                         memcpy(&pmask->sport, &ipv4_l4_mask->psrc,
 619                                sizeof(pmask->sport));
 620                         if (flow_type == UDP_V4_FLOW)
 621                                 req->features |= BIT_ULL(NPC_SPORT_UDP);
 622                         else if (flow_type == TCP_V4_FLOW)
 623                                 req->features |= BIT_ULL(NPC_SPORT_TCP);
 624                         else
 625                                 req->features |= BIT_ULL(NPC_SPORT_SCTP);
 626                 }
 627                 if (ipv4_l4_mask->pdst) {
 628                         memcpy(&pkt->dport, &ipv4_l4_hdr->pdst,
 629                                sizeof(pkt->dport));
 630                         memcpy(&pmask->dport, &ipv4_l4_mask->pdst,
 631                                sizeof(pmask->dport));
 632                         if (flow_type == UDP_V4_FLOW)
 633                                 req->features |= BIT_ULL(NPC_DPORT_UDP);
 634                         else if (flow_type == TCP_V4_FLOW)
 635                                 req->features |= BIT_ULL(NPC_DPORT_TCP);
 636                         else
 637                                 req->features |= BIT_ULL(NPC_DPORT_SCTP);
 638                 }
 639                 if (flow_type == UDP_V4_FLOW)
 640                         req->features |= BIT_ULL(NPC_IPPROTO_UDP);
 641                 else if (flow_type == TCP_V4_FLOW)
 642                         req->features |= BIT_ULL(NPC_IPPROTO_TCP);
 643                 else
 644                         req->features |= BIT_ULL(NPC_IPPROTO_SCTP);
 645                 break;
 646         case AH_V4_FLOW:
 647         case ESP_V4_FLOW:
 648                 pkt->etype = cpu_to_be16(ETH_P_IP);
 649                 pmask->etype = cpu_to_be16(0xFFFF);
 650                 req->features |= BIT_ULL(NPC_ETYPE);
 651                 if (ah_esp_mask->ip4src) {
 652                         memcpy(&pkt->ip4src, &ah_esp_hdr->ip4src,
 653                                sizeof(pkt->ip4src));
 654                         memcpy(&pmask->ip4src, &ah_esp_mask->ip4src,
 655                                sizeof(pmask->ip4src));
 656                         req->features |= BIT_ULL(NPC_SIP_IPV4);
 657                 }
 658                 if (ah_esp_mask->ip4dst) {
 659                         memcpy(&pkt->ip4dst, &ah_esp_hdr->ip4dst,
 660                                sizeof(pkt->ip4dst));
 661                         memcpy(&pmask->ip4dst, &ah_esp_mask->ip4dst,
 662                                sizeof(pmask->ip4dst));
 663                         req->features |= BIT_ULL(NPC_DIP_IPV4);
 664                 }
 665                 if (ah_esp_mask->tos) {
 666                         pkt->tos = ah_esp_hdr->tos;
 667                         pmask->tos = ah_esp_mask->tos;
 668                         req->features |= BIT_ULL(NPC_TOS);
 669                 }
 670
 671                 /* NPC profile doesn't extract AH/ESP header fields */
 672                 if (ah_esp_mask->spi & ah_esp_hdr->spi)
 673                         return -EOPNOTSUPP;
 674
 675                 if (flow_type == AH_V4_FLOW)
 676                         req->features |= BIT_ULL(NPC_IPPROTO_AH);
 677                 else
 678                         req->features |= BIT_ULL(NPC_IPPROTO_ESP);
 679                 break;
 680         default:
 681                 break;
 682         }
 683
 684         return 0;
 685 }
 686
 687 static int otx2_prepare_ipv6_flow(struct ethtool_rx_flow_spec *fsp,
 688                                   struct npc_install_flow_req *req,
 689                                   u32 flow_type)
 690 {
 691         struct ethtool_usrip6_spec *ipv6_usr_mask = &fsp->m_u.usr_ip6_spec;
 692         struct ethtool_usrip6_spec *ipv6_usr_hdr = &fsp->h_u.usr_ip6_spec;
 693         struct ethtool_tcpip6_spec *ipv6_l4_mask = &fsp->m_u.tcp_ip6_spec;
 694         struct ethtool_tcpip6_spec *ipv6_l4_hdr = &fsp->h_u.tcp_ip6_spec;
 695         struct ethtool_ah_espip6_spec *ah_esp_hdr = &fsp->h_u.ah_ip6_spec;
 696         struct ethtool_ah_espip6_spec *ah_esp_mask = &fsp->m_u.ah_ip6_spec;
 697         struct flow_msg *pmask = &req->mask;
 698         struct flow_msg *pkt = &req->packet;
 699
 700         switch (flow_type) {
 701         case IPV6_USER_FLOW:
 702                 if (!ipv6_addr_any((struct in6_addr *)ipv6_usr_mask->ip6src)) {
 703                         memcpy(&pkt->ip6src, &ipv6_usr_hdr->ip6src,
 704                                sizeof(pkt->ip6src));
 705                         memcpy(&pmask->ip6src, &ipv6_usr_mask->ip6src,
 706                                sizeof(pmask->ip6src));
 707                         req->features |= BIT_ULL(NPC_SIP_IPV6);
 708                 }
 709                 if (!ipv6_addr_any((struct in6_addr *)ipv6_usr_mask->ip6dst)) {
 710                         memcpy(&pkt->ip6dst, &ipv6_usr_hdr->ip6dst,
 711                                sizeof(pkt->ip6dst));
 712                         memcpy(&pmask->ip6dst, &ipv6_usr_mask->ip6dst,
 713                                sizeof(pmask->ip6dst));
 714                         req->features |= BIT_ULL(NPC_DIP_IPV6);
 715                 }
 716                 if (ipv6_usr_hdr->l4_proto == IPPROTO_FRAGMENT) {
 717                         pkt->next_header = ipv6_usr_hdr->l4_proto;
 718                         pmask->next_header = ipv6_usr_mask->l4_proto;
 719                         req->features |= BIT_ULL(NPC_IPFRAG_IPV6);
 720                 }
 721                 pkt->etype = cpu_to_be16(ETH_P_IPV6);
 722                 pmask->etype = cpu_to_be16(0xFFFF);
 723                 req->features |= BIT_ULL(NPC_ETYPE);
 724                 break;
 725         case TCP_V6_FLOW:
 726         case UDP_V6_FLOW:
 727         case SCTP_V6_FLOW:
 728                 pkt->etype = cpu_to_be16(ETH_P_IPV6);
 729                 pmask->etype = cpu_to_be16(0xFFFF);
 730                 req->features |= BIT_ULL(NPC_ETYPE);
 731                 if (!ipv6_addr_any((struct in6_addr *)ipv6_l4_mask->ip6src)) {
 732                         memcpy(&pkt->ip6src, &ipv6_l4_hdr->ip6src,
 733                                sizeof(pkt->ip6src));
 734                         memcpy(&pmask->ip6src, &ipv6_l4_mask->ip6src,
 735                                sizeof(pmask->ip6src));
 736                         req->features |= BIT_ULL(NPC_SIP_IPV6);
 737                 }
 738                 if (!ipv6_addr_any((struct in6_addr *)ipv6_l4_mask->ip6dst)) {
 739                         memcpy(&pkt->ip6dst, &ipv6_l4_hdr->ip6dst,
 740                                sizeof(pkt->ip6dst));
 741                         memcpy(&pmask->ip6dst, &ipv6_l4_mask->ip6dst,
 742                                sizeof(pmask->ip6dst));
 743                         req->features |= BIT_ULL(NPC_DIP_IPV6);
 744                 }
 745                 if (ipv6_l4_mask->psrc) {
 746                         memcpy(&pkt->sport, &ipv6_l4_hdr->psrc,
 747                                sizeof(pkt->sport));
 748                         memcpy(&pmask->sport, &ipv6_l4_mask->psrc,
 749                                sizeof(pmask->sport));
 750                         if (flow_type == UDP_V6_FLOW)
 751                                 req->features |= BIT_ULL(NPC_SPORT_UDP);
 752                         else if (flow_type == TCP_V6_FLOW)
 753                                 req->features |= BIT_ULL(NPC_SPORT_TCP);
 754                         else
 755                                 req->features |= BIT_ULL(NPC_SPORT_SCTP);
 756                 }
 757                 if (ipv6_l4_mask->pdst) {
 758                         memcpy(&pkt->dport, &ipv6_l4_hdr->pdst,
 759                                sizeof(pkt->dport));
 760                         memcpy(&pmask->dport, &ipv6_l4_mask->pdst,
 761                                sizeof(pmask->dport));
 762                         if (flow_type == UDP_V6_FLOW)
 763                                 req->features |= BIT_ULL(NPC_DPORT_UDP);
 764                         else if (flow_type == TCP_V6_FLOW)
 765                                 req->features |= BIT_ULL(NPC_DPORT_TCP);
 766                         else
 767                                 req->features |= BIT_ULL(NPC_DPORT_SCTP);
 768                 }
 769                 if (flow_type == UDP_V6_FLOW)
 770                         req->features |= BIT_ULL(NPC_IPPROTO_UDP);
 771                 else if (flow_type == TCP_V6_FLOW)
 772                         req->features |= BIT_ULL(NPC_IPPROTO_TCP);
 773                 else
 774                         req->features |= BIT_ULL(NPC_IPPROTO_SCTP);
 775                 break;
 776         case AH_V6_FLOW:
 777         case ESP_V6_FLOW:
 778                 pkt->etype = cpu_to_be16(ETH_P_IPV6);
 779                 pmask->etype = cpu_to_be16(0xFFFF);
 780                 req->features |= BIT_ULL(NPC_ETYPE);
 781                 if (!ipv6_addr_any((struct in6_addr *)ah_esp_hdr->ip6src)) {
 782                         memcpy(&pkt->ip6src, &ah_esp_hdr->ip6src,
 783                                sizeof(pkt->ip6src));
 784                         memcpy(&pmask->ip6src, &ah_esp_mask->ip6src,
 785                                sizeof(pmask->ip6src));
 786                         req->features |= BIT_ULL(NPC_SIP_IPV6);
 787                 }
 788                 if (!ipv6_addr_any((struct in6_addr *)ah_esp_hdr->ip6dst)) {
 789                         memcpy(&pkt->ip6dst, &ah_esp_hdr->ip6dst,
 790                                sizeof(pkt->ip6dst));
 791                         memcpy(&pmask->ip6dst, &ah_esp_mask->ip6dst,
 792                                sizeof(pmask->ip6dst));
 793                         req->features |= BIT_ULL(NPC_DIP_IPV6);
 794                 }
 795
 796                 /* NPC profile doesn't extract AH/ESP header fields */
 797                 if ((ah_esp_mask->spi & ah_esp_hdr->spi) ||
 798                     (ah_esp_mask->tclass & ah_esp_hdr->tclass))
 799                         return -EOPNOTSUPP;
 800
 801                 if (flow_type == AH_V6_FLOW)
 802                         req->features |= BIT_ULL(NPC_IPPROTO_AH);
 803                 else
 804                         req->features |= BIT_ULL(NPC_IPPROTO_ESP);
 805                 break;
 806         default:
 807                 break;
 808         }
 809
 810         return 0;
 811 }
 812
 813 static int otx2_prepare_flow_request(struct ethtool_rx_flow_spec *fsp,
 814                               struct npc_install_flow_req *req)
 815 {
 816         struct ethhdr *eth_mask = &fsp->m_u.ether_spec;
 817         struct ethhdr *eth_hdr = &fsp->h_u.ether_spec;
 818         struct flow_msg *pmask = &req->mask;
 819         struct flow_msg *pkt = &req->packet;
 820         u32 flow_type;
 821         int ret;
 822
 823         flow_type = fsp->flow_type & ~(FLOW_EXT | FLOW_MAC_EXT | FLOW_RSS);
 824         switch (flow_type) {
 825         /* bits not set in mask are don't care */
 826         case ETHER_FLOW:
 827                 if (!is_zero_ether_addr(eth_mask->h_source)) {
 828                         ether_addr_copy(pkt->smac, eth_hdr->h_source);
 829                         ether_addr_copy(pmask->smac, eth_mask->h_source);
 830                         req->features |= BIT_ULL(NPC_SMAC);
 831                 }
 832                 if (!is_zero_ether_addr(eth_mask->h_dest)) {
 833                         ether_addr_copy(pkt->dmac, eth_hdr->h_dest);
 834                         ether_addr_copy(pmask->dmac, eth_mask->h_dest);
 835                         req->features |= BIT_ULL(NPC_DMAC);
 836                 }
 837                 if (eth_hdr->h_proto) {
 838                         memcpy(&pkt->etype, &eth_hdr->h_proto,
 839                                sizeof(pkt->etype));
 840                         memcpy(&pmask->etype, &eth_mask->h_proto,
 841                                sizeof(pmask->etype));
 842                         req->features |= BIT_ULL(NPC_ETYPE);
 843                 }
 844                 break;
 845         case IP_USER_FLOW:
 846         case TCP_V4_FLOW:
 847         case UDP_V4_FLOW:
 848         case SCTP_V4_FLOW:
 849         case AH_V4_FLOW:
 850         case ESP_V4_FLOW:
 851                 ret = otx2_prepare_ipv4_flow(fsp, req, flow_type);
 852                 if (ret)
 853                         return ret;
 854                 break;
 855         case IPV6_USER_FLOW:
 856         case TCP_V6_FLOW:
 857         case UDP_V6_FLOW:
 858         case SCTP_V6_FLOW:
 859         case AH_V6_FLOW:
 860         case ESP_V6_FLOW:
 861                 ret = otx2_prepare_ipv6_flow(fsp, req, flow_type);
 862                 if (ret)
 863                         return ret;
 864                 break;
 865         default:
 866                 return -EOPNOTSUPP;
 867         }
 868         if (fsp->flow_type & FLOW_EXT) {
 869                 u16 vlan_etype;
 870
 871                 if (fsp->m_ext.vlan_etype) {
 872                         /* Partial masks not supported */
 873                         if (be16_to_cpu(fsp->m_ext.vlan_etype) != 0xFFFF)
 874                                 return -EINVAL;
 875
 876                         vlan_etype = be16_to_cpu(fsp->h_ext.vlan_etype);
 877
 878                         /* Drop rule with vlan_etype == 802.1Q
 879                          * and vlan_id == 0 is not supported
 880                          */
 881                         if (vlan_etype == ETH_P_8021Q && !fsp->m_ext.vlan_tci &&
 882                             fsp->ring_cookie == RX_CLS_FLOW_DISC)
 883                                 return -EINVAL;
 884
 885                         /* Only ETH_P_8021Q and ETH_P_802AD types supported */
 886                         if (vlan_etype != ETH_P_8021Q &&
 887                             vlan_etype != ETH_P_8021AD)
 888                                 return -EINVAL;
 889
 890                         memcpy(&pkt->vlan_etype, &fsp->h_ext.vlan_etype,
 891                                sizeof(pkt->vlan_etype));
 892                         memcpy(&pmask->vlan_etype, &fsp->m_ext.vlan_etype,
 893                                sizeof(pmask->vlan_etype));
 894
 895                         if (vlan_etype == ETH_P_8021Q)
 896                                 req->features |= BIT_ULL(NPC_VLAN_ETYPE_CTAG);
 897                         else
 898                                 req->features |= BIT_ULL(NPC_VLAN_ETYPE_STAG);
 899                 }
 900
 901                 if (fsp->m_ext.vlan_tci) {
 902                         memcpy(&pkt->vlan_tci, &fsp->h_ext.vlan_tci,
 903                                sizeof(pkt->vlan_tci));
 904                         memcpy(&pmask->vlan_tci, &fsp->m_ext.vlan_tci,
 905                                sizeof(pmask->vlan_tci));
 906                         req->features |= BIT_ULL(NPC_OUTER_VID);
 907                 }
 908
 909                 if (fsp->m_ext.data[1]) {
 910                         if (flow_type == IP_USER_FLOW) {
 911                                 if (be32_to_cpu(fsp->h_ext.data[1]) != IPV4_FLAG_MORE)
 912                                         return -EINVAL;
 913
 914                                 pkt->ip_flag = be32_to_cpu(fsp->h_ext.data[1]);
 915                                 pmask->ip_flag = be32_to_cpu(fsp->m_ext.data[1]);
 916                                 req->features |= BIT_ULL(NPC_IPFRAG_IPV4);
 917                         } else if (fsp->h_ext.data[1] ==
 918                                         cpu_to_be32(OTX2_DEFAULT_ACTION)) {
 919                                 /* Not Drop/Direct to queue but use action
 920                                  * in default entry
 921                                  */
 922                                 req->op = NIX_RX_ACTION_DEFAULT;
 923                         }
 924                 }
 925         }
 926
 927         if (fsp->flow_type & FLOW_MAC_EXT &&
 928             !is_zero_ether_addr(fsp->m_ext.h_dest)) {
 929                 ether_addr_copy(pkt->dmac, fsp->h_ext.h_dest);
 930                 ether_addr_copy(pmask->dmac, fsp->m_ext.h_dest);
 931                 req->features |= BIT_ULL(NPC_DMAC);
 932         }
 933
 934         if (!req->features)
 935                 return -EOPNOTSUPP;
 936
 937         return 0;
 938 }
 939
 940 static int otx2_is_flow_rule_dmacfilter(struct otx2_nic *pfvf,
 941                                         struct ethtool_rx_flow_spec *fsp)
 942 {
 943         struct ethhdr *eth_mask = &fsp->m_u.ether_spec;
 944         struct ethhdr *eth_hdr = &fsp->h_u.ether_spec;
 945         u64 ring_cookie = fsp->ring_cookie;
 946         u32 flow_type;
 947
 948         if (!(pfvf->flags & OTX2_FLAG_DMACFLTR_SUPPORT))
 949                 return false;
 950
 951         flow_type = fsp->flow_type & ~(FLOW_EXT | FLOW_MAC_EXT | FLOW_RSS);
 952
 953         /* CGX/RPM block dmac filtering configured for white listing
 954          * check for action other than DROP
 955          */
 956         if (flow_type == ETHER_FLOW && ring_cookie != RX_CLS_FLOW_DISC &&
 957             !ethtool_get_flow_spec_ring_vf(ring_cookie)) {
 958                 if (is_zero_ether_addr(eth_mask->h_dest) &&
 959                     is_valid_ether_addr(eth_hdr->h_dest))
 960                         return true;
 961         }
 962
 963         return false;
 964 }
 965
 966 static int otx2_add_flow_msg(struct otx2_nic *pfvf, struct otx2_flow *flow)
 967 {
 968         u64 ring_cookie = flow->flow_spec.ring_cookie;
 969 #ifdef CONFIG_DCB
 970         int vlan_prio, qidx, pfc_rule = 0;
 971 #endif
 972         struct npc_install_flow_req *req;
 973         int err, vf = 0;
 974
 975         mutex_lock(&pfvf->mbox.lock);
 976         req = otx2_mbox_alloc_msg_npc_install_flow(&pfvf->mbox);
 977         if (!req) {
 978                 mutex_unlock(&pfvf->mbox.lock);
 979                 return -ENOMEM;
 980         }
 981
 982         err = otx2_prepare_flow_request(&flow->flow_spec, req);
 983         if (err) {
 984                 /* free the allocated msg above */
 985                 otx2_mbox_reset(&pfvf->mbox.mbox, 0);
 986                 mutex_unlock(&pfvf->mbox.lock);
 987                 return err;
 988         }
 989
 990         req->entry = flow->entry;
 991         req->intf = NIX_INTF_RX;
 992         req->set_cntr = 1;
 993         req->channel = pfvf->hw.rx_chan_base;
 994         if (ring_cookie == RX_CLS_FLOW_DISC) {
 995                 req->op = NIX_RX_ACTIONOP_DROP;
 996         } else {
 997                 /* change to unicast only if action of default entry is not
 998                  * requested by user
 999                  */
1000                 if (flow->flow_spec.flow_type & FLOW_RSS) {
1001                         req->op = NIX_RX_ACTIONOP_RSS;
1002                         req->index = flow->rss_ctx_id;
1003                         req->flow_key_alg = pfvf->hw.flowkey_alg_idx;
1004                 } else {
1005                         req->op = NIX_RX_ACTIONOP_UCAST;
1006                         req->index = ethtool_get_flow_spec_ring(ring_cookie);
1007                 }
1008                 vf = ethtool_get_flow_spec_ring_vf(ring_cookie);
1009                 if (vf > pci_num_vf(pfvf->pdev)) {
1010                         mutex_unlock(&pfvf->mbox.lock);
1011                         return -EINVAL;
1012                 }
1013
1014 #ifdef CONFIG_DCB
1015                 /* Identify PFC rule if PFC enabled and ntuple rule is vlan */
1016                 if (!vf && (req->features & BIT_ULL(NPC_OUTER_VID)) &&
1017                     pfvf->pfc_en && req->op != NIX_RX_ACTIONOP_RSS) {
1018                         vlan_prio = ntohs(req->packet.vlan_tci) &
1019                                     ntohs(req->mask.vlan_tci);
1020
1021                         /* Get the priority */
1022                         vlan_prio >>= 13;
1023                         flow->rule_type |= PFC_FLOWCTRL_RULE;
1024                         /* Check if PFC enabled for this priority */
1025                         if (pfvf->pfc_en & BIT(vlan_prio)) {
1026                                 pfc_rule = true;
1027                                 qidx = req->index;
1028                         }
1029                 }
1030 #endif
1031         }
1032
1033         /* ethtool ring_cookie has (VF + 1) for VF */
1034         if (vf) {
1035                 req->vf = vf;
1036                 flow->is_vf = true;
1037                 flow->vf = vf;
1038         }
1039
1040         /* Send message to AF */
1041         err = otx2_sync_mbox_msg(&pfvf->mbox);
1042
1043 #ifdef CONFIG_DCB
1044         if (!err && pfc_rule)
1045                 otx2_update_bpid_in_rqctx(pfvf, vlan_prio, qidx, true);
1046 #endif
1047
1048         mutex_unlock(&pfvf->mbox.lock);
1049         return err;
1050 }
1051
1052 static int otx2_add_flow_with_pfmac(struct otx2_nic *pfvf,
1053                                     struct otx2_flow *flow)
1054 {
1055         struct otx2_flow *pf_mac;
1056         struct ethhdr *eth_hdr;
1057
1058         pf_mac = kzalloc(sizeof(*pf_mac), GFP_KERNEL);
1059         if (!pf_mac)
1060                 return -ENOMEM;
1061
1062         pf_mac->entry = 0;
1063         pf_mac->rule_type |= DMAC_FILTER_RULE;
1064         pf_mac->location = pfvf->flow_cfg->max_flows;
1065         memcpy(&pf_mac->flow_spec, &flow->flow_spec,
1066                sizeof(struct ethtool_rx_flow_spec));
1067         pf_mac->flow_spec.location = pf_mac->location;
1068
1069         /* Copy PF mac address */
1070         eth_hdr = &pf_mac->flow_spec.h_u.ether_spec;
1071         ether_addr_copy(eth_hdr->h_dest, pfvf->netdev->dev_addr);
1072
1073         /* Install DMAC filter with PF mac address */
1074         otx2_dmacflt_add(pfvf, eth_hdr->h_dest, 0);
1075
1076         otx2_add_flow_to_list(pfvf, pf_mac);
1077         pfvf->flow_cfg->nr_flows++;
1078         set_bit(0, pfvf->flow_cfg->dmacflt_bmap);
1079
1080         return 0;
1081 }
1082
1083 int otx2_add_flow(struct otx2_nic *pfvf, struct ethtool_rxnfc *nfc)
1084 {
1085         struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
1086         struct ethtool_rx_flow_spec *fsp = &nfc->fs;
1087         struct otx2_flow *flow;
1088         struct ethhdr *eth_hdr;
1089         bool new = false;
1090         int err = 0;
1091         u64 vf_num;
1092         u32 ring;
1093
1094         if (!flow_cfg->max_flows) {
1095                 netdev_err(pfvf->netdev,
1096                            "Ntuple rule count is 0, allocate and retry\n");
1097                 return -EINVAL;
1098         }
1099
1100         ring = ethtool_get_flow_spec_ring(fsp->ring_cookie);
1101         if (!(pfvf->flags & OTX2_FLAG_NTUPLE_SUPPORT))
1102                 return -ENOMEM;
1103
1104         /* Number of queues on a VF can be greater or less than
1105          * the PF's queue. Hence no need to check for the
1106          * queue count. Hence no need to check queue count if PF
1107          * is installing for its VF. Below is the expected vf_num value
1108          * based on the ethtool commands.
1109          *
1110          * e.g.
1111          * 1. ethtool -U <netdev> ... action -1  ==> vf_num:255
1112          * 2. ethtool -U <netdev> ... action <queue_num>  ==> vf_num:0
1113          * 3. ethtool -U <netdev> ... vf <vf_idx> queue <queue_num>  ==>
1114          *    vf_num:vf_idx+1
1115          */
1116         vf_num = ethtool_get_flow_spec_ring_vf(fsp->ring_cookie);
1117         if (!is_otx2_vf(pfvf->pcifunc) && !vf_num &&
1118             ring >= pfvf->hw.rx_queues && fsp->ring_cookie != RX_CLS_FLOW_DISC)
1119                 return -EINVAL;
1120
1121         if (fsp->location >= otx2_get_maxflows(flow_cfg))
1122                 return -EINVAL;
1123
1124         flow = otx2_find_flow(pfvf, fsp->location);
1125         if (!flow) {
1126                 flow = kzalloc(sizeof(*flow), GFP_KERNEL);
1127                 if (!flow)
1128                         return -ENOMEM;
1129                 flow->location = fsp->location;
1130                 flow->entry = flow_cfg->flow_ent[flow->location];
1131                 new = true;
1132         }
1133         /* struct copy */
1134         flow->flow_spec = *fsp;
1135
1136         if (fsp->flow_type & FLOW_RSS)
1137                 flow->rss_ctx_id = nfc->rss_context;
1138
1139         if (otx2_is_flow_rule_dmacfilter(pfvf, &flow->flow_spec)) {
1140                 eth_hdr = &flow->flow_spec.h_u.ether_spec;
1141
1142                 /* Sync dmac filter table with updated fields */
1143                 if (flow->rule_type & DMAC_FILTER_RULE)
1144                         return otx2_dmacflt_update(pfvf, eth_hdr->h_dest,
1145                                                    flow->entry);
1146
1147                 if (bitmap_full(flow_cfg->dmacflt_bmap,
1148                                 flow_cfg->dmacflt_max_flows)) {
1149                         netdev_warn(pfvf->netdev,
1150                                     "Can't insert the rule %d as max allowed dmac filters are %d\n",
1151                                     flow->location +
1152                                     flow_cfg->dmacflt_max_flows,
1153                                     flow_cfg->dmacflt_max_flows);
1154                         err = -EINVAL;
1155                         if (new)
1156                                 kfree(flow);
1157                         return err;
1158                 }
1159
1160                 /* Install PF mac address to DMAC filter list */
1161                 if (!test_bit(0, flow_cfg->dmacflt_bmap))
1162                         otx2_add_flow_with_pfmac(pfvf, flow);
1163
1164                 flow->rule_type |= DMAC_FILTER_RULE;
1165                 flow->entry = find_first_zero_bit(flow_cfg->dmacflt_bmap,
1166                                                   flow_cfg->dmacflt_max_flows);
1167                 fsp->location = flow_cfg->max_flows + flow->entry;
1168                 flow->flow_spec.location = fsp->location;
1169                 flow->location = fsp->location;
1170
1171                 set_bit(flow->entry, flow_cfg->dmacflt_bmap);
1172                 otx2_dmacflt_add(pfvf, eth_hdr->h_dest, flow->entry);
1173
1174         } else {
1175                 if (flow->location >= pfvf->flow_cfg->max_flows) {
1176                         netdev_warn(pfvf->netdev,
1177                                     "Can't insert non dmac ntuple rule at %d, allowed range %d-0\n",
1178                                     flow->location,
1179                                     flow_cfg->max_flows - 1);
1180                         err = -EINVAL;
1181                 } else {
1182                         err = otx2_add_flow_msg(pfvf, flow);
1183                 }
1184         }
1185
1186         if (err) {
1187                 if (err == MBOX_MSG_INVALID)
1188                         err = -EINVAL;
1189                 if (new)
1190                         kfree(flow);
1191                 return err;
1192         }
1193
1194         /* add the new flow installed to list */
1195         if (new) {
1196                 otx2_add_flow_to_list(pfvf, flow);
1197                 flow_cfg->nr_flows++;
1198         }
1199
1200         if (flow->is_vf)
1201                 netdev_info(pfvf->netdev,
1202                             "Make sure that VF's queue number is within its queue limit\n");
1203         return 0;
1204 }
1205
1206 static int otx2_remove_flow_msg(struct otx2_nic *pfvf, u16 entry, bool all)
1207 {
1208         struct npc_delete_flow_req *req;
1209         int err;
1210
1211         mutex_lock(&pfvf->mbox.lock);
1212         req = otx2_mbox_alloc_msg_npc_delete_flow(&pfvf->mbox);
1213         if (!req) {
1214                 mutex_unlock(&pfvf->mbox.lock);
1215                 return -ENOMEM;
1216         }
1217
1218         req->entry = entry;
1219         if (all)
1220                 req->all = 1;
1221
1222         /* Send message to AF */
1223         err = otx2_sync_mbox_msg(&pfvf->mbox);
1224         mutex_unlock(&pfvf->mbox.lock);
1225         return err;
1226 }
1227
1228 static void otx2_update_rem_pfmac(struct otx2_nic *pfvf, int req)
1229 {
1230         struct otx2_flow *iter;
1231         struct ethhdr *eth_hdr;
1232         bool found = false;
1233
1234         list_for_each_entry(iter, &pfvf->flow_cfg->flow_list, list) {
1235                 if ((iter->rule_type & DMAC_FILTER_RULE) && iter->entry == 0) {
1236                         eth_hdr = &iter->flow_spec.h_u.ether_spec;
1237                         if (req == DMAC_ADDR_DEL) {
1238                                 otx2_dmacflt_remove(pfvf, eth_hdr->h_dest,
1239                                                     0);
1240                                 clear_bit(0, pfvf->flow_cfg->dmacflt_bmap);
1241                                 found = true;
1242                         } else {
1243                                 ether_addr_copy(eth_hdr->h_dest,
1244                                                 pfvf->netdev->dev_addr);
1245
1246                                 otx2_dmacflt_update(pfvf, eth_hdr->h_dest, 0);
1247                         }
1248                         break;
1249                 }
1250         }
1251
1252         if (found) {
1253                 list_del(&iter->list);
1254                 kfree(iter);
1255                 pfvf->flow_cfg->nr_flows--;
1256         }
1257 }
1258
1259 int otx2_remove_flow(struct otx2_nic *pfvf, u32 location)
1260 {
1261         struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
1262         struct otx2_flow *flow;
1263         int err;
1264
1265         if (location >= otx2_get_maxflows(flow_cfg))
1266                 return -EINVAL;
1267
1268         flow = otx2_find_flow(pfvf, location);
1269         if (!flow)
1270                 return -ENOENT;
1271
1272         if (flow->rule_type & DMAC_FILTER_RULE) {
1273                 struct ethhdr *eth_hdr = &flow->flow_spec.h_u.ether_spec;
1274
1275                 /* user not allowed to remove dmac filter with interface mac */
1276                 if (ether_addr_equal(pfvf->netdev->dev_addr, eth_hdr->h_dest))
1277                         return -EPERM;
1278
1279                 err = otx2_dmacflt_remove(pfvf, eth_hdr->h_dest,
1280                                           flow->entry);
1281                 clear_bit(flow->entry, flow_cfg->dmacflt_bmap);
1282                 /* If all dmac filters are removed delete macfilter with
1283                  * interface mac address and configure CGX/RPM block in
1284                  * promiscuous mode
1285                  */
1286                 if (bitmap_weight(flow_cfg->dmacflt_bmap,
1287                                   flow_cfg->dmacflt_max_flows) == 1)
1288                         otx2_update_rem_pfmac(pfvf, DMAC_ADDR_DEL);
1289         } else {
1290 #ifdef CONFIG_DCB
1291                 if (flow->rule_type & PFC_FLOWCTRL_RULE)
1292                         otx2_update_bpid_in_rqctx(pfvf, 0,
1293                                                   flow->flow_spec.ring_cookie,
1294                                                   false);
1295 #endif
1296
1297                 err = otx2_remove_flow_msg(pfvf, flow->entry, false);
1298         }
1299
1300         if (err)
1301                 return err;
1302
1303         list_del(&flow->list);
1304         kfree(flow);
1305         flow_cfg->nr_flows--;
1306
1307         return 0;
1308 }
1309
1310 void otx2_rss_ctx_flow_del(struct otx2_nic *pfvf, int ctx_id)
1311 {
1312         struct otx2_flow *flow, *tmp;
1313         int err;
1314
1315         list_for_each_entry_safe(flow, tmp, &pfvf->flow_cfg->flow_list, list) {
1316                 if (flow->rss_ctx_id != ctx_id)
1317                         continue;
1318                 err = otx2_remove_flow(pfvf, flow->location);
1319                 if (err)
1320                         netdev_warn(pfvf->netdev,
1321                                     "Can't delete the rule %d associated with this rss group err:%d",
1322                                     flow->location, err);
1323         }
1324 }
1325
1326 int otx2_destroy_ntuple_flows(struct otx2_nic *pfvf)
1327 {
1328         struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
1329         struct npc_delete_flow_req *req;
1330         struct otx2_flow *iter, *tmp;
1331         int err;
1332
1333         if (!(pfvf->flags & OTX2_FLAG_NTUPLE_SUPPORT))
1334                 return 0;
1335
1336         if (!flow_cfg->max_flows)
1337                 return 0;
1338
1339         mutex_lock(&pfvf->mbox.lock);
1340         req = otx2_mbox_alloc_msg_npc_delete_flow(&pfvf->mbox);
1341         if (!req) {
1342                 mutex_unlock(&pfvf->mbox.lock);
1343                 return -ENOMEM;
1344         }
1345
1346         req->start = flow_cfg->flow_ent[0];
1347         req->end   = flow_cfg->flow_ent[flow_cfg->max_flows - 1];
1348         err = otx2_sync_mbox_msg(&pfvf->mbox);
1349         mutex_unlock(&pfvf->mbox.lock);
1350
1351         list_for_each_entry_safe(iter, tmp, &flow_cfg->flow_list, list) {
1352                 list_del(&iter->list);
1353                 kfree(iter);
1354                 flow_cfg->nr_flows--;
1355         }
1356         return err;
1357 }
1358
1359 int otx2_destroy_mcam_flows(struct otx2_nic *pfvf)
1360 {
1361         struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
1362         struct npc_mcam_free_entry_req *req;
1363         struct otx2_flow *iter, *tmp;
1364         int err;
1365
1366         if (!(pfvf->flags & OTX2_FLAG_MCAM_ENTRIES_ALLOC))
1367                 return 0;
1368
1369         /* remove all flows */
1370         err = otx2_remove_flow_msg(pfvf, 0, true);
1371         if (err)
1372                 return err;
1373
1374         list_for_each_entry_safe(iter, tmp, &flow_cfg->flow_list, list) {
1375                 list_del(&iter->list);
1376                 kfree(iter);
1377                 flow_cfg->nr_flows--;
1378         }
1379
1380         mutex_lock(&pfvf->mbox.lock);
1381         req = otx2_mbox_alloc_msg_npc_mcam_free_entry(&pfvf->mbox);
1382         if (!req) {
1383                 mutex_unlock(&pfvf->mbox.lock);
1384                 return -ENOMEM;
1385         }
1386
1387         req->all = 1;
1388         /* Send message to AF to free MCAM entries */
1389         err = otx2_sync_mbox_msg(&pfvf->mbox);
1390         if (err) {
1391                 mutex_unlock(&pfvf->mbox.lock);
1392                 return err;
1393         }
1394
1395         pfvf->flags &= ~OTX2_FLAG_MCAM_ENTRIES_ALLOC;
1396         mutex_unlock(&pfvf->mbox.lock);
1397
1398         return 0;
1399 }
1400
1401 int otx2_install_rxvlan_offload_flow(struct otx2_nic *pfvf)
1402 {
1403         struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
1404         struct npc_install_flow_req *req;
1405         int err;
1406
1407         mutex_lock(&pfvf->mbox.lock);
1408         req = otx2_mbox_alloc_msg_npc_install_flow(&pfvf->mbox);
1409         if (!req) {
1410                 mutex_unlock(&pfvf->mbox.lock);
1411                 return -ENOMEM;
1412         }
1413
1414         req->entry = flow_cfg->def_ent[flow_cfg->rx_vlan_offset];
1415         req->intf = NIX_INTF_RX;
1416         ether_addr_copy(req->packet.dmac, pfvf->netdev->dev_addr);
1417         eth_broadcast_addr((u8 *)&req->mask.dmac);
1418         req->channel = pfvf->hw.rx_chan_base;
1419         req->op = NIX_RX_ACTION_DEFAULT;
1420         req->features = BIT_ULL(NPC_OUTER_VID) | BIT_ULL(NPC_DMAC);
1421         req->vtag0_valid = true;
1422         req->vtag0_type = NIX_AF_LFX_RX_VTAG_TYPE0;
1423
1424         /* Send message to AF */
1425         err = otx2_sync_mbox_msg(&pfvf->mbox);
1426         mutex_unlock(&pfvf->mbox.lock);
1427         return err;
1428 }
1429
1430 static int otx2_delete_rxvlan_offload_flow(struct otx2_nic *pfvf)
1431 {
1432         struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
1433         struct npc_delete_flow_req *req;
1434         int err;
1435
1436         mutex_lock(&pfvf->mbox.lock);
1437         req = otx2_mbox_alloc_msg_npc_delete_flow(&pfvf->mbox);
1438         if (!req) {
1439                 mutex_unlock(&pfvf->mbox.lock);
1440                 return -ENOMEM;
1441         }
1442
1443         req->entry = flow_cfg->def_ent[flow_cfg->rx_vlan_offset];
1444         /* Send message to AF */
1445         err = otx2_sync_mbox_msg(&pfvf->mbox);
1446         mutex_unlock(&pfvf->mbox.lock);
1447         return err;
1448 }
1449
1450 int otx2_enable_rxvlan(struct otx2_nic *pf, bool enable)
1451 {
1452         struct nix_vtag_config *req;
1453         struct mbox_msghdr *rsp_hdr;
1454         int err;
1455
1456         /* Dont have enough mcam entries */
1457         if (!(pf->flags & OTX2_FLAG_RX_VLAN_SUPPORT))
1458                 return -ENOMEM;
1459
1460         if (enable) {
1461                 err = otx2_install_rxvlan_offload_flow(pf);
1462                 if (err)
1463                         return err;
1464         } else {
1465                 err = otx2_delete_rxvlan_offload_flow(pf);
1466                 if (err)
1467                         return err;
1468         }
1469
1470         mutex_lock(&pf->mbox.lock);
1471         req = otx2_mbox_alloc_msg_nix_vtag_cfg(&pf->mbox);
1472         if (!req) {
1473                 mutex_unlock(&pf->mbox.lock);
1474                 return -ENOMEM;
1475         }
1476
1477         /* config strip, capture and size */
1478         req->vtag_size = VTAGSIZE_T4;
1479         req->cfg_type = 1; /* rx vlan cfg */
1480         req->rx.vtag_type = NIX_AF_LFX_RX_VTAG_TYPE0;
1481         req->rx.strip_vtag = enable;
1482         req->rx.capture_vtag = enable;
1483
1484         err = otx2_sync_mbox_msg(&pf->mbox);
1485         if (err) {
1486                 mutex_unlock(&pf->mbox.lock);
1487                 return err;
1488         }
1489
1490         rsp_hdr = otx2_mbox_get_rsp(&pf->mbox.mbox, 0, &req->hdr);
1491         if (IS_ERR(rsp_hdr)) {
1492                 mutex_unlock(&pf->mbox.lock);
1493                 return PTR_ERR(rsp_hdr);
1494         }
1495
1496         mutex_unlock(&pf->mbox.lock);
1497         return rsp_hdr->rc;
1498 }
1499
1500 void otx2_dmacflt_reinstall_flows(struct otx2_nic *pf)
1501 {
1502         struct otx2_flow *iter;
1503         struct ethhdr *eth_hdr;
1504
1505         list_for_each_entry(iter, &pf->flow_cfg->flow_list, list) {
1506                 if (iter->rule_type & DMAC_FILTER_RULE) {
1507                         eth_hdr = &iter->flow_spec.h_u.ether_spec;
1508                         otx2_dmacflt_add(pf, eth_hdr->h_dest,
1509                                          iter->entry);
1510                 }
1511         }
1512 }
1513
1514 void otx2_dmacflt_update_pfmac_flow(struct otx2_nic *pfvf)
1515 {
1516         otx2_update_rem_pfmac(pfvf, DMAC_ADDR_UPDATE);
1517 }