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