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

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (C) 2021, Intel Corporation. */
   3
   4 #include "ice.h"
   5 #include "ice_base.h"
   6 #include "ice_lib.h"
   7 #include "ice_flow.h"
   8 #include "ice_vf_lib_private.h"
   9
  10 #define to_fltr_conf_from_desc(p) \
  11         container_of(p, struct virtchnl_fdir_fltr_conf, input)
  12
  13 #define ICE_FLOW_PROF_TYPE_S    0
  14 #define ICE_FLOW_PROF_TYPE_M    (0xFFFFFFFFULL << ICE_FLOW_PROF_TYPE_S)
  15 #define ICE_FLOW_PROF_VSI_S     32
  16 #define ICE_FLOW_PROF_VSI_M     (0xFFFFFFFFULL << ICE_FLOW_PROF_VSI_S)
  17
  18 /* Flow profile ID format:
  19  * [0:31] - flow type, flow + tun_offs
  20  * [32:63] - VSI index
  21  */
  22 #define ICE_FLOW_PROF_FD(vsi, flow, tun_offs) \
  23         ((u64)(((((flow) + (tun_offs)) & ICE_FLOW_PROF_TYPE_M)) | \
  24               (((u64)(vsi) << ICE_FLOW_PROF_VSI_S) & ICE_FLOW_PROF_VSI_M)))
  25
  26 #define GTPU_TEID_OFFSET 4
  27 #define GTPU_EH_QFI_OFFSET 1
  28 #define GTPU_EH_QFI_MASK 0x3F
  29 #define PFCP_S_OFFSET 0
  30 #define PFCP_S_MASK 0x1
  31 #define PFCP_PORT_NR 8805
  32
  33 #define FDIR_INSET_FLAG_ESP_S 0
  34 #define FDIR_INSET_FLAG_ESP_M BIT_ULL(FDIR_INSET_FLAG_ESP_S)
  35 #define FDIR_INSET_FLAG_ESP_UDP BIT_ULL(FDIR_INSET_FLAG_ESP_S)
  36 #define FDIR_INSET_FLAG_ESP_IPSEC (0ULL << FDIR_INSET_FLAG_ESP_S)
  37
  38 enum ice_fdir_tunnel_type {
  39         ICE_FDIR_TUNNEL_TYPE_NONE = 0,
  40         ICE_FDIR_TUNNEL_TYPE_GTPU,
  41         ICE_FDIR_TUNNEL_TYPE_GTPU_EH,
  42 };
  43
  44 struct virtchnl_fdir_fltr_conf {
  45         struct ice_fdir_fltr input;
  46         enum ice_fdir_tunnel_type ttype;
  47         u64 inset_flag;
  48         u32 flow_id;
  49 };
  50
  51 struct virtchnl_fdir_inset_map {
  52         enum virtchnl_proto_hdr_field field;
  53         enum ice_flow_field fld;
  54         u64 flag;
  55         u64 mask;
  56 };
  57
  58 static const struct virtchnl_fdir_inset_map fdir_inset_map[] = {
  59         {VIRTCHNL_PROTO_HDR_ETH_ETHERTYPE, ICE_FLOW_FIELD_IDX_ETH_TYPE, 0, 0},
  60         {VIRTCHNL_PROTO_HDR_IPV4_SRC, ICE_FLOW_FIELD_IDX_IPV4_SA, 0, 0},
  61         {VIRTCHNL_PROTO_HDR_IPV4_DST, ICE_FLOW_FIELD_IDX_IPV4_DA, 0, 0},
  62         {VIRTCHNL_PROTO_HDR_IPV4_DSCP, ICE_FLOW_FIELD_IDX_IPV4_DSCP, 0, 0},
  63         {VIRTCHNL_PROTO_HDR_IPV4_TTL, ICE_FLOW_FIELD_IDX_IPV4_TTL, 0, 0},
  64         {VIRTCHNL_PROTO_HDR_IPV4_PROT, ICE_FLOW_FIELD_IDX_IPV4_PROT, 0, 0},
  65         {VIRTCHNL_PROTO_HDR_IPV6_SRC, ICE_FLOW_FIELD_IDX_IPV6_SA, 0, 0},
  66         {VIRTCHNL_PROTO_HDR_IPV6_DST, ICE_FLOW_FIELD_IDX_IPV6_DA, 0, 0},
  67         {VIRTCHNL_PROTO_HDR_IPV6_TC, ICE_FLOW_FIELD_IDX_IPV6_DSCP, 0, 0},
  68         {VIRTCHNL_PROTO_HDR_IPV6_HOP_LIMIT, ICE_FLOW_FIELD_IDX_IPV6_TTL, 0, 0},
  69         {VIRTCHNL_PROTO_HDR_IPV6_PROT, ICE_FLOW_FIELD_IDX_IPV6_PROT, 0, 0},
  70         {VIRTCHNL_PROTO_HDR_UDP_SRC_PORT, ICE_FLOW_FIELD_IDX_UDP_SRC_PORT, 0, 0},
  71         {VIRTCHNL_PROTO_HDR_UDP_DST_PORT, ICE_FLOW_FIELD_IDX_UDP_DST_PORT, 0, 0},
  72         {VIRTCHNL_PROTO_HDR_TCP_SRC_PORT, ICE_FLOW_FIELD_IDX_TCP_SRC_PORT, 0, 0},
  73         {VIRTCHNL_PROTO_HDR_TCP_DST_PORT, ICE_FLOW_FIELD_IDX_TCP_DST_PORT, 0, 0},
  74         {VIRTCHNL_PROTO_HDR_SCTP_SRC_PORT, ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT, 0, 0},
  75         {VIRTCHNL_PROTO_HDR_SCTP_DST_PORT, ICE_FLOW_FIELD_IDX_SCTP_DST_PORT, 0, 0},
  76         {VIRTCHNL_PROTO_HDR_GTPU_IP_TEID, ICE_FLOW_FIELD_IDX_GTPU_IP_TEID, 0, 0},
  77         {VIRTCHNL_PROTO_HDR_GTPU_EH_QFI, ICE_FLOW_FIELD_IDX_GTPU_EH_QFI, 0, 0},
  78         {VIRTCHNL_PROTO_HDR_ESP_SPI, ICE_FLOW_FIELD_IDX_ESP_SPI,
  79                 FDIR_INSET_FLAG_ESP_IPSEC, FDIR_INSET_FLAG_ESP_M},
  80         {VIRTCHNL_PROTO_HDR_ESP_SPI, ICE_FLOW_FIELD_IDX_NAT_T_ESP_SPI,
  81                 FDIR_INSET_FLAG_ESP_UDP, FDIR_INSET_FLAG_ESP_M},
  82         {VIRTCHNL_PROTO_HDR_AH_SPI, ICE_FLOW_FIELD_IDX_AH_SPI, 0, 0},
  83         {VIRTCHNL_PROTO_HDR_L2TPV3_SESS_ID, ICE_FLOW_FIELD_IDX_L2TPV3_SESS_ID, 0, 0},
  84         {VIRTCHNL_PROTO_HDR_PFCP_S_FIELD, ICE_FLOW_FIELD_IDX_UDP_DST_PORT, 0, 0},
  85 };
  86
  87 /**
  88  * ice_vc_fdir_param_check
  89  * @vf: pointer to the VF structure
  90  * @vsi_id: VF relative VSI ID
  91  *
  92  * Check for the valid VSI ID, PF's state and VF's state
  93  *
  94  * Return: 0 on success, and -EINVAL on error.
  95  */
  96 static int
  97 ice_vc_fdir_param_check(struct ice_vf *vf, u16 vsi_id)
  98 {
  99         struct ice_pf *pf = vf->pf;
 100
 101         if (!test_bit(ICE_FLAG_FD_ENA, pf->flags))
 102                 return -EINVAL;
 103
 104         if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states))
 105                 return -EINVAL;
 106
 107         if (!(vf->driver_caps & VIRTCHNL_VF_OFFLOAD_FDIR_PF))
 108                 return -EINVAL;
 109
 110         if (vsi_id != vf->lan_vsi_num)
 111                 return -EINVAL;
 112
 113         if (!ice_vc_isvalid_vsi_id(vf, vsi_id))
 114                 return -EINVAL;
 115
 116         if (!ice_get_vf_vsi(vf))
 117                 return -EINVAL;
 118
 119         return 0;
 120 }
 121
 122 /**
 123  * ice_vf_start_ctrl_vsi
 124  * @vf: pointer to the VF structure
 125  *
 126  * Allocate ctrl_vsi for the first time and open the ctrl_vsi port for VF
 127  *
 128  * Return: 0 on success, and other on error.
 129  */
 130 static int ice_vf_start_ctrl_vsi(struct ice_vf *vf)
 131 {
 132         struct ice_pf *pf = vf->pf;
 133         struct ice_vsi *ctrl_vsi;
 134         struct device *dev;
 135         int err;
 136
 137         dev = ice_pf_to_dev(pf);
 138         if (vf->ctrl_vsi_idx != ICE_NO_VSI)
 139                 return -EEXIST;
 140
 141         ctrl_vsi = ice_vf_ctrl_vsi_setup(vf);
 142         if (!ctrl_vsi) {
 143                 dev_dbg(dev, "Could not setup control VSI for VF %d\n",
 144                         vf->vf_id);
 145                 return -ENOMEM;
 146         }
 147
 148         err = ice_vsi_open_ctrl(ctrl_vsi);
 149         if (err) {
 150                 dev_dbg(dev, "Could not open control VSI for VF %d\n",
 151                         vf->vf_id);
 152                 goto err_vsi_open;
 153         }
 154
 155         return 0;
 156
 157 err_vsi_open:
 158         ice_vsi_release(ctrl_vsi);
 159         if (vf->ctrl_vsi_idx != ICE_NO_VSI) {
 160                 pf->vsi[vf->ctrl_vsi_idx] = NULL;
 161                 vf->ctrl_vsi_idx = ICE_NO_VSI;
 162         }
 163         return err;
 164 }
 165
 166 /**
 167  * ice_vc_fdir_alloc_prof - allocate profile for this filter flow type
 168  * @vf: pointer to the VF structure
 169  * @flow: filter flow type
 170  *
 171  * Return: 0 on success, and other on error.
 172  */
 173 static int
 174 ice_vc_fdir_alloc_prof(struct ice_vf *vf, enum ice_fltr_ptype flow)
 175 {
 176         struct ice_vf_fdir *fdir = &vf->fdir;
 177
 178         if (!fdir->fdir_prof) {
 179                 fdir->fdir_prof = devm_kcalloc(ice_pf_to_dev(vf->pf),
 180                                                ICE_FLTR_PTYPE_MAX,
 181                                                sizeof(*fdir->fdir_prof),
 182                                                GFP_KERNEL);
 183                 if (!fdir->fdir_prof)
 184                         return -ENOMEM;
 185         }
 186
 187         if (!fdir->fdir_prof[flow]) {
 188                 fdir->fdir_prof[flow] = devm_kzalloc(ice_pf_to_dev(vf->pf),
 189                                                      sizeof(**fdir->fdir_prof),
 190                                                      GFP_KERNEL);
 191                 if (!fdir->fdir_prof[flow])
 192                         return -ENOMEM;
 193         }
 194
 195         return 0;
 196 }
 197
 198 /**
 199  * ice_vc_fdir_free_prof - free profile for this filter flow type
 200  * @vf: pointer to the VF structure
 201  * @flow: filter flow type
 202  */
 203 static void
 204 ice_vc_fdir_free_prof(struct ice_vf *vf, enum ice_fltr_ptype flow)
 205 {
 206         struct ice_vf_fdir *fdir = &vf->fdir;
 207
 208         if (!fdir->fdir_prof)
 209                 return;
 210
 211         if (!fdir->fdir_prof[flow])
 212                 return;
 213
 214         devm_kfree(ice_pf_to_dev(vf->pf), fdir->fdir_prof[flow]);
 215         fdir->fdir_prof[flow] = NULL;
 216 }
 217
 218 /**
 219  * ice_vc_fdir_free_prof_all - free all the profile for this VF
 220  * @vf: pointer to the VF structure
 221  */
 222 static void ice_vc_fdir_free_prof_all(struct ice_vf *vf)
 223 {
 224         struct ice_vf_fdir *fdir = &vf->fdir;
 225         enum ice_fltr_ptype flow;
 226
 227         if (!fdir->fdir_prof)
 228                 return;
 229
 230         for (flow = ICE_FLTR_PTYPE_NONF_NONE; flow < ICE_FLTR_PTYPE_MAX; flow++)
 231                 ice_vc_fdir_free_prof(vf, flow);
 232
 233         devm_kfree(ice_pf_to_dev(vf->pf), fdir->fdir_prof);
 234         fdir->fdir_prof = NULL;
 235 }
 236
 237 /**
 238  * ice_vc_fdir_parse_flow_fld
 239  * @proto_hdr: virtual channel protocol filter header
 240  * @conf: FDIR configuration for each filter
 241  * @fld: field type array
 242  * @fld_cnt: field counter
 243  *
 244  * Parse the virtual channel filter header and store them into field type array
 245  *
 246  * Return: 0 on success, and other on error.
 247  */
 248 static int
 249 ice_vc_fdir_parse_flow_fld(struct virtchnl_proto_hdr *proto_hdr,
 250                            struct virtchnl_fdir_fltr_conf *conf,
 251                            enum ice_flow_field *fld, int *fld_cnt)
 252 {
 253         struct virtchnl_proto_hdr hdr;
 254         u32 i;
 255
 256         memcpy(&hdr, proto_hdr, sizeof(hdr));
 257
 258         for (i = 0; (i < ARRAY_SIZE(fdir_inset_map)) &&
 259              VIRTCHNL_GET_PROTO_HDR_FIELD(&hdr); i++)
 260                 if (VIRTCHNL_TEST_PROTO_HDR(&hdr, fdir_inset_map[i].field)) {
 261                         if (fdir_inset_map[i].mask &&
 262                             ((fdir_inset_map[i].mask & conf->inset_flag) !=
 263                              fdir_inset_map[i].flag))
 264                                 continue;
 265
 266                         fld[*fld_cnt] = fdir_inset_map[i].fld;
 267                         *fld_cnt += 1;
 268                         if (*fld_cnt >= ICE_FLOW_FIELD_IDX_MAX)
 269                                 return -EINVAL;
 270                         VIRTCHNL_DEL_PROTO_HDR_FIELD(&hdr,
 271                                                      fdir_inset_map[i].field);
 272                 }
 273
 274         return 0;
 275 }
 276
 277 /**
 278  * ice_vc_fdir_set_flow_fld
 279  * @vf: pointer to the VF structure
 280  * @fltr: virtual channel add cmd buffer
 281  * @conf: FDIR configuration for each filter
 282  * @seg: array of one or more packet segments that describe the flow
 283  *
 284  * Parse the virtual channel add msg buffer's field vector and store them into
 285  * flow's packet segment field
 286  *
 287  * Return: 0 on success, and other on error.
 288  */
 289 static int
 290 ice_vc_fdir_set_flow_fld(struct ice_vf *vf, struct virtchnl_fdir_add *fltr,
 291                          struct virtchnl_fdir_fltr_conf *conf,
 292                          struct ice_flow_seg_info *seg)
 293 {
 294         struct virtchnl_fdir_rule *rule = &fltr->rule_cfg;
 295         enum ice_flow_field fld[ICE_FLOW_FIELD_IDX_MAX];
 296         struct device *dev = ice_pf_to_dev(vf->pf);
 297         struct virtchnl_proto_hdrs *proto;
 298         int fld_cnt = 0;
 299         int i;
 300
 301         proto = &rule->proto_hdrs;
 302         for (i = 0; i < proto->count; i++) {
 303                 struct virtchnl_proto_hdr *hdr = &proto->proto_hdr[i];
 304                 int ret;
 305
 306                 ret = ice_vc_fdir_parse_flow_fld(hdr, conf, fld, &fld_cnt);
 307                 if (ret)
 308                         return ret;
 309         }
 310
 311         if (fld_cnt == 0) {
 312                 dev_dbg(dev, "Empty input set for VF %d\n", vf->vf_id);
 313                 return -EINVAL;
 314         }
 315
 316         for (i = 0; i < fld_cnt; i++)
 317                 ice_flow_set_fld(seg, fld[i],
 318                                  ICE_FLOW_FLD_OFF_INVAL,
 319                                  ICE_FLOW_FLD_OFF_INVAL,
 320                                  ICE_FLOW_FLD_OFF_INVAL, false);
 321
 322         return 0;
 323 }
 324
 325 /**
 326  * ice_vc_fdir_set_flow_hdr - config the flow's packet segment header
 327  * @vf: pointer to the VF structure
 328  * @conf: FDIR configuration for each filter
 329  * @seg: array of one or more packet segments that describe the flow
 330  *
 331  * Return: 0 on success, and other on error.
 332  */
 333 static int
 334 ice_vc_fdir_set_flow_hdr(struct ice_vf *vf,
 335                          struct virtchnl_fdir_fltr_conf *conf,
 336                          struct ice_flow_seg_info *seg)
 337 {
 338         enum ice_fltr_ptype flow = conf->input.flow_type;
 339         enum ice_fdir_tunnel_type ttype = conf->ttype;
 340         struct device *dev = ice_pf_to_dev(vf->pf);
 341
 342         switch (flow) {
 343         case ICE_FLTR_PTYPE_NON_IP_L2:
 344                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_ETH_NON_IP);
 345                 break;
 346         case ICE_FLTR_PTYPE_NONF_IPV4_L2TPV3:
 347                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_L2TPV3 |
 348                                   ICE_FLOW_SEG_HDR_IPV4 |
 349                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 350                 break;
 351         case ICE_FLTR_PTYPE_NONF_IPV4_ESP:
 352                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_ESP |
 353                                   ICE_FLOW_SEG_HDR_IPV4 |
 354                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 355                 break;
 356         case ICE_FLTR_PTYPE_NONF_IPV4_AH:
 357                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_AH |
 358                                   ICE_FLOW_SEG_HDR_IPV4 |
 359                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 360                 break;
 361         case ICE_FLTR_PTYPE_NONF_IPV4_NAT_T_ESP:
 362                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_NAT_T_ESP |
 363                                   ICE_FLOW_SEG_HDR_IPV4 |
 364                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 365                 break;
 366         case ICE_FLTR_PTYPE_NONF_IPV4_PFCP_NODE:
 367                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_PFCP_NODE |
 368                                   ICE_FLOW_SEG_HDR_IPV4 |
 369                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 370                 break;
 371         case ICE_FLTR_PTYPE_NONF_IPV4_PFCP_SESSION:
 372                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_PFCP_SESSION |
 373                                   ICE_FLOW_SEG_HDR_IPV4 |
 374                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 375                 break;
 376         case ICE_FLTR_PTYPE_NONF_IPV4_OTHER:
 377                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_IPV4 |
 378                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 379                 break;
 380         case ICE_FLTR_PTYPE_NONF_IPV4_TCP:
 381                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_TCP |
 382                                   ICE_FLOW_SEG_HDR_IPV4 |
 383                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 384                 break;
 385         case ICE_FLTR_PTYPE_NONF_IPV4_UDP:
 386                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_UDP |
 387                                   ICE_FLOW_SEG_HDR_IPV4 |
 388                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 389                 break;
 390         case ICE_FLTR_PTYPE_NONF_IPV4_GTPU_IPV4_UDP:
 391         case ICE_FLTR_PTYPE_NONF_IPV4_GTPU_IPV4_TCP:
 392         case ICE_FLTR_PTYPE_NONF_IPV4_GTPU_IPV4_ICMP:
 393         case ICE_FLTR_PTYPE_NONF_IPV4_GTPU_IPV4_OTHER:
 394                 if (ttype == ICE_FDIR_TUNNEL_TYPE_GTPU) {
 395                         ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_GTPU_IP |
 396                                           ICE_FLOW_SEG_HDR_IPV4 |
 397                                           ICE_FLOW_SEG_HDR_IPV_OTHER);
 398                 } else if (ttype == ICE_FDIR_TUNNEL_TYPE_GTPU_EH) {
 399                         ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_GTPU_EH |
 400                                           ICE_FLOW_SEG_HDR_GTPU_IP |
 401                                           ICE_FLOW_SEG_HDR_IPV4 |
 402                                           ICE_FLOW_SEG_HDR_IPV_OTHER);
 403                 } else {
 404                         dev_dbg(dev, "Invalid tunnel type 0x%x for VF %d\n",
 405                                 flow, vf->vf_id);
 406                         return -EINVAL;
 407                 }
 408                 break;
 409         case ICE_FLTR_PTYPE_NONF_IPV4_SCTP:
 410                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_SCTP |
 411                                   ICE_FLOW_SEG_HDR_IPV4 |
 412                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 413                 break;
 414         case ICE_FLTR_PTYPE_NONF_IPV6_L2TPV3:
 415                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_L2TPV3 |
 416                                   ICE_FLOW_SEG_HDR_IPV6 |
 417                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 418                 break;
 419         case ICE_FLTR_PTYPE_NONF_IPV6_ESP:
 420                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_ESP |
 421                                   ICE_FLOW_SEG_HDR_IPV6 |
 422                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 423                 break;
 424         case ICE_FLTR_PTYPE_NONF_IPV6_AH:
 425                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_AH |
 426                                   ICE_FLOW_SEG_HDR_IPV6 |
 427                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 428                 break;
 429         case ICE_FLTR_PTYPE_NONF_IPV6_NAT_T_ESP:
 430                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_NAT_T_ESP |
 431                                   ICE_FLOW_SEG_HDR_IPV6 |
 432                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 433                 break;
 434         case ICE_FLTR_PTYPE_NONF_IPV6_PFCP_NODE:
 435                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_PFCP_NODE |
 436                                   ICE_FLOW_SEG_HDR_IPV6 |
 437                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 438                 break;
 439         case ICE_FLTR_PTYPE_NONF_IPV6_PFCP_SESSION:
 440                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_PFCP_SESSION |
 441                                   ICE_FLOW_SEG_HDR_IPV6 |
 442                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 443                 break;
 444         case ICE_FLTR_PTYPE_NONF_IPV6_OTHER:
 445                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_IPV6 |
 446                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 447                 break;
 448         case ICE_FLTR_PTYPE_NONF_IPV6_TCP:
 449                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_TCP |
 450                                   ICE_FLOW_SEG_HDR_IPV6 |
 451                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 452                 break;
 453         case ICE_FLTR_PTYPE_NONF_IPV6_UDP:
 454                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_UDP |
 455                                   ICE_FLOW_SEG_HDR_IPV6 |
 456                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 457                 break;
 458         case ICE_FLTR_PTYPE_NONF_IPV6_SCTP:
 459                 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_SCTP |
 460                                   ICE_FLOW_SEG_HDR_IPV6 |
 461                                   ICE_FLOW_SEG_HDR_IPV_OTHER);
 462                 break;
 463         default:
 464                 dev_dbg(dev, "Invalid flow type 0x%x for VF %d failed\n",
 465                         flow, vf->vf_id);
 466                 return -EINVAL;
 467         }
 468
 469         return 0;
 470 }
 471
 472 /**
 473  * ice_vc_fdir_rem_prof - remove profile for this filter flow type
 474  * @vf: pointer to the VF structure
 475  * @flow: filter flow type
 476  * @tun: 0 implies non-tunnel type filter, 1 implies tunnel type filter
 477  */
 478 static void
 479 ice_vc_fdir_rem_prof(struct ice_vf *vf, enum ice_fltr_ptype flow, int tun)
 480 {
 481         struct ice_vf_fdir *fdir = &vf->fdir;
 482         struct ice_fd_hw_prof *vf_prof;
 483         struct ice_pf *pf = vf->pf;
 484         struct ice_vsi *vf_vsi;
 485         struct device *dev;
 486         struct ice_hw *hw;
 487         u64 prof_id;
 488         int i;
 489
 490         dev = ice_pf_to_dev(pf);
 491         hw = &pf->hw;
 492         if (!fdir->fdir_prof || !fdir->fdir_prof[flow])
 493                 return;
 494
 495         vf_prof = fdir->fdir_prof[flow];
 496
 497         vf_vsi = ice_get_vf_vsi(vf);
 498         if (!vf_vsi) {
 499                 dev_dbg(dev, "NULL vf %d vsi pointer\n", vf->vf_id);
 500                 return;
 501         }
 502
 503         if (!fdir->prof_entry_cnt[flow][tun])
 504                 return;
 505
 506         prof_id = ICE_FLOW_PROF_FD(vf_vsi->vsi_num,
 507                                    flow, tun ? ICE_FLTR_PTYPE_MAX : 0);
 508
 509         for (i = 0; i < fdir->prof_entry_cnt[flow][tun]; i++)
 510                 if (vf_prof->entry_h[i][tun]) {
 511                         u16 vsi_num = ice_get_hw_vsi_num(hw, vf_prof->vsi_h[i]);
 512
 513                         ice_rem_prof_id_flow(hw, ICE_BLK_FD, vsi_num, prof_id);
 514                         ice_flow_rem_entry(hw, ICE_BLK_FD,
 515                                            vf_prof->entry_h[i][tun]);
 516                         vf_prof->entry_h[i][tun] = 0;
 517                 }
 518
 519         ice_flow_rem_prof(hw, ICE_BLK_FD, prof_id);
 520         devm_kfree(dev, vf_prof->fdir_seg[tun]);
 521         vf_prof->fdir_seg[tun] = NULL;
 522
 523         for (i = 0; i < vf_prof->cnt; i++)
 524                 vf_prof->vsi_h[i] = 0;
 525
 526         fdir->prof_entry_cnt[flow][tun] = 0;
 527 }
 528
 529 /**
 530  * ice_vc_fdir_rem_prof_all - remove profile for this VF
 531  * @vf: pointer to the VF structure
 532  */
 533 static void ice_vc_fdir_rem_prof_all(struct ice_vf *vf)
 534 {
 535         enum ice_fltr_ptype flow;
 536
 537         for (flow = ICE_FLTR_PTYPE_NONF_NONE;
 538              flow < ICE_FLTR_PTYPE_MAX; flow++) {
 539                 ice_vc_fdir_rem_prof(vf, flow, 0);
 540                 ice_vc_fdir_rem_prof(vf, flow, 1);
 541         }
 542 }
 543
 544 /**
 545  * ice_vc_fdir_write_flow_prof
 546  * @vf: pointer to the VF structure
 547  * @flow: filter flow type
 548  * @seg: array of one or more packet segments that describe the flow
 549  * @tun: 0 implies non-tunnel type filter, 1 implies tunnel type filter
 550  *
 551  * Write the flow's profile config and packet segment into the hardware
 552  *
 553  * Return: 0 on success, and other on error.
 554  */
 555 static int
 556 ice_vc_fdir_write_flow_prof(struct ice_vf *vf, enum ice_fltr_ptype flow,
 557                             struct ice_flow_seg_info *seg, int tun)
 558 {
 559         struct ice_vf_fdir *fdir = &vf->fdir;
 560         struct ice_vsi *vf_vsi, *ctrl_vsi;
 561         struct ice_flow_seg_info *old_seg;
 562         struct ice_flow_prof *prof = NULL;
 563         struct ice_fd_hw_prof *vf_prof;
 564         struct device *dev;
 565         struct ice_pf *pf;
 566         struct ice_hw *hw;
 567         u64 entry1_h = 0;
 568         u64 entry2_h = 0;
 569         u64 prof_id;
 570         int ret;
 571
 572         pf = vf->pf;
 573         dev = ice_pf_to_dev(pf);
 574         hw = &pf->hw;
 575         vf_vsi = ice_get_vf_vsi(vf);
 576         if (!vf_vsi)
 577                 return -EINVAL;
 578
 579         ctrl_vsi = pf->vsi[vf->ctrl_vsi_idx];
 580         if (!ctrl_vsi)
 581                 return -EINVAL;
 582
 583         vf_prof = fdir->fdir_prof[flow];
 584         old_seg = vf_prof->fdir_seg[tun];
 585         if (old_seg) {
 586                 if (!memcmp(old_seg, seg, sizeof(*seg))) {
 587                         dev_dbg(dev, "Duplicated profile for VF %d!\n",
 588                                 vf->vf_id);
 589                         return -EEXIST;
 590                 }
 591
 592                 if (fdir->fdir_fltr_cnt[flow][tun]) {
 593                         ret = -EINVAL;
 594                         dev_dbg(dev, "Input set conflicts for VF %d\n",
 595                                 vf->vf_id);
 596                         goto err_exit;
 597                 }
 598
 599                 /* remove previously allocated profile */
 600                 ice_vc_fdir_rem_prof(vf, flow, tun);
 601         }
 602
 603         prof_id = ICE_FLOW_PROF_FD(vf_vsi->vsi_num, flow,
 604                                    tun ? ICE_FLTR_PTYPE_MAX : 0);
 605
 606         ret = ice_flow_add_prof(hw, ICE_BLK_FD, ICE_FLOW_RX, prof_id, seg,
 607                                 tun + 1, &prof);
 608         if (ret) {
 609                 dev_dbg(dev, "Could not add VSI flow 0x%x for VF %d\n",
 610                         flow, vf->vf_id);
 611                 goto err_exit;
 612         }
 613
 614         ret = ice_flow_add_entry(hw, ICE_BLK_FD, prof_id, vf_vsi->idx,
 615                                  vf_vsi->idx, ICE_FLOW_PRIO_NORMAL,
 616                                  seg, &entry1_h);
 617         if (ret) {
 618                 dev_dbg(dev, "Could not add flow 0x%x VSI entry for VF %d\n",
 619                         flow, vf->vf_id);
 620                 goto err_prof;
 621         }
 622
 623         ret = ice_flow_add_entry(hw, ICE_BLK_FD, prof_id, vf_vsi->idx,
 624                                  ctrl_vsi->idx, ICE_FLOW_PRIO_NORMAL,
 625                                  seg, &entry2_h);
 626         if (ret) {
 627                 dev_dbg(dev,
 628                         "Could not add flow 0x%x Ctrl VSI entry for VF %d\n",
 629                         flow, vf->vf_id);
 630                 goto err_entry_1;
 631         }
 632
 633         vf_prof->fdir_seg[tun] = seg;
 634         vf_prof->cnt = 0;
 635         fdir->prof_entry_cnt[flow][tun] = 0;
 636
 637         vf_prof->entry_h[vf_prof->cnt][tun] = entry1_h;
 638         vf_prof->vsi_h[vf_prof->cnt] = vf_vsi->idx;
 639         vf_prof->cnt++;
 640         fdir->prof_entry_cnt[flow][tun]++;
 641
 642         vf_prof->entry_h[vf_prof->cnt][tun] = entry2_h;
 643         vf_prof->vsi_h[vf_prof->cnt] = ctrl_vsi->idx;
 644         vf_prof->cnt++;
 645         fdir->prof_entry_cnt[flow][tun]++;
 646
 647         return 0;
 648
 649 err_entry_1:
 650         ice_rem_prof_id_flow(hw, ICE_BLK_FD,
 651                              ice_get_hw_vsi_num(hw, vf_vsi->idx), prof_id);
 652         ice_flow_rem_entry(hw, ICE_BLK_FD, entry1_h);
 653 err_prof:
 654         ice_flow_rem_prof(hw, ICE_BLK_FD, prof_id);
 655 err_exit:
 656         return ret;
 657 }
 658
 659 /**
 660  * ice_vc_fdir_config_input_set
 661  * @vf: pointer to the VF structure
 662  * @fltr: virtual channel add cmd buffer
 663  * @conf: FDIR configuration for each filter
 664  * @tun: 0 implies non-tunnel type filter, 1 implies tunnel type filter
 665  *
 666  * Config the input set type and value for virtual channel add msg buffer
 667  *
 668  * Return: 0 on success, and other on error.
 669  */
 670 static int
 671 ice_vc_fdir_config_input_set(struct ice_vf *vf, struct virtchnl_fdir_add *fltr,
 672                              struct virtchnl_fdir_fltr_conf *conf, int tun)
 673 {
 674         struct ice_fdir_fltr *input = &conf->input;
 675         struct device *dev = ice_pf_to_dev(vf->pf);
 676         struct ice_flow_seg_info *seg;
 677         enum ice_fltr_ptype flow;
 678         int ret;
 679
 680         flow = input->flow_type;
 681         ret = ice_vc_fdir_alloc_prof(vf, flow);
 682         if (ret) {
 683                 dev_dbg(dev, "Alloc flow prof for VF %d failed\n", vf->vf_id);
 684                 return ret;
 685         }
 686
 687         seg = devm_kzalloc(dev, sizeof(*seg), GFP_KERNEL);
 688         if (!seg)
 689                 return -ENOMEM;
 690
 691         ret = ice_vc_fdir_set_flow_fld(vf, fltr, conf, seg);
 692         if (ret) {
 693                 dev_dbg(dev, "Set flow field for VF %d failed\n", vf->vf_id);
 694                 goto err_exit;
 695         }
 696
 697         ret = ice_vc_fdir_set_flow_hdr(vf, conf, seg);
 698         if (ret) {
 699                 dev_dbg(dev, "Set flow hdr for VF %d failed\n", vf->vf_id);
 700                 goto err_exit;
 701         }
 702
 703         ret = ice_vc_fdir_write_flow_prof(vf, flow, seg, tun);
 704         if (ret == -EEXIST) {
 705                 devm_kfree(dev, seg);
 706         } else if (ret) {
 707                 dev_dbg(dev, "Write flow profile for VF %d failed\n",
 708                         vf->vf_id);
 709                 goto err_exit;
 710         }
 711
 712         return 0;
 713
 714 err_exit:
 715         devm_kfree(dev, seg);
 716         return ret;
 717 }
 718
 719 /**
 720  * ice_vc_fdir_parse_pattern
 721  * @vf: pointer to the VF info
 722  * @fltr: virtual channel add cmd buffer
 723  * @conf: FDIR configuration for each filter
 724  *
 725  * Parse the virtual channel filter's pattern and store them into conf
 726  *
 727  * Return: 0 on success, and other on error.
 728  */
 729 static int
 730 ice_vc_fdir_parse_pattern(struct ice_vf *vf, struct virtchnl_fdir_add *fltr,
 731                           struct virtchnl_fdir_fltr_conf *conf)
 732 {
 733         struct virtchnl_proto_hdrs *proto = &fltr->rule_cfg.proto_hdrs;
 734         enum virtchnl_proto_hdr_type l3 = VIRTCHNL_PROTO_HDR_NONE;
 735         enum virtchnl_proto_hdr_type l4 = VIRTCHNL_PROTO_HDR_NONE;
 736         struct device *dev = ice_pf_to_dev(vf->pf);
 737         struct ice_fdir_fltr *input = &conf->input;
 738         int i;
 739
 740         if (proto->count > VIRTCHNL_MAX_NUM_PROTO_HDRS) {
 741                 dev_dbg(dev, "Invalid protocol count:0x%x for VF %d\n",
 742                         proto->count, vf->vf_id);
 743                 return -EINVAL;
 744         }
 745
 746         for (i = 0; i < proto->count; i++) {
 747                 struct virtchnl_proto_hdr *hdr = &proto->proto_hdr[i];
 748                 struct ip_esp_hdr *esph;
 749                 struct ip_auth_hdr *ah;
 750                 struct sctphdr *sctph;
 751                 struct ipv6hdr *ip6h;
 752                 struct udphdr *udph;
 753                 struct tcphdr *tcph;
 754                 struct ethhdr *eth;
 755                 struct iphdr *iph;
 756                 u8 s_field;
 757                 u8 *rawh;
 758
 759                 switch (hdr->type) {
 760                 case VIRTCHNL_PROTO_HDR_ETH:
 761                         eth = (struct ethhdr *)hdr->buffer;
 762                         input->flow_type = ICE_FLTR_PTYPE_NON_IP_L2;
 763
 764                         if (hdr->field_selector)
 765                                 input->ext_data.ether_type = eth->h_proto;
 766                         break;
 767                 case VIRTCHNL_PROTO_HDR_IPV4:
 768                         iph = (struct iphdr *)hdr->buffer;
 769                         l3 = VIRTCHNL_PROTO_HDR_IPV4;
 770                         input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_OTHER;
 771
 772                         if (hdr->field_selector) {
 773                                 input->ip.v4.src_ip = iph->saddr;
 774                                 input->ip.v4.dst_ip = iph->daddr;
 775                                 input->ip.v4.tos = iph->tos;
 776                                 input->ip.v4.proto = iph->protocol;
 777                         }
 778                         break;
 779                 case VIRTCHNL_PROTO_HDR_IPV6:
 780                         ip6h = (struct ipv6hdr *)hdr->buffer;
 781                         l3 = VIRTCHNL_PROTO_HDR_IPV6;
 782                         input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_OTHER;
 783
 784                         if (hdr->field_selector) {
 785                                 memcpy(input->ip.v6.src_ip,
 786                                        ip6h->saddr.in6_u.u6_addr8,
 787                                        sizeof(ip6h->saddr));
 788                                 memcpy(input->ip.v6.dst_ip,
 789                                        ip6h->daddr.in6_u.u6_addr8,
 790                                        sizeof(ip6h->daddr));
 791                                 input->ip.v6.tc = ((u8)(ip6h->priority) << 4) |
 792                                                   (ip6h->flow_lbl[0] >> 4);
 793                                 input->ip.v6.proto = ip6h->nexthdr;
 794                         }
 795                         break;
 796                 case VIRTCHNL_PROTO_HDR_TCP:
 797                         tcph = (struct tcphdr *)hdr->buffer;
 798                         if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
 799                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_TCP;
 800                         else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
 801                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_TCP;
 802
 803                         if (hdr->field_selector) {
 804                                 if (l3 == VIRTCHNL_PROTO_HDR_IPV4) {
 805                                         input->ip.v4.src_port = tcph->source;
 806                                         input->ip.v4.dst_port = tcph->dest;
 807                                 } else if (l3 == VIRTCHNL_PROTO_HDR_IPV6) {
 808                                         input->ip.v6.src_port = tcph->source;
 809                                         input->ip.v6.dst_port = tcph->dest;
 810                                 }
 811                         }
 812                         break;
 813                 case VIRTCHNL_PROTO_HDR_UDP:
 814                         udph = (struct udphdr *)hdr->buffer;
 815                         if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
 816                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_UDP;
 817                         else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
 818                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_UDP;
 819
 820                         if (hdr->field_selector) {
 821                                 if (l3 == VIRTCHNL_PROTO_HDR_IPV4) {
 822                                         input->ip.v4.src_port = udph->source;
 823                                         input->ip.v4.dst_port = udph->dest;
 824                                 } else if (l3 == VIRTCHNL_PROTO_HDR_IPV6) {
 825                                         input->ip.v6.src_port = udph->source;
 826                                         input->ip.v6.dst_port = udph->dest;
 827                                 }
 828                         }
 829                         break;
 830                 case VIRTCHNL_PROTO_HDR_SCTP:
 831                         sctph = (struct sctphdr *)hdr->buffer;
 832                         if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
 833                                 input->flow_type =
 834                                         ICE_FLTR_PTYPE_NONF_IPV4_SCTP;
 835                         else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
 836                                 input->flow_type =
 837                                         ICE_FLTR_PTYPE_NONF_IPV6_SCTP;
 838
 839                         if (hdr->field_selector) {
 840                                 if (l3 == VIRTCHNL_PROTO_HDR_IPV4) {
 841                                         input->ip.v4.src_port = sctph->source;
 842                                         input->ip.v4.dst_port = sctph->dest;
 843                                 } else if (l3 == VIRTCHNL_PROTO_HDR_IPV6) {
 844                                         input->ip.v6.src_port = sctph->source;
 845                                         input->ip.v6.dst_port = sctph->dest;
 846                                 }
 847                         }
 848                         break;
 849                 case VIRTCHNL_PROTO_HDR_L2TPV3:
 850                         if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
 851                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_L2TPV3;
 852                         else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
 853                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_L2TPV3;
 854
 855                         if (hdr->field_selector)
 856                                 input->l2tpv3_data.session_id = *((__be32 *)hdr->buffer);
 857                         break;
 858                 case VIRTCHNL_PROTO_HDR_ESP:
 859                         esph = (struct ip_esp_hdr *)hdr->buffer;
 860                         if (l3 == VIRTCHNL_PROTO_HDR_IPV4 &&
 861                             l4 == VIRTCHNL_PROTO_HDR_UDP)
 862                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_NAT_T_ESP;
 863                         else if (l3 == VIRTCHNL_PROTO_HDR_IPV6 &&
 864                                  l4 == VIRTCHNL_PROTO_HDR_UDP)
 865                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_NAT_T_ESP;
 866                         else if (l3 == VIRTCHNL_PROTO_HDR_IPV4 &&
 867                                  l4 == VIRTCHNL_PROTO_HDR_NONE)
 868                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_ESP;
 869                         else if (l3 == VIRTCHNL_PROTO_HDR_IPV6 &&
 870                                  l4 == VIRTCHNL_PROTO_HDR_NONE)
 871                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_ESP;
 872
 873                         if (l4 == VIRTCHNL_PROTO_HDR_UDP)
 874                                 conf->inset_flag |= FDIR_INSET_FLAG_ESP_UDP;
 875                         else
 876                                 conf->inset_flag |= FDIR_INSET_FLAG_ESP_IPSEC;
 877
 878                         if (hdr->field_selector) {
 879                                 if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
 880                                         input->ip.v4.sec_parm_idx = esph->spi;
 881                                 else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
 882                                         input->ip.v6.sec_parm_idx = esph->spi;
 883                         }
 884                         break;
 885                 case VIRTCHNL_PROTO_HDR_AH:
 886                         ah = (struct ip_auth_hdr *)hdr->buffer;
 887                         if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
 888                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_AH;
 889                         else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
 890                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_AH;
 891
 892                         if (hdr->field_selector) {
 893                                 if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
 894                                         input->ip.v4.sec_parm_idx = ah->spi;
 895                                 else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
 896                                         input->ip.v6.sec_parm_idx = ah->spi;
 897                         }
 898                         break;
 899                 case VIRTCHNL_PROTO_HDR_PFCP:
 900                         rawh = (u8 *)hdr->buffer;
 901                         s_field = (rawh[0] >> PFCP_S_OFFSET) & PFCP_S_MASK;
 902                         if (l3 == VIRTCHNL_PROTO_HDR_IPV4 && s_field == 0)
 903                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_PFCP_NODE;
 904                         else if (l3 == VIRTCHNL_PROTO_HDR_IPV4 && s_field == 1)
 905                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_PFCP_SESSION;
 906                         else if (l3 == VIRTCHNL_PROTO_HDR_IPV6 && s_field == 0)
 907                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_PFCP_NODE;
 908                         else if (l3 == VIRTCHNL_PROTO_HDR_IPV6 && s_field == 1)
 909                                 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_PFCP_SESSION;
 910
 911                         if (hdr->field_selector) {
 912                                 if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
 913                                         input->ip.v4.dst_port = cpu_to_be16(PFCP_PORT_NR);
 914                                 else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
 915                                         input->ip.v6.dst_port = cpu_to_be16(PFCP_PORT_NR);
 916                         }
 917                         break;
 918                 case VIRTCHNL_PROTO_HDR_GTPU_IP:
 919                         rawh = (u8 *)hdr->buffer;
 920                         input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_GTPU_IPV4_OTHER;
 921
 922                         if (hdr->field_selector)
 923                                 input->gtpu_data.teid = *(__be32 *)(&rawh[GTPU_TEID_OFFSET]);
 924                         conf->ttype = ICE_FDIR_TUNNEL_TYPE_GTPU;
 925                         break;
 926                 case VIRTCHNL_PROTO_HDR_GTPU_EH:
 927                         rawh = (u8 *)hdr->buffer;
 928
 929                         if (hdr->field_selector)
 930                                 input->gtpu_data.qfi = rawh[GTPU_EH_QFI_OFFSET] & GTPU_EH_QFI_MASK;
 931                         conf->ttype = ICE_FDIR_TUNNEL_TYPE_GTPU_EH;
 932                         break;
 933                 default:
 934                         dev_dbg(dev, "Invalid header type 0x:%x for VF %d\n",
 935                                 hdr->type, vf->vf_id);
 936                         return -EINVAL;
 937                 }
 938         }
 939
 940         return 0;
 941 }
 942
 943 /**
 944  * ice_vc_fdir_parse_action
 945  * @vf: pointer to the VF info
 946  * @fltr: virtual channel add cmd buffer
 947  * @conf: FDIR configuration for each filter
 948  *
 949  * Parse the virtual channel filter's action and store them into conf
 950  *
 951  * Return: 0 on success, and other on error.
 952  */
 953 static int
 954 ice_vc_fdir_parse_action(struct ice_vf *vf, struct virtchnl_fdir_add *fltr,
 955                          struct virtchnl_fdir_fltr_conf *conf)
 956 {
 957         struct virtchnl_filter_action_set *as = &fltr->rule_cfg.action_set;
 958         struct device *dev = ice_pf_to_dev(vf->pf);
 959         struct ice_fdir_fltr *input = &conf->input;
 960         u32 dest_num = 0;
 961         u32 mark_num = 0;
 962         int i;
 963
 964         if (as->count > VIRTCHNL_MAX_NUM_ACTIONS) {
 965                 dev_dbg(dev, "Invalid action numbers:0x%x for VF %d\n",
 966                         as->count, vf->vf_id);
 967                 return -EINVAL;
 968         }
 969
 970         for (i = 0; i < as->count; i++) {
 971                 struct virtchnl_filter_action *action = &as->actions[i];
 972
 973                 switch (action->type) {
 974                 case VIRTCHNL_ACTION_PASSTHRU:
 975                         dest_num++;
 976                         input->dest_ctl = ICE_FLTR_PRGM_DESC_DEST_DIRECT_PKT_OTHER;
 977                         break;
 978                 case VIRTCHNL_ACTION_DROP:
 979                         dest_num++;
 980                         input->dest_ctl = ICE_FLTR_PRGM_DESC_DEST_DROP_PKT;
 981                         break;
 982                 case VIRTCHNL_ACTION_QUEUE:
 983                         dest_num++;
 984                         input->dest_ctl = ICE_FLTR_PRGM_DESC_DEST_DIRECT_PKT_QINDEX;
 985                         input->q_index = action->act_conf.queue.index;
 986                         break;
 987                 case VIRTCHNL_ACTION_Q_REGION:
 988                         dest_num++;
 989                         input->dest_ctl = ICE_FLTR_PRGM_DESC_DEST_DIRECT_PKT_QGROUP;
 990                         input->q_index = action->act_conf.queue.index;
 991                         input->q_region = action->act_conf.queue.region;
 992                         break;
 993                 case VIRTCHNL_ACTION_MARK:
 994                         mark_num++;
 995                         input->fltr_id = action->act_conf.mark_id;
 996                         input->fdid_prio = ICE_FXD_FLTR_QW1_FDID_PRI_THREE;
 997                         break;
 998                 default:
 999                         dev_dbg(dev, "Invalid action type:0x%x for VF %d\n",
1000                                 action->type, vf->vf_id);
1001                         return -EINVAL;
1002                 }
1003         }
1004
1005         if (dest_num == 0 || dest_num >= 2) {
1006                 dev_dbg(dev, "Invalid destination action for VF %d\n",
1007                         vf->vf_id);
1008                 return -EINVAL;
1009         }
1010
1011         if (mark_num >= 2) {
1012                 dev_dbg(dev, "Too many mark actions for VF %d\n", vf->vf_id);
1013                 return -EINVAL;
1014         }
1015
1016         return 0;
1017 }
1018
1019 /**
1020  * ice_vc_validate_fdir_fltr - validate the virtual channel filter
1021  * @vf: pointer to the VF info
1022  * @fltr: virtual channel add cmd buffer
1023  * @conf: FDIR configuration for each filter
1024  *
1025  * Return: 0 on success, and other on error.
1026  */
1027 static int
1028 ice_vc_validate_fdir_fltr(struct ice_vf *vf, struct virtchnl_fdir_add *fltr,
1029                           struct virtchnl_fdir_fltr_conf *conf)
1030 {
1031         struct virtchnl_proto_hdrs *proto = &fltr->rule_cfg.proto_hdrs;
1032         int ret;
1033
1034         if (!ice_vc_validate_pattern(vf, proto))
1035                 return -EINVAL;
1036
1037         ret = ice_vc_fdir_parse_pattern(vf, fltr, conf);
1038         if (ret)
1039                 return ret;
1040
1041         return ice_vc_fdir_parse_action(vf, fltr, conf);
1042 }
1043
1044 /**
1045  * ice_vc_fdir_comp_rules - compare if two filter rules have the same value
1046  * @conf_a: FDIR configuration for filter a
1047  * @conf_b: FDIR configuration for filter b
1048  *
1049  * Return: 0 on success, and other on error.
1050  */
1051 static bool
1052 ice_vc_fdir_comp_rules(struct virtchnl_fdir_fltr_conf *conf_a,
1053                        struct virtchnl_fdir_fltr_conf *conf_b)
1054 {
1055         struct ice_fdir_fltr *a = &conf_a->input;
1056         struct ice_fdir_fltr *b = &conf_b->input;
1057
1058         if (conf_a->ttype != conf_b->ttype)
1059                 return false;
1060         if (a->flow_type != b->flow_type)
1061                 return false;
1062         if (memcmp(&a->ip, &b->ip, sizeof(a->ip)))
1063                 return false;
1064         if (memcmp(&a->mask, &b->mask, sizeof(a->mask)))
1065                 return false;
1066         if (memcmp(&a->gtpu_data, &b->gtpu_data, sizeof(a->gtpu_data)))
1067                 return false;
1068         if (memcmp(&a->gtpu_mask, &b->gtpu_mask, sizeof(a->gtpu_mask)))
1069                 return false;
1070         if (memcmp(&a->l2tpv3_data, &b->l2tpv3_data, sizeof(a->l2tpv3_data)))
1071                 return false;
1072         if (memcmp(&a->l2tpv3_mask, &b->l2tpv3_mask, sizeof(a->l2tpv3_mask)))
1073                 return false;
1074         if (memcmp(&a->ext_data, &b->ext_data, sizeof(a->ext_data)))
1075                 return false;
1076         if (memcmp(&a->ext_mask, &b->ext_mask, sizeof(a->ext_mask)))
1077                 return false;
1078
1079         return true;
1080 }
1081
1082 /**
1083  * ice_vc_fdir_is_dup_fltr
1084  * @vf: pointer to the VF info
1085  * @conf: FDIR configuration for each filter
1086  *
1087  * Check if there is duplicated rule with same conf value
1088  *
1089  * Return: 0 true success, and false on error.
1090  */
1091 static bool
1092 ice_vc_fdir_is_dup_fltr(struct ice_vf *vf, struct virtchnl_fdir_fltr_conf *conf)
1093 {
1094         struct ice_fdir_fltr *desc;
1095         bool ret;
1096
1097         list_for_each_entry(desc, &vf->fdir.fdir_rule_list, fltr_node) {
1098                 struct virtchnl_fdir_fltr_conf *node =
1099                                 to_fltr_conf_from_desc(desc);
1100
1101                 ret = ice_vc_fdir_comp_rules(node, conf);
1102                 if (ret)
1103                         return true;
1104         }
1105
1106         return false;
1107 }
1108
1109 /**
1110  * ice_vc_fdir_insert_entry
1111  * @vf: pointer to the VF info
1112  * @conf: FDIR configuration for each filter
1113  * @id: pointer to ID value allocated by driver
1114  *
1115  * Insert FDIR conf entry into list and allocate ID for this filter
1116  *
1117  * Return: 0 true success, and other on error.
1118  */
1119 static int
1120 ice_vc_fdir_insert_entry(struct ice_vf *vf,
1121                          struct virtchnl_fdir_fltr_conf *conf, u32 *id)
1122 {
1123         struct ice_fdir_fltr *input = &conf->input;
1124         int i;
1125
1126         /* alloc ID corresponding with conf */
1127         i = idr_alloc(&vf->fdir.fdir_rule_idr, conf, 0,
1128                       ICE_FDIR_MAX_FLTRS, GFP_KERNEL);
1129         if (i < 0)
1130                 return -EINVAL;
1131         *id = i;
1132
1133         list_add(&input->fltr_node, &vf->fdir.fdir_rule_list);
1134         return 0;
1135 }
1136
1137 /**
1138  * ice_vc_fdir_remove_entry - remove FDIR conf entry by ID value
1139  * @vf: pointer to the VF info
1140  * @conf: FDIR configuration for each filter
1141  * @id: filter rule's ID
1142  */
1143 static void
1144 ice_vc_fdir_remove_entry(struct ice_vf *vf,
1145                          struct virtchnl_fdir_fltr_conf *conf, u32 id)
1146 {
1147         struct ice_fdir_fltr *input = &conf->input;
1148
1149         idr_remove(&vf->fdir.fdir_rule_idr, id);
1150         list_del(&input->fltr_node);
1151 }
1152
1153 /**
1154  * ice_vc_fdir_lookup_entry - lookup FDIR conf entry by ID value
1155  * @vf: pointer to the VF info
1156  * @id: filter rule's ID
1157  *
1158  * Return: NULL on error, and other on success.
1159  */
1160 static struct virtchnl_fdir_fltr_conf *
1161 ice_vc_fdir_lookup_entry(struct ice_vf *vf, u32 id)
1162 {
1163         return idr_find(&vf->fdir.fdir_rule_idr, id);
1164 }
1165
1166 /**
1167  * ice_vc_fdir_flush_entry - remove all FDIR conf entry
1168  * @vf: pointer to the VF info
1169  */
1170 static void ice_vc_fdir_flush_entry(struct ice_vf *vf)
1171 {
1172         struct virtchnl_fdir_fltr_conf *conf;
1173         struct ice_fdir_fltr *desc, *temp;
1174
1175         list_for_each_entry_safe(desc, temp,
1176                                  &vf->fdir.fdir_rule_list, fltr_node) {
1177                 conf = to_fltr_conf_from_desc(desc);
1178                 list_del(&desc->fltr_node);
1179                 devm_kfree(ice_pf_to_dev(vf->pf), conf);
1180         }
1181 }
1182
1183 /**
1184  * ice_vc_fdir_write_fltr - write filter rule into hardware
1185  * @vf: pointer to the VF info
1186  * @conf: FDIR configuration for each filter
1187  * @add: true implies add rule, false implies del rules
1188  * @is_tun: false implies non-tunnel type filter, true implies tunnel filter
1189  *
1190  * Return: 0 on success, and other on error.
1191  */
1192 static int ice_vc_fdir_write_fltr(struct ice_vf *vf,
1193                                   struct virtchnl_fdir_fltr_conf *conf,
1194                                   bool add, bool is_tun)
1195 {
1196         struct ice_fdir_fltr *input = &conf->input;
1197         struct ice_vsi *vsi, *ctrl_vsi;
1198         struct ice_fltr_desc desc;
1199         struct device *dev;
1200         struct ice_pf *pf;
1201         struct ice_hw *hw;
1202         int ret;
1203         u8 *pkt;
1204
1205         pf = vf->pf;
1206         dev = ice_pf_to_dev(pf);
1207         hw = &pf->hw;
1208         vsi = ice_get_vf_vsi(vf);
1209         if (!vsi) {
1210                 dev_dbg(dev, "Invalid vsi for VF %d\n", vf->vf_id);
1211                 return -EINVAL;
1212         }
1213
1214         input->dest_vsi = vsi->idx;
1215         input->comp_report = ICE_FXD_FLTR_QW0_COMP_REPORT_SW;
1216
1217         ctrl_vsi = pf->vsi[vf->ctrl_vsi_idx];
1218         if (!ctrl_vsi) {
1219                 dev_dbg(dev, "Invalid ctrl_vsi for VF %d\n", vf->vf_id);
1220                 return -EINVAL;
1221         }
1222
1223         pkt = devm_kzalloc(dev, ICE_FDIR_MAX_RAW_PKT_SIZE, GFP_KERNEL);
1224         if (!pkt)
1225                 return -ENOMEM;
1226
1227         ice_fdir_get_prgm_desc(hw, input, &desc, add);
1228         ret = ice_fdir_get_gen_prgm_pkt(hw, input, pkt, false, is_tun);
1229         if (ret) {
1230                 dev_dbg(dev, "Gen training pkt for VF %d ptype %d failed\n",
1231                         vf->vf_id, input->flow_type);
1232                 goto err_free_pkt;
1233         }
1234
1235         ret = ice_prgm_fdir_fltr(ctrl_vsi, &desc, pkt);
1236         if (ret)
1237                 goto err_free_pkt;
1238
1239         return 0;
1240
1241 err_free_pkt:
1242         devm_kfree(dev, pkt);
1243         return ret;
1244 }
1245
1246 /**
1247  * ice_vf_fdir_timer - FDIR program waiting timer interrupt handler
1248  * @t: pointer to timer_list
1249  */
1250 static void ice_vf_fdir_timer(struct timer_list *t)
1251 {
1252         struct ice_vf_fdir_ctx *ctx_irq = from_timer(ctx_irq, t, rx_tmr);
1253         struct ice_vf_fdir_ctx *ctx_done;
1254         struct ice_vf_fdir *fdir;
1255         unsigned long flags;
1256         struct ice_vf *vf;
1257         struct ice_pf *pf;
1258
1259         fdir = container_of(ctx_irq, struct ice_vf_fdir, ctx_irq);
1260         vf = container_of(fdir, struct ice_vf, fdir);
1261         ctx_done = &fdir->ctx_done;
1262         pf = vf->pf;
1263         spin_lock_irqsave(&fdir->ctx_lock, flags);
1264         if (!(ctx_irq->flags & ICE_VF_FDIR_CTX_VALID)) {
1265                 spin_unlock_irqrestore(&fdir->ctx_lock, flags);
1266                 WARN_ON_ONCE(1);
1267                 return;
1268         }
1269
1270         ctx_irq->flags &= ~ICE_VF_FDIR_CTX_VALID;
1271
1272         ctx_done->flags |= ICE_VF_FDIR_CTX_VALID;
1273         ctx_done->conf = ctx_irq->conf;
1274         ctx_done->stat = ICE_FDIR_CTX_TIMEOUT;
1275         ctx_done->v_opcode = ctx_irq->v_opcode;
1276         spin_unlock_irqrestore(&fdir->ctx_lock, flags);
1277
1278         set_bit(ICE_FD_VF_FLUSH_CTX, pf->state);
1279         ice_service_task_schedule(pf);
1280 }
1281
1282 /**
1283  * ice_vc_fdir_irq_handler - ctrl_vsi Rx queue interrupt handler
1284  * @ctrl_vsi: pointer to a VF's CTRL VSI
1285  * @rx_desc: pointer to FDIR Rx queue descriptor
1286  */
1287 void
1288 ice_vc_fdir_irq_handler(struct ice_vsi *ctrl_vsi,
1289                         union ice_32b_rx_flex_desc *rx_desc)
1290 {
1291         struct ice_pf *pf = ctrl_vsi->back;
1292         struct ice_vf *vf = ctrl_vsi->vf;
1293         struct ice_vf_fdir_ctx *ctx_done;
1294         struct ice_vf_fdir_ctx *ctx_irq;
1295         struct ice_vf_fdir *fdir;
1296         unsigned long flags;
1297         struct device *dev;
1298         int ret;
1299
1300         if (WARN_ON(!vf))
1301                 return;
1302
1303         fdir = &vf->fdir;
1304         ctx_done = &fdir->ctx_done;
1305         ctx_irq = &fdir->ctx_irq;
1306         dev = ice_pf_to_dev(pf);
1307         spin_lock_irqsave(&fdir->ctx_lock, flags);
1308         if (!(ctx_irq->flags & ICE_VF_FDIR_CTX_VALID)) {
1309                 spin_unlock_irqrestore(&fdir->ctx_lock, flags);
1310                 WARN_ON_ONCE(1);
1311                 return;
1312         }
1313
1314         ctx_irq->flags &= ~ICE_VF_FDIR_CTX_VALID;
1315
1316         ctx_done->flags |= ICE_VF_FDIR_CTX_VALID;
1317         ctx_done->conf = ctx_irq->conf;
1318         ctx_done->stat = ICE_FDIR_CTX_IRQ;
1319         ctx_done->v_opcode = ctx_irq->v_opcode;
1320         memcpy(&ctx_done->rx_desc, rx_desc, sizeof(*rx_desc));
1321         spin_unlock_irqrestore(&fdir->ctx_lock, flags);
1322
1323         ret = del_timer(&ctx_irq->rx_tmr);
1324         if (!ret)
1325                 dev_err(dev, "VF %d: Unexpected inactive timer!\n", vf->vf_id);
1326
1327         set_bit(ICE_FD_VF_FLUSH_CTX, pf->state);
1328         ice_service_task_schedule(pf);
1329 }
1330
1331 /**
1332  * ice_vf_fdir_dump_info - dump FDIR information for diagnosis
1333  * @vf: pointer to the VF info
1334  */
1335 static void ice_vf_fdir_dump_info(struct ice_vf *vf)
1336 {
1337         struct ice_vsi *vf_vsi;
1338         u32 fd_size, fd_cnt;
1339         struct device *dev;
1340         struct ice_pf *pf;
1341         struct ice_hw *hw;
1342         u16 vsi_num;
1343
1344         pf = vf->pf;
1345         hw = &pf->hw;
1346         dev = ice_pf_to_dev(pf);
1347         vf_vsi = ice_get_vf_vsi(vf);
1348         if (!vf_vsi) {
1349                 dev_dbg(dev, "VF %d: invalid VSI pointer\n", vf->vf_id);
1350                 return;
1351         }
1352
1353         vsi_num = ice_get_hw_vsi_num(hw, vf_vsi->idx);
1354
1355         fd_size = rd32(hw, VSIQF_FD_SIZE(vsi_num));
1356         fd_cnt = rd32(hw, VSIQF_FD_CNT(vsi_num));
1357         dev_dbg(dev, "VF %d: space allocated: guar:0x%x, be:0x%x, space consumed: guar:0x%x, be:0x%x\n",
1358                 vf->vf_id,
1359                 (fd_size & VSIQF_FD_CNT_FD_GCNT_M) >> VSIQF_FD_CNT_FD_GCNT_S,
1360                 (fd_size & VSIQF_FD_CNT_FD_BCNT_M) >> VSIQF_FD_CNT_FD_BCNT_S,
1361                 (fd_cnt & VSIQF_FD_CNT_FD_GCNT_M) >> VSIQF_FD_CNT_FD_GCNT_S,
1362                 (fd_cnt & VSIQF_FD_CNT_FD_BCNT_M) >> VSIQF_FD_CNT_FD_BCNT_S);
1363 }
1364
1365 /**
1366  * ice_vf_verify_rx_desc - verify received FDIR programming status descriptor
1367  * @vf: pointer to the VF info
1368  * @ctx: FDIR context info for post processing
1369  * @status: virtchnl FDIR program status
1370  *
1371  * Return: 0 on success, and other on error.
1372  */
1373 static int
1374 ice_vf_verify_rx_desc(struct ice_vf *vf, struct ice_vf_fdir_ctx *ctx,
1375                       enum virtchnl_fdir_prgm_status *status)
1376 {
1377         struct device *dev = ice_pf_to_dev(vf->pf);
1378         u32 stat_err, error, prog_id;
1379         int ret;
1380
1381         stat_err = le16_to_cpu(ctx->rx_desc.wb.status_error0);
1382         if (((stat_err & ICE_FXD_FLTR_WB_QW1_DD_M) >>
1383             ICE_FXD_FLTR_WB_QW1_DD_S) != ICE_FXD_FLTR_WB_QW1_DD_YES) {
1384                 *status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
1385                 dev_err(dev, "VF %d: Desc Done not set\n", vf->vf_id);
1386                 ret = -EINVAL;
1387                 goto err_exit;
1388         }
1389
1390         prog_id = (stat_err & ICE_FXD_FLTR_WB_QW1_PROG_ID_M) >>
1391                 ICE_FXD_FLTR_WB_QW1_PROG_ID_S;
1392         if (prog_id == ICE_FXD_FLTR_WB_QW1_PROG_ADD &&
1393             ctx->v_opcode != VIRTCHNL_OP_ADD_FDIR_FILTER) {
1394                 dev_err(dev, "VF %d: Desc show add, but ctx not",
1395                         vf->vf_id);
1396                 *status = VIRTCHNL_FDIR_FAILURE_RULE_INVALID;
1397                 ret = -EINVAL;
1398                 goto err_exit;
1399         }
1400
1401         if (prog_id == ICE_FXD_FLTR_WB_QW1_PROG_DEL &&
1402             ctx->v_opcode != VIRTCHNL_OP_DEL_FDIR_FILTER) {
1403                 dev_err(dev, "VF %d: Desc show del, but ctx not",
1404                         vf->vf_id);
1405                 *status = VIRTCHNL_FDIR_FAILURE_RULE_INVALID;
1406                 ret = -EINVAL;
1407                 goto err_exit;
1408         }
1409
1410         error = (stat_err & ICE_FXD_FLTR_WB_QW1_FAIL_M) >>
1411                 ICE_FXD_FLTR_WB_QW1_FAIL_S;
1412         if (error == ICE_FXD_FLTR_WB_QW1_FAIL_YES) {
1413                 if (prog_id == ICE_FXD_FLTR_WB_QW1_PROG_ADD) {
1414                         dev_err(dev, "VF %d, Failed to add FDIR rule due to no space in the table",
1415                                 vf->vf_id);
1416                         *status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
1417                 } else {
1418                         dev_err(dev, "VF %d, Failed to remove FDIR rule, attempt to remove non-existent entry",
1419                                 vf->vf_id);
1420                         *status = VIRTCHNL_FDIR_FAILURE_RULE_NONEXIST;
1421                 }
1422                 ret = -EINVAL;
1423                 goto err_exit;
1424         }
1425
1426         error = (stat_err & ICE_FXD_FLTR_WB_QW1_FAIL_PROF_M) >>
1427                 ICE_FXD_FLTR_WB_QW1_FAIL_PROF_S;
1428         if (error == ICE_FXD_FLTR_WB_QW1_FAIL_PROF_YES) {
1429                 dev_err(dev, "VF %d: Profile matching error", vf->vf_id);
1430                 *status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
1431                 ret = -EINVAL;
1432                 goto err_exit;
1433         }
1434
1435         *status = VIRTCHNL_FDIR_SUCCESS;
1436
1437         return 0;
1438
1439 err_exit:
1440         ice_vf_fdir_dump_info(vf);
1441         return ret;
1442 }
1443
1444 /**
1445  * ice_vc_add_fdir_fltr_post
1446  * @vf: pointer to the VF structure
1447  * @ctx: FDIR context info for post processing
1448  * @status: virtchnl FDIR program status
1449  * @success: true implies success, false implies failure
1450  *
1451  * Post process for flow director add command. If success, then do post process
1452  * and send back success msg by virtchnl. Otherwise, do context reversion and
1453  * send back failure msg by virtchnl.
1454  *
1455  * Return: 0 on success, and other on error.
1456  */
1457 static int
1458 ice_vc_add_fdir_fltr_post(struct ice_vf *vf, struct ice_vf_fdir_ctx *ctx,
1459                           enum virtchnl_fdir_prgm_status status,
1460                           bool success)
1461 {
1462         struct virtchnl_fdir_fltr_conf *conf = ctx->conf;
1463         struct device *dev = ice_pf_to_dev(vf->pf);
1464         enum virtchnl_status_code v_ret;
1465         struct virtchnl_fdir_add *resp;
1466         int ret, len, is_tun;
1467
1468         v_ret = VIRTCHNL_STATUS_SUCCESS;
1469         len = sizeof(*resp);
1470         resp = kzalloc(len, GFP_KERNEL);
1471         if (!resp) {
1472                 len = 0;
1473                 v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY;
1474                 dev_dbg(dev, "VF %d: Alloc resp buf fail", vf->vf_id);
1475                 goto err_exit;
1476         }
1477
1478         if (!success)
1479                 goto err_exit;
1480
1481         is_tun = 0;
1482         resp->status = status;
1483         resp->flow_id = conf->flow_id;
1484         vf->fdir.fdir_fltr_cnt[conf->input.flow_type][is_tun]++;
1485
1486         ret = ice_vc_send_msg_to_vf(vf, ctx->v_opcode, v_ret,
1487                                     (u8 *)resp, len);
1488         kfree(resp);
1489
1490         dev_dbg(dev, "VF %d: flow_id:0x%X, FDIR %s success!\n",
1491                 vf->vf_id, conf->flow_id,
1492                 (ctx->v_opcode == VIRTCHNL_OP_ADD_FDIR_FILTER) ?
1493                 "add" : "del");
1494         return ret;
1495
1496 err_exit:
1497         if (resp)
1498                 resp->status = status;
1499         ice_vc_fdir_remove_entry(vf, conf, conf->flow_id);
1500         devm_kfree(dev, conf);
1501
1502         ret = ice_vc_send_msg_to_vf(vf, ctx->v_opcode, v_ret,
1503                                     (u8 *)resp, len);
1504         kfree(resp);
1505         return ret;
1506 }
1507
1508 /**
1509  * ice_vc_del_fdir_fltr_post
1510  * @vf: pointer to the VF structure
1511  * @ctx: FDIR context info for post processing
1512  * @status: virtchnl FDIR program status
1513  * @success: true implies success, false implies failure
1514  *
1515  * Post process for flow director del command. If success, then do post process
1516  * and send back success msg by virtchnl. Otherwise, do context reversion and
1517  * send back failure msg by virtchnl.
1518  *
1519  * Return: 0 on success, and other on error.
1520  */
1521 static int
1522 ice_vc_del_fdir_fltr_post(struct ice_vf *vf, struct ice_vf_fdir_ctx *ctx,
1523                           enum virtchnl_fdir_prgm_status status,
1524                           bool success)
1525 {
1526         struct virtchnl_fdir_fltr_conf *conf = ctx->conf;
1527         struct device *dev = ice_pf_to_dev(vf->pf);
1528         enum virtchnl_status_code v_ret;
1529         struct virtchnl_fdir_del *resp;
1530         int ret, len, is_tun;
1531
1532         v_ret = VIRTCHNL_STATUS_SUCCESS;
1533         len = sizeof(*resp);
1534         resp = kzalloc(len, GFP_KERNEL);
1535         if (!resp) {
1536                 len = 0;
1537                 v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY;
1538                 dev_dbg(dev, "VF %d: Alloc resp buf fail", vf->vf_id);
1539                 goto err_exit;
1540         }
1541
1542         if (!success)
1543                 goto err_exit;
1544
1545         is_tun = 0;
1546         resp->status = status;
1547         ice_vc_fdir_remove_entry(vf, conf, conf->flow_id);
1548         vf->fdir.fdir_fltr_cnt[conf->input.flow_type][is_tun]--;
1549
1550         ret = ice_vc_send_msg_to_vf(vf, ctx->v_opcode, v_ret,
1551                                     (u8 *)resp, len);
1552         kfree(resp);
1553
1554         dev_dbg(dev, "VF %d: flow_id:0x%X, FDIR %s success!\n",
1555                 vf->vf_id, conf->flow_id,
1556                 (ctx->v_opcode == VIRTCHNL_OP_ADD_FDIR_FILTER) ?
1557                 "add" : "del");
1558         devm_kfree(dev, conf);
1559         return ret;
1560
1561 err_exit:
1562         if (resp)
1563                 resp->status = status;
1564         if (success)
1565                 devm_kfree(dev, conf);
1566
1567         ret = ice_vc_send_msg_to_vf(vf, ctx->v_opcode, v_ret,
1568                                     (u8 *)resp, len);
1569         kfree(resp);
1570         return ret;
1571 }
1572
1573 /**
1574  * ice_flush_fdir_ctx
1575  * @pf: pointer to the PF structure
1576  *
1577  * Flush all the pending event on ctx_done list and process them.
1578  */
1579 void ice_flush_fdir_ctx(struct ice_pf *pf)
1580 {
1581         struct ice_vf *vf;
1582         unsigned int bkt;
1583
1584         if (!test_and_clear_bit(ICE_FD_VF_FLUSH_CTX, pf->state))
1585                 return;
1586
1587         mutex_lock(&pf->vfs.table_lock);
1588         ice_for_each_vf(pf, bkt, vf) {
1589                 struct device *dev = ice_pf_to_dev(pf);
1590                 enum virtchnl_fdir_prgm_status status;
1591                 struct ice_vf_fdir_ctx *ctx;
1592                 unsigned long flags;
1593                 int ret;
1594
1595                 if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states))
1596                         continue;
1597
1598                 if (vf->ctrl_vsi_idx == ICE_NO_VSI)
1599                         continue;
1600
1601                 ctx = &vf->fdir.ctx_done;
1602                 spin_lock_irqsave(&vf->fdir.ctx_lock, flags);
1603                 if (!(ctx->flags & ICE_VF_FDIR_CTX_VALID)) {
1604                         spin_unlock_irqrestore(&vf->fdir.ctx_lock, flags);
1605                         continue;
1606                 }
1607                 spin_unlock_irqrestore(&vf->fdir.ctx_lock, flags);
1608
1609                 WARN_ON(ctx->stat == ICE_FDIR_CTX_READY);
1610                 if (ctx->stat == ICE_FDIR_CTX_TIMEOUT) {
1611                         status = VIRTCHNL_FDIR_FAILURE_RULE_TIMEOUT;
1612                         dev_err(dev, "VF %d: ctrl_vsi irq timeout\n",
1613                                 vf->vf_id);
1614                         goto err_exit;
1615                 }
1616
1617                 ret = ice_vf_verify_rx_desc(vf, ctx, &status);
1618                 if (ret)
1619                         goto err_exit;
1620
1621                 if (ctx->v_opcode == VIRTCHNL_OP_ADD_FDIR_FILTER)
1622                         ice_vc_add_fdir_fltr_post(vf, ctx, status, true);
1623                 else if (ctx->v_opcode == VIRTCHNL_OP_DEL_FDIR_FILTER)
1624                         ice_vc_del_fdir_fltr_post(vf, ctx, status, true);
1625                 else
1626                         dev_err(dev, "VF %d: Unsupported opcode\n", vf->vf_id);
1627
1628                 spin_lock_irqsave(&vf->fdir.ctx_lock, flags);
1629                 ctx->flags &= ~ICE_VF_FDIR_CTX_VALID;
1630                 spin_unlock_irqrestore(&vf->fdir.ctx_lock, flags);
1631                 continue;
1632 err_exit:
1633                 if (ctx->v_opcode == VIRTCHNL_OP_ADD_FDIR_FILTER)
1634                         ice_vc_add_fdir_fltr_post(vf, ctx, status, false);
1635                 else if (ctx->v_opcode == VIRTCHNL_OP_DEL_FDIR_FILTER)
1636                         ice_vc_del_fdir_fltr_post(vf, ctx, status, false);
1637                 else
1638                         dev_err(dev, "VF %d: Unsupported opcode\n", vf->vf_id);
1639
1640                 spin_lock_irqsave(&vf->fdir.ctx_lock, flags);
1641                 ctx->flags &= ~ICE_VF_FDIR_CTX_VALID;
1642                 spin_unlock_irqrestore(&vf->fdir.ctx_lock, flags);
1643         }
1644         mutex_unlock(&pf->vfs.table_lock);
1645 }
1646
1647 /**
1648  * ice_vc_fdir_set_irq_ctx - set FDIR context info for later IRQ handler
1649  * @vf: pointer to the VF structure
1650  * @conf: FDIR configuration for each filter
1651  * @v_opcode: virtual channel operation code
1652  *
1653  * Return: 0 on success, and other on error.
1654  */
1655 static int
1656 ice_vc_fdir_set_irq_ctx(struct ice_vf *vf, struct virtchnl_fdir_fltr_conf *conf,
1657                         enum virtchnl_ops v_opcode)
1658 {
1659         struct device *dev = ice_pf_to_dev(vf->pf);
1660         struct ice_vf_fdir_ctx *ctx;
1661         unsigned long flags;
1662
1663         ctx = &vf->fdir.ctx_irq;
1664         spin_lock_irqsave(&vf->fdir.ctx_lock, flags);
1665         if ((vf->fdir.ctx_irq.flags & ICE_VF_FDIR_CTX_VALID) ||
1666             (vf->fdir.ctx_done.flags & ICE_VF_FDIR_CTX_VALID)) {
1667                 spin_unlock_irqrestore(&vf->fdir.ctx_lock, flags);
1668                 dev_dbg(dev, "VF %d: Last request is still in progress\n",
1669                         vf->vf_id);
1670                 return -EBUSY;
1671         }
1672         ctx->flags |= ICE_VF_FDIR_CTX_VALID;
1673         spin_unlock_irqrestore(&vf->fdir.ctx_lock, flags);
1674
1675         ctx->conf = conf;
1676         ctx->v_opcode = v_opcode;
1677         ctx->stat = ICE_FDIR_CTX_READY;
1678         timer_setup(&ctx->rx_tmr, ice_vf_fdir_timer, 0);
1679
1680         mod_timer(&ctx->rx_tmr, round_jiffies(msecs_to_jiffies(10) + jiffies));
1681
1682         return 0;
1683 }
1684
1685 /**
1686  * ice_vc_fdir_clear_irq_ctx - clear FDIR context info for IRQ handler
1687  * @vf: pointer to the VF structure
1688  *
1689  * Return: 0 on success, and other on error.
1690  */
1691 static void ice_vc_fdir_clear_irq_ctx(struct ice_vf *vf)
1692 {
1693         struct ice_vf_fdir_ctx *ctx = &vf->fdir.ctx_irq;
1694         unsigned long flags;
1695
1696         del_timer(&ctx->rx_tmr);
1697         spin_lock_irqsave(&vf->fdir.ctx_lock, flags);
1698         ctx->flags &= ~ICE_VF_FDIR_CTX_VALID;
1699         spin_unlock_irqrestore(&vf->fdir.ctx_lock, flags);
1700 }
1701
1702 /**
1703  * ice_vc_add_fdir_fltr - add a FDIR filter for VF by the msg buffer
1704  * @vf: pointer to the VF info
1705  * @msg: pointer to the msg buffer
1706  *
1707  * Return: 0 on success, and other on error.
1708  */
1709 int ice_vc_add_fdir_fltr(struct ice_vf *vf, u8 *msg)
1710 {
1711         struct virtchnl_fdir_add *fltr = (struct virtchnl_fdir_add *)msg;
1712         struct virtchnl_fdir_add *stat = NULL;
1713         struct virtchnl_fdir_fltr_conf *conf;
1714         enum virtchnl_status_code v_ret;
1715         struct device *dev;
1716         struct ice_pf *pf;
1717         int is_tun = 0;
1718         int len = 0;
1719         int ret;
1720
1721         pf = vf->pf;
1722         dev = ice_pf_to_dev(pf);
1723         ret = ice_vc_fdir_param_check(vf, fltr->vsi_id);
1724         if (ret) {
1725                 v_ret = VIRTCHNL_STATUS_ERR_PARAM;
1726                 dev_dbg(dev, "Parameter check for VF %d failed\n", vf->vf_id);
1727                 goto err_exit;
1728         }
1729
1730         ret = ice_vf_start_ctrl_vsi(vf);
1731         if (ret && (ret != -EEXIST)) {
1732                 v_ret = VIRTCHNL_STATUS_ERR_PARAM;
1733                 dev_err(dev, "Init FDIR for VF %d failed, ret:%d\n",
1734                         vf->vf_id, ret);
1735                 goto err_exit;
1736         }
1737
1738         stat = kzalloc(sizeof(*stat), GFP_KERNEL);
1739         if (!stat) {
1740                 v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY;
1741                 dev_dbg(dev, "Alloc stat for VF %d failed\n", vf->vf_id);
1742                 goto err_exit;
1743         }
1744
1745         conf = devm_kzalloc(dev, sizeof(*conf), GFP_KERNEL);
1746         if (!conf) {
1747                 v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY;
1748                 dev_dbg(dev, "Alloc conf for VF %d failed\n", vf->vf_id);
1749                 goto err_exit;
1750         }
1751
1752         len = sizeof(*stat);
1753         ret = ice_vc_validate_fdir_fltr(vf, fltr, conf);
1754         if (ret) {
1755                 v_ret = VIRTCHNL_STATUS_SUCCESS;
1756                 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_INVALID;
1757                 dev_dbg(dev, "Invalid FDIR filter from VF %d\n", vf->vf_id);
1758                 goto err_free_conf;
1759         }
1760
1761         if (fltr->validate_only) {
1762                 v_ret = VIRTCHNL_STATUS_SUCCESS;
1763                 stat->status = VIRTCHNL_FDIR_SUCCESS;
1764                 devm_kfree(dev, conf);
1765                 ret = ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_ADD_FDIR_FILTER,
1766                                             v_ret, (u8 *)stat, len);
1767                 goto exit;
1768         }
1769
1770         ret = ice_vc_fdir_config_input_set(vf, fltr, conf, is_tun);
1771         if (ret) {
1772                 v_ret = VIRTCHNL_STATUS_SUCCESS;
1773                 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_CONFLICT;
1774                 dev_err(dev, "VF %d: FDIR input set configure failed, ret:%d\n",
1775                         vf->vf_id, ret);
1776                 goto err_free_conf;
1777         }
1778
1779         ret = ice_vc_fdir_is_dup_fltr(vf, conf);
1780         if (ret) {
1781                 v_ret = VIRTCHNL_STATUS_SUCCESS;
1782                 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_EXIST;
1783                 dev_dbg(dev, "VF %d: duplicated FDIR rule detected\n",
1784                         vf->vf_id);
1785                 goto err_free_conf;
1786         }
1787
1788         ret = ice_vc_fdir_insert_entry(vf, conf, &conf->flow_id);
1789         if (ret) {
1790                 v_ret = VIRTCHNL_STATUS_SUCCESS;
1791                 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
1792                 dev_dbg(dev, "VF %d: insert FDIR list failed\n", vf->vf_id);
1793                 goto err_free_conf;
1794         }
1795
1796         ret = ice_vc_fdir_set_irq_ctx(vf, conf, VIRTCHNL_OP_ADD_FDIR_FILTER);
1797         if (ret) {
1798                 v_ret = VIRTCHNL_STATUS_SUCCESS;
1799                 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
1800                 dev_dbg(dev, "VF %d: set FDIR context failed\n", vf->vf_id);
1801                 goto err_free_conf;
1802         }
1803
1804         ret = ice_vc_fdir_write_fltr(vf, conf, true, is_tun);
1805         if (ret) {
1806                 v_ret = VIRTCHNL_STATUS_SUCCESS;
1807                 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
1808                 dev_err(dev, "VF %d: writing FDIR rule failed, ret:%d\n",
1809                         vf->vf_id, ret);
1810                 goto err_rem_entry;
1811         }
1812
1813 exit:
1814         kfree(stat);
1815         return ret;
1816
1817 err_rem_entry:
1818         ice_vc_fdir_clear_irq_ctx(vf);
1819         ice_vc_fdir_remove_entry(vf, conf, conf->flow_id);
1820 err_free_conf:
1821         devm_kfree(dev, conf);
1822 err_exit:
1823         ret = ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_ADD_FDIR_FILTER, v_ret,
1824                                     (u8 *)stat, len);
1825         kfree(stat);
1826         return ret;
1827 }
1828
1829 /**
1830  * ice_vc_del_fdir_fltr - delete a FDIR filter for VF by the msg buffer
1831  * @vf: pointer to the VF info
1832  * @msg: pointer to the msg buffer
1833  *
1834  * Return: 0 on success, and other on error.
1835  */
1836 int ice_vc_del_fdir_fltr(struct ice_vf *vf, u8 *msg)
1837 {
1838         struct virtchnl_fdir_del *fltr = (struct virtchnl_fdir_del *)msg;
1839         struct virtchnl_fdir_del *stat = NULL;
1840         struct virtchnl_fdir_fltr_conf *conf;
1841         enum virtchnl_status_code v_ret;
1842         struct device *dev;
1843         struct ice_pf *pf;
1844         int is_tun = 0;
1845         int len = 0;
1846         int ret;
1847
1848         pf = vf->pf;
1849         dev = ice_pf_to_dev(pf);
1850         ret = ice_vc_fdir_param_check(vf, fltr->vsi_id);
1851         if (ret) {
1852                 v_ret = VIRTCHNL_STATUS_ERR_PARAM;
1853                 dev_dbg(dev, "Parameter check for VF %d failed\n", vf->vf_id);
1854                 goto err_exit;
1855         }
1856
1857         stat = kzalloc(sizeof(*stat), GFP_KERNEL);
1858         if (!stat) {
1859                 v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY;
1860                 dev_dbg(dev, "Alloc stat for VF %d failed\n", vf->vf_id);
1861                 goto err_exit;
1862         }
1863
1864         len = sizeof(*stat);
1865
1866         conf = ice_vc_fdir_lookup_entry(vf, fltr->flow_id);
1867         if (!conf) {
1868                 v_ret = VIRTCHNL_STATUS_SUCCESS;
1869                 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NONEXIST;
1870                 dev_dbg(dev, "VF %d: FDIR invalid flow_id:0x%X\n",
1871                         vf->vf_id, fltr->flow_id);
1872                 goto err_exit;
1873         }
1874
1875         /* Just return failure when ctrl_vsi idx is invalid */
1876         if (vf->ctrl_vsi_idx == ICE_NO_VSI) {
1877                 v_ret = VIRTCHNL_STATUS_SUCCESS;
1878                 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
1879                 dev_err(dev, "Invalid FDIR ctrl_vsi for VF %d\n", vf->vf_id);
1880                 goto err_exit;
1881         }
1882
1883         ret = ice_vc_fdir_set_irq_ctx(vf, conf, VIRTCHNL_OP_DEL_FDIR_FILTER);
1884         if (ret) {
1885                 v_ret = VIRTCHNL_STATUS_SUCCESS;
1886                 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
1887                 dev_dbg(dev, "VF %d: set FDIR context failed\n", vf->vf_id);
1888                 goto err_exit;
1889         }
1890
1891         ret = ice_vc_fdir_write_fltr(vf, conf, false, is_tun);
1892         if (ret) {
1893                 v_ret = VIRTCHNL_STATUS_SUCCESS;
1894                 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
1895                 dev_err(dev, "VF %d: writing FDIR rule failed, ret:%d\n",
1896                         vf->vf_id, ret);
1897                 goto err_del_tmr;
1898         }
1899
1900         kfree(stat);
1901
1902         return ret;
1903
1904 err_del_tmr:
1905         ice_vc_fdir_clear_irq_ctx(vf);
1906 err_exit:
1907         ret = ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_DEL_FDIR_FILTER, v_ret,
1908                                     (u8 *)stat, len);
1909         kfree(stat);
1910         return ret;
1911 }
1912
1913 /**
1914  * ice_vf_fdir_init - init FDIR resource for VF
1915  * @vf: pointer to the VF info
1916  */
1917 void ice_vf_fdir_init(struct ice_vf *vf)
1918 {
1919         struct ice_vf_fdir *fdir = &vf->fdir;
1920
1921         idr_init(&fdir->fdir_rule_idr);
1922         INIT_LIST_HEAD(&fdir->fdir_rule_list);
1923
1924         spin_lock_init(&fdir->ctx_lock);
1925         fdir->ctx_irq.flags = 0;
1926         fdir->ctx_done.flags = 0;
1927 }
1928
1929 /**
1930  * ice_vf_fdir_exit - destroy FDIR resource for VF
1931  * @vf: pointer to the VF info
1932  */
1933 void ice_vf_fdir_exit(struct ice_vf *vf)
1934 {
1935         ice_vc_fdir_flush_entry(vf);
1936         idr_destroy(&vf->fdir.fdir_rule_idr);
1937         ice_vc_fdir_rem_prof_all(vf);
1938         ice_vc_fdir_free_prof_all(vf);
1939 }