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

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (C) 2018-2020, Intel Corporation. */
   3
   4 /* flow director ethtool support for ice */
   5
   6 #include "ice.h"
   7 #include "ice_lib.h"
   8 #include "ice_fdir.h"
   9 #include "ice_flow.h"
  10
  11 static struct in6_addr full_ipv6_addr_mask = {
  12         .in6_u = {
  13                 .u6_addr8 = {
  14                         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  15                         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  16                 }
  17         }
  18 };
  19
  20 static struct in6_addr zero_ipv6_addr_mask = {
  21         .in6_u = {
  22                 .u6_addr8 = {
  23                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  24                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  25                 }
  26         }
  27 };
  28
  29 /* calls to ice_flow_add_prof require the number of segments in the array
  30  * for segs_cnt. In this code that is one more than the index.
  31  */
  32 #define TNL_SEG_CNT(_TNL_) ((_TNL_) + 1)
  33
  34 /**
  35  * ice_fltr_to_ethtool_flow - convert filter type values to ethtool
  36  * flow type values
  37  * @flow: filter type to be converted
  38  *
  39  * Returns the corresponding ethtool flow type.
  40  */
  41 static int ice_fltr_to_ethtool_flow(enum ice_fltr_ptype flow)
  42 {
  43         switch (flow) {
  44         case ICE_FLTR_PTYPE_NONF_IPV4_TCP:
  45                 return TCP_V4_FLOW;
  46         case ICE_FLTR_PTYPE_NONF_IPV4_UDP:
  47                 return UDP_V4_FLOW;
  48         case ICE_FLTR_PTYPE_NONF_IPV4_SCTP:
  49                 return SCTP_V4_FLOW;
  50         case ICE_FLTR_PTYPE_NONF_IPV4_OTHER:
  51                 return IPV4_USER_FLOW;
  52         case ICE_FLTR_PTYPE_NONF_IPV6_TCP:
  53                 return TCP_V6_FLOW;
  54         case ICE_FLTR_PTYPE_NONF_IPV6_UDP:
  55                 return UDP_V6_FLOW;
  56         case ICE_FLTR_PTYPE_NONF_IPV6_SCTP:
  57                 return SCTP_V6_FLOW;
  58         case ICE_FLTR_PTYPE_NONF_IPV6_OTHER:
  59                 return IPV6_USER_FLOW;
  60         default:
  61                 /* 0 is undefined ethtool flow */
  62                 return 0;
  63         }
  64 }
  65
  66 /**
  67  * ice_ethtool_flow_to_fltr - convert ethtool flow type to filter enum
  68  * @eth: Ethtool flow type to be converted
  69  *
  70  * Returns flow enum
  71  */
  72 static enum ice_fltr_ptype ice_ethtool_flow_to_fltr(int eth)
  73 {
  74         switch (eth) {
  75         case TCP_V4_FLOW:
  76                 return ICE_FLTR_PTYPE_NONF_IPV4_TCP;
  77         case UDP_V4_FLOW:
  78                 return ICE_FLTR_PTYPE_NONF_IPV4_UDP;
  79         case SCTP_V4_FLOW:
  80                 return ICE_FLTR_PTYPE_NONF_IPV4_SCTP;
  81         case IPV4_USER_FLOW:
  82                 return ICE_FLTR_PTYPE_NONF_IPV4_OTHER;
  83         case TCP_V6_FLOW:
  84                 return ICE_FLTR_PTYPE_NONF_IPV6_TCP;
  85         case UDP_V6_FLOW:
  86                 return ICE_FLTR_PTYPE_NONF_IPV6_UDP;
  87         case SCTP_V6_FLOW:
  88                 return ICE_FLTR_PTYPE_NONF_IPV6_SCTP;
  89         case IPV6_USER_FLOW:
  90                 return ICE_FLTR_PTYPE_NONF_IPV6_OTHER;
  91         default:
  92                 return ICE_FLTR_PTYPE_NONF_NONE;
  93         }
  94 }
  95
  96 /**
  97  * ice_is_mask_valid - check mask field set
  98  * @mask: full mask to check
  99  * @field: field for which mask should be valid
 100  *
 101  * If the mask is fully set return true. If it is not valid for field return
 102  * false.
 103  */
 104 static bool ice_is_mask_valid(u64 mask, u64 field)
 105 {
 106         return (mask & field) == field;
 107 }
 108
 109 /**
 110  * ice_get_ethtool_fdir_entry - fill ethtool structure with fdir filter data
 111  * @hw: hardware structure that contains filter list
 112  * @cmd: ethtool command data structure to receive the filter data
 113  *
 114  * Returns 0 on success and -EINVAL on failure
 115  */
 116 int ice_get_ethtool_fdir_entry(struct ice_hw *hw, struct ethtool_rxnfc *cmd)
 117 {
 118         struct ethtool_rx_flow_spec *fsp;
 119         struct ice_fdir_fltr *rule;
 120         int ret = 0;
 121         u16 idx;
 122
 123         fsp = (struct ethtool_rx_flow_spec *)&cmd->fs;
 124
 125         mutex_lock(&hw->fdir_fltr_lock);
 126
 127         rule = ice_fdir_find_fltr_by_idx(hw, fsp->location);
 128
 129         if (!rule || fsp->location != rule->fltr_id) {
 130                 ret = -EINVAL;
 131                 goto release_lock;
 132         }
 133
 134         fsp->flow_type = ice_fltr_to_ethtool_flow(rule->flow_type);
 135
 136         memset(&fsp->m_u, 0, sizeof(fsp->m_u));
 137         memset(&fsp->m_ext, 0, sizeof(fsp->m_ext));
 138
 139         switch (fsp->flow_type) {
 140         case IPV4_USER_FLOW:
 141                 fsp->h_u.usr_ip4_spec.ip_ver = ETH_RX_NFC_IP4;
 142                 fsp->h_u.usr_ip4_spec.proto = 0;
 143                 fsp->h_u.usr_ip4_spec.l4_4_bytes = rule->ip.v4.l4_header;
 144                 fsp->h_u.usr_ip4_spec.tos = rule->ip.v4.tos;
 145                 fsp->h_u.usr_ip4_spec.ip4src = rule->ip.v4.src_ip;
 146                 fsp->h_u.usr_ip4_spec.ip4dst = rule->ip.v4.dst_ip;
 147                 fsp->m_u.usr_ip4_spec.ip4src = rule->mask.v4.src_ip;
 148                 fsp->m_u.usr_ip4_spec.ip4dst = rule->mask.v4.dst_ip;
 149                 fsp->m_u.usr_ip4_spec.ip_ver = 0xFF;
 150                 fsp->m_u.usr_ip4_spec.proto = 0;
 151                 fsp->m_u.usr_ip4_spec.l4_4_bytes = rule->mask.v4.l4_header;
 152                 fsp->m_u.usr_ip4_spec.tos = rule->mask.v4.tos;
 153                 break;
 154         case TCP_V4_FLOW:
 155         case UDP_V4_FLOW:
 156         case SCTP_V4_FLOW:
 157                 fsp->h_u.tcp_ip4_spec.psrc = rule->ip.v4.src_port;
 158                 fsp->h_u.tcp_ip4_spec.pdst = rule->ip.v4.dst_port;
 159                 fsp->h_u.tcp_ip4_spec.ip4src = rule->ip.v4.src_ip;
 160                 fsp->h_u.tcp_ip4_spec.ip4dst = rule->ip.v4.dst_ip;
 161                 fsp->m_u.tcp_ip4_spec.psrc = rule->mask.v4.src_port;
 162                 fsp->m_u.tcp_ip4_spec.pdst = rule->mask.v4.dst_port;
 163                 fsp->m_u.tcp_ip4_spec.ip4src = rule->mask.v4.src_ip;
 164                 fsp->m_u.tcp_ip4_spec.ip4dst = rule->mask.v4.dst_ip;
 165                 break;
 166         case IPV6_USER_FLOW:
 167                 fsp->h_u.usr_ip6_spec.l4_4_bytes = rule->ip.v6.l4_header;
 168                 fsp->h_u.usr_ip6_spec.tclass = rule->ip.v6.tc;
 169                 fsp->h_u.usr_ip6_spec.l4_proto = rule->ip.v6.proto;
 170                 memcpy(fsp->h_u.tcp_ip6_spec.ip6src, rule->ip.v6.src_ip,
 171                        sizeof(struct in6_addr));
 172                 memcpy(fsp->h_u.tcp_ip6_spec.ip6dst, rule->ip.v6.dst_ip,
 173                        sizeof(struct in6_addr));
 174                 memcpy(fsp->m_u.tcp_ip6_spec.ip6src, rule->mask.v6.src_ip,
 175                        sizeof(struct in6_addr));
 176                 memcpy(fsp->m_u.tcp_ip6_spec.ip6dst, rule->mask.v6.dst_ip,
 177                        sizeof(struct in6_addr));
 178                 fsp->m_u.usr_ip6_spec.l4_4_bytes = rule->mask.v6.l4_header;
 179                 fsp->m_u.usr_ip6_spec.tclass = rule->mask.v6.tc;
 180                 fsp->m_u.usr_ip6_spec.l4_proto = rule->mask.v6.proto;
 181                 break;
 182         case TCP_V6_FLOW:
 183         case UDP_V6_FLOW:
 184         case SCTP_V6_FLOW:
 185                 memcpy(fsp->h_u.tcp_ip6_spec.ip6src, rule->ip.v6.src_ip,
 186                        sizeof(struct in6_addr));
 187                 memcpy(fsp->h_u.tcp_ip6_spec.ip6dst, rule->ip.v6.dst_ip,
 188                        sizeof(struct in6_addr));
 189                 fsp->h_u.tcp_ip6_spec.psrc = rule->ip.v6.src_port;
 190                 fsp->h_u.tcp_ip6_spec.pdst = rule->ip.v6.dst_port;
 191                 memcpy(fsp->m_u.tcp_ip6_spec.ip6src,
 192                        rule->mask.v6.src_ip,
 193                        sizeof(struct in6_addr));
 194                 memcpy(fsp->m_u.tcp_ip6_spec.ip6dst,
 195                        rule->mask.v6.dst_ip,
 196                        sizeof(struct in6_addr));
 197                 fsp->m_u.tcp_ip6_spec.psrc = rule->mask.v6.src_port;
 198                 fsp->m_u.tcp_ip6_spec.pdst = rule->mask.v6.dst_port;
 199                 fsp->h_u.tcp_ip6_spec.tclass = rule->ip.v6.tc;
 200                 fsp->m_u.tcp_ip6_spec.tclass = rule->mask.v6.tc;
 201                 break;
 202         default:
 203                 break;
 204         }
 205
 206         if (rule->dest_ctl == ICE_FLTR_PRGM_DESC_DEST_DROP_PKT)
 207                 fsp->ring_cookie = RX_CLS_FLOW_DISC;
 208         else
 209                 fsp->ring_cookie = rule->orig_q_index;
 210
 211         idx = ice_ethtool_flow_to_fltr(fsp->flow_type);
 212         if (idx == ICE_FLTR_PTYPE_NONF_NONE) {
 213                 dev_err(ice_hw_to_dev(hw), "Missing input index for flow_type %d\n",
 214                         rule->flow_type);
 215                 ret = -EINVAL;
 216         }
 217
 218 release_lock:
 219         mutex_unlock(&hw->fdir_fltr_lock);
 220         return ret;
 221 }
 222
 223 /**
 224  * ice_get_fdir_fltr_ids - fill buffer with filter IDs of active filters
 225  * @hw: hardware structure containing the filter list
 226  * @cmd: ethtool command data structure
 227  * @rule_locs: ethtool array passed in from OS to receive filter IDs
 228  *
 229  * Returns 0 as expected for success by ethtool
 230  */
 231 int
 232 ice_get_fdir_fltr_ids(struct ice_hw *hw, struct ethtool_rxnfc *cmd,
 233                       u32 *rule_locs)
 234 {
 235         struct ice_fdir_fltr *f_rule;
 236         unsigned int cnt = 0;
 237         int val = 0;
 238
 239         /* report total rule count */
 240         cmd->data = ice_get_fdir_cnt_all(hw);
 241
 242         mutex_lock(&hw->fdir_fltr_lock);
 243
 244         list_for_each_entry(f_rule, &hw->fdir_list_head, fltr_node) {
 245                 if (cnt == cmd->rule_cnt) {
 246                         val = -EMSGSIZE;
 247                         goto release_lock;
 248                 }
 249                 rule_locs[cnt] = f_rule->fltr_id;
 250                 cnt++;
 251         }
 252
 253 release_lock:
 254         mutex_unlock(&hw->fdir_fltr_lock);
 255         if (!val)
 256                 cmd->rule_cnt = cnt;
 257         return val;
 258 }
 259
 260 /**
 261  * ice_fdir_remap_entries - update the FDir entries in profile
 262  * @prof: FDir structure pointer
 263  * @tun: tunneled or non-tunneled packet
 264  * @idx: FDir entry index
 265  */
 266 static void
 267 ice_fdir_remap_entries(struct ice_fd_hw_prof *prof, int tun, int idx)
 268 {
 269         if (idx != prof->cnt && tun < ICE_FD_HW_SEG_MAX) {
 270                 int i;
 271
 272                 for (i = idx; i < (prof->cnt - 1); i++) {
 273                         u64 old_entry_h;
 274
 275                         old_entry_h = prof->entry_h[i + 1][tun];
 276                         prof->entry_h[i][tun] = old_entry_h;
 277                         prof->vsi_h[i] = prof->vsi_h[i + 1];
 278                 }
 279
 280                 prof->entry_h[i][tun] = 0;
 281                 prof->vsi_h[i] = 0;
 282         }
 283 }
 284
 285 /**
 286  * ice_fdir_rem_adq_chnl - remove an ADQ channel from HW filter rules
 287  * @hw: hardware structure containing filter list
 288  * @vsi_idx: VSI handle
 289  */
 290 void ice_fdir_rem_adq_chnl(struct ice_hw *hw, u16 vsi_idx)
 291 {
 292         int status, flow;
 293
 294         if (!hw->fdir_prof)
 295                 return;
 296
 297         for (flow = 0; flow < ICE_FLTR_PTYPE_MAX; flow++) {
 298                 struct ice_fd_hw_prof *prof = hw->fdir_prof[flow];
 299                 int tun, i;
 300
 301                 if (!prof || !prof->cnt)
 302                         continue;
 303
 304                 for (tun = 0; tun < ICE_FD_HW_SEG_MAX; tun++) {
 305                         u64 prof_id;
 306
 307                         prof_id = flow + tun * ICE_FLTR_PTYPE_MAX;
 308
 309                         for (i = 0; i < prof->cnt; i++) {
 310                                 if (prof->vsi_h[i] != vsi_idx)
 311                                         continue;
 312
 313                                 prof->entry_h[i][tun] = 0;
 314                                 prof->vsi_h[i] = 0;
 315                                 break;
 316                         }
 317
 318                         /* after clearing FDir entries update the remaining */
 319                         ice_fdir_remap_entries(prof, tun, i);
 320
 321                         /* find flow profile corresponding to prof_id and clear
 322                          * vsi_idx from bitmap.
 323                          */
 324                         status = ice_flow_rem_vsi_prof(hw, vsi_idx, prof_id);
 325                         if (status) {
 326                                 dev_err(ice_hw_to_dev(hw), "ice_flow_rem_vsi_prof() failed status=%d\n",
 327                                         status);
 328                         }
 329                 }
 330                 prof->cnt--;
 331         }
 332 }
 333
 334 /**
 335  * ice_fdir_get_hw_prof - return the ice_fd_hw_proc associated with a flow
 336  * @hw: hardware structure containing the filter list
 337  * @blk: hardware block
 338  * @flow: FDir flow type to release
 339  */
 340 static struct ice_fd_hw_prof *
 341 ice_fdir_get_hw_prof(struct ice_hw *hw, enum ice_block blk, int flow)
 342 {
 343         if (blk == ICE_BLK_FD && hw->fdir_prof)
 344                 return hw->fdir_prof[flow];
 345
 346         return NULL;
 347 }
 348
 349 /**
 350  * ice_fdir_erase_flow_from_hw - remove a flow from the HW profile tables
 351  * @hw: hardware structure containing the filter list
 352  * @blk: hardware block
 353  * @flow: FDir flow type to release
 354  */
 355 static void
 356 ice_fdir_erase_flow_from_hw(struct ice_hw *hw, enum ice_block blk, int flow)
 357 {
 358         struct ice_fd_hw_prof *prof = ice_fdir_get_hw_prof(hw, blk, flow);
 359         int tun;
 360
 361         if (!prof)
 362                 return;
 363
 364         for (tun = 0; tun < ICE_FD_HW_SEG_MAX; tun++) {
 365                 u64 prof_id;
 366                 int j;
 367
 368                 prof_id = flow + tun * ICE_FLTR_PTYPE_MAX;
 369                 for (j = 0; j < prof->cnt; j++) {
 370                         u16 vsi_num;
 371
 372                         if (!prof->entry_h[j][tun] || !prof->vsi_h[j])
 373                                 continue;
 374                         vsi_num = ice_get_hw_vsi_num(hw, prof->vsi_h[j]);
 375                         ice_rem_prof_id_flow(hw, blk, vsi_num, prof_id);
 376                         ice_flow_rem_entry(hw, blk, prof->entry_h[j][tun]);
 377                         prof->entry_h[j][tun] = 0;
 378                 }
 379                 ice_flow_rem_prof(hw, blk, prof_id);
 380         }
 381 }
 382
 383 /**
 384  * ice_fdir_rem_flow - release the ice_flow structures for a filter type
 385  * @hw: hardware structure containing the filter list
 386  * @blk: hardware block
 387  * @flow_type: FDir flow type to release
 388  */
 389 static void
 390 ice_fdir_rem_flow(struct ice_hw *hw, enum ice_block blk,
 391                   enum ice_fltr_ptype flow_type)
 392 {
 393         int flow = (int)flow_type & ~FLOW_EXT;
 394         struct ice_fd_hw_prof *prof;
 395         int tun, i;
 396
 397         prof = ice_fdir_get_hw_prof(hw, blk, flow);
 398         if (!prof)
 399                 return;
 400
 401         ice_fdir_erase_flow_from_hw(hw, blk, flow);
 402         for (i = 0; i < prof->cnt; i++)
 403                 prof->vsi_h[i] = 0;
 404         for (tun = 0; tun < ICE_FD_HW_SEG_MAX; tun++) {
 405                 if (!prof->fdir_seg[tun])
 406                         continue;
 407                 devm_kfree(ice_hw_to_dev(hw), prof->fdir_seg[tun]);
 408                 prof->fdir_seg[tun] = NULL;
 409         }
 410         prof->cnt = 0;
 411 }
 412
 413 /**
 414  * ice_fdir_release_flows - release all flows in use for later replay
 415  * @hw: pointer to HW instance
 416  */
 417 void ice_fdir_release_flows(struct ice_hw *hw)
 418 {
 419         int flow;
 420
 421         /* release Flow Director HW table entries */
 422         for (flow = 0; flow < ICE_FLTR_PTYPE_MAX; flow++)
 423                 ice_fdir_erase_flow_from_hw(hw, ICE_BLK_FD, flow);
 424 }
 425
 426 /**
 427  * ice_fdir_replay_flows - replay HW Flow Director filter info
 428  * @hw: pointer to HW instance
 429  */
 430 void ice_fdir_replay_flows(struct ice_hw *hw)
 431 {
 432         int flow;
 433
 434         for (flow = 0; flow < ICE_FLTR_PTYPE_MAX; flow++) {
 435                 int tun;
 436
 437                 if (!hw->fdir_prof[flow] || !hw->fdir_prof[flow]->cnt)
 438                         continue;
 439                 for (tun = 0; tun < ICE_FD_HW_SEG_MAX; tun++) {
 440                         struct ice_flow_prof *hw_prof;
 441                         struct ice_fd_hw_prof *prof;
 442                         u64 prof_id;
 443                         int j;
 444
 445                         prof = hw->fdir_prof[flow];
 446                         prof_id = flow + tun * ICE_FLTR_PTYPE_MAX;
 447                         ice_flow_add_prof(hw, ICE_BLK_FD, ICE_FLOW_RX, prof_id,
 448                                           prof->fdir_seg[tun], TNL_SEG_CNT(tun),
 449                                           &hw_prof);
 450                         for (j = 0; j < prof->cnt; j++) {
 451                                 enum ice_flow_priority prio;
 452                                 u64 entry_h = 0;
 453                                 int err;
 454
 455                                 prio = ICE_FLOW_PRIO_NORMAL;
 456                                 err = ice_flow_add_entry(hw, ICE_BLK_FD,
 457                                                          prof_id,
 458                                                          prof->vsi_h[0],
 459                                                          prof->vsi_h[j],
 460                                                          prio, prof->fdir_seg,
 461                                                          &entry_h);
 462                                 if (err) {
 463                                         dev_err(ice_hw_to_dev(hw), "Could not replay Flow Director, flow type %d\n",
 464                                                 flow);
 465                                         continue;
 466                                 }
 467                                 prof->entry_h[j][tun] = entry_h;
 468                         }
 469                 }
 470         }
 471 }
 472
 473 /**
 474  * ice_parse_rx_flow_user_data - deconstruct user-defined data
 475  * @fsp: pointer to ethtool Rx flow specification
 476  * @data: pointer to userdef data structure for storage
 477  *
 478  * Returns 0 on success, negative error value on failure
 479  */
 480 static int
 481 ice_parse_rx_flow_user_data(struct ethtool_rx_flow_spec *fsp,
 482                             struct ice_rx_flow_userdef *data)
 483 {
 484         u64 value, mask;
 485
 486         memset(data, 0, sizeof(*data));
 487         if (!(fsp->flow_type & FLOW_EXT))
 488                 return 0;
 489
 490         value = be64_to_cpu(*((__force __be64 *)fsp->h_ext.data));
 491         mask = be64_to_cpu(*((__force __be64 *)fsp->m_ext.data));
 492         if (!mask)
 493                 return 0;
 494
 495 #define ICE_USERDEF_FLEX_WORD_M GENMASK_ULL(15, 0)
 496 #define ICE_USERDEF_FLEX_OFFS_S 16
 497 #define ICE_USERDEF_FLEX_OFFS_M GENMASK_ULL(31, ICE_USERDEF_FLEX_OFFS_S)
 498 #define ICE_USERDEF_FLEX_FLTR_M GENMASK_ULL(31, 0)
 499
 500         /* 0x1fe is the maximum value for offsets stored in the internal
 501          * filtering tables.
 502          */
 503 #define ICE_USERDEF_FLEX_MAX_OFFS_VAL 0x1fe
 504
 505         if (!ice_is_mask_valid(mask, ICE_USERDEF_FLEX_FLTR_M) ||
 506             value > ICE_USERDEF_FLEX_FLTR_M)
 507                 return -EINVAL;
 508
 509         data->flex_word = value & ICE_USERDEF_FLEX_WORD_M;
 510         data->flex_offset = (value & ICE_USERDEF_FLEX_OFFS_M) >>
 511                              ICE_USERDEF_FLEX_OFFS_S;
 512         if (data->flex_offset > ICE_USERDEF_FLEX_MAX_OFFS_VAL)
 513                 return -EINVAL;
 514
 515         data->flex_fltr = true;
 516
 517         return 0;
 518 }
 519
 520 /**
 521  * ice_fdir_num_avail_fltr - return the number of unused flow director filters
 522  * @hw: pointer to hardware structure
 523  * @vsi: software VSI structure
 524  *
 525  * There are 2 filter pools: guaranteed and best effort(shared). Each VSI can
 526  * use filters from either pool. The guaranteed pool is divided between VSIs.
 527  * The best effort filter pool is common to all VSIs and is a device shared
 528  * resource pool. The number of filters available to this VSI is the sum of
 529  * the VSIs guaranteed filter pool and the global available best effort
 530  * filter pool.
 531  *
 532  * Returns the number of available flow director filters to this VSI
 533  */
 534 static int ice_fdir_num_avail_fltr(struct ice_hw *hw, struct ice_vsi *vsi)
 535 {
 536         u16 vsi_num = ice_get_hw_vsi_num(hw, vsi->idx);
 537         u16 num_guar;
 538         u16 num_be;
 539
 540         /* total guaranteed filters assigned to this VSI */
 541         num_guar = vsi->num_gfltr;
 542
 543         /* minus the guaranteed filters programed by this VSI */
 544         num_guar -= (rd32(hw, VSIQF_FD_CNT(vsi_num)) &
 545                      VSIQF_FD_CNT_FD_GCNT_M) >> VSIQF_FD_CNT_FD_GCNT_S;
 546
 547         /* total global best effort filters */
 548         num_be = hw->func_caps.fd_fltr_best_effort;
 549
 550         /* minus the global best effort filters programmed */
 551         num_be -= (rd32(hw, GLQF_FD_CNT) & GLQF_FD_CNT_FD_BCNT_M) >>
 552                    GLQF_FD_CNT_FD_BCNT_S;
 553
 554         return num_guar + num_be;
 555 }
 556
 557 /**
 558  * ice_fdir_alloc_flow_prof - allocate FDir flow profile structure(s)
 559  * @hw: HW structure containing the FDir flow profile structure(s)
 560  * @flow: flow type to allocate the flow profile for
 561  *
 562  * Allocate the fdir_prof and fdir_prof[flow] if not already created. Return 0
 563  * on success and negative on error.
 564  */
 565 static int
 566 ice_fdir_alloc_flow_prof(struct ice_hw *hw, enum ice_fltr_ptype flow)
 567 {
 568         if (!hw)
 569                 return -EINVAL;
 570
 571         if (!hw->fdir_prof) {
 572                 hw->fdir_prof = devm_kcalloc(ice_hw_to_dev(hw),
 573                                              ICE_FLTR_PTYPE_MAX,
 574                                              sizeof(*hw->fdir_prof),
 575                                              GFP_KERNEL);
 576                 if (!hw->fdir_prof)
 577                         return -ENOMEM;
 578         }
 579
 580         if (!hw->fdir_prof[flow]) {
 581                 hw->fdir_prof[flow] = devm_kzalloc(ice_hw_to_dev(hw),
 582                                                    sizeof(**hw->fdir_prof),
 583                                                    GFP_KERNEL);
 584                 if (!hw->fdir_prof[flow])
 585                         return -ENOMEM;
 586         }
 587
 588         return 0;
 589 }
 590
 591 /**
 592  * ice_fdir_prof_vsi_idx - find or insert a vsi_idx in structure
 593  * @prof: pointer to flow director HW profile
 594  * @vsi_idx: vsi_idx to locate
 595  *
 596  * return the index of the vsi_idx. if vsi_idx is not found insert it
 597  * into the vsi_h table.
 598  */
 599 static u16
 600 ice_fdir_prof_vsi_idx(struct ice_fd_hw_prof *prof, int vsi_idx)
 601 {
 602         u16 idx = 0;
 603
 604         for (idx = 0; idx < prof->cnt; idx++)
 605                 if (prof->vsi_h[idx] == vsi_idx)
 606                         return idx;
 607
 608         if (idx == prof->cnt)
 609                 prof->vsi_h[prof->cnt++] = vsi_idx;
 610         return idx;
 611 }
 612
 613 /**
 614  * ice_fdir_set_hw_fltr_rule - Configure HW tables to generate a FDir rule
 615  * @pf: pointer to the PF structure
 616  * @seg: protocol header description pointer
 617  * @flow: filter enum
 618  * @tun: FDir segment to program
 619  */
 620 static int
 621 ice_fdir_set_hw_fltr_rule(struct ice_pf *pf, struct ice_flow_seg_info *seg,
 622                           enum ice_fltr_ptype flow, enum ice_fd_hw_seg tun)
 623 {
 624         struct device *dev = ice_pf_to_dev(pf);
 625         struct ice_vsi *main_vsi, *ctrl_vsi;
 626         struct ice_flow_seg_info *old_seg;
 627         struct ice_flow_prof *prof = NULL;
 628         struct ice_fd_hw_prof *hw_prof;
 629         struct ice_hw *hw = &pf->hw;
 630         u64 entry1_h = 0;
 631         u64 entry2_h = 0;
 632         bool del_last;
 633         u64 prof_id;
 634         int err;
 635         int idx;
 636
 637         main_vsi = ice_get_main_vsi(pf);
 638         if (!main_vsi)
 639                 return -EINVAL;
 640
 641         ctrl_vsi = ice_get_ctrl_vsi(pf);
 642         if (!ctrl_vsi)
 643                 return -EINVAL;
 644
 645         err = ice_fdir_alloc_flow_prof(hw, flow);
 646         if (err)
 647                 return err;
 648
 649         hw_prof = hw->fdir_prof[flow];
 650         old_seg = hw_prof->fdir_seg[tun];
 651         if (old_seg) {
 652                 /* This flow_type already has a changed input set.
 653                  * If it matches the requested input set then we are
 654                  * done. Or, if it's different then it's an error.
 655                  */
 656                 if (!memcmp(old_seg, seg, sizeof(*seg)))
 657                         return -EEXIST;
 658
 659                 /* if there are FDir filters using this flow,
 660                  * then return error.
 661                  */
 662                 if (hw->fdir_fltr_cnt[flow]) {
 663                         dev_err(dev, "Failed to add filter.  Flow director filters on each port must have the same input set.\n");
 664                         return -EINVAL;
 665                 }
 666
 667                 if (ice_is_arfs_using_perfect_flow(hw, flow)) {
 668                         dev_err(dev, "aRFS using perfect flow type %d, cannot change input set\n",
 669                                 flow);
 670                         return -EINVAL;
 671                 }
 672
 673                 /* remove HW filter definition */
 674                 ice_fdir_rem_flow(hw, ICE_BLK_FD, flow);
 675         }
 676
 677         /* Adding a profile, but there is only one header supported.
 678          * That is the final parameters are 1 header (segment), no
 679          * actions (NULL) and zero actions 0.
 680          */
 681         prof_id = flow + tun * ICE_FLTR_PTYPE_MAX;
 682         err = ice_flow_add_prof(hw, ICE_BLK_FD, ICE_FLOW_RX, prof_id, seg,
 683                                 TNL_SEG_CNT(tun), &prof);
 684         if (err)
 685                 return err;
 686         err = ice_flow_add_entry(hw, ICE_BLK_FD, prof_id, main_vsi->idx,
 687                                  main_vsi->idx, ICE_FLOW_PRIO_NORMAL,
 688                                  seg, &entry1_h);
 689         if (err)
 690                 goto err_prof;
 691         err = ice_flow_add_entry(hw, ICE_BLK_FD, prof_id, main_vsi->idx,
 692                                  ctrl_vsi->idx, ICE_FLOW_PRIO_NORMAL,
 693                                  seg, &entry2_h);
 694         if (err)
 695                 goto err_entry;
 696
 697         hw_prof->fdir_seg[tun] = seg;
 698         hw_prof->entry_h[0][tun] = entry1_h;
 699         hw_prof->entry_h[1][tun] = entry2_h;
 700         hw_prof->vsi_h[0] = main_vsi->idx;
 701         hw_prof->vsi_h[1] = ctrl_vsi->idx;
 702         if (!hw_prof->cnt)
 703                 hw_prof->cnt = 2;
 704
 705         for (idx = 1; idx < ICE_CHNL_MAX_TC; idx++) {
 706                 u16 vsi_idx;
 707                 u16 vsi_h;
 708
 709                 if (!ice_is_adq_active(pf) || !main_vsi->tc_map_vsi[idx])
 710                         continue;
 711
 712                 entry1_h = 0;
 713                 vsi_h = main_vsi->tc_map_vsi[idx]->idx;
 714                 err = ice_flow_add_entry(hw, ICE_BLK_FD, prof_id,
 715                                          main_vsi->idx, vsi_h,
 716                                          ICE_FLOW_PRIO_NORMAL, seg,
 717                                          &entry1_h);
 718                 if (err) {
 719                         dev_err(dev, "Could not add Channel VSI %d to flow group\n",
 720                                 idx);
 721                         goto err_unroll;
 722                 }
 723
 724                 vsi_idx = ice_fdir_prof_vsi_idx(hw_prof,
 725                                                 main_vsi->tc_map_vsi[idx]->idx);
 726                 hw_prof->entry_h[vsi_idx][tun] = entry1_h;
 727         }
 728
 729         return 0;
 730
 731 err_unroll:
 732         entry1_h = 0;
 733         hw_prof->fdir_seg[tun] = NULL;
 734
 735         /* The variable del_last will be used to determine when to clean up
 736          * the VSI group data. The VSI data is not needed if there are no
 737          * segments.
 738          */
 739         del_last = true;
 740         for (idx = 0; idx < ICE_FD_HW_SEG_MAX; idx++)
 741                 if (hw_prof->fdir_seg[idx]) {
 742                         del_last = false;
 743                         break;
 744                 }
 745
 746         for (idx = 0; idx < hw_prof->cnt; idx++) {
 747                 u16 vsi_num = ice_get_hw_vsi_num(hw, hw_prof->vsi_h[idx]);
 748
 749                 if (!hw_prof->entry_h[idx][tun])
 750                         continue;
 751                 ice_rem_prof_id_flow(hw, ICE_BLK_FD, vsi_num, prof_id);
 752                 ice_flow_rem_entry(hw, ICE_BLK_FD, hw_prof->entry_h[idx][tun]);
 753                 hw_prof->entry_h[idx][tun] = 0;
 754                 if (del_last)
 755                         hw_prof->vsi_h[idx] = 0;
 756         }
 757         if (del_last)
 758                 hw_prof->cnt = 0;
 759 err_entry:
 760         ice_rem_prof_id_flow(hw, ICE_BLK_FD,
 761                              ice_get_hw_vsi_num(hw, main_vsi->idx), prof_id);
 762         ice_flow_rem_entry(hw, ICE_BLK_FD, entry1_h);
 763 err_prof:
 764         ice_flow_rem_prof(hw, ICE_BLK_FD, prof_id);
 765         dev_err(dev, "Failed to add filter.  Flow director filters on each port must have the same input set.\n");
 766
 767         return err;
 768 }
 769
 770 /**
 771  * ice_set_init_fdir_seg
 772  * @seg: flow segment for programming
 773  * @l3_proto: ICE_FLOW_SEG_HDR_IPV4 or ICE_FLOW_SEG_HDR_IPV6
 774  * @l4_proto: ICE_FLOW_SEG_HDR_TCP or ICE_FLOW_SEG_HDR_UDP
 775  *
 776  * Set the configuration for perfect filters to the provided flow segment for
 777  * programming the HW filter. This is to be called only when initializing
 778  * filters as this function it assumes no filters exist.
 779  */
 780 static int
 781 ice_set_init_fdir_seg(struct ice_flow_seg_info *seg,
 782                       enum ice_flow_seg_hdr l3_proto,
 783                       enum ice_flow_seg_hdr l4_proto)
 784 {
 785         enum ice_flow_field src_addr, dst_addr, src_port, dst_port;
 786
 787         if (!seg)
 788                 return -EINVAL;
 789
 790         if (l3_proto == ICE_FLOW_SEG_HDR_IPV4) {
 791                 src_addr = ICE_FLOW_FIELD_IDX_IPV4_SA;
 792                 dst_addr = ICE_FLOW_FIELD_IDX_IPV4_DA;
 793         } else if (l3_proto == ICE_FLOW_SEG_HDR_IPV6) {
 794                 src_addr = ICE_FLOW_FIELD_IDX_IPV6_SA;
 795                 dst_addr = ICE_FLOW_FIELD_IDX_IPV6_DA;
 796         } else {
 797                 return -EINVAL;
 798         }
 799
 800         if (l4_proto == ICE_FLOW_SEG_HDR_TCP) {
 801                 src_port = ICE_FLOW_FIELD_IDX_TCP_SRC_PORT;
 802                 dst_port = ICE_FLOW_FIELD_IDX_TCP_DST_PORT;
 803         } else if (l4_proto == ICE_FLOW_SEG_HDR_UDP) {
 804                 src_port = ICE_FLOW_FIELD_IDX_UDP_SRC_PORT;
 805                 dst_port = ICE_FLOW_FIELD_IDX_UDP_DST_PORT;
 806         } else {
 807                 return -EINVAL;
 808         }
 809
 810         ICE_FLOW_SET_HDRS(seg, l3_proto | l4_proto);
 811
 812         /* IP source address */
 813         ice_flow_set_fld(seg, src_addr, ICE_FLOW_FLD_OFF_INVAL,
 814                          ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL, false);
 815
 816         /* IP destination address */
 817         ice_flow_set_fld(seg, dst_addr, ICE_FLOW_FLD_OFF_INVAL,
 818                          ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL, false);
 819
 820         /* Layer 4 source port */
 821         ice_flow_set_fld(seg, src_port, ICE_FLOW_FLD_OFF_INVAL,
 822                          ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL, false);
 823
 824         /* Layer 4 destination port */
 825         ice_flow_set_fld(seg, dst_port, ICE_FLOW_FLD_OFF_INVAL,
 826                          ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL, false);
 827
 828         return 0;
 829 }
 830
 831 /**
 832  * ice_create_init_fdir_rule
 833  * @pf: PF structure
 834  * @flow: filter enum
 835  *
 836  * Return error value or 0 on success.
 837  */
 838 static int
 839 ice_create_init_fdir_rule(struct ice_pf *pf, enum ice_fltr_ptype flow)
 840 {
 841         struct ice_flow_seg_info *seg, *tun_seg;
 842         struct device *dev = ice_pf_to_dev(pf);
 843         struct ice_hw *hw = &pf->hw;
 844         int ret;
 845
 846         /* if there is already a filter rule for kind return -EINVAL */
 847         if (hw->fdir_prof && hw->fdir_prof[flow] &&
 848             hw->fdir_prof[flow]->fdir_seg[0])
 849                 return -EINVAL;
 850
 851         seg = devm_kzalloc(dev, sizeof(*seg), GFP_KERNEL);
 852         if (!seg)
 853                 return -ENOMEM;
 854
 855         tun_seg = devm_kcalloc(dev, ICE_FD_HW_SEG_MAX, sizeof(*tun_seg),
 856                                GFP_KERNEL);
 857         if (!tun_seg) {
 858                 devm_kfree(dev, seg);
 859                 return -ENOMEM;
 860         }
 861
 862         if (flow == ICE_FLTR_PTYPE_NONF_IPV4_TCP)
 863                 ret = ice_set_init_fdir_seg(seg, ICE_FLOW_SEG_HDR_IPV4,
 864                                             ICE_FLOW_SEG_HDR_TCP);
 865         else if (flow == ICE_FLTR_PTYPE_NONF_IPV4_UDP)
 866                 ret = ice_set_init_fdir_seg(seg, ICE_FLOW_SEG_HDR_IPV4,
 867                                             ICE_FLOW_SEG_HDR_UDP);
 868         else if (flow == ICE_FLTR_PTYPE_NONF_IPV6_TCP)
 869                 ret = ice_set_init_fdir_seg(seg, ICE_FLOW_SEG_HDR_IPV6,
 870                                             ICE_FLOW_SEG_HDR_TCP);
 871         else if (flow == ICE_FLTR_PTYPE_NONF_IPV6_UDP)
 872                 ret = ice_set_init_fdir_seg(seg, ICE_FLOW_SEG_HDR_IPV6,
 873                                             ICE_FLOW_SEG_HDR_UDP);
 874         else
 875                 ret = -EINVAL;
 876         if (ret)
 877                 goto err_exit;
 878
 879         /* add filter for outer headers */
 880         ret = ice_fdir_set_hw_fltr_rule(pf, seg, flow, ICE_FD_HW_SEG_NON_TUN);
 881         if (ret)
 882                 /* could not write filter, free memory */
 883                 goto err_exit;
 884
 885         /* make tunneled filter HW entries if possible */
 886         memcpy(&tun_seg[1], seg, sizeof(*seg));
 887         ret = ice_fdir_set_hw_fltr_rule(pf, tun_seg, flow, ICE_FD_HW_SEG_TUN);
 888         if (ret)
 889                 /* could not write tunnel filter, but outer header filter
 890                  * exists
 891                  */
 892                 devm_kfree(dev, tun_seg);
 893
 894         set_bit(flow, hw->fdir_perfect_fltr);
 895         return ret;
 896 err_exit:
 897         devm_kfree(dev, tun_seg);
 898         devm_kfree(dev, seg);
 899
 900         return -EOPNOTSUPP;
 901 }
 902
 903 /**
 904  * ice_set_fdir_ip4_seg
 905  * @seg: flow segment for programming
 906  * @tcp_ip4_spec: mask data from ethtool
 907  * @l4_proto: Layer 4 protocol to program
 908  * @perfect_fltr: only valid on success; returns true if perfect filter,
 909  *                false if not
 910  *
 911  * Set the mask data into the flow segment to be used to program HW
 912  * table based on provided L4 protocol for IPv4
 913  */
 914 static int
 915 ice_set_fdir_ip4_seg(struct ice_flow_seg_info *seg,
 916                      struct ethtool_tcpip4_spec *tcp_ip4_spec,
 917                      enum ice_flow_seg_hdr l4_proto, bool *perfect_fltr)
 918 {
 919         enum ice_flow_field src_port, dst_port;
 920
 921         /* make sure we don't have any empty rule */
 922         if (!tcp_ip4_spec->psrc && !tcp_ip4_spec->ip4src &&
 923             !tcp_ip4_spec->pdst && !tcp_ip4_spec->ip4dst)
 924                 return -EINVAL;
 925
 926         /* filtering on TOS not supported */
 927         if (tcp_ip4_spec->tos)
 928                 return -EOPNOTSUPP;
 929
 930         if (l4_proto == ICE_FLOW_SEG_HDR_TCP) {
 931                 src_port = ICE_FLOW_FIELD_IDX_TCP_SRC_PORT;
 932                 dst_port = ICE_FLOW_FIELD_IDX_TCP_DST_PORT;
 933         } else if (l4_proto == ICE_FLOW_SEG_HDR_UDP) {
 934                 src_port = ICE_FLOW_FIELD_IDX_UDP_SRC_PORT;
 935                 dst_port = ICE_FLOW_FIELD_IDX_UDP_DST_PORT;
 936         } else if (l4_proto == ICE_FLOW_SEG_HDR_SCTP) {
 937                 src_port = ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT;
 938                 dst_port = ICE_FLOW_FIELD_IDX_SCTP_DST_PORT;
 939         } else {
 940                 return -EOPNOTSUPP;
 941         }
 942
 943         *perfect_fltr = true;
 944         ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_IPV4 | l4_proto);
 945
 946         /* IP source address */
 947         if (tcp_ip4_spec->ip4src == htonl(0xFFFFFFFF))
 948                 ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV4_SA,
 949                                  ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
 950                                  ICE_FLOW_FLD_OFF_INVAL, false);
 951         else if (!tcp_ip4_spec->ip4src)
 952                 *perfect_fltr = false;
 953         else
 954                 return -EOPNOTSUPP;
 955
 956         /* IP destination address */
 957         if (tcp_ip4_spec->ip4dst == htonl(0xFFFFFFFF))
 958                 ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV4_DA,
 959                                  ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
 960                                  ICE_FLOW_FLD_OFF_INVAL, false);
 961         else if (!tcp_ip4_spec->ip4dst)
 962                 *perfect_fltr = false;
 963         else
 964                 return -EOPNOTSUPP;
 965
 966         /* Layer 4 source port */
 967         if (tcp_ip4_spec->psrc == htons(0xFFFF))
 968                 ice_flow_set_fld(seg, src_port, ICE_FLOW_FLD_OFF_INVAL,
 969                                  ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
 970                                  false);
 971         else if (!tcp_ip4_spec->psrc)
 972                 *perfect_fltr = false;
 973         else
 974                 return -EOPNOTSUPP;
 975
 976         /* Layer 4 destination port */
 977         if (tcp_ip4_spec->pdst == htons(0xFFFF))
 978                 ice_flow_set_fld(seg, dst_port, ICE_FLOW_FLD_OFF_INVAL,
 979                                  ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
 980                                  false);
 981         else if (!tcp_ip4_spec->pdst)
 982                 *perfect_fltr = false;
 983         else
 984                 return -EOPNOTSUPP;
 985
 986         return 0;
 987 }
 988
 989 /**
 990  * ice_set_fdir_ip4_usr_seg
 991  * @seg: flow segment for programming
 992  * @usr_ip4_spec: ethtool userdef packet offset
 993  * @perfect_fltr: only valid on success; returns true if perfect filter,
 994  *                false if not
 995  *
 996  * Set the offset data into the flow segment to be used to program HW
 997  * table for IPv4
 998  */
 999 static int
1000 ice_set_fdir_ip4_usr_seg(struct ice_flow_seg_info *seg,
1001                          struct ethtool_usrip4_spec *usr_ip4_spec,
1002                          bool *perfect_fltr)
1003 {
1004         /* first 4 bytes of Layer 4 header */
1005         if (usr_ip4_spec->l4_4_bytes)
1006                 return -EINVAL;
1007         if (usr_ip4_spec->tos)
1008                 return -EINVAL;
1009         if (usr_ip4_spec->ip_ver)
1010                 return -EINVAL;
1011         /* Filtering on Layer 4 protocol not supported */
1012         if (usr_ip4_spec->proto)
1013                 return -EOPNOTSUPP;
1014         /* empty rules are not valid */
1015         if (!usr_ip4_spec->ip4src && !usr_ip4_spec->ip4dst)
1016                 return -EINVAL;
1017
1018         *perfect_fltr = true;
1019         ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_IPV4);
1020
1021         /* IP source address */
1022         if (usr_ip4_spec->ip4src == htonl(0xFFFFFFFF))
1023                 ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV4_SA,
1024                                  ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1025                                  ICE_FLOW_FLD_OFF_INVAL, false);
1026         else if (!usr_ip4_spec->ip4src)
1027                 *perfect_fltr = false;
1028         else
1029                 return -EOPNOTSUPP;
1030
1031         /* IP destination address */
1032         if (usr_ip4_spec->ip4dst == htonl(0xFFFFFFFF))
1033                 ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV4_DA,
1034                                  ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1035                                  ICE_FLOW_FLD_OFF_INVAL, false);
1036         else if (!usr_ip4_spec->ip4dst)
1037                 *perfect_fltr = false;
1038         else
1039                 return -EOPNOTSUPP;
1040
1041         return 0;
1042 }
1043
1044 /**
1045  * ice_set_fdir_ip6_seg
1046  * @seg: flow segment for programming
1047  * @tcp_ip6_spec: mask data from ethtool
1048  * @l4_proto: Layer 4 protocol to program
1049  * @perfect_fltr: only valid on success; returns true if perfect filter,
1050  *                false if not
1051  *
1052  * Set the mask data into the flow segment to be used to program HW
1053  * table based on provided L4 protocol for IPv6
1054  */
1055 static int
1056 ice_set_fdir_ip6_seg(struct ice_flow_seg_info *seg,
1057                      struct ethtool_tcpip6_spec *tcp_ip6_spec,
1058                      enum ice_flow_seg_hdr l4_proto, bool *perfect_fltr)
1059 {
1060         enum ice_flow_field src_port, dst_port;
1061
1062         /* make sure we don't have any empty rule */
1063         if (!memcmp(tcp_ip6_spec->ip6src, &zero_ipv6_addr_mask,
1064                     sizeof(struct in6_addr)) &&
1065             !memcmp(tcp_ip6_spec->ip6dst, &zero_ipv6_addr_mask,
1066                     sizeof(struct in6_addr)) &&
1067             !tcp_ip6_spec->psrc && !tcp_ip6_spec->pdst)
1068                 return -EINVAL;
1069
1070         /* filtering on TC not supported */
1071         if (tcp_ip6_spec->tclass)
1072                 return -EOPNOTSUPP;
1073
1074         if (l4_proto == ICE_FLOW_SEG_HDR_TCP) {
1075                 src_port = ICE_FLOW_FIELD_IDX_TCP_SRC_PORT;
1076                 dst_port = ICE_FLOW_FIELD_IDX_TCP_DST_PORT;
1077         } else if (l4_proto == ICE_FLOW_SEG_HDR_UDP) {
1078                 src_port = ICE_FLOW_FIELD_IDX_UDP_SRC_PORT;
1079                 dst_port = ICE_FLOW_FIELD_IDX_UDP_DST_PORT;
1080         } else if (l4_proto == ICE_FLOW_SEG_HDR_SCTP) {
1081                 src_port = ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT;
1082                 dst_port = ICE_FLOW_FIELD_IDX_SCTP_DST_PORT;
1083         } else {
1084                 return -EINVAL;
1085         }
1086
1087         *perfect_fltr = true;
1088         ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_IPV6 | l4_proto);
1089
1090         if (!memcmp(tcp_ip6_spec->ip6src, &full_ipv6_addr_mask,
1091                     sizeof(struct in6_addr)))
1092                 ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV6_SA,
1093                                  ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1094                                  ICE_FLOW_FLD_OFF_INVAL, false);
1095         else if (!memcmp(tcp_ip6_spec->ip6src, &zero_ipv6_addr_mask,
1096                          sizeof(struct in6_addr)))
1097                 *perfect_fltr = false;
1098         else
1099                 return -EOPNOTSUPP;
1100
1101         if (!memcmp(tcp_ip6_spec->ip6dst, &full_ipv6_addr_mask,
1102                     sizeof(struct in6_addr)))
1103                 ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV6_DA,
1104                                  ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1105                                  ICE_FLOW_FLD_OFF_INVAL, false);
1106         else if (!memcmp(tcp_ip6_spec->ip6dst, &zero_ipv6_addr_mask,
1107                          sizeof(struct in6_addr)))
1108                 *perfect_fltr = false;
1109         else
1110                 return -EOPNOTSUPP;
1111
1112         /* Layer 4 source port */
1113         if (tcp_ip6_spec->psrc == htons(0xFFFF))
1114                 ice_flow_set_fld(seg, src_port, ICE_FLOW_FLD_OFF_INVAL,
1115                                  ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1116                                  false);
1117         else if (!tcp_ip6_spec->psrc)
1118                 *perfect_fltr = false;
1119         else
1120                 return -EOPNOTSUPP;
1121
1122         /* Layer 4 destination port */
1123         if (tcp_ip6_spec->pdst == htons(0xFFFF))
1124                 ice_flow_set_fld(seg, dst_port, ICE_FLOW_FLD_OFF_INVAL,
1125                                  ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1126                                  false);
1127         else if (!tcp_ip6_spec->pdst)
1128                 *perfect_fltr = false;
1129         else
1130                 return -EOPNOTSUPP;
1131
1132         return 0;
1133 }
1134
1135 /**
1136  * ice_set_fdir_ip6_usr_seg
1137  * @seg: flow segment for programming
1138  * @usr_ip6_spec: ethtool userdef packet offset
1139  * @perfect_fltr: only valid on success; returns true if perfect filter,
1140  *                false if not
1141  *
1142  * Set the offset data into the flow segment to be used to program HW
1143  * table for IPv6
1144  */
1145 static int
1146 ice_set_fdir_ip6_usr_seg(struct ice_flow_seg_info *seg,
1147                          struct ethtool_usrip6_spec *usr_ip6_spec,
1148                          bool *perfect_fltr)
1149 {
1150         /* filtering on Layer 4 bytes not supported */
1151         if (usr_ip6_spec->l4_4_bytes)
1152                 return -EOPNOTSUPP;
1153         /* filtering on TC not supported */
1154         if (usr_ip6_spec->tclass)
1155                 return -EOPNOTSUPP;
1156         /* filtering on Layer 4 protocol not supported */
1157         if (usr_ip6_spec->l4_proto)
1158                 return -EOPNOTSUPP;
1159         /* empty rules are not valid */
1160         if (!memcmp(usr_ip6_spec->ip6src, &zero_ipv6_addr_mask,
1161                     sizeof(struct in6_addr)) &&
1162             !memcmp(usr_ip6_spec->ip6dst, &zero_ipv6_addr_mask,
1163                     sizeof(struct in6_addr)))
1164                 return -EINVAL;
1165
1166         *perfect_fltr = true;
1167         ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_IPV6);
1168
1169         if (!memcmp(usr_ip6_spec->ip6src, &full_ipv6_addr_mask,
1170                     sizeof(struct in6_addr)))
1171                 ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV6_SA,
1172                                  ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1173                                  ICE_FLOW_FLD_OFF_INVAL, false);
1174         else if (!memcmp(usr_ip6_spec->ip6src, &zero_ipv6_addr_mask,
1175                          sizeof(struct in6_addr)))
1176                 *perfect_fltr = false;
1177         else
1178                 return -EOPNOTSUPP;
1179
1180         if (!memcmp(usr_ip6_spec->ip6dst, &full_ipv6_addr_mask,
1181                     sizeof(struct in6_addr)))
1182                 ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV6_DA,
1183                                  ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1184                                  ICE_FLOW_FLD_OFF_INVAL, false);
1185         else if (!memcmp(usr_ip6_spec->ip6dst, &zero_ipv6_addr_mask,
1186                          sizeof(struct in6_addr)))
1187                 *perfect_fltr = false;
1188         else
1189                 return -EOPNOTSUPP;
1190
1191         return 0;
1192 }
1193
1194 /**
1195  * ice_cfg_fdir_xtrct_seq - Configure extraction sequence for the given filter
1196  * @pf: PF structure
1197  * @fsp: pointer to ethtool Rx flow specification
1198  * @user: user defined data from flow specification
1199  *
1200  * Returns 0 on success.
1201  */
1202 static int
1203 ice_cfg_fdir_xtrct_seq(struct ice_pf *pf, struct ethtool_rx_flow_spec *fsp,
1204                        struct ice_rx_flow_userdef *user)
1205 {
1206         struct ice_flow_seg_info *seg, *tun_seg;
1207         struct device *dev = ice_pf_to_dev(pf);
1208         enum ice_fltr_ptype fltr_idx;
1209         struct ice_hw *hw = &pf->hw;
1210         bool perfect_filter;
1211         int ret;
1212
1213         seg = devm_kzalloc(dev, sizeof(*seg), GFP_KERNEL);
1214         if (!seg)
1215                 return -ENOMEM;
1216
1217         tun_seg = devm_kcalloc(dev, ICE_FD_HW_SEG_MAX, sizeof(*tun_seg),
1218                                GFP_KERNEL);
1219         if (!tun_seg) {
1220                 devm_kfree(dev, seg);
1221                 return -ENOMEM;
1222         }
1223
1224         switch (fsp->flow_type & ~FLOW_EXT) {
1225         case TCP_V4_FLOW:
1226                 ret = ice_set_fdir_ip4_seg(seg, &fsp->m_u.tcp_ip4_spec,
1227                                            ICE_FLOW_SEG_HDR_TCP,
1228                                            &perfect_filter);
1229                 break;
1230         case UDP_V4_FLOW:
1231                 ret = ice_set_fdir_ip4_seg(seg, &fsp->m_u.tcp_ip4_spec,
1232                                            ICE_FLOW_SEG_HDR_UDP,
1233                                            &perfect_filter);
1234                 break;
1235         case SCTP_V4_FLOW:
1236                 ret = ice_set_fdir_ip4_seg(seg, &fsp->m_u.tcp_ip4_spec,
1237                                            ICE_FLOW_SEG_HDR_SCTP,
1238                                            &perfect_filter);
1239                 break;
1240         case IPV4_USER_FLOW:
1241                 ret = ice_set_fdir_ip4_usr_seg(seg, &fsp->m_u.usr_ip4_spec,
1242                                                &perfect_filter);
1243                 break;
1244         case TCP_V6_FLOW:
1245                 ret = ice_set_fdir_ip6_seg(seg, &fsp->m_u.tcp_ip6_spec,
1246                                            ICE_FLOW_SEG_HDR_TCP,
1247                                            &perfect_filter);
1248                 break;
1249         case UDP_V6_FLOW:
1250                 ret = ice_set_fdir_ip6_seg(seg, &fsp->m_u.tcp_ip6_spec,
1251                                            ICE_FLOW_SEG_HDR_UDP,
1252                                            &perfect_filter);
1253                 break;
1254         case SCTP_V6_FLOW:
1255                 ret = ice_set_fdir_ip6_seg(seg, &fsp->m_u.tcp_ip6_spec,
1256                                            ICE_FLOW_SEG_HDR_SCTP,
1257                                            &perfect_filter);
1258                 break;
1259         case IPV6_USER_FLOW:
1260                 ret = ice_set_fdir_ip6_usr_seg(seg, &fsp->m_u.usr_ip6_spec,
1261                                                &perfect_filter);
1262                 break;
1263         default:
1264                 ret = -EINVAL;
1265         }
1266         if (ret)
1267                 goto err_exit;
1268
1269         /* tunnel segments are shifted up one. */
1270         memcpy(&tun_seg[1], seg, sizeof(*seg));
1271
1272         if (user && user->flex_fltr) {
1273                 perfect_filter = false;
1274                 ice_flow_add_fld_raw(seg, user->flex_offset,
1275                                      ICE_FLTR_PRGM_FLEX_WORD_SIZE,
1276                                      ICE_FLOW_FLD_OFF_INVAL,
1277                                      ICE_FLOW_FLD_OFF_INVAL);
1278                 ice_flow_add_fld_raw(&tun_seg[1], user->flex_offset,
1279                                      ICE_FLTR_PRGM_FLEX_WORD_SIZE,
1280                                      ICE_FLOW_FLD_OFF_INVAL,
1281                                      ICE_FLOW_FLD_OFF_INVAL);
1282         }
1283
1284         /* add filter for outer headers */
1285         fltr_idx = ice_ethtool_flow_to_fltr(fsp->flow_type & ~FLOW_EXT);
1286         ret = ice_fdir_set_hw_fltr_rule(pf, seg, fltr_idx,
1287                                         ICE_FD_HW_SEG_NON_TUN);
1288         if (ret == -EEXIST)
1289                 /* Rule already exists, free memory and continue */
1290                 devm_kfree(dev, seg);
1291         else if (ret)
1292                 /* could not write filter, free memory */
1293                 goto err_exit;
1294
1295         /* make tunneled filter HW entries if possible */
1296         memcpy(&tun_seg[1], seg, sizeof(*seg));
1297         ret = ice_fdir_set_hw_fltr_rule(pf, tun_seg, fltr_idx,
1298                                         ICE_FD_HW_SEG_TUN);
1299         if (ret == -EEXIST) {
1300                 /* Rule already exists, free memory and count as success */
1301                 devm_kfree(dev, tun_seg);
1302                 ret = 0;
1303         } else if (ret) {
1304                 /* could not write tunnel filter, but outer filter exists */
1305                 devm_kfree(dev, tun_seg);
1306         }
1307
1308         if (perfect_filter)
1309                 set_bit(fltr_idx, hw->fdir_perfect_fltr);
1310         else
1311                 clear_bit(fltr_idx, hw->fdir_perfect_fltr);
1312
1313         return ret;
1314
1315 err_exit:
1316         devm_kfree(dev, tun_seg);
1317         devm_kfree(dev, seg);
1318
1319         return -EOPNOTSUPP;
1320 }
1321
1322 /**
1323  * ice_update_per_q_fltr
1324  * @vsi: ptr to VSI
1325  * @q_index: queue index
1326  * @inc: true to increment or false to decrement per queue filter count
1327  *
1328  * This function is used to keep track of per queue sideband filters
1329  */
1330 static void ice_update_per_q_fltr(struct ice_vsi *vsi, u32 q_index, bool inc)
1331 {
1332         struct ice_rx_ring *rx_ring;
1333
1334         if (!vsi->num_rxq || q_index >= vsi->num_rxq)
1335                 return;
1336
1337         rx_ring = vsi->rx_rings[q_index];
1338         if (!rx_ring || !rx_ring->ch)
1339                 return;
1340
1341         if (inc)
1342                 atomic_inc(&rx_ring->ch->num_sb_fltr);
1343         else
1344                 atomic_dec_if_positive(&rx_ring->ch->num_sb_fltr);
1345 }
1346
1347 /**
1348  * ice_fdir_write_fltr - send a flow director filter to the hardware
1349  * @pf: PF data structure
1350  * @input: filter structure
1351  * @add: true adds filter and false removed filter
1352  * @is_tun: true adds inner filter on tunnel and false outer headers
1353  *
1354  * returns 0 on success and negative value on error
1355  */
1356 int
1357 ice_fdir_write_fltr(struct ice_pf *pf, struct ice_fdir_fltr *input, bool add,
1358                     bool is_tun)
1359 {
1360         struct device *dev = ice_pf_to_dev(pf);
1361         struct ice_hw *hw = &pf->hw;
1362         struct ice_fltr_desc desc;
1363         struct ice_vsi *ctrl_vsi;
1364         u8 *pkt, *frag_pkt;
1365         bool has_frag;
1366         int err;
1367
1368         ctrl_vsi = ice_get_ctrl_vsi(pf);
1369         if (!ctrl_vsi)
1370                 return -EINVAL;
1371
1372         pkt = devm_kzalloc(dev, ICE_FDIR_MAX_RAW_PKT_SIZE, GFP_KERNEL);
1373         if (!pkt)
1374                 return -ENOMEM;
1375         frag_pkt = devm_kzalloc(dev, ICE_FDIR_MAX_RAW_PKT_SIZE, GFP_KERNEL);
1376         if (!frag_pkt) {
1377                 err = -ENOMEM;
1378                 goto err_free;
1379         }
1380
1381         ice_fdir_get_prgm_desc(hw, input, &desc, add);
1382         err = ice_fdir_get_gen_prgm_pkt(hw, input, pkt, false, is_tun);
1383         if (err)
1384                 goto err_free_all;
1385         err = ice_prgm_fdir_fltr(ctrl_vsi, &desc, pkt);
1386         if (err)
1387                 goto err_free_all;
1388
1389         /* repeat for fragment packet */
1390         has_frag = ice_fdir_has_frag(input->flow_type);
1391         if (has_frag) {
1392                 /* does not return error */
1393                 ice_fdir_get_prgm_desc(hw, input, &desc, add);
1394                 err = ice_fdir_get_gen_prgm_pkt(hw, input, frag_pkt, true,
1395                                                 is_tun);
1396                 if (err)
1397                         goto err_frag;
1398                 err = ice_prgm_fdir_fltr(ctrl_vsi, &desc, frag_pkt);
1399                 if (err)
1400                         goto err_frag;
1401         } else {
1402                 devm_kfree(dev, frag_pkt);
1403         }
1404
1405         return 0;
1406
1407 err_free_all:
1408         devm_kfree(dev, frag_pkt);
1409 err_free:
1410         devm_kfree(dev, pkt);
1411         return err;
1412
1413 err_frag:
1414         devm_kfree(dev, frag_pkt);
1415         return err;
1416 }
1417
1418 /**
1419  * ice_fdir_write_all_fltr - send a flow director filter to the hardware
1420  * @pf: PF data structure
1421  * @input: filter structure
1422  * @add: true adds filter and false removed filter
1423  *
1424  * returns 0 on success and negative value on error
1425  */
1426 static int
1427 ice_fdir_write_all_fltr(struct ice_pf *pf, struct ice_fdir_fltr *input,
1428                         bool add)
1429 {
1430         u16 port_num;
1431         int tun;
1432
1433         for (tun = 0; tun < ICE_FD_HW_SEG_MAX; tun++) {
1434                 bool is_tun = tun == ICE_FD_HW_SEG_TUN;
1435                 int err;
1436
1437                 if (is_tun && !ice_get_open_tunnel_port(&pf->hw, &port_num, TNL_ALL))
1438                         continue;
1439                 err = ice_fdir_write_fltr(pf, input, add, is_tun);
1440                 if (err)
1441                         return err;
1442         }
1443         return 0;
1444 }
1445
1446 /**
1447  * ice_fdir_replay_fltrs - replay filters from the HW filter list
1448  * @pf: board private structure
1449  */
1450 void ice_fdir_replay_fltrs(struct ice_pf *pf)
1451 {
1452         struct ice_fdir_fltr *f_rule;
1453         struct ice_hw *hw = &pf->hw;
1454
1455         list_for_each_entry(f_rule, &hw->fdir_list_head, fltr_node) {
1456                 int err = ice_fdir_write_all_fltr(pf, f_rule, true);
1457
1458                 if (err)
1459                         dev_dbg(ice_pf_to_dev(pf), "Flow Director error %d, could not reprogram filter %d\n",
1460                                 err, f_rule->fltr_id);
1461         }
1462 }
1463
1464 /**
1465  * ice_fdir_create_dflt_rules - create default perfect filters
1466  * @pf: PF data structure
1467  *
1468  * Returns 0 for success or error.
1469  */
1470 int ice_fdir_create_dflt_rules(struct ice_pf *pf)
1471 {
1472         int err;
1473
1474         /* Create perfect TCP and UDP rules in hardware. */
1475         err = ice_create_init_fdir_rule(pf, ICE_FLTR_PTYPE_NONF_IPV4_TCP);
1476         if (err)
1477                 return err;
1478
1479         err = ice_create_init_fdir_rule(pf, ICE_FLTR_PTYPE_NONF_IPV4_UDP);
1480         if (err)
1481                 return err;
1482
1483         err = ice_create_init_fdir_rule(pf, ICE_FLTR_PTYPE_NONF_IPV6_TCP);
1484         if (err)
1485                 return err;
1486
1487         err = ice_create_init_fdir_rule(pf, ICE_FLTR_PTYPE_NONF_IPV6_UDP);
1488
1489         return err;
1490 }
1491
1492 /**
1493  * ice_fdir_del_all_fltrs - Delete all flow director filters
1494  * @vsi: the VSI being changed
1495  *
1496  * This function needs to be called while holding hw->fdir_fltr_lock
1497  */
1498 void ice_fdir_del_all_fltrs(struct ice_vsi *vsi)
1499 {
1500         struct ice_fdir_fltr *f_rule, *tmp;
1501         struct ice_pf *pf = vsi->back;
1502         struct ice_hw *hw = &pf->hw;
1503
1504         list_for_each_entry_safe(f_rule, tmp, &hw->fdir_list_head, fltr_node) {
1505                 ice_fdir_write_all_fltr(pf, f_rule, false);
1506                 ice_fdir_update_cntrs(hw, f_rule->flow_type, false);
1507                 list_del(&f_rule->fltr_node);
1508                 devm_kfree(ice_pf_to_dev(pf), f_rule);
1509         }
1510 }
1511
1512 /**
1513  * ice_vsi_manage_fdir - turn on/off flow director
1514  * @vsi: the VSI being changed
1515  * @ena: boolean value indicating if this is an enable or disable request
1516  */
1517 void ice_vsi_manage_fdir(struct ice_vsi *vsi, bool ena)
1518 {
1519         struct ice_pf *pf = vsi->back;
1520         struct ice_hw *hw = &pf->hw;
1521         enum ice_fltr_ptype flow;
1522
1523         if (ena) {
1524                 set_bit(ICE_FLAG_FD_ENA, pf->flags);
1525                 ice_fdir_create_dflt_rules(pf);
1526                 return;
1527         }
1528
1529         mutex_lock(&hw->fdir_fltr_lock);
1530         if (!test_and_clear_bit(ICE_FLAG_FD_ENA, pf->flags))
1531                 goto release_lock;
1532
1533         ice_fdir_del_all_fltrs(vsi);
1534
1535         if (hw->fdir_prof)
1536                 for (flow = ICE_FLTR_PTYPE_NONF_NONE; flow < ICE_FLTR_PTYPE_MAX;
1537                      flow++)
1538                         if (hw->fdir_prof[flow])
1539                                 ice_fdir_rem_flow(hw, ICE_BLK_FD, flow);
1540
1541 release_lock:
1542         mutex_unlock(&hw->fdir_fltr_lock);
1543 }
1544
1545 /**
1546  * ice_fdir_do_rem_flow - delete flow and possibly add perfect flow
1547  * @pf: PF structure
1548  * @flow_type: FDir flow type to release
1549  */
1550 static void
1551 ice_fdir_do_rem_flow(struct ice_pf *pf, enum ice_fltr_ptype flow_type)
1552 {
1553         struct ice_hw *hw = &pf->hw;
1554         bool need_perfect = false;
1555
1556         if (flow_type == ICE_FLTR_PTYPE_NONF_IPV4_TCP ||
1557             flow_type == ICE_FLTR_PTYPE_NONF_IPV4_UDP ||
1558             flow_type == ICE_FLTR_PTYPE_NONF_IPV6_TCP ||
1559             flow_type == ICE_FLTR_PTYPE_NONF_IPV6_UDP)
1560                 need_perfect = true;
1561
1562         if (need_perfect && test_bit(flow_type, hw->fdir_perfect_fltr))
1563                 return;
1564
1565         ice_fdir_rem_flow(hw, ICE_BLK_FD, flow_type);
1566         if (need_perfect)
1567                 ice_create_init_fdir_rule(pf, flow_type);
1568 }
1569
1570 /**
1571  * ice_fdir_update_list_entry - add or delete a filter from the filter list
1572  * @pf: PF structure
1573  * @input: filter structure
1574  * @fltr_idx: ethtool index of filter to modify
1575  *
1576  * returns 0 on success and negative on errors
1577  */
1578 static int
1579 ice_fdir_update_list_entry(struct ice_pf *pf, struct ice_fdir_fltr *input,
1580                            int fltr_idx)
1581 {
1582         struct ice_fdir_fltr *old_fltr;
1583         struct ice_hw *hw = &pf->hw;
1584         struct ice_vsi *vsi;
1585         int err = -ENOENT;
1586
1587         /* Do not update filters during reset */
1588         if (ice_is_reset_in_progress(pf->state))
1589                 return -EBUSY;
1590
1591         vsi = ice_get_main_vsi(pf);
1592         if (!vsi)
1593                 return -EINVAL;
1594
1595         old_fltr = ice_fdir_find_fltr_by_idx(hw, fltr_idx);
1596         if (old_fltr) {
1597                 err = ice_fdir_write_all_fltr(pf, old_fltr, false);
1598                 if (err)
1599                         return err;
1600                 ice_fdir_update_cntrs(hw, old_fltr->flow_type, false);
1601                 /* update sb-filters count, specific to ring->channel */
1602                 ice_update_per_q_fltr(vsi, old_fltr->orig_q_index, false);
1603                 if (!input && !hw->fdir_fltr_cnt[old_fltr->flow_type])
1604                         /* we just deleted the last filter of flow_type so we
1605                          * should also delete the HW filter info.
1606                          */
1607                         ice_fdir_do_rem_flow(pf, old_fltr->flow_type);
1608                 list_del(&old_fltr->fltr_node);
1609                 devm_kfree(ice_hw_to_dev(hw), old_fltr);
1610         }
1611         if (!input)
1612                 return err;
1613         ice_fdir_list_add_fltr(hw, input);
1614         /* update sb-filters count, specific to ring->channel */
1615         ice_update_per_q_fltr(vsi, input->orig_q_index, true);
1616         ice_fdir_update_cntrs(hw, input->flow_type, true);
1617         return 0;
1618 }
1619
1620 /**
1621  * ice_del_fdir_ethtool - delete Flow Director filter
1622  * @vsi: pointer to target VSI
1623  * @cmd: command to add or delete Flow Director filter
1624  *
1625  * Returns 0 on success and negative values for failure
1626  */
1627 int ice_del_fdir_ethtool(struct ice_vsi *vsi, struct ethtool_rxnfc *cmd)
1628 {
1629         struct ethtool_rx_flow_spec *fsp =
1630                 (struct ethtool_rx_flow_spec *)&cmd->fs;
1631         struct ice_pf *pf = vsi->back;
1632         struct ice_hw *hw = &pf->hw;
1633         int val;
1634
1635         if (!test_bit(ICE_FLAG_FD_ENA, pf->flags))
1636                 return -EOPNOTSUPP;
1637
1638         /* Do not delete filters during reset */
1639         if (ice_is_reset_in_progress(pf->state)) {
1640                 dev_err(ice_pf_to_dev(pf), "Device is resetting - deleting Flow Director filters not supported during reset\n");
1641                 return -EBUSY;
1642         }
1643
1644         if (test_bit(ICE_FD_FLUSH_REQ, pf->state))
1645                 return -EBUSY;
1646
1647         mutex_lock(&hw->fdir_fltr_lock);
1648         val = ice_fdir_update_list_entry(pf, NULL, fsp->location);
1649         mutex_unlock(&hw->fdir_fltr_lock);
1650
1651         return val;
1652 }
1653
1654 /**
1655  * ice_update_ring_dest_vsi - update dest ring and dest VSI
1656  * @vsi: pointer to target VSI
1657  * @dest_vsi: ptr to dest VSI index
1658  * @ring: ptr to dest ring
1659  *
1660  * This function updates destination VSI and queue if user specifies
1661  * target queue which falls in channel's (aka ADQ) queue region
1662  */
1663 static void
1664 ice_update_ring_dest_vsi(struct ice_vsi *vsi, u16 *dest_vsi, u32 *ring)
1665 {
1666         struct ice_channel *ch;
1667
1668         list_for_each_entry(ch, &vsi->ch_list, list) {
1669                 if (!ch->ch_vsi)
1670                         continue;
1671
1672                 /* make sure to locate corresponding channel based on "queue"
1673                  * specified
1674                  */
1675                 if ((*ring < ch->base_q) ||
1676                     (*ring >= (ch->base_q + ch->num_rxq)))
1677                         continue;
1678
1679                 /* update the dest_vsi based on channel */
1680                 *dest_vsi = ch->ch_vsi->idx;
1681
1682                 /* update the "ring" to be correct based on channel */
1683                 *ring -= ch->base_q;
1684         }
1685 }
1686
1687 /**
1688  * ice_set_fdir_input_set - Set the input set for Flow Director
1689  * @vsi: pointer to target VSI
1690  * @fsp: pointer to ethtool Rx flow specification
1691  * @input: filter structure
1692  */
1693 static int
1694 ice_set_fdir_input_set(struct ice_vsi *vsi, struct ethtool_rx_flow_spec *fsp,
1695                        struct ice_fdir_fltr *input)
1696 {
1697         u16 dest_vsi, q_index = 0;
1698         u16 orig_q_index = 0;
1699         struct ice_pf *pf;
1700         struct ice_hw *hw;
1701         int flow_type;
1702         u8 dest_ctl;
1703
1704         if (!vsi || !fsp || !input)
1705                 return -EINVAL;
1706
1707         pf = vsi->back;
1708         hw = &pf->hw;
1709
1710         dest_vsi = vsi->idx;
1711         if (fsp->ring_cookie == RX_CLS_FLOW_DISC) {
1712                 dest_ctl = ICE_FLTR_PRGM_DESC_DEST_DROP_PKT;
1713         } else {
1714                 u32 ring = ethtool_get_flow_spec_ring(fsp->ring_cookie);
1715                 u8 vf = ethtool_get_flow_spec_ring_vf(fsp->ring_cookie);
1716
1717                 if (vf) {
1718                         dev_err(ice_pf_to_dev(pf), "Failed to add filter. Flow director filters are not supported on VF queues.\n");
1719                         return -EINVAL;
1720                 }
1721
1722                 if (ring >= vsi->num_rxq)
1723                         return -EINVAL;
1724
1725                 orig_q_index = ring;
1726                 ice_update_ring_dest_vsi(vsi, &dest_vsi, &ring);
1727                 dest_ctl = ICE_FLTR_PRGM_DESC_DEST_DIRECT_PKT_QINDEX;
1728                 q_index = ring;
1729         }
1730
1731         input->fltr_id = fsp->location;
1732         input->q_index = q_index;
1733         flow_type = fsp->flow_type & ~FLOW_EXT;
1734
1735         /* Record the original queue index as specified by user.
1736          * with channel configuration 'q_index' becomes relative
1737          * to TC (channel).
1738          */
1739         input->orig_q_index = orig_q_index;
1740         input->dest_vsi = dest_vsi;
1741         input->dest_ctl = dest_ctl;
1742         input->fltr_status = ICE_FLTR_PRGM_DESC_FD_STATUS_FD_ID;
1743         input->cnt_index = ICE_FD_SB_STAT_IDX(hw->fd_ctr_base);
1744         input->flow_type = ice_ethtool_flow_to_fltr(flow_type);
1745
1746         if (fsp->flow_type & FLOW_EXT) {
1747                 memcpy(input->ext_data.usr_def, fsp->h_ext.data,
1748                        sizeof(input->ext_data.usr_def));
1749                 input->ext_data.vlan_type = fsp->h_ext.vlan_etype;
1750                 input->ext_data.vlan_tag = fsp->h_ext.vlan_tci;
1751                 memcpy(input->ext_mask.usr_def, fsp->m_ext.data,
1752                        sizeof(input->ext_mask.usr_def));
1753                 input->ext_mask.vlan_type = fsp->m_ext.vlan_etype;
1754                 input->ext_mask.vlan_tag = fsp->m_ext.vlan_tci;
1755         }
1756
1757         switch (flow_type) {
1758         case TCP_V4_FLOW:
1759         case UDP_V4_FLOW:
1760         case SCTP_V4_FLOW:
1761                 input->ip.v4.dst_port = fsp->h_u.tcp_ip4_spec.pdst;
1762                 input->ip.v4.src_port = fsp->h_u.tcp_ip4_spec.psrc;
1763                 input->ip.v4.dst_ip = fsp->h_u.tcp_ip4_spec.ip4dst;
1764                 input->ip.v4.src_ip = fsp->h_u.tcp_ip4_spec.ip4src;
1765                 input->mask.v4.dst_port = fsp->m_u.tcp_ip4_spec.pdst;
1766                 input->mask.v4.src_port = fsp->m_u.tcp_ip4_spec.psrc;
1767                 input->mask.v4.dst_ip = fsp->m_u.tcp_ip4_spec.ip4dst;
1768                 input->mask.v4.src_ip = fsp->m_u.tcp_ip4_spec.ip4src;
1769                 break;
1770         case IPV4_USER_FLOW:
1771                 input->ip.v4.dst_ip = fsp->h_u.usr_ip4_spec.ip4dst;
1772                 input->ip.v4.src_ip = fsp->h_u.usr_ip4_spec.ip4src;
1773                 input->ip.v4.l4_header = fsp->h_u.usr_ip4_spec.l4_4_bytes;
1774                 input->ip.v4.proto = fsp->h_u.usr_ip4_spec.proto;
1775                 input->ip.v4.ip_ver = fsp->h_u.usr_ip4_spec.ip_ver;
1776                 input->ip.v4.tos = fsp->h_u.usr_ip4_spec.tos;
1777                 input->mask.v4.dst_ip = fsp->m_u.usr_ip4_spec.ip4dst;
1778                 input->mask.v4.src_ip = fsp->m_u.usr_ip4_spec.ip4src;
1779                 input->mask.v4.l4_header = fsp->m_u.usr_ip4_spec.l4_4_bytes;
1780                 input->mask.v4.proto = fsp->m_u.usr_ip4_spec.proto;
1781                 input->mask.v4.ip_ver = fsp->m_u.usr_ip4_spec.ip_ver;
1782                 input->mask.v4.tos = fsp->m_u.usr_ip4_spec.tos;
1783                 break;
1784         case TCP_V6_FLOW:
1785         case UDP_V6_FLOW:
1786         case SCTP_V6_FLOW:
1787                 memcpy(input->ip.v6.dst_ip, fsp->h_u.usr_ip6_spec.ip6dst,
1788                        sizeof(struct in6_addr));
1789                 memcpy(input->ip.v6.src_ip, fsp->h_u.usr_ip6_spec.ip6src,
1790                        sizeof(struct in6_addr));
1791                 input->ip.v6.dst_port = fsp->h_u.tcp_ip6_spec.pdst;
1792                 input->ip.v6.src_port = fsp->h_u.tcp_ip6_spec.psrc;
1793                 input->ip.v6.tc = fsp->h_u.tcp_ip6_spec.tclass;
1794                 memcpy(input->mask.v6.dst_ip, fsp->m_u.tcp_ip6_spec.ip6dst,
1795                        sizeof(struct in6_addr));
1796                 memcpy(input->mask.v6.src_ip, fsp->m_u.tcp_ip6_spec.ip6src,
1797                        sizeof(struct in6_addr));
1798                 input->mask.v6.dst_port = fsp->m_u.tcp_ip6_spec.pdst;
1799                 input->mask.v6.src_port = fsp->m_u.tcp_ip6_spec.psrc;
1800                 input->mask.v6.tc = fsp->m_u.tcp_ip6_spec.tclass;
1801                 break;
1802         case IPV6_USER_FLOW:
1803                 memcpy(input->ip.v6.dst_ip, fsp->h_u.usr_ip6_spec.ip6dst,
1804                        sizeof(struct in6_addr));
1805                 memcpy(input->ip.v6.src_ip, fsp->h_u.usr_ip6_spec.ip6src,
1806                        sizeof(struct in6_addr));
1807                 input->ip.v6.l4_header = fsp->h_u.usr_ip6_spec.l4_4_bytes;
1808                 input->ip.v6.tc = fsp->h_u.usr_ip6_spec.tclass;
1809
1810                 /* if no protocol requested, use IPPROTO_NONE */
1811                 if (!fsp->m_u.usr_ip6_spec.l4_proto)
1812                         input->ip.v6.proto = IPPROTO_NONE;
1813                 else
1814                         input->ip.v6.proto = fsp->h_u.usr_ip6_spec.l4_proto;
1815
1816                 memcpy(input->mask.v6.dst_ip, fsp->m_u.usr_ip6_spec.ip6dst,
1817                        sizeof(struct in6_addr));
1818                 memcpy(input->mask.v6.src_ip, fsp->m_u.usr_ip6_spec.ip6src,
1819                        sizeof(struct in6_addr));
1820                 input->mask.v6.l4_header = fsp->m_u.usr_ip6_spec.l4_4_bytes;
1821                 input->mask.v6.tc = fsp->m_u.usr_ip6_spec.tclass;
1822                 input->mask.v6.proto = fsp->m_u.usr_ip6_spec.l4_proto;
1823                 break;
1824         default:
1825                 /* not doing un-parsed flow types */
1826                 return -EINVAL;
1827         }
1828
1829         return 0;
1830 }
1831
1832 /**
1833  * ice_add_fdir_ethtool - Add/Remove Flow Director filter
1834  * @vsi: pointer to target VSI
1835  * @cmd: command to add or delete Flow Director filter
1836  *
1837  * Returns 0 on success and negative values for failure
1838  */
1839 int ice_add_fdir_ethtool(struct ice_vsi *vsi, struct ethtool_rxnfc *cmd)
1840 {
1841         struct ice_rx_flow_userdef userdata;
1842         struct ethtool_rx_flow_spec *fsp;
1843         struct ice_fdir_fltr *input;
1844         struct device *dev;
1845         struct ice_pf *pf;
1846         struct ice_hw *hw;
1847         int fltrs_needed;
1848         u16 tunnel_port;
1849         int ret;
1850
1851         if (!vsi)
1852                 return -EINVAL;
1853
1854         pf = vsi->back;
1855         hw = &pf->hw;
1856         dev = ice_pf_to_dev(pf);
1857
1858         if (!test_bit(ICE_FLAG_FD_ENA, pf->flags))
1859                 return -EOPNOTSUPP;
1860
1861         /* Do not program filters during reset */
1862         if (ice_is_reset_in_progress(pf->state)) {
1863                 dev_err(dev, "Device is resetting - adding Flow Director filters not supported during reset\n");
1864                 return -EBUSY;
1865         }
1866
1867         fsp = (struct ethtool_rx_flow_spec *)&cmd->fs;
1868
1869         if (ice_parse_rx_flow_user_data(fsp, &userdata))
1870                 return -EINVAL;
1871
1872         if (fsp->flow_type & FLOW_MAC_EXT)
1873                 return -EINVAL;
1874
1875         ret = ice_cfg_fdir_xtrct_seq(pf, fsp, &userdata);
1876         if (ret)
1877                 return ret;
1878
1879         if (fsp->location >= ice_get_fdir_cnt_all(hw)) {
1880                 dev_err(dev, "Failed to add filter.  The maximum number of flow director filters has been reached.\n");
1881                 return -ENOSPC;
1882         }
1883
1884         /* return error if not an update and no available filters */
1885         fltrs_needed = ice_get_open_tunnel_port(hw, &tunnel_port, TNL_ALL) ? 2 : 1;
1886         if (!ice_fdir_find_fltr_by_idx(hw, fsp->location) &&
1887             ice_fdir_num_avail_fltr(hw, pf->vsi[vsi->idx]) < fltrs_needed) {
1888                 dev_err(dev, "Failed to add filter.  The maximum number of flow director filters has been reached.\n");
1889                 return -ENOSPC;
1890         }
1891
1892         input = devm_kzalloc(dev, sizeof(*input), GFP_KERNEL);
1893         if (!input)
1894                 return -ENOMEM;
1895
1896         ret = ice_set_fdir_input_set(vsi, fsp, input);
1897         if (ret)
1898                 goto free_input;
1899
1900         mutex_lock(&hw->fdir_fltr_lock);
1901         if (ice_fdir_is_dup_fltr(hw, input)) {
1902                 ret = -EINVAL;
1903                 goto release_lock;
1904         }
1905
1906         if (userdata.flex_fltr) {
1907                 input->flex_fltr = true;
1908                 input->flex_word = cpu_to_be16(userdata.flex_word);
1909                 input->flex_offset = userdata.flex_offset;
1910         }
1911
1912         input->cnt_ena = ICE_FXD_FLTR_QW0_STAT_ENA_PKTS;
1913         input->fdid_prio = ICE_FXD_FLTR_QW1_FDID_PRI_THREE;
1914         input->comp_report = ICE_FXD_FLTR_QW0_COMP_REPORT_SW_FAIL;
1915
1916         /* input struct is added to the HW filter list */
1917         ice_fdir_update_list_entry(pf, input, fsp->location);
1918
1919         ret = ice_fdir_write_all_fltr(pf, input, true);
1920         if (ret)
1921                 goto remove_sw_rule;
1922
1923         goto release_lock;
1924
1925 remove_sw_rule:
1926         ice_fdir_update_cntrs(hw, input->flow_type, false);
1927         /* update sb-filters count, specific to ring->channel */
1928         ice_update_per_q_fltr(vsi, input->orig_q_index, false);
1929         list_del(&input->fltr_node);
1930 release_lock:
1931         mutex_unlock(&hw->fdir_fltr_lock);
1932 free_input:
1933         if (ret)
1934                 devm_kfree(dev, input);
1935
1936         return ret;
1937 }