drivers/net/ethernet/intel/ice/ice_tc_lib.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (C) 2019-2021, Intel Corporation. */
   3
   4 #include "ice.h"
   5 #include "ice_tc_lib.h"
   6 #include "ice_fltr.h"
   7 #include "ice_lib.h"
   8 #include "ice_protocol_type.h"
   9
  10 /**
  11  * ice_tc_count_lkups - determine lookup count for switch filter
  12  * @flags: TC-flower flags
  13  * @headers: Pointer to TC flower filter header structure
  14  * @fltr: Pointer to outer TC filter structure
  15  *
  16  * Determine lookup count based on TC flower input for switch filter.
  17  */
  18 static int
  19 ice_tc_count_lkups(u32 flags, struct ice_tc_flower_lyr_2_4_hdrs *headers,
  20                    struct ice_tc_flower_fltr *fltr)
  21 {
  22         int lkups_cnt = 0;
  23
  24         if (flags & ICE_TC_FLWR_FIELD_TENANT_ID)
  25                 lkups_cnt++;
  26
  27         if (flags & ICE_TC_FLWR_FIELD_ENC_DST_MAC)
  28                 lkups_cnt++;
  29
  30         if (flags & ICE_TC_FLWR_FIELD_ENC_OPTS)
  31                 lkups_cnt++;
  32
  33         if (flags & (ICE_TC_FLWR_FIELD_ENC_SRC_IPV4 |
  34                      ICE_TC_FLWR_FIELD_ENC_DEST_IPV4 |
  35                      ICE_TC_FLWR_FIELD_ENC_SRC_IPV6 |
  36                      ICE_TC_FLWR_FIELD_ENC_DEST_IPV6))
  37                 lkups_cnt++;
  38
  39         if (flags & (ICE_TC_FLWR_FIELD_ENC_IP_TOS |
  40                      ICE_TC_FLWR_FIELD_ENC_IP_TTL))
  41                 lkups_cnt++;
  42
  43         if (flags & ICE_TC_FLWR_FIELD_ENC_DEST_L4_PORT)
  44                 lkups_cnt++;
  45
  46         if (flags & ICE_TC_FLWR_FIELD_ETH_TYPE_ID)
  47                 lkups_cnt++;
  48
  49         /* are MAC fields specified? */
  50         if (flags & (ICE_TC_FLWR_FIELD_DST_MAC | ICE_TC_FLWR_FIELD_SRC_MAC))
  51                 lkups_cnt++;
  52
  53         /* is VLAN specified? */
  54         if (flags & (ICE_TC_FLWR_FIELD_VLAN | ICE_TC_FLWR_FIELD_VLAN_PRIO))
  55                 lkups_cnt++;
  56
  57         /* is VLAN TPID specified */
  58         if (flags & ICE_TC_FLWR_FIELD_VLAN_TPID)
  59                 lkups_cnt++;
  60
  61         /* is CVLAN specified? */
  62         if (flags & (ICE_TC_FLWR_FIELD_CVLAN | ICE_TC_FLWR_FIELD_CVLAN_PRIO))
  63                 lkups_cnt++;
  64
  65         /* are PPPoE options specified? */
  66         if (flags & (ICE_TC_FLWR_FIELD_PPPOE_SESSID |
  67                      ICE_TC_FLWR_FIELD_PPP_PROTO))
  68                 lkups_cnt++;
  69
  70         /* are IPv[4|6] fields specified? */
  71         if (flags & (ICE_TC_FLWR_FIELD_DEST_IPV4 | ICE_TC_FLWR_FIELD_SRC_IPV4 |
  72                      ICE_TC_FLWR_FIELD_DEST_IPV6 | ICE_TC_FLWR_FIELD_SRC_IPV6))
  73                 lkups_cnt++;
  74
  75         if (flags & (ICE_TC_FLWR_FIELD_IP_TOS | ICE_TC_FLWR_FIELD_IP_TTL))
  76                 lkups_cnt++;
  77
  78         /* are L2TPv3 options specified? */
  79         if (flags & ICE_TC_FLWR_FIELD_L2TPV3_SESSID)
  80                 lkups_cnt++;
  81
  82         /* is L4 (TCP/UDP/any other L4 protocol fields) specified? */
  83         if (flags & (ICE_TC_FLWR_FIELD_DEST_L4_PORT |
  84                      ICE_TC_FLWR_FIELD_SRC_L4_PORT))
  85                 lkups_cnt++;
  86
  87         /* matching for tunneled packets in metadata */
  88         if (fltr->tunnel_type != TNL_LAST)
  89                 lkups_cnt++;
  90
  91         return lkups_cnt;
  92 }
  93
  94 static enum ice_protocol_type ice_proto_type_from_mac(bool inner)
  95 {
  96         return inner ? ICE_MAC_IL : ICE_MAC_OFOS;
  97 }
  98
  99 static enum ice_protocol_type ice_proto_type_from_etype(bool inner)
 100 {
 101         return inner ? ICE_ETYPE_IL : ICE_ETYPE_OL;
 102 }
 103
 104 static enum ice_protocol_type ice_proto_type_from_ipv4(bool inner)
 105 {
 106         return inner ? ICE_IPV4_IL : ICE_IPV4_OFOS;
 107 }
 108
 109 static enum ice_protocol_type ice_proto_type_from_ipv6(bool inner)
 110 {
 111         return inner ? ICE_IPV6_IL : ICE_IPV6_OFOS;
 112 }
 113
 114 static enum ice_protocol_type ice_proto_type_from_l4_port(u16 ip_proto)
 115 {
 116         switch (ip_proto) {
 117         case IPPROTO_TCP:
 118                 return ICE_TCP_IL;
 119         case IPPROTO_UDP:
 120                 return ICE_UDP_ILOS;
 121         }
 122
 123         return 0;
 124 }
 125
 126 static enum ice_protocol_type
 127 ice_proto_type_from_tunnel(enum ice_tunnel_type type)
 128 {
 129         switch (type) {
 130         case TNL_VXLAN:
 131                 return ICE_VXLAN;
 132         case TNL_GENEVE:
 133                 return ICE_GENEVE;
 134         case TNL_GRETAP:
 135                 return ICE_NVGRE;
 136         case TNL_GTPU:
 137                 /* NO_PAY profiles will not work with GTP-U */
 138                 return ICE_GTP;
 139         case TNL_GTPC:
 140                 return ICE_GTP_NO_PAY;
 141         default:
 142                 return 0;
 143         }
 144 }
 145
 146 static enum ice_sw_tunnel_type
 147 ice_sw_type_from_tunnel(enum ice_tunnel_type type)
 148 {
 149         switch (type) {
 150         case TNL_VXLAN:
 151                 return ICE_SW_TUN_VXLAN;
 152         case TNL_GENEVE:
 153                 return ICE_SW_TUN_GENEVE;
 154         case TNL_GRETAP:
 155                 return ICE_SW_TUN_NVGRE;
 156         case TNL_GTPU:
 157                 return ICE_SW_TUN_GTPU;
 158         case TNL_GTPC:
 159                 return ICE_SW_TUN_GTPC;
 160         default:
 161                 return ICE_NON_TUN;
 162         }
 163 }
 164
 165 static u16 ice_check_supported_vlan_tpid(u16 vlan_tpid)
 166 {
 167         switch (vlan_tpid) {
 168         case ETH_P_8021Q:
 169         case ETH_P_8021AD:
 170         case ETH_P_QINQ1:
 171                 return vlan_tpid;
 172         default:
 173                 return 0;
 174         }
 175 }
 176
 177 static int
 178 ice_tc_fill_tunnel_outer(u32 flags, struct ice_tc_flower_fltr *fltr,
 179                          struct ice_adv_lkup_elem *list)
 180 {
 181         struct ice_tc_flower_lyr_2_4_hdrs *hdr = &fltr->outer_headers;
 182         int i = 0;
 183
 184         if (flags & ICE_TC_FLWR_FIELD_TENANT_ID) {
 185                 u32 tenant_id;
 186
 187                 list[i].type = ice_proto_type_from_tunnel(fltr->tunnel_type);
 188                 switch (fltr->tunnel_type) {
 189                 case TNL_VXLAN:
 190                 case TNL_GENEVE:
 191                         tenant_id = be32_to_cpu(fltr->tenant_id) << 8;
 192                         list[i].h_u.tnl_hdr.vni = cpu_to_be32(tenant_id);
 193                         memcpy(&list[i].m_u.tnl_hdr.vni, "\xff\xff\xff\x00", 4);
 194                         i++;
 195                         break;
 196                 case TNL_GRETAP:
 197                         list[i].h_u.nvgre_hdr.tni_flow = fltr->tenant_id;
 198                         memcpy(&list[i].m_u.nvgre_hdr.tni_flow,
 199                                "\xff\xff\xff\xff", 4);
 200                         i++;
 201                         break;
 202                 case TNL_GTPC:
 203                 case TNL_GTPU:
 204                         list[i].h_u.gtp_hdr.teid = fltr->tenant_id;
 205                         memcpy(&list[i].m_u.gtp_hdr.teid,
 206                                "\xff\xff\xff\xff", 4);
 207                         i++;
 208                         break;
 209                 default:
 210                         break;
 211                 }
 212         }
 213
 214         if (flags & ICE_TC_FLWR_FIELD_ENC_DST_MAC) {
 215                 list[i].type = ice_proto_type_from_mac(false);
 216                 ether_addr_copy(list[i].h_u.eth_hdr.dst_addr,
 217                                 hdr->l2_key.dst_mac);
 218                 ether_addr_copy(list[i].m_u.eth_hdr.dst_addr,
 219                                 hdr->l2_mask.dst_mac);
 220                 i++;
 221         }
 222
 223         if (flags & ICE_TC_FLWR_FIELD_ENC_OPTS &&
 224             (fltr->tunnel_type == TNL_GTPU || fltr->tunnel_type == TNL_GTPC)) {
 225                 list[i].type = ice_proto_type_from_tunnel(fltr->tunnel_type);
 226
 227                 if (fltr->gtp_pdu_info_masks.pdu_type) {
 228                         list[i].h_u.gtp_hdr.pdu_type =
 229                                 fltr->gtp_pdu_info_keys.pdu_type << 4;
 230                         memcpy(&list[i].m_u.gtp_hdr.pdu_type, "\xf0", 1);
 231                 }
 232
 233                 if (fltr->gtp_pdu_info_masks.qfi) {
 234                         list[i].h_u.gtp_hdr.qfi = fltr->gtp_pdu_info_keys.qfi;
 235                         memcpy(&list[i].m_u.gtp_hdr.qfi, "\x3f", 1);
 236                 }
 237
 238                 i++;
 239         }
 240
 241         if (flags & (ICE_TC_FLWR_FIELD_ENC_SRC_IPV4 |
 242                      ICE_TC_FLWR_FIELD_ENC_DEST_IPV4)) {
 243                 list[i].type = ice_proto_type_from_ipv4(false);
 244
 245                 if (flags & ICE_TC_FLWR_FIELD_ENC_SRC_IPV4) {
 246                         list[i].h_u.ipv4_hdr.src_addr = hdr->l3_key.src_ipv4;
 247                         list[i].m_u.ipv4_hdr.src_addr = hdr->l3_mask.src_ipv4;
 248                 }
 249                 if (flags & ICE_TC_FLWR_FIELD_ENC_DEST_IPV4) {
 250                         list[i].h_u.ipv4_hdr.dst_addr = hdr->l3_key.dst_ipv4;
 251                         list[i].m_u.ipv4_hdr.dst_addr = hdr->l3_mask.dst_ipv4;
 252                 }
 253                 i++;
 254         }
 255
 256         if (flags & (ICE_TC_FLWR_FIELD_ENC_SRC_IPV6 |
 257                      ICE_TC_FLWR_FIELD_ENC_DEST_IPV6)) {
 258                 list[i].type = ice_proto_type_from_ipv6(false);
 259
 260                 if (flags & ICE_TC_FLWR_FIELD_ENC_SRC_IPV6) {
 261                         memcpy(&list[i].h_u.ipv6_hdr.src_addr,
 262                                &hdr->l3_key.src_ipv6_addr,
 263                                sizeof(hdr->l3_key.src_ipv6_addr));
 264                         memcpy(&list[i].m_u.ipv6_hdr.src_addr,
 265                                &hdr->l3_mask.src_ipv6_addr,
 266                                sizeof(hdr->l3_mask.src_ipv6_addr));
 267                 }
 268                 if (flags & ICE_TC_FLWR_FIELD_ENC_DEST_IPV6) {
 269                         memcpy(&list[i].h_u.ipv6_hdr.dst_addr,
 270                                &hdr->l3_key.dst_ipv6_addr,
 271                                sizeof(hdr->l3_key.dst_ipv6_addr));
 272                         memcpy(&list[i].m_u.ipv6_hdr.dst_addr,
 273                                &hdr->l3_mask.dst_ipv6_addr,
 274                                sizeof(hdr->l3_mask.dst_ipv6_addr));
 275                 }
 276                 i++;
 277         }
 278
 279         if (fltr->inner_headers.l2_key.n_proto == htons(ETH_P_IP) &&
 280             (flags & (ICE_TC_FLWR_FIELD_ENC_IP_TOS |
 281                       ICE_TC_FLWR_FIELD_ENC_IP_TTL))) {
 282                 list[i].type = ice_proto_type_from_ipv4(false);
 283
 284                 if (flags & ICE_TC_FLWR_FIELD_ENC_IP_TOS) {
 285                         list[i].h_u.ipv4_hdr.tos = hdr->l3_key.tos;
 286                         list[i].m_u.ipv4_hdr.tos = hdr->l3_mask.tos;
 287                 }
 288
 289                 if (flags & ICE_TC_FLWR_FIELD_ENC_IP_TTL) {
 290                         list[i].h_u.ipv4_hdr.time_to_live = hdr->l3_key.ttl;
 291                         list[i].m_u.ipv4_hdr.time_to_live = hdr->l3_mask.ttl;
 292                 }
 293
 294                 i++;
 295         }
 296
 297         if (fltr->inner_headers.l2_key.n_proto == htons(ETH_P_IPV6) &&
 298             (flags & (ICE_TC_FLWR_FIELD_ENC_IP_TOS |
 299                       ICE_TC_FLWR_FIELD_ENC_IP_TTL))) {
 300                 struct ice_ipv6_hdr *hdr_h, *hdr_m;
 301
 302                 hdr_h = &list[i].h_u.ipv6_hdr;
 303                 hdr_m = &list[i].m_u.ipv6_hdr;
 304                 list[i].type = ice_proto_type_from_ipv6(false);
 305
 306                 if (flags & ICE_TC_FLWR_FIELD_ENC_IP_TOS) {
 307                         be32p_replace_bits(&hdr_h->be_ver_tc_flow,
 308                                            hdr->l3_key.tos,
 309                                            ICE_IPV6_HDR_TC_MASK);
 310                         be32p_replace_bits(&hdr_m->be_ver_tc_flow,
 311                                            hdr->l3_mask.tos,
 312                                            ICE_IPV6_HDR_TC_MASK);
 313                 }
 314
 315                 if (flags & ICE_TC_FLWR_FIELD_ENC_IP_TTL) {
 316                         hdr_h->hop_limit = hdr->l3_key.ttl;
 317                         hdr_m->hop_limit = hdr->l3_mask.ttl;
 318                 }
 319
 320                 i++;
 321         }
 322
 323         if ((flags & ICE_TC_FLWR_FIELD_ENC_DEST_L4_PORT) &&
 324             hdr->l3_key.ip_proto == IPPROTO_UDP) {
 325                 list[i].type = ICE_UDP_OF;
 326                 list[i].h_u.l4_hdr.dst_port = hdr->l4_key.dst_port;
 327                 list[i].m_u.l4_hdr.dst_port = hdr->l4_mask.dst_port;
 328                 i++;
 329         }
 330
 331         /* always fill matching on tunneled packets in metadata */
 332         ice_rule_add_tunnel_metadata(&list[i]);
 333         i++;
 334
 335         return i;
 336 }
 337
 338 /**
 339  * ice_tc_fill_rules - fill filter rules based on TC fltr
 340  * @hw: pointer to HW structure
 341  * @flags: tc flower field flags
 342  * @tc_fltr: pointer to TC flower filter
 343  * @list: list of advance rule elements
 344  * @rule_info: pointer to information about rule
 345  * @l4_proto: pointer to information such as L4 proto type
 346  *
 347  * Fill ice_adv_lkup_elem list based on TC flower flags and
 348  * TC flower headers. This list should be used to add
 349  * advance filter in hardware.
 350  */
 351 static int
 352 ice_tc_fill_rules(struct ice_hw *hw, u32 flags,
 353                   struct ice_tc_flower_fltr *tc_fltr,
 354                   struct ice_adv_lkup_elem *list,
 355                   struct ice_adv_rule_info *rule_info,
 356                   u16 *l4_proto)
 357 {
 358         struct ice_tc_flower_lyr_2_4_hdrs *headers = &tc_fltr->outer_headers;
 359         bool inner = false;
 360         u16 vlan_tpid = 0;
 361         int i = 0;
 362
 363         rule_info->vlan_type = vlan_tpid;
 364
 365         rule_info->tun_type = ice_sw_type_from_tunnel(tc_fltr->tunnel_type);
 366         if (tc_fltr->tunnel_type != TNL_LAST) {
 367                 i = ice_tc_fill_tunnel_outer(flags, tc_fltr, list);
 368
 369                 headers = &tc_fltr->inner_headers;
 370                 inner = true;
 371         }
 372
 373         if (flags & ICE_TC_FLWR_FIELD_ETH_TYPE_ID) {
 374                 list[i].type = ice_proto_type_from_etype(inner);
 375                 list[i].h_u.ethertype.ethtype_id = headers->l2_key.n_proto;
 376                 list[i].m_u.ethertype.ethtype_id = headers->l2_mask.n_proto;
 377                 i++;
 378         }
 379
 380         if (flags & (ICE_TC_FLWR_FIELD_DST_MAC |
 381                      ICE_TC_FLWR_FIELD_SRC_MAC)) {
 382                 struct ice_tc_l2_hdr *l2_key, *l2_mask;
 383
 384                 l2_key = &headers->l2_key;
 385                 l2_mask = &headers->l2_mask;
 386
 387                 list[i].type = ice_proto_type_from_mac(inner);
 388                 if (flags & ICE_TC_FLWR_FIELD_DST_MAC) {
 389                         ether_addr_copy(list[i].h_u.eth_hdr.dst_addr,
 390                                         l2_key->dst_mac);
 391                         ether_addr_copy(list[i].m_u.eth_hdr.dst_addr,
 392                                         l2_mask->dst_mac);
 393                 }
 394                 if (flags & ICE_TC_FLWR_FIELD_SRC_MAC) {
 395                         ether_addr_copy(list[i].h_u.eth_hdr.src_addr,
 396                                         l2_key->src_mac);
 397                         ether_addr_copy(list[i].m_u.eth_hdr.src_addr,
 398                                         l2_mask->src_mac);
 399                 }
 400                 i++;
 401         }
 402
 403         /* copy VLAN info */
 404         if (flags & (ICE_TC_FLWR_FIELD_VLAN | ICE_TC_FLWR_FIELD_VLAN_PRIO)) {
 405                 if (flags & ICE_TC_FLWR_FIELD_CVLAN)
 406                         list[i].type = ICE_VLAN_EX;
 407                 else
 408                         list[i].type = ICE_VLAN_OFOS;
 409
 410                 if (flags & ICE_TC_FLWR_FIELD_VLAN) {
 411                         list[i].h_u.vlan_hdr.vlan = headers->vlan_hdr.vlan_id;
 412                         list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0x0FFF);
 413                 }
 414
 415                 if (flags & ICE_TC_FLWR_FIELD_VLAN_PRIO) {
 416                         if (flags & ICE_TC_FLWR_FIELD_VLAN) {
 417                                 list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0xEFFF);
 418                         } else {
 419                                 list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0xE000);
 420                                 list[i].h_u.vlan_hdr.vlan = 0;
 421                         }
 422                         list[i].h_u.vlan_hdr.vlan |=
 423                                 headers->vlan_hdr.vlan_prio;
 424                 }
 425
 426                 i++;
 427         }
 428
 429         if (flags & ICE_TC_FLWR_FIELD_VLAN_TPID) {
 430                 vlan_tpid = be16_to_cpu(headers->vlan_hdr.vlan_tpid);
 431                 rule_info->vlan_type =
 432                                 ice_check_supported_vlan_tpid(vlan_tpid);
 433
 434                 ice_rule_add_vlan_metadata(&list[i]);
 435                 i++;
 436         }
 437
 438         if (flags & (ICE_TC_FLWR_FIELD_CVLAN | ICE_TC_FLWR_FIELD_CVLAN_PRIO)) {
 439                 list[i].type = ICE_VLAN_IN;
 440
 441                 if (flags & ICE_TC_FLWR_FIELD_CVLAN) {
 442                         list[i].h_u.vlan_hdr.vlan = headers->cvlan_hdr.vlan_id;
 443                         list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0x0FFF);
 444                 }
 445
 446                 if (flags & ICE_TC_FLWR_FIELD_CVLAN_PRIO) {
 447                         if (flags & ICE_TC_FLWR_FIELD_CVLAN) {
 448                                 list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0xEFFF);
 449                         } else {
 450                                 list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0xE000);
 451                                 list[i].h_u.vlan_hdr.vlan = 0;
 452                         }
 453                         list[i].h_u.vlan_hdr.vlan |=
 454                                 headers->cvlan_hdr.vlan_prio;
 455                 }
 456
 457                 i++;
 458         }
 459
 460         if (flags & (ICE_TC_FLWR_FIELD_PPPOE_SESSID |
 461                      ICE_TC_FLWR_FIELD_PPP_PROTO)) {
 462                 struct ice_pppoe_hdr *vals, *masks;
 463
 464                 vals = &list[i].h_u.pppoe_hdr;
 465                 masks = &list[i].m_u.pppoe_hdr;
 466
 467                 list[i].type = ICE_PPPOE;
 468
 469                 if (flags & ICE_TC_FLWR_FIELD_PPPOE_SESSID) {
 470                         vals->session_id = headers->pppoe_hdr.session_id;
 471                         masks->session_id = cpu_to_be16(0xFFFF);
 472                 }
 473
 474                 if (flags & ICE_TC_FLWR_FIELD_PPP_PROTO) {
 475                         vals->ppp_prot_id = headers->pppoe_hdr.ppp_proto;
 476                         masks->ppp_prot_id = cpu_to_be16(0xFFFF);
 477                 }
 478
 479                 i++;
 480         }
 481
 482         /* copy L3 (IPv[4|6]: src, dest) address */
 483         if (flags & (ICE_TC_FLWR_FIELD_DEST_IPV4 |
 484                      ICE_TC_FLWR_FIELD_SRC_IPV4)) {
 485                 struct ice_tc_l3_hdr *l3_key, *l3_mask;
 486
 487                 list[i].type = ice_proto_type_from_ipv4(inner);
 488                 l3_key = &headers->l3_key;
 489                 l3_mask = &headers->l3_mask;
 490                 if (flags & ICE_TC_FLWR_FIELD_DEST_IPV4) {
 491                         list[i].h_u.ipv4_hdr.dst_addr = l3_key->dst_ipv4;
 492                         list[i].m_u.ipv4_hdr.dst_addr = l3_mask->dst_ipv4;
 493                 }
 494                 if (flags & ICE_TC_FLWR_FIELD_SRC_IPV4) {
 495                         list[i].h_u.ipv4_hdr.src_addr = l3_key->src_ipv4;
 496                         list[i].m_u.ipv4_hdr.src_addr = l3_mask->src_ipv4;
 497                 }
 498                 i++;
 499         } else if (flags & (ICE_TC_FLWR_FIELD_DEST_IPV6 |
 500                             ICE_TC_FLWR_FIELD_SRC_IPV6)) {
 501                 struct ice_ipv6_hdr *ipv6_hdr, *ipv6_mask;
 502                 struct ice_tc_l3_hdr *l3_key, *l3_mask;
 503
 504                 list[i].type = ice_proto_type_from_ipv6(inner);
 505                 ipv6_hdr = &list[i].h_u.ipv6_hdr;
 506                 ipv6_mask = &list[i].m_u.ipv6_hdr;
 507                 l3_key = &headers->l3_key;
 508                 l3_mask = &headers->l3_mask;
 509
 510                 if (flags & ICE_TC_FLWR_FIELD_DEST_IPV6) {
 511                         memcpy(&ipv6_hdr->dst_addr, &l3_key->dst_ipv6_addr,
 512                                sizeof(l3_key->dst_ipv6_addr));
 513                         memcpy(&ipv6_mask->dst_addr, &l3_mask->dst_ipv6_addr,
 514                                sizeof(l3_mask->dst_ipv6_addr));
 515                 }
 516                 if (flags & ICE_TC_FLWR_FIELD_SRC_IPV6) {
 517                         memcpy(&ipv6_hdr->src_addr, &l3_key->src_ipv6_addr,
 518                                sizeof(l3_key->src_ipv6_addr));
 519                         memcpy(&ipv6_mask->src_addr, &l3_mask->src_ipv6_addr,
 520                                sizeof(l3_mask->src_ipv6_addr));
 521                 }
 522                 i++;
 523         }
 524
 525         if (headers->l2_key.n_proto == htons(ETH_P_IP) &&
 526             (flags & (ICE_TC_FLWR_FIELD_IP_TOS | ICE_TC_FLWR_FIELD_IP_TTL))) {
 527                 list[i].type = ice_proto_type_from_ipv4(inner);
 528
 529                 if (flags & ICE_TC_FLWR_FIELD_IP_TOS) {
 530                         list[i].h_u.ipv4_hdr.tos = headers->l3_key.tos;
 531                         list[i].m_u.ipv4_hdr.tos = headers->l3_mask.tos;
 532                 }
 533
 534                 if (flags & ICE_TC_FLWR_FIELD_IP_TTL) {
 535                         list[i].h_u.ipv4_hdr.time_to_live =
 536                                 headers->l3_key.ttl;
 537                         list[i].m_u.ipv4_hdr.time_to_live =
 538                                 headers->l3_mask.ttl;
 539                 }
 540
 541                 i++;
 542         }
 543
 544         if (headers->l2_key.n_proto == htons(ETH_P_IPV6) &&
 545             (flags & (ICE_TC_FLWR_FIELD_IP_TOS | ICE_TC_FLWR_FIELD_IP_TTL))) {
 546                 struct ice_ipv6_hdr *hdr_h, *hdr_m;
 547
 548                 hdr_h = &list[i].h_u.ipv6_hdr;
 549                 hdr_m = &list[i].m_u.ipv6_hdr;
 550                 list[i].type = ice_proto_type_from_ipv6(inner);
 551
 552                 if (flags & ICE_TC_FLWR_FIELD_IP_TOS) {
 553                         be32p_replace_bits(&hdr_h->be_ver_tc_flow,
 554                                            headers->l3_key.tos,
 555                                            ICE_IPV6_HDR_TC_MASK);
 556                         be32p_replace_bits(&hdr_m->be_ver_tc_flow,
 557                                            headers->l3_mask.tos,
 558                                            ICE_IPV6_HDR_TC_MASK);
 559                 }
 560
 561                 if (flags & ICE_TC_FLWR_FIELD_IP_TTL) {
 562                         hdr_h->hop_limit = headers->l3_key.ttl;
 563                         hdr_m->hop_limit = headers->l3_mask.ttl;
 564                 }
 565
 566                 i++;
 567         }
 568
 569         if (flags & ICE_TC_FLWR_FIELD_L2TPV3_SESSID) {
 570                 list[i].type = ICE_L2TPV3;
 571
 572                 list[i].h_u.l2tpv3_sess_hdr.session_id =
 573                         headers->l2tpv3_hdr.session_id;
 574                 list[i].m_u.l2tpv3_sess_hdr.session_id =
 575                         cpu_to_be32(0xFFFFFFFF);
 576
 577                 i++;
 578         }
 579
 580         /* copy L4 (src, dest) port */
 581         if (flags & (ICE_TC_FLWR_FIELD_DEST_L4_PORT |
 582                      ICE_TC_FLWR_FIELD_SRC_L4_PORT)) {
 583                 struct ice_tc_l4_hdr *l4_key, *l4_mask;
 584
 585                 list[i].type = ice_proto_type_from_l4_port(headers->l3_key.ip_proto);
 586                 l4_key = &headers->l4_key;
 587                 l4_mask = &headers->l4_mask;
 588
 589                 if (flags & ICE_TC_FLWR_FIELD_DEST_L4_PORT) {
 590                         list[i].h_u.l4_hdr.dst_port = l4_key->dst_port;
 591                         list[i].m_u.l4_hdr.dst_port = l4_mask->dst_port;
 592                 }
 593                 if (flags & ICE_TC_FLWR_FIELD_SRC_L4_PORT) {
 594                         list[i].h_u.l4_hdr.src_port = l4_key->src_port;
 595                         list[i].m_u.l4_hdr.src_port = l4_mask->src_port;
 596                 }
 597                 i++;
 598         }
 599
 600         return i;
 601 }
 602
 603 /**
 604  * ice_tc_tun_get_type - get the tunnel type
 605  * @tunnel_dev: ptr to tunnel device
 606  *
 607  * This function detects appropriate tunnel_type if specified device is
 608  * tunnel device such as VXLAN/Geneve
 609  */
 610 static int ice_tc_tun_get_type(struct net_device *tunnel_dev)
 611 {
 612         if (netif_is_vxlan(tunnel_dev))
 613                 return TNL_VXLAN;
 614         if (netif_is_geneve(tunnel_dev))
 615                 return TNL_GENEVE;
 616         if (netif_is_gretap(tunnel_dev) ||
 617             netif_is_ip6gretap(tunnel_dev))
 618                 return TNL_GRETAP;
 619
 620         /* Assume GTP-U by default in case of GTP netdev.
 621          * GTP-C may be selected later, based on enc_dst_port.
 622          */
 623         if (netif_is_gtp(tunnel_dev))
 624                 return TNL_GTPU;
 625         return TNL_LAST;
 626 }
 627
 628 bool ice_is_tunnel_supported(struct net_device *dev)
 629 {
 630         return ice_tc_tun_get_type(dev) != TNL_LAST;
 631 }
 632
 633 static int
 634 ice_eswitch_tc_parse_action(struct ice_tc_flower_fltr *fltr,
 635                             struct flow_action_entry *act)
 636 {
 637         struct ice_repr *repr;
 638
 639         switch (act->id) {
 640         case FLOW_ACTION_DROP:
 641                 fltr->action.fltr_act = ICE_DROP_PACKET;
 642                 break;
 643
 644         case FLOW_ACTION_REDIRECT:
 645                 fltr->action.fltr_act = ICE_FWD_TO_VSI;
 646
 647                 if (ice_is_port_repr_netdev(act->dev)) {
 648                         repr = ice_netdev_to_repr(act->dev);
 649
 650                         fltr->dest_vsi = repr->src_vsi;
 651                         fltr->direction = ICE_ESWITCH_FLTR_INGRESS;
 652                 } else if (netif_is_ice(act->dev) ||
 653                            ice_is_tunnel_supported(act->dev)) {
 654                         fltr->direction = ICE_ESWITCH_FLTR_EGRESS;
 655                 } else {
 656                         NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported netdevice in switchdev mode");
 657                         return -EINVAL;
 658                 }
 659
 660                 break;
 661
 662         default:
 663                 NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported action in switchdev mode");
 664                 return -EINVAL;
 665         }
 666
 667         return 0;
 668 }
 669
 670 static int
 671 ice_eswitch_add_tc_fltr(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr)
 672 {
 673         struct ice_tc_flower_lyr_2_4_hdrs *headers = &fltr->outer_headers;
 674         struct ice_adv_rule_info rule_info = { 0 };
 675         struct ice_rule_query_data rule_added;
 676         struct ice_hw *hw = &vsi->back->hw;
 677         struct ice_adv_lkup_elem *list;
 678         u32 flags = fltr->flags;
 679         int lkups_cnt;
 680         int ret;
 681         int i;
 682
 683         if (!flags || (flags & ICE_TC_FLWR_FIELD_ENC_SRC_L4_PORT)) {
 684                 NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported encap field(s)");
 685                 return -EOPNOTSUPP;
 686         }
 687
 688         lkups_cnt = ice_tc_count_lkups(flags, headers, fltr);
 689         list = kcalloc(lkups_cnt, sizeof(*list), GFP_ATOMIC);
 690         if (!list)
 691                 return -ENOMEM;
 692
 693         i = ice_tc_fill_rules(hw, flags, fltr, list, &rule_info, NULL);
 694         if (i != lkups_cnt) {
 695                 ret = -EINVAL;
 696                 goto exit;
 697         }
 698
 699         /* egress traffic is always redirect to uplink */
 700         if (fltr->direction == ICE_ESWITCH_FLTR_EGRESS)
 701                 fltr->dest_vsi = vsi->back->switchdev.uplink_vsi;
 702
 703         rule_info.sw_act.fltr_act = fltr->action.fltr_act;
 704         if (fltr->action.fltr_act != ICE_DROP_PACKET)
 705                 rule_info.sw_act.vsi_handle = fltr->dest_vsi->idx;
 706         /* For now, making priority to be highest, and it also becomes
 707          * the priority for recipe which will get created as a result of
 708          * new extraction sequence based on input set.
 709          * Priority '7' is max val for switch recipe, higher the number
 710          * results into order of switch rule evaluation.
 711          */
 712         rule_info.priority = 7;
 713         rule_info.flags_info.act_valid = true;
 714
 715         if (fltr->direction == ICE_ESWITCH_FLTR_INGRESS) {
 716                 rule_info.sw_act.flag |= ICE_FLTR_RX;
 717                 rule_info.sw_act.src = hw->pf_id;
 718                 rule_info.flags_info.act = ICE_SINGLE_ACT_LB_ENABLE;
 719         } else {
 720                 rule_info.sw_act.flag |= ICE_FLTR_TX;
 721                 rule_info.sw_act.src = vsi->idx;
 722                 rule_info.flags_info.act = ICE_SINGLE_ACT_LAN_ENABLE;
 723         }
 724
 725         /* specify the cookie as filter_rule_id */
 726         rule_info.fltr_rule_id = fltr->cookie;
 727
 728         ret = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info, &rule_added);
 729         if (ret == -EEXIST) {
 730                 NL_SET_ERR_MSG_MOD(fltr->extack, "Unable to add filter because it already exist");
 731                 ret = -EINVAL;
 732                 goto exit;
 733         } else if (ret) {
 734                 NL_SET_ERR_MSG_MOD(fltr->extack, "Unable to add filter due to error");
 735                 goto exit;
 736         }
 737
 738         /* store the output params, which are needed later for removing
 739          * advanced switch filter
 740          */
 741         fltr->rid = rule_added.rid;
 742         fltr->rule_id = rule_added.rule_id;
 743         fltr->dest_vsi_handle = rule_added.vsi_handle;
 744
 745 exit:
 746         kfree(list);
 747         return ret;
 748 }
 749
 750 /**
 751  * ice_locate_vsi_using_queue - locate VSI using queue (forward to queue action)
 752  * @vsi: Pointer to VSI
 753  * @queue: Queue index
 754  *
 755  * Locate the VSI using specified "queue". When ADQ is not enabled,
 756  * always return input VSI, otherwise locate corresponding
 757  * VSI based on per channel "offset" and "qcount"
 758  */
 759 struct ice_vsi *
 760 ice_locate_vsi_using_queue(struct ice_vsi *vsi, int queue)
 761 {
 762         int num_tc, tc;
 763
 764         /* if ADQ is not active, passed VSI is the candidate VSI */
 765         if (!ice_is_adq_active(vsi->back))
 766                 return vsi;
 767
 768         /* Locate the VSI (it could still be main PF VSI or CHNL_VSI depending
 769          * upon queue number)
 770          */
 771         num_tc = vsi->mqprio_qopt.qopt.num_tc;
 772
 773         for (tc = 0; tc < num_tc; tc++) {
 774                 int qcount = vsi->mqprio_qopt.qopt.count[tc];
 775                 int offset = vsi->mqprio_qopt.qopt.offset[tc];
 776
 777                 if (queue >= offset && queue < offset + qcount) {
 778                         /* for non-ADQ TCs, passed VSI is the candidate VSI */
 779                         if (tc < ICE_CHNL_START_TC)
 780                                 return vsi;
 781                         else
 782                                 return vsi->tc_map_vsi[tc];
 783                 }
 784         }
 785         return NULL;
 786 }
 787
 788 static struct ice_rx_ring *
 789 ice_locate_rx_ring_using_queue(struct ice_vsi *vsi,
 790                                struct ice_tc_flower_fltr *tc_fltr)
 791 {
 792         u16 queue = tc_fltr->action.fwd.q.queue;
 793
 794         return queue < vsi->num_rxq ? vsi->rx_rings[queue] : NULL;
 795 }
 796
 797 /**
 798  * ice_tc_forward_action - Determine destination VSI and queue for the action
 799  * @vsi: Pointer to VSI
 800  * @tc_fltr: Pointer to TC flower filter structure
 801  *
 802  * Validates the tc forward action and determines the destination VSI and queue
 803  * for the forward action.
 804  */
 805 static struct ice_vsi *
 806 ice_tc_forward_action(struct ice_vsi *vsi, struct ice_tc_flower_fltr *tc_fltr)
 807 {
 808         struct ice_rx_ring *ring = NULL;
 809         struct ice_vsi *dest_vsi = NULL;
 810         struct ice_pf *pf = vsi->back;
 811         struct device *dev;
 812         u32 tc_class;
 813         int q;
 814
 815         dev = ice_pf_to_dev(pf);
 816
 817         /* Get the destination VSI and/or destination queue and validate them */
 818         switch (tc_fltr->action.fltr_act) {
 819         case ICE_FWD_TO_VSI:
 820                 tc_class = tc_fltr->action.fwd.tc.tc_class;
 821                 /* Select the destination VSI */
 822                 if (tc_class < ICE_CHNL_START_TC) {
 823                         NL_SET_ERR_MSG_MOD(tc_fltr->extack,
 824                                            "Unable to add filter because of unsupported destination");
 825                         return ERR_PTR(-EOPNOTSUPP);
 826                 }
 827                 /* Locate ADQ VSI depending on hw_tc number */
 828                 dest_vsi = vsi->tc_map_vsi[tc_class];
 829                 break;
 830         case ICE_FWD_TO_Q:
 831                 /* Locate the Rx queue */
 832                 ring = ice_locate_rx_ring_using_queue(vsi, tc_fltr);
 833                 if (!ring) {
 834                         dev_err(dev,
 835                                 "Unable to locate Rx queue for action fwd_to_queue: %u\n",
 836                                 tc_fltr->action.fwd.q.queue);
 837                         return ERR_PTR(-EINVAL);
 838                 }
 839                 /* Determine destination VSI even though the action is
 840                  * FWD_TO_QUEUE, because QUEUE is associated with VSI
 841                  */
 842                 q = tc_fltr->action.fwd.q.queue;
 843                 dest_vsi = ice_locate_vsi_using_queue(vsi, q);
 844                 break;
 845         default:
 846                 dev_err(dev,
 847                         "Unable to add filter because of unsupported action %u (supported actions: fwd to tc, fwd to queue)\n",
 848                         tc_fltr->action.fltr_act);
 849                 return ERR_PTR(-EINVAL);
 850         }
 851         /* Must have valid dest_vsi (it could be main VSI or ADQ VSI) */
 852         if (!dest_vsi) {
 853                 dev_err(dev,
 854                         "Unable to add filter because specified destination VSI doesn't exist\n");
 855                 return ERR_PTR(-EINVAL);
 856         }
 857         return dest_vsi;
 858 }
 859
 860 /**
 861  * ice_add_tc_flower_adv_fltr - add appropriate filter rules
 862  * @vsi: Pointer to VSI
 863  * @tc_fltr: Pointer to TC flower filter structure
 864  *
 865  * based on filter parameters using Advance recipes supported
 866  * by OS package.
 867  */
 868 static int
 869 ice_add_tc_flower_adv_fltr(struct ice_vsi *vsi,
 870                            struct ice_tc_flower_fltr *tc_fltr)
 871 {
 872         struct ice_tc_flower_lyr_2_4_hdrs *headers = &tc_fltr->outer_headers;
 873         struct ice_adv_rule_info rule_info = {0};
 874         struct ice_rule_query_data rule_added;
 875         struct ice_adv_lkup_elem *list;
 876         struct ice_pf *pf = vsi->back;
 877         struct ice_hw *hw = &pf->hw;
 878         u32 flags = tc_fltr->flags;
 879         struct ice_vsi *dest_vsi;
 880         struct device *dev;
 881         u16 lkups_cnt = 0;
 882         u16 l4_proto = 0;
 883         int ret = 0;
 884         u16 i = 0;
 885
 886         dev = ice_pf_to_dev(pf);
 887         if (ice_is_safe_mode(pf)) {
 888                 NL_SET_ERR_MSG_MOD(tc_fltr->extack, "Unable to add filter because driver is in safe mode");
 889                 return -EOPNOTSUPP;
 890         }
 891
 892         if (!flags || (flags & (ICE_TC_FLWR_FIELD_ENC_DEST_IPV4 |
 893                                 ICE_TC_FLWR_FIELD_ENC_SRC_IPV4 |
 894                                 ICE_TC_FLWR_FIELD_ENC_DEST_IPV6 |
 895                                 ICE_TC_FLWR_FIELD_ENC_SRC_IPV6 |
 896                                 ICE_TC_FLWR_FIELD_ENC_SRC_L4_PORT))) {
 897                 NL_SET_ERR_MSG_MOD(tc_fltr->extack, "Unsupported encap field(s)");
 898                 return -EOPNOTSUPP;
 899         }
 900
 901         /* validate forwarding action VSI and queue */
 902         if (ice_is_forward_action(tc_fltr->action.fltr_act)) {
 903                 dest_vsi = ice_tc_forward_action(vsi, tc_fltr);
 904                 if (IS_ERR(dest_vsi))
 905                         return PTR_ERR(dest_vsi);
 906         }
 907
 908         lkups_cnt = ice_tc_count_lkups(flags, headers, tc_fltr);
 909         list = kcalloc(lkups_cnt, sizeof(*list), GFP_ATOMIC);
 910         if (!list)
 911                 return -ENOMEM;
 912
 913         i = ice_tc_fill_rules(hw, flags, tc_fltr, list, &rule_info, &l4_proto);
 914         if (i != lkups_cnt) {
 915                 ret = -EINVAL;
 916                 goto exit;
 917         }
 918
 919         rule_info.sw_act.fltr_act = tc_fltr->action.fltr_act;
 920         /* specify the cookie as filter_rule_id */
 921         rule_info.fltr_rule_id = tc_fltr->cookie;
 922
 923         switch (tc_fltr->action.fltr_act) {
 924         case ICE_FWD_TO_VSI:
 925                 rule_info.sw_act.vsi_handle = dest_vsi->idx;
 926                 rule_info.priority = ICE_SWITCH_FLTR_PRIO_VSI;
 927                 rule_info.sw_act.src = hw->pf_id;
 928                 dev_dbg(dev, "add switch rule for TC:%u vsi_idx:%u, lkups_cnt:%u\n",
 929                         tc_fltr->action.fwd.tc.tc_class,
 930                         rule_info.sw_act.vsi_handle, lkups_cnt);
 931                 break;
 932         case ICE_FWD_TO_Q:
 933                 /* HW queue number in global space */
 934                 rule_info.sw_act.fwd_id.q_id = tc_fltr->action.fwd.q.hw_queue;
 935                 rule_info.sw_act.vsi_handle = dest_vsi->idx;
 936                 rule_info.priority = ICE_SWITCH_FLTR_PRIO_QUEUE;
 937                 rule_info.sw_act.src = hw->pf_id;
 938                 dev_dbg(dev, "add switch rule action to forward to queue:%u (HW queue %u), lkups_cnt:%u\n",
 939                         tc_fltr->action.fwd.q.queue,
 940                         tc_fltr->action.fwd.q.hw_queue, lkups_cnt);
 941                 break;
 942         case ICE_DROP_PACKET:
 943                 rule_info.sw_act.flag |= ICE_FLTR_RX;
 944                 rule_info.sw_act.src = hw->pf_id;
 945                 rule_info.priority = ICE_SWITCH_FLTR_PRIO_VSI;
 946                 break;
 947         default:
 948                 ret = -EOPNOTSUPP;
 949                 goto exit;
 950         }
 951
 952         ret = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info, &rule_added);
 953         if (ret == -EEXIST) {
 954                 NL_SET_ERR_MSG_MOD(tc_fltr->extack,
 955                                    "Unable to add filter because it already exist");
 956                 ret = -EINVAL;
 957                 goto exit;
 958         } else if (ret) {
 959                 NL_SET_ERR_MSG_MOD(tc_fltr->extack,
 960                                    "Unable to add filter due to error");
 961                 goto exit;
 962         }
 963
 964         /* store the output params, which are needed later for removing
 965          * advanced switch filter
 966          */
 967         tc_fltr->rid = rule_added.rid;
 968         tc_fltr->rule_id = rule_added.rule_id;
 969         tc_fltr->dest_vsi_handle = rule_added.vsi_handle;
 970         if (tc_fltr->action.fltr_act == ICE_FWD_TO_VSI ||
 971             tc_fltr->action.fltr_act == ICE_FWD_TO_Q) {
 972                 tc_fltr->dest_vsi = dest_vsi;
 973                 /* keep track of advanced switch filter for
 974                  * destination VSI
 975                  */
 976                 dest_vsi->num_chnl_fltr++;
 977
 978                 /* keeps track of channel filters for PF VSI */
 979                 if (vsi->type == ICE_VSI_PF &&
 980                     (flags & (ICE_TC_FLWR_FIELD_DST_MAC |
 981                               ICE_TC_FLWR_FIELD_ENC_DST_MAC)))
 982                         pf->num_dmac_chnl_fltrs++;
 983         }
 984         switch (tc_fltr->action.fltr_act) {
 985         case ICE_FWD_TO_VSI:
 986                 dev_dbg(dev, "added switch rule (lkups_cnt %u, flags 0x%x), action is forward to TC %u, rid %u, rule_id %u, vsi_idx %u\n",
 987                         lkups_cnt, flags,
 988                         tc_fltr->action.fwd.tc.tc_class, rule_added.rid,
 989                         rule_added.rule_id, rule_added.vsi_handle);
 990                 break;
 991         case ICE_FWD_TO_Q:
 992                 dev_dbg(dev, "added switch rule (lkups_cnt %u, flags 0x%x), action is forward to queue: %u (HW queue %u)     , rid %u, rule_id %u\n",
 993                         lkups_cnt, flags, tc_fltr->action.fwd.q.queue,
 994                         tc_fltr->action.fwd.q.hw_queue, rule_added.rid,
 995                         rule_added.rule_id);
 996                 break;
 997         case ICE_DROP_PACKET:
 998                 dev_dbg(dev, "added switch rule (lkups_cnt %u, flags 0x%x), action is drop, rid %u, rule_id %u\n",
 999                         lkups_cnt, flags, rule_added.rid, rule_added.rule_id);
1000                 break;
1001         default:
1002                 break;
1003         }
1004 exit:
1005         kfree(list);
1006         return ret;
1007 }
1008
1009 /**
1010  * ice_tc_set_pppoe - Parse PPPoE fields from TC flower filter
1011  * @match: Pointer to flow match structure
1012  * @fltr: Pointer to filter structure
1013  * @headers: Pointer to outer header fields
1014  * @returns PPP protocol used in filter (ppp_ses or ppp_disc)
1015  */
1016 static u16
1017 ice_tc_set_pppoe(struct flow_match_pppoe *match,
1018                  struct ice_tc_flower_fltr *fltr,
1019                  struct ice_tc_flower_lyr_2_4_hdrs *headers)
1020 {
1021         if (match->mask->session_id) {
1022                 fltr->flags |= ICE_TC_FLWR_FIELD_PPPOE_SESSID;
1023                 headers->pppoe_hdr.session_id = match->key->session_id;
1024         }
1025
1026         if (match->mask->ppp_proto) {
1027                 fltr->flags |= ICE_TC_FLWR_FIELD_PPP_PROTO;
1028                 headers->pppoe_hdr.ppp_proto = match->key->ppp_proto;
1029         }
1030
1031         return be16_to_cpu(match->key->type);
1032 }
1033
1034 /**
1035  * ice_tc_set_ipv4 - Parse IPv4 addresses from TC flower filter
1036  * @match: Pointer to flow match structure
1037  * @fltr: Pointer to filter structure
1038  * @headers: inner or outer header fields
1039  * @is_encap: set true for tunnel IPv4 address
1040  */
1041 static int
1042 ice_tc_set_ipv4(struct flow_match_ipv4_addrs *match,
1043                 struct ice_tc_flower_fltr *fltr,
1044                 struct ice_tc_flower_lyr_2_4_hdrs *headers, bool is_encap)
1045 {
1046         if (match->key->dst) {
1047                 if (is_encap)
1048                         fltr->flags |= ICE_TC_FLWR_FIELD_ENC_DEST_IPV4;
1049                 else
1050                         fltr->flags |= ICE_TC_FLWR_FIELD_DEST_IPV4;
1051                 headers->l3_key.dst_ipv4 = match->key->dst;
1052                 headers->l3_mask.dst_ipv4 = match->mask->dst;
1053         }
1054         if (match->key->src) {
1055                 if (is_encap)
1056                         fltr->flags |= ICE_TC_FLWR_FIELD_ENC_SRC_IPV4;
1057                 else
1058                         fltr->flags |= ICE_TC_FLWR_FIELD_SRC_IPV4;
1059                 headers->l3_key.src_ipv4 = match->key->src;
1060                 headers->l3_mask.src_ipv4 = match->mask->src;
1061         }
1062         return 0;
1063 }
1064
1065 /**
1066  * ice_tc_set_ipv6 - Parse IPv6 addresses from TC flower filter
1067  * @match: Pointer to flow match structure
1068  * @fltr: Pointer to filter structure
1069  * @headers: inner or outer header fields
1070  * @is_encap: set true for tunnel IPv6 address
1071  */
1072 static int
1073 ice_tc_set_ipv6(struct flow_match_ipv6_addrs *match,
1074                 struct ice_tc_flower_fltr *fltr,
1075                 struct ice_tc_flower_lyr_2_4_hdrs *headers, bool is_encap)
1076 {
1077         struct ice_tc_l3_hdr *l3_key, *l3_mask;
1078
1079         /* src and dest IPV6 address should not be LOOPBACK
1080          * (0:0:0:0:0:0:0:1), which can be represented as ::1
1081          */
1082         if (ipv6_addr_loopback(&match->key->dst) ||
1083             ipv6_addr_loopback(&match->key->src)) {
1084                 NL_SET_ERR_MSG_MOD(fltr->extack, "Bad IPv6, addr is LOOPBACK");
1085                 return -EINVAL;
1086         }
1087         /* if src/dest IPv6 address is *,* error */
1088         if (ipv6_addr_any(&match->mask->dst) &&
1089             ipv6_addr_any(&match->mask->src)) {
1090                 NL_SET_ERR_MSG_MOD(fltr->extack, "Bad src/dest IPv6, addr is any");
1091                 return -EINVAL;
1092         }
1093         if (!ipv6_addr_any(&match->mask->dst)) {
1094                 if (is_encap)
1095                         fltr->flags |= ICE_TC_FLWR_FIELD_ENC_DEST_IPV6;
1096                 else
1097                         fltr->flags |= ICE_TC_FLWR_FIELD_DEST_IPV6;
1098         }
1099         if (!ipv6_addr_any(&match->mask->src)) {
1100                 if (is_encap)
1101                         fltr->flags |= ICE_TC_FLWR_FIELD_ENC_SRC_IPV6;
1102                 else
1103                         fltr->flags |= ICE_TC_FLWR_FIELD_SRC_IPV6;
1104         }
1105
1106         l3_key = &headers->l3_key;
1107         l3_mask = &headers->l3_mask;
1108
1109         if (fltr->flags & (ICE_TC_FLWR_FIELD_ENC_SRC_IPV6 |
1110                            ICE_TC_FLWR_FIELD_SRC_IPV6)) {
1111                 memcpy(&l3_key->src_ipv6_addr, &match->key->src.s6_addr,
1112                        sizeof(match->key->src.s6_addr));
1113                 memcpy(&l3_mask->src_ipv6_addr, &match->mask->src.s6_addr,
1114                        sizeof(match->mask->src.s6_addr));
1115         }
1116         if (fltr->flags & (ICE_TC_FLWR_FIELD_ENC_DEST_IPV6 |
1117                            ICE_TC_FLWR_FIELD_DEST_IPV6)) {
1118                 memcpy(&l3_key->dst_ipv6_addr, &match->key->dst.s6_addr,
1119                        sizeof(match->key->dst.s6_addr));
1120                 memcpy(&l3_mask->dst_ipv6_addr, &match->mask->dst.s6_addr,
1121                        sizeof(match->mask->dst.s6_addr));
1122         }
1123
1124         return 0;
1125 }
1126
1127 /**
1128  * ice_tc_set_tos_ttl - Parse IP ToS/TTL from TC flower filter
1129  * @match: Pointer to flow match structure
1130  * @fltr: Pointer to filter structure
1131  * @headers: inner or outer header fields
1132  * @is_encap: set true for tunnel
1133  */
1134 static void
1135 ice_tc_set_tos_ttl(struct flow_match_ip *match,
1136                    struct ice_tc_flower_fltr *fltr,
1137                    struct ice_tc_flower_lyr_2_4_hdrs *headers,
1138                    bool is_encap)
1139 {
1140         if (match->mask->tos) {
1141                 if (is_encap)
1142                         fltr->flags |= ICE_TC_FLWR_FIELD_ENC_IP_TOS;
1143                 else
1144                         fltr->flags |= ICE_TC_FLWR_FIELD_IP_TOS;
1145
1146                 headers->l3_key.tos = match->key->tos;
1147                 headers->l3_mask.tos = match->mask->tos;
1148         }
1149
1150         if (match->mask->ttl) {
1151                 if (is_encap)
1152                         fltr->flags |= ICE_TC_FLWR_FIELD_ENC_IP_TTL;
1153                 else
1154                         fltr->flags |= ICE_TC_FLWR_FIELD_IP_TTL;
1155
1156                 headers->l3_key.ttl = match->key->ttl;
1157                 headers->l3_mask.ttl = match->mask->ttl;
1158         }
1159 }
1160
1161 /**
1162  * ice_tc_set_port - Parse ports from TC flower filter
1163  * @match: Flow match structure
1164  * @fltr: Pointer to filter structure
1165  * @headers: inner or outer header fields
1166  * @is_encap: set true for tunnel port
1167  */
1168 static int
1169 ice_tc_set_port(struct flow_match_ports match,
1170                 struct ice_tc_flower_fltr *fltr,
1171                 struct ice_tc_flower_lyr_2_4_hdrs *headers, bool is_encap)
1172 {
1173         if (match.key->dst) {
1174                 if (is_encap)
1175                         fltr->flags |= ICE_TC_FLWR_FIELD_ENC_DEST_L4_PORT;
1176                 else
1177                         fltr->flags |= ICE_TC_FLWR_FIELD_DEST_L4_PORT;
1178
1179                 headers->l4_key.dst_port = match.key->dst;
1180                 headers->l4_mask.dst_port = match.mask->dst;
1181         }
1182         if (match.key->src) {
1183                 if (is_encap)
1184                         fltr->flags |= ICE_TC_FLWR_FIELD_ENC_SRC_L4_PORT;
1185                 else
1186                         fltr->flags |= ICE_TC_FLWR_FIELD_SRC_L4_PORT;
1187
1188                 headers->l4_key.src_port = match.key->src;
1189                 headers->l4_mask.src_port = match.mask->src;
1190         }
1191         return 0;
1192 }
1193
1194 static struct net_device *
1195 ice_get_tunnel_device(struct net_device *dev, struct flow_rule *rule)
1196 {
1197         struct flow_action_entry *act;
1198         int i;
1199
1200         if (ice_is_tunnel_supported(dev))
1201                 return dev;
1202
1203         flow_action_for_each(i, act, &rule->action) {
1204                 if (act->id == FLOW_ACTION_REDIRECT &&
1205                     ice_is_tunnel_supported(act->dev))
1206                         return act->dev;
1207         }
1208
1209         return NULL;
1210 }
1211
1212 /**
1213  * ice_parse_gtp_type - Sets GTP tunnel type to GTP-U or GTP-C
1214  * @match: Flow match structure
1215  * @fltr: Pointer to filter structure
1216  *
1217  * GTP-C/GTP-U is selected based on destination port number (enc_dst_port).
1218  * Before calling this funtcion, fltr->tunnel_type should be set to TNL_GTPU,
1219  * therefore making GTP-U the default choice (when destination port number is
1220  * not specified).
1221  */
1222 static int
1223 ice_parse_gtp_type(struct flow_match_ports match,
1224                    struct ice_tc_flower_fltr *fltr)
1225 {
1226         u16 dst_port;
1227
1228         if (match.key->dst) {
1229                 dst_port = be16_to_cpu(match.key->dst);
1230
1231                 switch (dst_port) {
1232                 case 2152:
1233                         break;
1234                 case 2123:
1235                         fltr->tunnel_type = TNL_GTPC;
1236                         break;
1237                 default:
1238                         NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported GTP port number");
1239                         return -EINVAL;
1240                 }
1241         }
1242
1243         return 0;
1244 }
1245
1246 static int
1247 ice_parse_tunnel_attr(struct net_device *dev, struct flow_rule *rule,
1248                       struct ice_tc_flower_fltr *fltr)
1249 {
1250         struct ice_tc_flower_lyr_2_4_hdrs *headers = &fltr->outer_headers;
1251         struct flow_match_control enc_control;
1252
1253         fltr->tunnel_type = ice_tc_tun_get_type(dev);
1254         headers->l3_key.ip_proto = IPPROTO_UDP;
1255
1256         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_KEYID)) {
1257                 struct flow_match_enc_keyid enc_keyid;
1258
1259                 flow_rule_match_enc_keyid(rule, &enc_keyid);
1260
1261                 if (!enc_keyid.mask->keyid ||
1262                     enc_keyid.mask->keyid != cpu_to_be32(ICE_TC_FLOWER_MASK_32))
1263                         return -EINVAL;
1264
1265                 fltr->flags |= ICE_TC_FLWR_FIELD_TENANT_ID;
1266                 fltr->tenant_id = enc_keyid.key->keyid;
1267         }
1268
1269         flow_rule_match_enc_control(rule, &enc_control);
1270
1271         if (enc_control.key->addr_type == FLOW_DISSECTOR_KEY_IPV4_ADDRS) {
1272                 struct flow_match_ipv4_addrs match;
1273
1274                 flow_rule_match_enc_ipv4_addrs(rule, &match);
1275                 if (ice_tc_set_ipv4(&match, fltr, headers, true))
1276                         return -EINVAL;
1277         } else if (enc_control.key->addr_type ==
1278                                         FLOW_DISSECTOR_KEY_IPV6_ADDRS) {
1279                 struct flow_match_ipv6_addrs match;
1280
1281                 flow_rule_match_enc_ipv6_addrs(rule, &match);
1282                 if (ice_tc_set_ipv6(&match, fltr, headers, true))
1283                         return -EINVAL;
1284         }
1285
1286         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_IP)) {
1287                 struct flow_match_ip match;
1288
1289                 flow_rule_match_enc_ip(rule, &match);
1290                 ice_tc_set_tos_ttl(&match, fltr, headers, true);
1291         }
1292
1293         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_PORTS) &&
1294             fltr->tunnel_type != TNL_VXLAN && fltr->tunnel_type != TNL_GENEVE) {
1295                 struct flow_match_ports match;
1296
1297                 flow_rule_match_enc_ports(rule, &match);
1298
1299                 if (fltr->tunnel_type != TNL_GTPU) {
1300                         if (ice_tc_set_port(match, fltr, headers, true))
1301                                 return -EINVAL;
1302                 } else {
1303                         if (ice_parse_gtp_type(match, fltr))
1304                                 return -EINVAL;
1305                 }
1306         }
1307
1308         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_OPTS)) {
1309                 struct flow_match_enc_opts match;
1310
1311                 flow_rule_match_enc_opts(rule, &match);
1312
1313                 memcpy(&fltr->gtp_pdu_info_keys, &match.key->data[0],
1314                        sizeof(struct gtp_pdu_session_info));
1315
1316                 memcpy(&fltr->gtp_pdu_info_masks, &match.mask->data[0],
1317                        sizeof(struct gtp_pdu_session_info));
1318
1319                 fltr->flags |= ICE_TC_FLWR_FIELD_ENC_OPTS;
1320         }
1321
1322         return 0;
1323 }
1324
1325 /**
1326  * ice_parse_cls_flower - Parse TC flower filters provided by kernel
1327  * @vsi: Pointer to the VSI
1328  * @filter_dev: Pointer to device on which filter is being added
1329  * @f: Pointer to struct flow_cls_offload
1330  * @fltr: Pointer to filter structure
1331  */
1332 static int
1333 ice_parse_cls_flower(struct net_device *filter_dev, struct ice_vsi *vsi,
1334                      struct flow_cls_offload *f,
1335                      struct ice_tc_flower_fltr *fltr)
1336 {
1337         struct ice_tc_flower_lyr_2_4_hdrs *headers = &fltr->outer_headers;
1338         struct flow_rule *rule = flow_cls_offload_flow_rule(f);
1339         u16 n_proto_mask = 0, n_proto_key = 0, addr_type = 0;
1340         struct flow_dissector *dissector;
1341         struct net_device *tunnel_dev;
1342
1343         dissector = rule->match.dissector;
1344
1345         if (dissector->used_keys &
1346             ~(BIT(FLOW_DISSECTOR_KEY_CONTROL) |
1347               BIT(FLOW_DISSECTOR_KEY_BASIC) |
1348               BIT(FLOW_DISSECTOR_KEY_ETH_ADDRS) |
1349               BIT(FLOW_DISSECTOR_KEY_VLAN) |
1350               BIT(FLOW_DISSECTOR_KEY_CVLAN) |
1351               BIT(FLOW_DISSECTOR_KEY_IPV4_ADDRS) |
1352               BIT(FLOW_DISSECTOR_KEY_IPV6_ADDRS) |
1353               BIT(FLOW_DISSECTOR_KEY_ENC_CONTROL) |
1354               BIT(FLOW_DISSECTOR_KEY_ENC_KEYID) |
1355               BIT(FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS) |
1356               BIT(FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS) |
1357               BIT(FLOW_DISSECTOR_KEY_ENC_PORTS) |
1358               BIT(FLOW_DISSECTOR_KEY_ENC_OPTS) |
1359               BIT(FLOW_DISSECTOR_KEY_IP) |
1360               BIT(FLOW_DISSECTOR_KEY_ENC_IP) |
1361               BIT(FLOW_DISSECTOR_KEY_PORTS) |
1362               BIT(FLOW_DISSECTOR_KEY_PPPOE) |
1363               BIT(FLOW_DISSECTOR_KEY_L2TPV3))) {
1364                 NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported key used");
1365                 return -EOPNOTSUPP;
1366         }
1367
1368         tunnel_dev = ice_get_tunnel_device(filter_dev, rule);
1369         if (tunnel_dev) {
1370                 int err;
1371
1372                 filter_dev = tunnel_dev;
1373
1374                 err = ice_parse_tunnel_attr(filter_dev, rule, fltr);
1375                 if (err) {
1376                         NL_SET_ERR_MSG_MOD(fltr->extack, "Failed to parse TC flower tunnel attributes");
1377                         return err;
1378                 }
1379
1380                 /* header pointers should point to the inner headers, outer
1381                  * header were already set by ice_parse_tunnel_attr
1382                  */
1383                 headers = &fltr->inner_headers;
1384         } else if (dissector->used_keys &
1385                   (BIT(FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS) |
1386                    BIT(FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS) |
1387                    BIT(FLOW_DISSECTOR_KEY_ENC_KEYID) |
1388                    BIT(FLOW_DISSECTOR_KEY_ENC_PORTS))) {
1389                 NL_SET_ERR_MSG_MOD(fltr->extack, "Tunnel key used, but device isn't a tunnel");
1390                 return -EOPNOTSUPP;
1391         } else {
1392                 fltr->tunnel_type = TNL_LAST;
1393         }
1394
1395         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_BASIC)) {
1396                 struct flow_match_basic match;
1397
1398                 flow_rule_match_basic(rule, &match);
1399
1400                 n_proto_key = ntohs(match.key->n_proto);
1401                 n_proto_mask = ntohs(match.mask->n_proto);
1402
1403                 if (n_proto_key == ETH_P_ALL || n_proto_key == 0 ||
1404                     fltr->tunnel_type == TNL_GTPU ||
1405                     fltr->tunnel_type == TNL_GTPC) {
1406                         n_proto_key = 0;
1407                         n_proto_mask = 0;
1408                 } else {
1409                         fltr->flags |= ICE_TC_FLWR_FIELD_ETH_TYPE_ID;
1410                 }
1411
1412                 headers->l2_key.n_proto = cpu_to_be16(n_proto_key);
1413                 headers->l2_mask.n_proto = cpu_to_be16(n_proto_mask);
1414                 headers->l3_key.ip_proto = match.key->ip_proto;
1415         }
1416
1417         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ETH_ADDRS)) {
1418                 struct flow_match_eth_addrs match;
1419
1420                 flow_rule_match_eth_addrs(rule, &match);
1421
1422                 if (!is_zero_ether_addr(match.key->dst)) {
1423                         ether_addr_copy(headers->l2_key.dst_mac,
1424                                         match.key->dst);
1425                         ether_addr_copy(headers->l2_mask.dst_mac,
1426                                         match.mask->dst);
1427                         fltr->flags |= ICE_TC_FLWR_FIELD_DST_MAC;
1428                 }
1429
1430                 if (!is_zero_ether_addr(match.key->src)) {
1431                         ether_addr_copy(headers->l2_key.src_mac,
1432                                         match.key->src);
1433                         ether_addr_copy(headers->l2_mask.src_mac,
1434                                         match.mask->src);
1435                         fltr->flags |= ICE_TC_FLWR_FIELD_SRC_MAC;
1436                 }
1437         }
1438
1439         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_VLAN) ||
1440             is_vlan_dev(filter_dev)) {
1441                 struct flow_dissector_key_vlan mask;
1442                 struct flow_dissector_key_vlan key;
1443                 struct flow_match_vlan match;
1444
1445                 if (is_vlan_dev(filter_dev)) {
1446                         match.key = &key;
1447                         match.key->vlan_id = vlan_dev_vlan_id(filter_dev);
1448                         match.key->vlan_priority = 0;
1449                         match.mask = &mask;
1450                         memset(match.mask, 0xff, sizeof(*match.mask));
1451                         match.mask->vlan_priority = 0;
1452                 } else {
1453                         flow_rule_match_vlan(rule, &match);
1454                 }
1455
1456                 if (match.mask->vlan_id) {
1457                         if (match.mask->vlan_id == VLAN_VID_MASK) {
1458                                 fltr->flags |= ICE_TC_FLWR_FIELD_VLAN;
1459                                 headers->vlan_hdr.vlan_id =
1460                                         cpu_to_be16(match.key->vlan_id &
1461                                                     VLAN_VID_MASK);
1462                         } else {
1463                                 NL_SET_ERR_MSG_MOD(fltr->extack, "Bad VLAN mask");
1464                                 return -EINVAL;
1465                         }
1466                 }
1467
1468                 if (match.mask->vlan_priority) {
1469                         fltr->flags |= ICE_TC_FLWR_FIELD_VLAN_PRIO;
1470                         headers->vlan_hdr.vlan_prio =
1471                                 be16_encode_bits(match.key->vlan_priority,
1472                                                  VLAN_PRIO_MASK);
1473                 }
1474
1475                 if (match.mask->vlan_tpid) {
1476                         headers->vlan_hdr.vlan_tpid = match.key->vlan_tpid;
1477                         fltr->flags |= ICE_TC_FLWR_FIELD_VLAN_TPID;
1478                 }
1479         }
1480
1481         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_CVLAN)) {
1482                 struct flow_match_vlan match;
1483
1484                 if (!ice_is_dvm_ena(&vsi->back->hw)) {
1485                         NL_SET_ERR_MSG_MOD(fltr->extack, "Double VLAN mode is not enabled");
1486                         return -EINVAL;
1487                 }
1488
1489                 flow_rule_match_cvlan(rule, &match);
1490
1491                 if (match.mask->vlan_id) {
1492                         if (match.mask->vlan_id == VLAN_VID_MASK) {
1493                                 fltr->flags |= ICE_TC_FLWR_FIELD_CVLAN;
1494                                 headers->cvlan_hdr.vlan_id =
1495                                         cpu_to_be16(match.key->vlan_id &
1496                                                     VLAN_VID_MASK);
1497                         } else {
1498                                 NL_SET_ERR_MSG_MOD(fltr->extack,
1499                                                    "Bad CVLAN mask");
1500                                 return -EINVAL;
1501                         }
1502                 }
1503
1504                 if (match.mask->vlan_priority) {
1505                         fltr->flags |= ICE_TC_FLWR_FIELD_CVLAN_PRIO;
1506                         headers->cvlan_hdr.vlan_prio =
1507                                 be16_encode_bits(match.key->vlan_priority,
1508                                                  VLAN_PRIO_MASK);
1509                 }
1510         }
1511
1512         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_PPPOE)) {
1513                 struct flow_match_pppoe match;
1514
1515                 flow_rule_match_pppoe(rule, &match);
1516                 n_proto_key = ice_tc_set_pppoe(&match, fltr, headers);
1517
1518                 /* If ethertype equals ETH_P_PPP_SES, n_proto might be
1519                  * overwritten by encapsulated protocol (ppp_proto field) or set
1520                  * to 0. To correct this, flow_match_pppoe provides the type
1521                  * field, which contains the actual ethertype (ETH_P_PPP_SES).
1522                  */
1523                 headers->l2_key.n_proto = cpu_to_be16(n_proto_key);
1524                 headers->l2_mask.n_proto = cpu_to_be16(0xFFFF);
1525                 fltr->flags |= ICE_TC_FLWR_FIELD_ETH_TYPE_ID;
1526         }
1527
1528         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_CONTROL)) {
1529                 struct flow_match_control match;
1530
1531                 flow_rule_match_control(rule, &match);
1532
1533                 addr_type = match.key->addr_type;
1534         }
1535
1536         if (addr_type == FLOW_DISSECTOR_KEY_IPV4_ADDRS) {
1537                 struct flow_match_ipv4_addrs match;
1538
1539                 flow_rule_match_ipv4_addrs(rule, &match);
1540                 if (ice_tc_set_ipv4(&match, fltr, headers, false))
1541                         return -EINVAL;
1542         }
1543
1544         if (addr_type == FLOW_DISSECTOR_KEY_IPV6_ADDRS) {
1545                 struct flow_match_ipv6_addrs match;
1546
1547                 flow_rule_match_ipv6_addrs(rule, &match);
1548                 if (ice_tc_set_ipv6(&match, fltr, headers, false))
1549                         return -EINVAL;
1550         }
1551
1552         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_IP)) {
1553                 struct flow_match_ip match;
1554
1555                 flow_rule_match_ip(rule, &match);
1556                 ice_tc_set_tos_ttl(&match, fltr, headers, false);
1557         }
1558
1559         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_L2TPV3)) {
1560                 struct flow_match_l2tpv3 match;
1561
1562                 flow_rule_match_l2tpv3(rule, &match);
1563
1564                 fltr->flags |= ICE_TC_FLWR_FIELD_L2TPV3_SESSID;
1565                 headers->l2tpv3_hdr.session_id = match.key->session_id;
1566         }
1567
1568         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_PORTS)) {
1569                 struct flow_match_ports match;
1570
1571                 flow_rule_match_ports(rule, &match);
1572                 if (ice_tc_set_port(match, fltr, headers, false))
1573                         return -EINVAL;
1574                 switch (headers->l3_key.ip_proto) {
1575                 case IPPROTO_TCP:
1576                 case IPPROTO_UDP:
1577                         break;
1578                 default:
1579                         NL_SET_ERR_MSG_MOD(fltr->extack, "Only UDP and TCP transport are supported");
1580                         return -EINVAL;
1581                 }
1582         }
1583         return 0;
1584 }
1585
1586 /**
1587  * ice_add_switch_fltr - Add TC flower filters
1588  * @vsi: Pointer to VSI
1589  * @fltr: Pointer to struct ice_tc_flower_fltr
1590  *
1591  * Add filter in HW switch block
1592  */
1593 static int
1594 ice_add_switch_fltr(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr)
1595 {
1596         if (fltr->action.fltr_act == ICE_FWD_TO_QGRP)
1597                 return -EOPNOTSUPP;
1598
1599         if (ice_is_eswitch_mode_switchdev(vsi->back))
1600                 return ice_eswitch_add_tc_fltr(vsi, fltr);
1601
1602         return ice_add_tc_flower_adv_fltr(vsi, fltr);
1603 }
1604
1605 /**
1606  * ice_prep_adq_filter - Prepare ADQ filter with the required additional headers
1607  * @vsi: Pointer to VSI
1608  * @fltr: Pointer to TC flower filter structure
1609  *
1610  * Prepare ADQ filter with the required additional header fields
1611  */
1612 static int
1613 ice_prep_adq_filter(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr)
1614 {
1615         if ((fltr->flags & ICE_TC_FLWR_FIELD_TENANT_ID) &&
1616             (fltr->flags & (ICE_TC_FLWR_FIELD_DST_MAC |
1617                            ICE_TC_FLWR_FIELD_SRC_MAC))) {
1618                 NL_SET_ERR_MSG_MOD(fltr->extack,
1619                                    "Unable to add filter because filter using tunnel key and inner MAC is unsupported combination");
1620                 return -EOPNOTSUPP;
1621         }
1622
1623         /* For ADQ, filter must include dest MAC address, otherwise unwanted
1624          * packets with unrelated MAC address get delivered to ADQ VSIs as long
1625          * as remaining filter criteria is satisfied such as dest IP address
1626          * and dest/src L4 port. Below code handles the following cases:
1627          * 1. For non-tunnel, if user specify MAC addresses, use them.
1628          * 2. For non-tunnel, if user didn't specify MAC address, add implicit
1629          * dest MAC to be lower netdev's active unicast MAC address
1630          * 3. For tunnel,  as of now TC-filter through flower classifier doesn't
1631          * have provision for user to specify outer DMAC, hence driver to
1632          * implicitly add outer dest MAC to be lower netdev's active unicast
1633          * MAC address.
1634          */
1635         if (fltr->tunnel_type != TNL_LAST &&
1636             !(fltr->flags & ICE_TC_FLWR_FIELD_ENC_DST_MAC))
1637                 fltr->flags |= ICE_TC_FLWR_FIELD_ENC_DST_MAC;
1638
1639         if (fltr->tunnel_type == TNL_LAST &&
1640             !(fltr->flags & ICE_TC_FLWR_FIELD_DST_MAC))
1641                 fltr->flags |= ICE_TC_FLWR_FIELD_DST_MAC;
1642
1643         if (fltr->flags & (ICE_TC_FLWR_FIELD_DST_MAC |
1644                            ICE_TC_FLWR_FIELD_ENC_DST_MAC)) {
1645                 ether_addr_copy(fltr->outer_headers.l2_key.dst_mac,
1646                                 vsi->netdev->dev_addr);
1647                 eth_broadcast_addr(fltr->outer_headers.l2_mask.dst_mac);
1648         }
1649
1650         /* Make sure VLAN is already added to main VSI, before allowing ADQ to
1651          * add a VLAN based filter such as MAC + VLAN + L4 port.
1652          */
1653         if (fltr->flags & ICE_TC_FLWR_FIELD_VLAN) {
1654                 u16 vlan_id = be16_to_cpu(fltr->outer_headers.vlan_hdr.vlan_id);
1655
1656                 if (!ice_vlan_fltr_exist(&vsi->back->hw, vlan_id, vsi->idx)) {
1657                         NL_SET_ERR_MSG_MOD(fltr->extack,
1658                                            "Unable to add filter because legacy VLAN filter for specified destination doesn't exist");
1659                         return -EINVAL;
1660                 }
1661         }
1662         return 0;
1663 }
1664
1665 /**
1666  * ice_handle_tclass_action - Support directing to a traffic class
1667  * @vsi: Pointer to VSI
1668  * @cls_flower: Pointer to TC flower offload structure
1669  * @fltr: Pointer to TC flower filter structure
1670  *
1671  * Support directing traffic to a traffic class/queue-set
1672  */
1673 static int
1674 ice_handle_tclass_action(struct ice_vsi *vsi,
1675                          struct flow_cls_offload *cls_flower,
1676                          struct ice_tc_flower_fltr *fltr)
1677 {
1678         int tc = tc_classid_to_hwtc(vsi->netdev, cls_flower->classid);
1679
1680         /* user specified hw_tc (must be non-zero for ADQ TC), action is forward
1681          * to hw_tc (i.e. ADQ channel number)
1682          */
1683         if (tc < ICE_CHNL_START_TC) {
1684                 NL_SET_ERR_MSG_MOD(fltr->extack,
1685                                    "Unable to add filter because of unsupported destination");
1686                 return -EOPNOTSUPP;
1687         }
1688         if (!(vsi->all_enatc & BIT(tc))) {
1689                 NL_SET_ERR_MSG_MOD(fltr->extack,
1690                                    "Unable to add filter because of non-existence destination");
1691                 return -EINVAL;
1692         }
1693         fltr->action.fltr_act = ICE_FWD_TO_VSI;
1694         fltr->action.fwd.tc.tc_class = tc;
1695
1696         return ice_prep_adq_filter(vsi, fltr);
1697 }
1698
1699 static int
1700 ice_tc_forward_to_queue(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr,
1701                         struct flow_action_entry *act)
1702 {
1703         struct ice_vsi *ch_vsi = NULL;
1704         u16 queue = act->rx_queue;
1705
1706         if (queue >= vsi->num_rxq) {
1707                 NL_SET_ERR_MSG_MOD(fltr->extack,
1708                                    "Unable to add filter because specified queue is invalid");
1709                 return -EINVAL;
1710         }
1711         fltr->action.fltr_act = ICE_FWD_TO_Q;
1712         fltr->action.fwd.q.queue = queue;
1713         /* determine corresponding HW queue */
1714         fltr->action.fwd.q.hw_queue = vsi->rxq_map[queue];
1715
1716         /* If ADQ is configured, and the queue belongs to ADQ VSI, then prepare
1717          * ADQ switch filter
1718          */
1719         ch_vsi = ice_locate_vsi_using_queue(vsi, fltr->action.fwd.q.queue);
1720         if (!ch_vsi)
1721                 return -EINVAL;
1722         fltr->dest_vsi = ch_vsi;
1723         if (!ice_is_chnl_fltr(fltr))
1724                 return 0;
1725
1726         return ice_prep_adq_filter(vsi, fltr);
1727 }
1728
1729 static int
1730 ice_tc_parse_action(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr,
1731                     struct flow_action_entry *act)
1732 {
1733         switch (act->id) {
1734         case FLOW_ACTION_RX_QUEUE_MAPPING:
1735                 /* forward to queue */
1736                 return ice_tc_forward_to_queue(vsi, fltr, act);
1737         case FLOW_ACTION_DROP:
1738                 fltr->action.fltr_act = ICE_DROP_PACKET;
1739                 return 0;
1740         default:
1741                 NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported TC action");
1742                 return -EOPNOTSUPP;
1743         }
1744 }
1745
1746 /**
1747  * ice_parse_tc_flower_actions - Parse the actions for a TC filter
1748  * @vsi: Pointer to VSI
1749  * @cls_flower: Pointer to TC flower offload structure
1750  * @fltr: Pointer to TC flower filter structure
1751  *
1752  * Parse the actions for a TC filter
1753  */
1754 static int
1755 ice_parse_tc_flower_actions(struct ice_vsi *vsi,
1756                             struct flow_cls_offload *cls_flower,
1757                             struct ice_tc_flower_fltr *fltr)
1758 {
1759         struct flow_rule *rule = flow_cls_offload_flow_rule(cls_flower);
1760         struct flow_action *flow_action = &rule->action;
1761         struct flow_action_entry *act;
1762         int i, err;
1763
1764         if (cls_flower->classid)
1765                 return ice_handle_tclass_action(vsi, cls_flower, fltr);
1766
1767         if (!flow_action_has_entries(flow_action))
1768                 return -EINVAL;
1769
1770         flow_action_for_each(i, act, flow_action) {
1771                 if (ice_is_eswitch_mode_switchdev(vsi->back))
1772                         err = ice_eswitch_tc_parse_action(fltr, act);
1773                 else
1774                         err = ice_tc_parse_action(vsi, fltr, act);
1775                 if (err)
1776                         return err;
1777                 continue;
1778         }
1779         return 0;
1780 }
1781
1782 /**
1783  * ice_del_tc_fltr - deletes a filter from HW table
1784  * @vsi: Pointer to VSI
1785  * @fltr: Pointer to struct ice_tc_flower_fltr
1786  *
1787  * This function deletes a filter from HW table and manages book-keeping
1788  */
1789 static int ice_del_tc_fltr(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr)
1790 {
1791         struct ice_rule_query_data rule_rem;
1792         struct ice_pf *pf = vsi->back;
1793         int err;
1794
1795         rule_rem.rid = fltr->rid;
1796         rule_rem.rule_id = fltr->rule_id;
1797         rule_rem.vsi_handle = fltr->dest_vsi_handle;
1798         err = ice_rem_adv_rule_by_id(&pf->hw, &rule_rem);
1799         if (err) {
1800                 if (err == -ENOENT) {
1801                         NL_SET_ERR_MSG_MOD(fltr->extack, "Filter does not exist");
1802                         return -ENOENT;
1803                 }
1804                 NL_SET_ERR_MSG_MOD(fltr->extack, "Failed to delete TC flower filter");
1805                 return -EIO;
1806         }
1807
1808         /* update advanced switch filter count for destination
1809          * VSI if filter destination was VSI
1810          */
1811         if (fltr->dest_vsi) {
1812                 if (fltr->dest_vsi->type == ICE_VSI_CHNL) {
1813                         fltr->dest_vsi->num_chnl_fltr--;
1814
1815                         /* keeps track of channel filters for PF VSI */
1816                         if (vsi->type == ICE_VSI_PF &&
1817                             (fltr->flags & (ICE_TC_FLWR_FIELD_DST_MAC |
1818                                             ICE_TC_FLWR_FIELD_ENC_DST_MAC)))
1819                                 pf->num_dmac_chnl_fltrs--;
1820                 }
1821         }
1822         return 0;
1823 }
1824
1825 /**
1826  * ice_add_tc_fltr - adds a TC flower filter
1827  * @netdev: Pointer to netdev
1828  * @vsi: Pointer to VSI
1829  * @f: Pointer to flower offload structure
1830  * @__fltr: Pointer to struct ice_tc_flower_fltr
1831  *
1832  * This function parses TC-flower input fields, parses action,
1833  * and adds a filter.
1834  */
1835 static int
1836 ice_add_tc_fltr(struct net_device *netdev, struct ice_vsi *vsi,
1837                 struct flow_cls_offload *f,
1838                 struct ice_tc_flower_fltr **__fltr)
1839 {
1840         struct ice_tc_flower_fltr *fltr;
1841         int err;
1842
1843         /* by default, set output to be INVALID */
1844         *__fltr = NULL;
1845
1846         fltr = kzalloc(sizeof(*fltr), GFP_KERNEL);
1847         if (!fltr)
1848                 return -ENOMEM;
1849
1850         fltr->cookie = f->cookie;
1851         fltr->extack = f->common.extack;
1852         fltr->src_vsi = vsi;
1853         INIT_HLIST_NODE(&fltr->tc_flower_node);
1854
1855         err = ice_parse_cls_flower(netdev, vsi, f, fltr);
1856         if (err < 0)
1857                 goto err;
1858
1859         err = ice_parse_tc_flower_actions(vsi, f, fltr);
1860         if (err < 0)
1861                 goto err;
1862
1863         err = ice_add_switch_fltr(vsi, fltr);
1864         if (err < 0)
1865                 goto err;
1866
1867         /* return the newly created filter */
1868         *__fltr = fltr;
1869
1870         return 0;
1871 err:
1872         kfree(fltr);
1873         return err;
1874 }
1875
1876 /**
1877  * ice_find_tc_flower_fltr - Find the TC flower filter in the list
1878  * @pf: Pointer to PF
1879  * @cookie: filter specific cookie
1880  */
1881 static struct ice_tc_flower_fltr *
1882 ice_find_tc_flower_fltr(struct ice_pf *pf, unsigned long cookie)
1883 {
1884         struct ice_tc_flower_fltr *fltr;
1885
1886         hlist_for_each_entry(fltr, &pf->tc_flower_fltr_list, tc_flower_node)
1887                 if (cookie == fltr->cookie)
1888                         return fltr;
1889
1890         return NULL;
1891 }
1892
1893 /**
1894  * ice_add_cls_flower - add TC flower filters
1895  * @netdev: Pointer to filter device
1896  * @vsi: Pointer to VSI
1897  * @cls_flower: Pointer to flower offload structure
1898  */
1899 int
1900 ice_add_cls_flower(struct net_device *netdev, struct ice_vsi *vsi,
1901                    struct flow_cls_offload *cls_flower)
1902 {
1903         struct netlink_ext_ack *extack = cls_flower->common.extack;
1904         struct net_device *vsi_netdev = vsi->netdev;
1905         struct ice_tc_flower_fltr *fltr;
1906         struct ice_pf *pf = vsi->back;
1907         int err;
1908
1909         if (ice_is_reset_in_progress(pf->state))
1910                 return -EBUSY;
1911         if (test_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags))
1912                 return -EINVAL;
1913
1914         if (ice_is_port_repr_netdev(netdev))
1915                 vsi_netdev = netdev;
1916
1917         if (!(vsi_netdev->features & NETIF_F_HW_TC) &&
1918             !test_bit(ICE_FLAG_CLS_FLOWER, pf->flags)) {
1919                 /* Based on TC indirect notifications from kernel, all ice
1920                  * devices get an instance of rule from higher level device.
1921                  * Avoid triggering explicit error in this case.
1922                  */
1923                 if (netdev == vsi_netdev)
1924                         NL_SET_ERR_MSG_MOD(extack, "can't apply TC flower filters, turn ON hw-tc-offload and try again");
1925                 return -EINVAL;
1926         }
1927
1928         /* avoid duplicate entries, if exists - return error */
1929         fltr = ice_find_tc_flower_fltr(pf, cls_flower->cookie);
1930         if (fltr) {
1931                 NL_SET_ERR_MSG_MOD(extack, "filter cookie already exists, ignoring");
1932                 return -EEXIST;
1933         }
1934
1935         /* prep and add TC-flower filter in HW */
1936         err = ice_add_tc_fltr(netdev, vsi, cls_flower, &fltr);
1937         if (err)
1938                 return err;
1939
1940         /* add filter into an ordered list */
1941         hlist_add_head(&fltr->tc_flower_node, &pf->tc_flower_fltr_list);
1942         return 0;
1943 }
1944
1945 /**
1946  * ice_del_cls_flower - delete TC flower filters
1947  * @vsi: Pointer to VSI
1948  * @cls_flower: Pointer to struct flow_cls_offload
1949  */
1950 int
1951 ice_del_cls_flower(struct ice_vsi *vsi, struct flow_cls_offload *cls_flower)
1952 {
1953         struct ice_tc_flower_fltr *fltr;
1954         struct ice_pf *pf = vsi->back;
1955         int err;
1956
1957         /* find filter */
1958         fltr = ice_find_tc_flower_fltr(pf, cls_flower->cookie);
1959         if (!fltr) {
1960                 if (!test_bit(ICE_FLAG_TC_MQPRIO, pf->flags) &&
1961                     hlist_empty(&pf->tc_flower_fltr_list))
1962                         return 0;
1963
1964                 NL_SET_ERR_MSG_MOD(cls_flower->common.extack, "failed to delete TC flower filter because unable to find it");
1965                 return -EINVAL;
1966         }
1967
1968         fltr->extack = cls_flower->common.extack;
1969         /* delete filter from HW */
1970         err = ice_del_tc_fltr(vsi, fltr);
1971         if (err)
1972                 return err;
1973
1974         /* delete filter from an ordered list */
1975         hlist_del(&fltr->tc_flower_node);
1976
1977         /* free the filter node */
1978         kfree(fltr);
1979
1980         return 0;
1981 }
1982
1983 /**
1984  * ice_replay_tc_fltrs - replay TC filters
1985  * @pf: pointer to PF struct
1986  */
1987 void ice_replay_tc_fltrs(struct ice_pf *pf)
1988 {
1989         struct ice_tc_flower_fltr *fltr;
1990         struct hlist_node *node;
1991
1992         hlist_for_each_entry_safe(fltr, node,
1993                                   &pf->tc_flower_fltr_list,
1994                                   tc_flower_node) {
1995                 fltr->extack = NULL;
1996                 ice_add_switch_fltr(fltr->src_vsi, fltr);
1997         }
1998 }