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