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