drivers/net/ethernet/aquantia/atlantic/aq_filters.c

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