1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* Copyright (C) 2014-2017 aQuantia Corporation. */ 3 4 /* File aq_filters.c: RX filters related functions. */ 5 6 #include "aq_filters.h" 7 8 static bool __must_check 9 aq_rule_is_approve(struct ethtool_rx_flow_spec *fsp) 10 { 11 if (fsp->flow_type & FLOW_MAC_EXT) 12 return false; 13 14 switch (fsp->flow_type & ~FLOW_EXT) { 15 case ETHER_FLOW: 16 case TCP_V4_FLOW: 17 case UDP_V4_FLOW: 18 case SCTP_V4_FLOW: 19 case TCP_V6_FLOW: 20 case UDP_V6_FLOW: 21 case SCTP_V6_FLOW: 22 case IPV4_FLOW: 23 case IPV6_FLOW: 24 return true; 25 case IP_USER_FLOW: 26 switch (fsp->h_u.usr_ip4_spec.proto) { 27 case IPPROTO_TCP: 28 case IPPROTO_UDP: 29 case IPPROTO_SCTP: 30 case IPPROTO_IP: 31 return true; 32 default: 33 return false; 34 } 35 case IPV6_USER_FLOW: 36 switch (fsp->h_u.usr_ip6_spec.l4_proto) { 37 case IPPROTO_TCP: 38 case IPPROTO_UDP: 39 case IPPROTO_SCTP: 40 case IPPROTO_IP: 41 return true; 42 default: 43 return false; 44 } 45 default: 46 return false; 47 } 48 49 return false; 50 } 51 52 static bool __must_check 53 aq_match_filter(struct ethtool_rx_flow_spec *fsp1, 54 struct ethtool_rx_flow_spec *fsp2) 55 { 56 if (fsp1->flow_type != fsp2->flow_type || 57 memcmp(&fsp1->h_u, &fsp2->h_u, sizeof(fsp2->h_u)) || 58 memcmp(&fsp1->h_ext, &fsp2->h_ext, sizeof(fsp2->h_ext)) || 59 memcmp(&fsp1->m_u, &fsp2->m_u, sizeof(fsp2->m_u)) || 60 memcmp(&fsp1->m_ext, &fsp2->m_ext, sizeof(fsp2->m_ext))) 61 return false; 62 63 return true; 64 } 65 66 static bool __must_check 67 aq_rule_already_exists(struct aq_nic_s *aq_nic, 68 struct ethtool_rx_flow_spec *fsp) 69 { 70 struct aq_rx_filter *rule; 71 struct hlist_node *aq_node2; 72 struct aq_hw_rx_fltrs_s *rx_fltrs = aq_get_hw_rx_fltrs(aq_nic); 73 74 hlist_for_each_entry_safe(rule, aq_node2, 75 &rx_fltrs->filter_list, aq_node) { 76 if (rule->aq_fsp.location == fsp->location) 77 continue; 78 if (aq_match_filter(&rule->aq_fsp, fsp)) { 79 netdev_err(aq_nic->ndev, 80 "ethtool: This filter is already set\n"); 81 return true; 82 } 83 } 84 85 return false; 86 } 87 88 static int aq_check_approve_fl3l4(struct aq_nic_s *aq_nic, 89 struct aq_hw_rx_fltrs_s *rx_fltrs, 90 struct ethtool_rx_flow_spec *fsp) 91 { 92 if (fsp->location < AQ_RX_FIRST_LOC_FL3L4 || 93 fsp->location > AQ_RX_LAST_LOC_FL3L4) { 94 netdev_err(aq_nic->ndev, 95 "ethtool: location must be in range [%d, %d]", 96 AQ_RX_FIRST_LOC_FL3L4, 97 AQ_RX_LAST_LOC_FL3L4); 98 return -EINVAL; 99 } 100 if (rx_fltrs->fl3l4.is_ipv6 && rx_fltrs->fl3l4.active_ipv4) { 101 rx_fltrs->fl3l4.is_ipv6 = false; 102 netdev_err(aq_nic->ndev, 103 "ethtool: mixing ipv4 and ipv6 is not allowed"); 104 return -EINVAL; 105 } else if (!rx_fltrs->fl3l4.is_ipv6 && rx_fltrs->fl3l4.active_ipv6) { 106 rx_fltrs->fl3l4.is_ipv6 = true; 107 netdev_err(aq_nic->ndev, 108 "ethtool: mixing ipv4 and ipv6 is not allowed"); 109 return -EINVAL; 110 } else if (rx_fltrs->fl3l4.is_ipv6 && 111 fsp->location != AQ_RX_FIRST_LOC_FL3L4 + 4 && 112 fsp->location != AQ_RX_FIRST_LOC_FL3L4) { 113 netdev_err(aq_nic->ndev, 114 "ethtool: The specified location for ipv6 must be %d or %d", 115 AQ_RX_FIRST_LOC_FL3L4, AQ_RX_FIRST_LOC_FL3L4 + 4); 116 return -EINVAL; 117 } 118 119 return 0; 120 } 121 122 static int __must_check 123 aq_check_approve_fl2(struct aq_nic_s *aq_nic, 124 struct aq_hw_rx_fltrs_s *rx_fltrs, 125 struct ethtool_rx_flow_spec *fsp) 126 { 127 if (fsp->location < AQ_RX_FIRST_LOC_FETHERT || 128 fsp->location > AQ_RX_LAST_LOC_FETHERT) { 129 netdev_err(aq_nic->ndev, 130 "ethtool: location must be in range [%d, %d]", 131 AQ_RX_FIRST_LOC_FETHERT, 132 AQ_RX_LAST_LOC_FETHERT); 133 return -EINVAL; 134 } 135 136 if (be16_to_cpu(fsp->m_ext.vlan_tci) == VLAN_PRIO_MASK && 137 fsp->m_u.ether_spec.h_proto == 0U) { 138 netdev_err(aq_nic->ndev, 139 "ethtool: proto (ether_type) parameter must be specified"); 140 return -EINVAL; 141 } 142 143 return 0; 144 } 145 146 static int __must_check 147 aq_check_approve_fvlan(struct aq_nic_s *aq_nic, 148 struct aq_hw_rx_fltrs_s *rx_fltrs, 149 struct ethtool_rx_flow_spec *fsp) 150 { 151 if (fsp->location < AQ_RX_FIRST_LOC_FVLANID || 152 fsp->location > AQ_RX_LAST_LOC_FVLANID) { 153 netdev_err(aq_nic->ndev, 154 "ethtool: location must be in range [%d, %d]", 155 AQ_RX_FIRST_LOC_FVLANID, 156 AQ_RX_LAST_LOC_FVLANID); 157 return -EINVAL; 158 } 159 160 if ((aq_nic->ndev->features & NETIF_F_HW_VLAN_CTAG_FILTER) && 161 (!test_bit(be16_to_cpu(fsp->h_ext.vlan_tci), 162 aq_nic->active_vlans))) { 163 netdev_err(aq_nic->ndev, 164 "ethtool: unknown vlan-id specified"); 165 return -EINVAL; 166 } 167 168 if (fsp->ring_cookie > aq_nic->aq_nic_cfg.num_rss_queues) { 169 netdev_err(aq_nic->ndev, 170 "ethtool: queue number must be in range [0, %d]", 171 aq_nic->aq_nic_cfg.num_rss_queues - 1); 172 return -EINVAL; 173 } 174 return 0; 175 } 176 177 static int __must_check 178 aq_check_filter(struct aq_nic_s *aq_nic, 179 struct ethtool_rx_flow_spec *fsp) 180 { 181 int err = 0; 182 struct aq_hw_rx_fltrs_s *rx_fltrs = aq_get_hw_rx_fltrs(aq_nic); 183 184 if (fsp->flow_type & FLOW_EXT) { 185 if (be16_to_cpu(fsp->m_ext.vlan_tci) == VLAN_VID_MASK) { 186 err = aq_check_approve_fvlan(aq_nic, rx_fltrs, fsp); 187 } else if (be16_to_cpu(fsp->m_ext.vlan_tci) == VLAN_PRIO_MASK) { 188 err = aq_check_approve_fl2(aq_nic, rx_fltrs, fsp); 189 } else { 190 netdev_err(aq_nic->ndev, 191 "ethtool: invalid vlan mask 0x%x specified", 192 be16_to_cpu(fsp->m_ext.vlan_tci)); 193 err = -EINVAL; 194 } 195 } else { 196 switch (fsp->flow_type & ~FLOW_EXT) { 197 case ETHER_FLOW: 198 err = aq_check_approve_fl2(aq_nic, rx_fltrs, fsp); 199 break; 200 case TCP_V4_FLOW: 201 case UDP_V4_FLOW: 202 case SCTP_V4_FLOW: 203 case IPV4_FLOW: 204 case IP_USER_FLOW: 205 rx_fltrs->fl3l4.is_ipv6 = false; 206 err = aq_check_approve_fl3l4(aq_nic, rx_fltrs, fsp); 207 break; 208 case TCP_V6_FLOW: 209 case UDP_V6_FLOW: 210 case SCTP_V6_FLOW: 211 case IPV6_FLOW: 212 case IPV6_USER_FLOW: 213 rx_fltrs->fl3l4.is_ipv6 = true; 214 err = aq_check_approve_fl3l4(aq_nic, rx_fltrs, fsp); 215 break; 216 default: 217 netdev_err(aq_nic->ndev, 218 "ethtool: unknown flow-type specified"); 219 err = -EINVAL; 220 } 221 } 222 223 return err; 224 } 225 226 static bool __must_check 227 aq_rule_is_not_support(struct aq_nic_s *aq_nic, 228 struct ethtool_rx_flow_spec *fsp) 229 { 230 bool rule_is_not_support = false; 231 232 if (!(aq_nic->ndev->features & NETIF_F_NTUPLE)) { 233 netdev_err(aq_nic->ndev, 234 "ethtool: Please, to enable the RX flow control:\n" 235 "ethtool -K %s ntuple on\n", aq_nic->ndev->name); 236 rule_is_not_support = true; 237 } else if (!aq_rule_is_approve(fsp)) { 238 netdev_err(aq_nic->ndev, 239 "ethtool: The specified flow type is not supported\n"); 240 rule_is_not_support = true; 241 } else if ((fsp->flow_type & ~FLOW_EXT) != ETHER_FLOW && 242 (fsp->h_u.tcp_ip4_spec.tos || 243 fsp->h_u.tcp_ip6_spec.tclass)) { 244 netdev_err(aq_nic->ndev, 245 "ethtool: The specified tos tclass are not supported\n"); 246 rule_is_not_support = true; 247 } else if (fsp->flow_type & FLOW_MAC_EXT) { 248 netdev_err(aq_nic->ndev, 249 "ethtool: MAC_EXT is not supported"); 250 rule_is_not_support = true; 251 } 252 253 return rule_is_not_support; 254 } 255 256 static bool __must_check 257 aq_rule_is_not_correct(struct aq_nic_s *aq_nic, 258 struct ethtool_rx_flow_spec *fsp) 259 { 260 bool rule_is_not_correct = false; 261 262 if (!aq_nic) { 263 rule_is_not_correct = true; 264 } else if (fsp->location > AQ_RX_MAX_RXNFC_LOC) { 265 netdev_err(aq_nic->ndev, 266 "ethtool: The specified number %u rule is invalid\n", 267 fsp->location); 268 rule_is_not_correct = true; 269 } else if (aq_check_filter(aq_nic, fsp)) { 270 rule_is_not_correct = true; 271 } else if (fsp->ring_cookie != RX_CLS_FLOW_DISC) { 272 if (fsp->ring_cookie >= aq_nic->aq_nic_cfg.num_rss_queues) { 273 netdev_err(aq_nic->ndev, 274 "ethtool: The specified action is invalid.\n" 275 "Maximum allowable value action is %u.\n", 276 aq_nic->aq_nic_cfg.num_rss_queues - 1); 277 rule_is_not_correct = true; 278 } 279 } 280 281 return rule_is_not_correct; 282 } 283 284 static int __must_check 285 aq_check_rule(struct aq_nic_s *aq_nic, 286 struct ethtool_rx_flow_spec *fsp) 287 { 288 int err = 0; 289 290 if (aq_rule_is_not_correct(aq_nic, fsp)) 291 err = -EINVAL; 292 else if (aq_rule_is_not_support(aq_nic, fsp)) 293 err = -EOPNOTSUPP; 294 else if (aq_rule_already_exists(aq_nic, fsp)) 295 err = -EEXIST; 296 297 return err; 298 } 299 300 static void aq_set_data_fl2(struct aq_nic_s *aq_nic, 301 struct aq_rx_filter *aq_rx_fltr, 302 struct aq_rx_filter_l2 *data, bool add) 303 { 304 const struct ethtool_rx_flow_spec *fsp = &aq_rx_fltr->aq_fsp; 305 306 memset(data, 0, sizeof(*data)); 307 308 data->location = fsp->location - AQ_RX_FIRST_LOC_FETHERT; 309 310 if (fsp->ring_cookie != RX_CLS_FLOW_DISC) 311 data->queue = fsp->ring_cookie; 312 else 313 data->queue = -1; 314 315 data->ethertype = be16_to_cpu(fsp->h_u.ether_spec.h_proto); 316 data->user_priority_en = be16_to_cpu(fsp->m_ext.vlan_tci) 317 == VLAN_PRIO_MASK; 318 data->user_priority = (be16_to_cpu(fsp->h_ext.vlan_tci) 319 & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT; 320 } 321 322 static int aq_add_del_fether(struct aq_nic_s *aq_nic, 323 struct aq_rx_filter *aq_rx_fltr, bool add) 324 { 325 struct aq_rx_filter_l2 data; 326 struct aq_hw_s *aq_hw = aq_nic->aq_hw; 327 const struct aq_hw_ops *aq_hw_ops = aq_nic->aq_hw_ops; 328 329 aq_set_data_fl2(aq_nic, aq_rx_fltr, &data, add); 330 331 if (unlikely(!aq_hw_ops->hw_filter_l2_set)) 332 return -EOPNOTSUPP; 333 if (unlikely(!aq_hw_ops->hw_filter_l2_clear)) 334 return -EOPNOTSUPP; 335 336 if (add) 337 return aq_hw_ops->hw_filter_l2_set(aq_hw, &data); 338 else 339 return aq_hw_ops->hw_filter_l2_clear(aq_hw, &data); 340 } 341 342 static bool aq_fvlan_is_busy(struct aq_rx_filter_vlan *aq_vlans, int vlan) 343 { 344 int i; 345 346 for (i = 0; i < AQ_VLAN_MAX_FILTERS; ++i) { 347 if (aq_vlans[i].enable && 348 aq_vlans[i].queue != AQ_RX_QUEUE_NOT_ASSIGNED && 349 aq_vlans[i].vlan_id == vlan) { 350 return true; 351 } 352 } 353 354 return false; 355 } 356 357 /* Function rebuilds array of vlan filters so that filters with assigned 358 * queue have a precedence over just vlans on the interface. 359 */ 360 static void aq_fvlan_rebuild(struct aq_nic_s *aq_nic, 361 unsigned long *active_vlans, 362 struct aq_rx_filter_vlan *aq_vlans) 363 { 364 bool vlan_busy = false; 365 int vlan = -1; 366 int i; 367 368 for (i = 0; i < AQ_VLAN_MAX_FILTERS; ++i) { 369 if (aq_vlans[i].enable && 370 aq_vlans[i].queue != AQ_RX_QUEUE_NOT_ASSIGNED) 371 continue; 372 do { 373 vlan = find_next_bit(active_vlans, 374 VLAN_N_VID, 375 vlan + 1); 376 if (vlan == VLAN_N_VID) { 377 aq_vlans[i].enable = 0U; 378 aq_vlans[i].queue = AQ_RX_QUEUE_NOT_ASSIGNED; 379 aq_vlans[i].vlan_id = 0; 380 continue; 381 } 382 383 vlan_busy = aq_fvlan_is_busy(aq_vlans, vlan); 384 if (!vlan_busy) { 385 aq_vlans[i].enable = 1U; 386 aq_vlans[i].queue = AQ_RX_QUEUE_NOT_ASSIGNED; 387 aq_vlans[i].vlan_id = vlan; 388 } 389 } while (vlan_busy && vlan != VLAN_N_VID); 390 } 391 } 392 393 static int aq_set_data_fvlan(struct aq_nic_s *aq_nic, 394 struct aq_rx_filter *aq_rx_fltr, 395 struct aq_rx_filter_vlan *aq_vlans, bool add) 396 { 397 const struct ethtool_rx_flow_spec *fsp = &aq_rx_fltr->aq_fsp; 398 int location = fsp->location - AQ_RX_FIRST_LOC_FVLANID; 399 int i; 400 401 memset(&aq_vlans[location], 0, sizeof(aq_vlans[location])); 402 403 if (!add) 404 return 0; 405 406 /* remove vlan if it was in table without queue assignment */ 407 for (i = 0; i < AQ_VLAN_MAX_FILTERS; ++i) { 408 if (aq_vlans[i].vlan_id == 409 (be16_to_cpu(fsp->h_ext.vlan_tci) & VLAN_VID_MASK)) { 410 aq_vlans[i].enable = false; 411 } 412 } 413 414 aq_vlans[location].location = location; 415 aq_vlans[location].vlan_id = be16_to_cpu(fsp->h_ext.vlan_tci) 416 & VLAN_VID_MASK; 417 aq_vlans[location].queue = fsp->ring_cookie & 0x1FU; 418 aq_vlans[location].enable = 1U; 419 420 return 0; 421 } 422 423 int aq_del_fvlan_by_vlan(struct aq_nic_s *aq_nic, u16 vlan_id) 424 { 425 struct aq_hw_rx_fltrs_s *rx_fltrs = aq_get_hw_rx_fltrs(aq_nic); 426 struct aq_rx_filter *rule = NULL; 427 struct hlist_node *aq_node2; 428 429 hlist_for_each_entry_safe(rule, aq_node2, 430 &rx_fltrs->filter_list, aq_node) { 431 if (be16_to_cpu(rule->aq_fsp.h_ext.vlan_tci) == vlan_id) 432 break; 433 } 434 if (rule && be16_to_cpu(rule->aq_fsp.h_ext.vlan_tci) == vlan_id) { 435 struct ethtool_rxnfc cmd; 436 437 cmd.fs.location = rule->aq_fsp.location; 438 return aq_del_rxnfc_rule(aq_nic, &cmd); 439 } 440 441 return -ENOENT; 442 } 443 444 static int aq_add_del_fvlan(struct aq_nic_s *aq_nic, 445 struct aq_rx_filter *aq_rx_fltr, bool add) 446 { 447 const struct aq_hw_ops *aq_hw_ops = aq_nic->aq_hw_ops; 448 449 if (unlikely(!aq_hw_ops->hw_filter_vlan_set)) 450 return -EOPNOTSUPP; 451 452 aq_set_data_fvlan(aq_nic, 453 aq_rx_fltr, 454 aq_nic->aq_hw_rx_fltrs.fl2.aq_vlans, 455 add); 456 457 return aq_filters_vlans_update(aq_nic); 458 } 459 460 static int aq_set_data_fl3l4(struct aq_nic_s *aq_nic, 461 struct aq_rx_filter *aq_rx_fltr, 462 struct aq_rx_filter_l3l4 *data, bool add) 463 { 464 struct aq_hw_rx_fltrs_s *rx_fltrs = aq_get_hw_rx_fltrs(aq_nic); 465 const struct ethtool_rx_flow_spec *fsp = &aq_rx_fltr->aq_fsp; 466 467 memset(data, 0, sizeof(*data)); 468 469 data->is_ipv6 = rx_fltrs->fl3l4.is_ipv6; 470 data->location = HW_ATL_GET_REG_LOCATION_FL3L4(fsp->location); 471 472 if (!add) { 473 if (!data->is_ipv6) 474 rx_fltrs->fl3l4.active_ipv4 &= ~BIT(data->location); 475 else 476 rx_fltrs->fl3l4.active_ipv6 &= 477 ~BIT((data->location) / 4); 478 479 return 0; 480 } 481 482 data->cmd |= HW_ATL_RX_ENABLE_FLTR_L3L4; 483 484 switch (fsp->flow_type) { 485 case TCP_V4_FLOW: 486 case TCP_V6_FLOW: 487 data->cmd |= HW_ATL_RX_ENABLE_CMP_PROT_L4; 488 break; 489 case UDP_V4_FLOW: 490 case UDP_V6_FLOW: 491 data->cmd |= HW_ATL_RX_UDP; 492 data->cmd |= HW_ATL_RX_ENABLE_CMP_PROT_L4; 493 break; 494 case SCTP_V4_FLOW: 495 case SCTP_V6_FLOW: 496 data->cmd |= HW_ATL_RX_SCTP; 497 data->cmd |= HW_ATL_RX_ENABLE_CMP_PROT_L4; 498 break; 499 default: 500 break; 501 } 502 503 if (!data->is_ipv6) { 504 data->ip_src[0] = 505 ntohl(fsp->h_u.tcp_ip4_spec.ip4src); 506 data->ip_dst[0] = 507 ntohl(fsp->h_u.tcp_ip4_spec.ip4dst); 508 rx_fltrs->fl3l4.active_ipv4 |= BIT(data->location); 509 } else { 510 int i; 511 512 rx_fltrs->fl3l4.active_ipv6 |= BIT((data->location) / 4); 513 for (i = 0; i < HW_ATL_RX_CNT_REG_ADDR_IPV6; ++i) { 514 data->ip_dst[i] = 515 ntohl(fsp->h_u.tcp_ip6_spec.ip6dst[i]); 516 data->ip_src[i] = 517 ntohl(fsp->h_u.tcp_ip6_spec.ip6src[i]); 518 } 519 data->cmd |= HW_ATL_RX_ENABLE_L3_IPV6; 520 } 521 if (fsp->flow_type != IP_USER_FLOW && 522 fsp->flow_type != IPV6_USER_FLOW) { 523 if (!data->is_ipv6) { 524 data->p_dst = 525 ntohs(fsp->h_u.tcp_ip4_spec.pdst); 526 data->p_src = 527 ntohs(fsp->h_u.tcp_ip4_spec.psrc); 528 } else { 529 data->p_dst = 530 ntohs(fsp->h_u.tcp_ip6_spec.pdst); 531 data->p_src = 532 ntohs(fsp->h_u.tcp_ip6_spec.psrc); 533 } 534 } 535 if (data->ip_src[0] && !data->is_ipv6) 536 data->cmd |= HW_ATL_RX_ENABLE_CMP_SRC_ADDR_L3; 537 if (data->ip_dst[0] && !data->is_ipv6) 538 data->cmd |= HW_ATL_RX_ENABLE_CMP_DEST_ADDR_L3; 539 if (data->p_dst) 540 data->cmd |= HW_ATL_RX_ENABLE_CMP_DEST_PORT_L4; 541 if (data->p_src) 542 data->cmd |= HW_ATL_RX_ENABLE_CMP_SRC_PORT_L4; 543 if (fsp->ring_cookie != RX_CLS_FLOW_DISC) { 544 data->cmd |= HW_ATL_RX_HOST << HW_ATL_RX_ACTION_FL3F4_SHIFT; 545 data->cmd |= fsp->ring_cookie << HW_ATL_RX_QUEUE_FL3L4_SHIFT; 546 data->cmd |= HW_ATL_RX_ENABLE_QUEUE_L3L4; 547 } else { 548 data->cmd |= HW_ATL_RX_DISCARD << HW_ATL_RX_ACTION_FL3F4_SHIFT; 549 } 550 551 return 0; 552 } 553 554 static int aq_set_fl3l4(struct aq_hw_s *aq_hw, 555 const struct aq_hw_ops *aq_hw_ops, 556 struct aq_rx_filter_l3l4 *data) 557 { 558 if (unlikely(!aq_hw_ops->hw_filter_l3l4_set)) 559 return -EOPNOTSUPP; 560 561 return aq_hw_ops->hw_filter_l3l4_set(aq_hw, data); 562 } 563 564 static int aq_add_del_fl3l4(struct aq_nic_s *aq_nic, 565 struct aq_rx_filter *aq_rx_fltr, bool add) 566 { 567 const struct aq_hw_ops *aq_hw_ops = aq_nic->aq_hw_ops; 568 struct aq_hw_s *aq_hw = aq_nic->aq_hw; 569 struct aq_rx_filter_l3l4 data; 570 571 if (unlikely(aq_rx_fltr->aq_fsp.location < AQ_RX_FIRST_LOC_FL3L4 || 572 aq_rx_fltr->aq_fsp.location > AQ_RX_LAST_LOC_FL3L4 || 573 aq_set_data_fl3l4(aq_nic, aq_rx_fltr, &data, add))) 574 return -EINVAL; 575 576 return aq_set_fl3l4(aq_hw, aq_hw_ops, &data); 577 } 578 579 static int aq_add_del_rule(struct aq_nic_s *aq_nic, 580 struct aq_rx_filter *aq_rx_fltr, bool add) 581 { 582 int err = -EINVAL; 583 584 if (aq_rx_fltr->aq_fsp.flow_type & FLOW_EXT) { 585 if (be16_to_cpu(aq_rx_fltr->aq_fsp.m_ext.vlan_tci) 586 == VLAN_VID_MASK) { 587 aq_rx_fltr->type = aq_rx_filter_vlan; 588 err = aq_add_del_fvlan(aq_nic, aq_rx_fltr, add); 589 } else if (be16_to_cpu(aq_rx_fltr->aq_fsp.m_ext.vlan_tci) 590 == VLAN_PRIO_MASK) { 591 aq_rx_fltr->type = aq_rx_filter_ethertype; 592 err = aq_add_del_fether(aq_nic, aq_rx_fltr, add); 593 } 594 } else { 595 switch (aq_rx_fltr->aq_fsp.flow_type & ~FLOW_EXT) { 596 case ETHER_FLOW: 597 aq_rx_fltr->type = aq_rx_filter_ethertype; 598 err = aq_add_del_fether(aq_nic, aq_rx_fltr, add); 599 break; 600 case TCP_V4_FLOW: 601 case UDP_V4_FLOW: 602 case SCTP_V4_FLOW: 603 case IP_USER_FLOW: 604 case TCP_V6_FLOW: 605 case UDP_V6_FLOW: 606 case SCTP_V6_FLOW: 607 case IPV6_USER_FLOW: 608 aq_rx_fltr->type = aq_rx_filter_l3l4; 609 err = aq_add_del_fl3l4(aq_nic, aq_rx_fltr, add); 610 break; 611 default: 612 err = -EINVAL; 613 break; 614 } 615 } 616 617 return err; 618 } 619 620 static int aq_update_table_filters(struct aq_nic_s *aq_nic, 621 struct aq_rx_filter *aq_rx_fltr, u16 index, 622 struct ethtool_rxnfc *cmd) 623 { 624 struct aq_hw_rx_fltrs_s *rx_fltrs = aq_get_hw_rx_fltrs(aq_nic); 625 struct aq_rx_filter *rule = NULL, *parent = NULL; 626 struct hlist_node *aq_node2; 627 int err = -EINVAL; 628 629 hlist_for_each_entry_safe(rule, aq_node2, 630 &rx_fltrs->filter_list, aq_node) { 631 if (rule->aq_fsp.location >= index) 632 break; 633 parent = rule; 634 } 635 636 if (rule && rule->aq_fsp.location == index) { 637 err = aq_add_del_rule(aq_nic, rule, false); 638 hlist_del(&rule->aq_node); 639 kfree(rule); 640 --rx_fltrs->active_filters; 641 } 642 643 if (unlikely(!aq_rx_fltr)) 644 return err; 645 646 INIT_HLIST_NODE(&aq_rx_fltr->aq_node); 647 648 if (parent) 649 hlist_add_behind(&aq_rx_fltr->aq_node, &parent->aq_node); 650 else 651 hlist_add_head(&aq_rx_fltr->aq_node, &rx_fltrs->filter_list); 652 653 ++rx_fltrs->active_filters; 654 655 return 0; 656 } 657 658 u16 aq_get_rxnfc_count_all_rules(struct aq_nic_s *aq_nic) 659 { 660 struct aq_hw_rx_fltrs_s *rx_fltrs = aq_get_hw_rx_fltrs(aq_nic); 661 662 return rx_fltrs->active_filters; 663 } 664 665 struct aq_hw_rx_fltrs_s *aq_get_hw_rx_fltrs(struct aq_nic_s *aq_nic) 666 { 667 return &aq_nic->aq_hw_rx_fltrs; 668 } 669 670 int aq_add_rxnfc_rule(struct aq_nic_s *aq_nic, const struct ethtool_rxnfc *cmd) 671 { 672 struct aq_hw_rx_fltrs_s *rx_fltrs = aq_get_hw_rx_fltrs(aq_nic); 673 struct ethtool_rx_flow_spec *fsp = 674 (struct ethtool_rx_flow_spec *)&cmd->fs; 675 struct aq_rx_filter *aq_rx_fltr; 676 int err = 0; 677 678 err = aq_check_rule(aq_nic, fsp); 679 if (err) 680 goto err_exit; 681 682 aq_rx_fltr = kzalloc(sizeof(*aq_rx_fltr), GFP_KERNEL); 683 if (unlikely(!aq_rx_fltr)) { 684 err = -ENOMEM; 685 goto err_exit; 686 } 687 688 memcpy(&aq_rx_fltr->aq_fsp, fsp, sizeof(*fsp)); 689 690 err = aq_update_table_filters(aq_nic, aq_rx_fltr, fsp->location, NULL); 691 if (unlikely(err)) 692 goto err_free; 693 694 err = aq_add_del_rule(aq_nic, aq_rx_fltr, true); 695 if (unlikely(err)) { 696 hlist_del(&aq_rx_fltr->aq_node); 697 --rx_fltrs->active_filters; 698 goto err_free; 699 } 700 701 return 0; 702 703 err_free: 704 kfree(aq_rx_fltr); 705 err_exit: 706 return err; 707 } 708 709 int aq_del_rxnfc_rule(struct aq_nic_s *aq_nic, const struct ethtool_rxnfc *cmd) 710 { 711 struct aq_hw_rx_fltrs_s *rx_fltrs = aq_get_hw_rx_fltrs(aq_nic); 712 struct aq_rx_filter *rule = NULL; 713 struct hlist_node *aq_node2; 714 int err = -EINVAL; 715 716 hlist_for_each_entry_safe(rule, aq_node2, 717 &rx_fltrs->filter_list, aq_node) { 718 if (rule->aq_fsp.location == cmd->fs.location) 719 break; 720 } 721 722 if (rule && rule->aq_fsp.location == cmd->fs.location) { 723 err = aq_add_del_rule(aq_nic, rule, false); 724 hlist_del(&rule->aq_node); 725 kfree(rule); 726 --rx_fltrs->active_filters; 727 } 728 return err; 729 } 730 731 int aq_get_rxnfc_rule(struct aq_nic_s *aq_nic, struct ethtool_rxnfc *cmd) 732 { 733 struct aq_hw_rx_fltrs_s *rx_fltrs = aq_get_hw_rx_fltrs(aq_nic); 734 struct ethtool_rx_flow_spec *fsp = 735 (struct ethtool_rx_flow_spec *)&cmd->fs; 736 struct aq_rx_filter *rule = NULL; 737 struct hlist_node *aq_node2; 738 739 hlist_for_each_entry_safe(rule, aq_node2, 740 &rx_fltrs->filter_list, aq_node) 741 if (fsp->location <= rule->aq_fsp.location) 742 break; 743 744 if (unlikely(!rule || fsp->location != rule->aq_fsp.location)) 745 return -EINVAL; 746 747 memcpy(fsp, &rule->aq_fsp, sizeof(*fsp)); 748 749 return 0; 750 } 751 752 int aq_get_rxnfc_all_rules(struct aq_nic_s *aq_nic, struct ethtool_rxnfc *cmd, 753 u32 *rule_locs) 754 { 755 struct aq_hw_rx_fltrs_s *rx_fltrs = aq_get_hw_rx_fltrs(aq_nic); 756 struct hlist_node *aq_node2; 757 struct aq_rx_filter *rule; 758 int count = 0; 759 760 cmd->data = aq_get_rxnfc_count_all_rules(aq_nic); 761 762 hlist_for_each_entry_safe(rule, aq_node2, 763 &rx_fltrs->filter_list, aq_node) { 764 if (unlikely(count == cmd->rule_cnt)) 765 return -EMSGSIZE; 766 767 rule_locs[count++] = rule->aq_fsp.location; 768 } 769 770 cmd->rule_cnt = count; 771 772 return 0; 773 } 774 775 int aq_clear_rxnfc_all_rules(struct aq_nic_s *aq_nic) 776 { 777 struct aq_hw_rx_fltrs_s *rx_fltrs = aq_get_hw_rx_fltrs(aq_nic); 778 struct hlist_node *aq_node2; 779 struct aq_rx_filter *rule; 780 int err = 0; 781 782 hlist_for_each_entry_safe(rule, aq_node2, 783 &rx_fltrs->filter_list, aq_node) { 784 err = aq_add_del_rule(aq_nic, rule, false); 785 if (err) 786 goto err_exit; 787 hlist_del(&rule->aq_node); 788 kfree(rule); 789 --rx_fltrs->active_filters; 790 } 791 792 err_exit: 793 return err; 794 } 795 796 int aq_reapply_rxnfc_all_rules(struct aq_nic_s *aq_nic) 797 { 798 struct aq_hw_rx_fltrs_s *rx_fltrs = aq_get_hw_rx_fltrs(aq_nic); 799 struct hlist_node *aq_node2; 800 struct aq_rx_filter *rule; 801 int err = 0; 802 803 hlist_for_each_entry_safe(rule, aq_node2, 804 &rx_fltrs->filter_list, aq_node) { 805 err = aq_add_del_rule(aq_nic, rule, true); 806 if (err) 807 goto err_exit; 808 } 809 810 err_exit: 811 return err; 812 } 813 814 int aq_filters_vlans_update(struct aq_nic_s *aq_nic) 815 { 816 const struct aq_hw_ops *aq_hw_ops = aq_nic->aq_hw_ops; 817 struct aq_hw_s *aq_hw = aq_nic->aq_hw; 818 int hweight = 0; 819 int err = 0; 820 int i; 821 822 if (unlikely(!aq_hw_ops->hw_filter_vlan_set)) 823 return -EOPNOTSUPP; 824 if (unlikely(!aq_hw_ops->hw_filter_vlan_ctrl)) 825 return -EOPNOTSUPP; 826 827 aq_fvlan_rebuild(aq_nic, aq_nic->active_vlans, 828 aq_nic->aq_hw_rx_fltrs.fl2.aq_vlans); 829 830 if (aq_nic->ndev->features & NETIF_F_HW_VLAN_CTAG_FILTER) { 831 for (i = 0; i < BITS_TO_LONGS(VLAN_N_VID); i++) 832 hweight += hweight_long(aq_nic->active_vlans[i]); 833 834 err = aq_hw_ops->hw_filter_vlan_ctrl(aq_hw, false); 835 if (err) 836 return err; 837 } 838 839 err = aq_hw_ops->hw_filter_vlan_set(aq_hw, 840 aq_nic->aq_hw_rx_fltrs.fl2.aq_vlans 841 ); 842 if (err) 843 return err; 844 845 if (aq_nic->ndev->features & NETIF_F_HW_VLAN_CTAG_FILTER) { 846 if (hweight < AQ_VLAN_MAX_FILTERS) 847 err = aq_hw_ops->hw_filter_vlan_ctrl(aq_hw, true); 848 /* otherwise left in promiscue mode */ 849 } 850 851 return err; 852 } 853 854 int aq_filters_vlan_offload_off(struct aq_nic_s *aq_nic) 855 { 856 const struct aq_hw_ops *aq_hw_ops = aq_nic->aq_hw_ops; 857 struct aq_hw_s *aq_hw = aq_nic->aq_hw; 858 int err = 0; 859 860 memset(aq_nic->active_vlans, 0, sizeof(aq_nic->active_vlans)); 861 aq_fvlan_rebuild(aq_nic, aq_nic->active_vlans, 862 aq_nic->aq_hw_rx_fltrs.fl2.aq_vlans); 863 864 if (unlikely(!aq_hw_ops->hw_filter_vlan_set)) 865 return -EOPNOTSUPP; 866 if (unlikely(!aq_hw_ops->hw_filter_vlan_ctrl)) 867 return -EOPNOTSUPP; 868 869 err = aq_hw_ops->hw_filter_vlan_ctrl(aq_hw, false); 870 if (err) 871 return err; 872 err = aq_hw_ops->hw_filter_vlan_set(aq_hw, 873 aq_nic->aq_hw_rx_fltrs.fl2.aq_vlans 874 ); 875 return err; 876 } 877