drivers/net/ethernet/qlogic/qede/qede

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
qede_configure_arfs_fltr
qede_free_arfs_filter
qede_enqueue_fltr_and_config_searcher
qede_dequeue_fltr_and_config_searcher
qede_arfs_filter_op
qede_process_arfs_filters
qede_poll_for_freeing_arfs_filters
qede_alloc_arfs
qede_free_arfs
qede_compare_ip_addr
qede_arfs_htbl_key_search
qede_alloc_filter
qede_rx_flow_steer
qede_udp_ports_update
qede_force_mac
qede_fill_rss_params
qede_set_ucast_rx_mac
qede_set_ucast_rx_vlan
qede_config_accept_any_vlan
qede_vlan_rx_add_vid
qede_del_vlan_from_list
qede_configure_vlan_filters
qede_vlan_rx_kill_vid
qede_vlan_mark_nonconfigured
qede_set_features_reload
qede_fix_features
qede_set_features
qede_udp_tunnel_add
qede_udp_tunnel_del
qede_xdp_reload_func
qede_xdp_set
qede_xdp
qede_set_mcast_rx_mac
qede_set_mac_addr
qede_configure_mcast_filtering
qede_set_rx_mode
qede_config_rx_mode
qede_get_arfs_fltr_by_loc
qede_get_cls_rule_all
qede_get_cls_rule_entry
qede_poll_arfs_filter_config
qede_flow_get_min_header_size
qede_flow_spec_ipv4_cmp
qede_flow_build_ipv4_hdr
qede_flow_stringify_ipv4_hdr
qede_flow_spec_ipv6_cmp
qede_flow_build_ipv6_hdr
qede_flow_spec_validate_unused
qede_set_v4_tuple_to_profile
qede_set_v6_tuple_to_profile
qede_flow_find_fltr
qede_flow_set_destination
qede_delete_flow_filter
qede_get_arfs_filter_count
qede_parse_actions
qede_flow_parse_ports
qede_flow_parse_v6_common
qede_flow_parse_v4_common
qede_flow_parse_tcp_v6
qede_flow_parse_tcp_v4
qede_flow_parse_udp_v6
qede_flow_parse_udp_v4
qede_parse_flow_attr
qede_add_tc_flower_fltr
qede_flow_spec_validate
qede_flow_spec_to_rule
qede_add_cls_rule
   1 /* QLogic qede NIC Driver
   2  * Copyright (c) 2015-2017  QLogic Corporation
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and /or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32 #include <linux/netdevice.h>
  33 #include <linux/etherdevice.h>
  34 #include <net/udp_tunnel.h>
  35 #include <linux/bitops.h>
  36 #include <linux/vmalloc.h>
  37 
  38 #include <linux/qed/qed_if.h>
  39 #include "qede.h"
  40 
  41 #define QEDE_FILTER_PRINT_MAX_LEN       (64)
  42 struct qede_arfs_tuple {
  43         union {
  44                 __be32 src_ipv4;
  45                 struct in6_addr src_ipv6;
  46         };
  47         union {
  48                 __be32 dst_ipv4;
  49                 struct in6_addr dst_ipv6;
  50         };
  51         __be16  src_port;
  52         __be16  dst_port;
  53         __be16  eth_proto;
  54         u8      ip_proto;
  55 
  56         /* Describe filtering mode needed for this kind of filter */
  57         enum qed_filter_config_mode mode;
  58 
  59         /* Used to compare new/old filters. Return true if IPs match */
  60         bool (*ip_comp)(struct qede_arfs_tuple *a, struct qede_arfs_tuple *b);
  61 
  62         /* Given an address into ethhdr build a header from tuple info */
  63         void (*build_hdr)(struct qede_arfs_tuple *t, void *header);
  64 
  65         /* Stringify the tuple for a print into the provided buffer */
  66         void (*stringify)(struct qede_arfs_tuple *t, void *buffer);
  67 };
  68 
  69 struct qede_arfs_fltr_node {
  70 #define QEDE_FLTR_VALID  0
  71         unsigned long state;
  72 
  73         /* pointer to aRFS packet buffer */
  74         void *data;
  75 
  76         /* dma map address of aRFS packet buffer */
  77         dma_addr_t mapping;
  78 
  79         /* length of aRFS packet buffer */
  80         int buf_len;
  81 
  82         /* tuples to hold from aRFS packet buffer */
  83         struct qede_arfs_tuple tuple;
  84 
  85         u32 flow_id;
  86         u64 sw_id;
  87         u16 rxq_id;
  88         u16 next_rxq_id;
  89         u8 vfid;
  90         bool filter_op;
  91         bool used;
  92         u8 fw_rc;
  93         bool b_is_drop;
  94         struct hlist_node node;
  95 };
  96 
  97 struct qede_arfs {
  98 #define QEDE_ARFS_BUCKET_HEAD(edev, idx) (&(edev)->arfs->arfs_hl_head[idx])
  99 #define QEDE_ARFS_POLL_COUNT    100
 100 #define QEDE_RFS_FLW_BITSHIFT   (4)
 101 #define QEDE_RFS_FLW_MASK       ((1 << QEDE_RFS_FLW_BITSHIFT) - 1)
 102         struct hlist_head       arfs_hl_head[1 << QEDE_RFS_FLW_BITSHIFT];
 103 
 104         /* lock for filter list access */
 105         spinlock_t              arfs_list_lock;
 106         unsigned long           *arfs_fltr_bmap;
 107         int                     filter_count;
 108 
 109         /* Currently configured filtering mode */
 110         enum qed_filter_config_mode mode;
 111 };
 112 
 113 static void qede_configure_arfs_fltr(struct qede_dev *edev,
 114                                      struct qede_arfs_fltr_node *n,
 115                                      u16 rxq_id, bool add_fltr)
 116 {
 117         const struct qed_eth_ops *op = edev->ops;
 118         struct qed_ntuple_filter_params params;
 119 
 120         if (n->used)
 121                 return;
 122 
 123         memset(&params, 0, sizeof(params));
 124 
 125         params.addr = n->mapping;
 126         params.length = n->buf_len;
 127         params.qid = rxq_id;
 128         params.b_is_add = add_fltr;
 129         params.b_is_drop = n->b_is_drop;
 130 
 131         if (n->vfid) {
 132                 params.b_is_vf = true;
 133                 params.vf_id = n->vfid - 1;
 134         }
 135 
 136         if (n->tuple.stringify) {
 137                 char tuple_buffer[QEDE_FILTER_PRINT_MAX_LEN];
 138 
 139                 n->tuple.stringify(&n->tuple, tuple_buffer);
 140                 DP_VERBOSE(edev, NETIF_MSG_RX_STATUS,
 141                            "%s sw_id[0x%llx]: %s [vf %u queue %d]\n",
 142                            add_fltr ? "Adding" : "Deleting",
 143                            n->sw_id, tuple_buffer, n->vfid, rxq_id);
 144         }
 145 
 146         n->used = true;
 147         n->filter_op = add_fltr;
 148         op->ntuple_filter_config(edev->cdev, n, &params);
 149 }
 150 
 151 static void
 152 qede_free_arfs_filter(struct qede_dev *edev,  struct qede_arfs_fltr_node *fltr)
 153 {
 154         kfree(fltr->data);
 155 
 156         if (fltr->sw_id < QEDE_RFS_MAX_FLTR)
 157                 clear_bit(fltr->sw_id, edev->arfs->arfs_fltr_bmap);
 158 
 159         kfree(fltr);
 160 }
 161 
 162 static int
 163 qede_enqueue_fltr_and_config_searcher(struct qede_dev *edev,
 164                                       struct qede_arfs_fltr_node *fltr,
 165                                       u16 bucket_idx)
 166 {
 167         fltr->mapping = dma_map_single(&edev->pdev->dev, fltr->data,
 168                                        fltr->buf_len, DMA_TO_DEVICE);
 169         if (dma_mapping_error(&edev->pdev->dev, fltr->mapping)) {
 170                 DP_NOTICE(edev, "Failed to map DMA memory for rule\n");
 171                 qede_free_arfs_filter(edev, fltr);
 172                 return -ENOMEM;
 173         }
 174 
 175         INIT_HLIST_NODE(&fltr->node);
 176         hlist_add_head(&fltr->node,
 177                        QEDE_ARFS_BUCKET_HEAD(edev, bucket_idx));
 178 
 179         edev->arfs->filter_count++;
 180         if (edev->arfs->filter_count == 1 &&
 181             edev->arfs->mode == QED_FILTER_CONFIG_MODE_DISABLE) {
 182                 edev->ops->configure_arfs_searcher(edev->cdev,
 183                                                    fltr->tuple.mode);
 184                 edev->arfs->mode = fltr->tuple.mode;
 185         }
 186 
 187         return 0;
 188 }
 189 
 190 static void
 191 qede_dequeue_fltr_and_config_searcher(struct qede_dev *edev,
 192                                       struct qede_arfs_fltr_node *fltr)
 193 {
 194         hlist_del(&fltr->node);
 195         dma_unmap_single(&edev->pdev->dev, fltr->mapping,
 196                          fltr->buf_len, DMA_TO_DEVICE);
 197 
 198         qede_free_arfs_filter(edev, fltr);
 199 
 200         edev->arfs->filter_count--;
 201         if (!edev->arfs->filter_count &&
 202             edev->arfs->mode != QED_FILTER_CONFIG_MODE_DISABLE) {
 203                 enum qed_filter_config_mode mode;
 204 
 205                 mode = QED_FILTER_CONFIG_MODE_DISABLE;
 206                 edev->ops->configure_arfs_searcher(edev->cdev, mode);
 207                 edev->arfs->mode = QED_FILTER_CONFIG_MODE_DISABLE;
 208         }
 209 }
 210 
 211 void qede_arfs_filter_op(void *dev, void *filter, u8 fw_rc)
 212 {
 213         struct qede_arfs_fltr_node *fltr = filter;
 214         struct qede_dev *edev = dev;
 215 
 216         fltr->fw_rc = fw_rc;
 217 
 218         if (fw_rc) {
 219                 DP_NOTICE(edev,
 220                           "Failed arfs filter configuration fw_rc=%d, flow_id=%d, sw_id=0x%llx, src_port=%d, dst_port=%d, rxq=%d\n",
 221                           fw_rc, fltr->flow_id, fltr->sw_id,
 222                           ntohs(fltr->tuple.src_port),
 223                           ntohs(fltr->tuple.dst_port), fltr->rxq_id);
 224 
 225                 spin_lock_bh(&edev->arfs->arfs_list_lock);
 226 
 227                 fltr->used = false;
 228                 clear_bit(QEDE_FLTR_VALID, &fltr->state);
 229 
 230                 spin_unlock_bh(&edev->arfs->arfs_list_lock);
 231                 return;
 232         }
 233 
 234         spin_lock_bh(&edev->arfs->arfs_list_lock);
 235 
 236         fltr->used = false;
 237 
 238         if (fltr->filter_op) {
 239                 set_bit(QEDE_FLTR_VALID, &fltr->state);
 240                 if (fltr->rxq_id != fltr->next_rxq_id)
 241                         qede_configure_arfs_fltr(edev, fltr, fltr->rxq_id,
 242                                                  false);
 243         } else {
 244                 clear_bit(QEDE_FLTR_VALID, &fltr->state);
 245                 if (fltr->rxq_id != fltr->next_rxq_id) {
 246                         fltr->rxq_id = fltr->next_rxq_id;
 247                         qede_configure_arfs_fltr(edev, fltr,
 248                                                  fltr->rxq_id, true);
 249                 }
 250         }
 251 
 252         spin_unlock_bh(&edev->arfs->arfs_list_lock);
 253 }
 254 
 255 /* Should be called while qede_lock is held */
 256 void qede_process_arfs_filters(struct qede_dev *edev, bool free_fltr)
 257 {
 258         int i;
 259 
 260         for (i = 0; i <= QEDE_RFS_FLW_MASK; i++) {
 261                 struct hlist_node *temp;
 262                 struct hlist_head *head;
 263                 struct qede_arfs_fltr_node *fltr;
 264 
 265                 head = &edev->arfs->arfs_hl_head[i];
 266 
 267                 hlist_for_each_entry_safe(fltr, temp, head, node) {
 268                         bool del = false;
 269 
 270                         if (edev->state != QEDE_STATE_OPEN)
 271                                 del = true;
 272 
 273                         spin_lock_bh(&edev->arfs->arfs_list_lock);
 274 
 275                         if ((!test_bit(QEDE_FLTR_VALID, &fltr->state) &&
 276                              !fltr->used) || free_fltr) {
 277                                 qede_dequeue_fltr_and_config_searcher(edev,
 278                                                                       fltr);
 279                         } else {
 280                                 bool flow_exp = false;
 281 #ifdef CONFIG_RFS_ACCEL
 282                                 flow_exp = rps_may_expire_flow(edev->ndev,
 283                                                                fltr->rxq_id,
 284                                                                fltr->flow_id,
 285                                                                fltr->sw_id);
 286 #endif
 287                                 if ((flow_exp || del) && !free_fltr)
 288                                         qede_configure_arfs_fltr(edev, fltr,
 289                                                                  fltr->rxq_id,
 290                                                                  false);
 291                         }
 292 
 293                         spin_unlock_bh(&edev->arfs->arfs_list_lock);
 294                 }
 295         }
 296 
 297 #ifdef CONFIG_RFS_ACCEL
 298         spin_lock_bh(&edev->arfs->arfs_list_lock);
 299 
 300         if (edev->arfs->filter_count) {
 301                 set_bit(QEDE_SP_ARFS_CONFIG, &edev->sp_flags);
 302                 schedule_delayed_work(&edev->sp_task,
 303                                       QEDE_SP_TASK_POLL_DELAY);
 304         }
 305 
 306         spin_unlock_bh(&edev->arfs->arfs_list_lock);
 307 #endif
 308 }
 309 
 310 /* This function waits until all aRFS filters get deleted and freed.
 311  * On timeout it frees all filters forcefully.
 312  */
 313 void qede_poll_for_freeing_arfs_filters(struct qede_dev *edev)
 314 {
 315         int count = QEDE_ARFS_POLL_COUNT;
 316 
 317         while (count) {
 318                 qede_process_arfs_filters(edev, false);
 319 
 320                 if (!edev->arfs->filter_count)
 321                         break;
 322 
 323                 msleep(100);
 324                 count--;
 325         }
 326 
 327         if (!count) {
 328                 DP_NOTICE(edev, "Timeout in polling for arfs filter free\n");
 329 
 330                 /* Something is terribly wrong, free forcefully */
 331                 qede_process_arfs_filters(edev, true);
 332         }
 333 }
 334 
 335 int qede_alloc_arfs(struct qede_dev *edev)
 336 {
 337         int i;
 338 
 339         edev->arfs = vzalloc(sizeof(*edev->arfs));
 340         if (!edev->arfs)
 341                 return -ENOMEM;
 342 
 343         spin_lock_init(&edev->arfs->arfs_list_lock);
 344 
 345         for (i = 0; i <= QEDE_RFS_FLW_MASK; i++)
 346                 INIT_HLIST_HEAD(QEDE_ARFS_BUCKET_HEAD(edev, i));
 347 
 348         edev->arfs->arfs_fltr_bmap =
 349                 vzalloc(array_size(sizeof(long),
 350                                    BITS_TO_LONGS(QEDE_RFS_MAX_FLTR)));
 351         if (!edev->arfs->arfs_fltr_bmap) {
 352                 vfree(edev->arfs);
 353                 edev->arfs = NULL;
 354                 return -ENOMEM;
 355         }
 356 
 357 #ifdef CONFIG_RFS_ACCEL
 358         edev->ndev->rx_cpu_rmap = alloc_irq_cpu_rmap(QEDE_RSS_COUNT(edev));
 359         if (!edev->ndev->rx_cpu_rmap) {
 360                 vfree(edev->arfs->arfs_fltr_bmap);
 361                 edev->arfs->arfs_fltr_bmap = NULL;
 362                 vfree(edev->arfs);
 363                 edev->arfs = NULL;
 364                 return -ENOMEM;
 365         }
 366 #endif
 367         return 0;
 368 }
 369 
 370 void qede_free_arfs(struct qede_dev *edev)
 371 {
 372         if (!edev->arfs)
 373                 return;
 374 
 375 #ifdef CONFIG_RFS_ACCEL
 376         if (edev->ndev->rx_cpu_rmap)
 377                 free_irq_cpu_rmap(edev->ndev->rx_cpu_rmap);
 378 
 379         edev->ndev->rx_cpu_rmap = NULL;
 380 #endif
 381         vfree(edev->arfs->arfs_fltr_bmap);
 382         edev->arfs->arfs_fltr_bmap = NULL;
 383         vfree(edev->arfs);
 384         edev->arfs = NULL;
 385 }
 386 
 387 #ifdef CONFIG_RFS_ACCEL
 388 static bool qede_compare_ip_addr(struct qede_arfs_fltr_node *tpos,
 389                                  const struct sk_buff *skb)
 390 {
 391         if (skb->protocol == htons(ETH_P_IP)) {
 392                 if (tpos->tuple.src_ipv4 == ip_hdr(skb)->saddr &&
 393                     tpos->tuple.dst_ipv4 == ip_hdr(skb)->daddr)
 394                         return true;
 395                 else
 396                         return false;
 397         } else {
 398                 struct in6_addr *src = &tpos->tuple.src_ipv6;
 399                 u8 size = sizeof(struct in6_addr);
 400 
 401                 if (!memcmp(src, &ipv6_hdr(skb)->saddr, size) &&
 402                     !memcmp(&tpos->tuple.dst_ipv6, &ipv6_hdr(skb)->daddr, size))
 403                         return true;
 404                 else
 405                         return false;
 406         }
 407 }
 408 
 409 static struct qede_arfs_fltr_node *
 410 qede_arfs_htbl_key_search(struct hlist_head *h, const struct sk_buff *skb,
 411                           __be16 src_port, __be16 dst_port, u8 ip_proto)
 412 {
 413         struct qede_arfs_fltr_node *tpos;
 414 
 415         hlist_for_each_entry(tpos, h, node)
 416                 if (tpos->tuple.ip_proto == ip_proto &&
 417                     tpos->tuple.eth_proto == skb->protocol &&
 418                     qede_compare_ip_addr(tpos, skb) &&
 419                     tpos->tuple.src_port == src_port &&
 420                     tpos->tuple.dst_port == dst_port)
 421                         return tpos;
 422 
 423         return NULL;
 424 }
 425 
 426 static struct qede_arfs_fltr_node *
 427 qede_alloc_filter(struct qede_dev *edev, int min_hlen)
 428 {
 429         struct qede_arfs_fltr_node *n;
 430         int bit_id;
 431 
 432         bit_id = find_first_zero_bit(edev->arfs->arfs_fltr_bmap,
 433                                      QEDE_RFS_MAX_FLTR);
 434 
 435         if (bit_id >= QEDE_RFS_MAX_FLTR)
 436                 return NULL;
 437 
 438         n = kzalloc(sizeof(*n), GFP_ATOMIC);
 439         if (!n)
 440                 return NULL;
 441 
 442         n->data = kzalloc(min_hlen, GFP_ATOMIC);
 443         if (!n->data) {
 444                 kfree(n);
 445                 return NULL;
 446         }
 447 
 448         n->sw_id = (u16)bit_id;
 449         set_bit(bit_id, edev->arfs->arfs_fltr_bmap);
 450         return n;
 451 }
 452 
 453 int qede_rx_flow_steer(struct net_device *dev, const struct sk_buff *skb,
 454                        u16 rxq_index, u32 flow_id)
 455 {
 456         struct qede_dev *edev = netdev_priv(dev);
 457         struct qede_arfs_fltr_node *n;
 458         int min_hlen, rc, tp_offset;
 459         struct ethhdr *eth;
 460         __be16 *ports;
 461         u16 tbl_idx;
 462         u8 ip_proto;
 463 
 464         if (skb->encapsulation)
 465                 return -EPROTONOSUPPORT;
 466 
 467         if (skb->protocol != htons(ETH_P_IP) &&
 468             skb->protocol != htons(ETH_P_IPV6))
 469                 return -EPROTONOSUPPORT;
 470 
 471         if (skb->protocol == htons(ETH_P_IP)) {
 472                 ip_proto = ip_hdr(skb)->protocol;
 473                 tp_offset = sizeof(struct iphdr);
 474         } else {
 475                 ip_proto = ipv6_hdr(skb)->nexthdr;
 476                 tp_offset = sizeof(struct ipv6hdr);
 477         }
 478 
 479         if (ip_proto != IPPROTO_TCP && ip_proto != IPPROTO_UDP)
 480                 return -EPROTONOSUPPORT;
 481 
 482         ports = (__be16 *)(skb->data + tp_offset);
 483         tbl_idx = skb_get_hash_raw(skb) & QEDE_RFS_FLW_MASK;
 484 
 485         spin_lock_bh(&edev->arfs->arfs_list_lock);
 486 
 487         n = qede_arfs_htbl_key_search(QEDE_ARFS_BUCKET_HEAD(edev, tbl_idx),
 488                                       skb, ports[0], ports[1], ip_proto);
 489         if (n) {
 490                 /* Filter match */
 491                 n->next_rxq_id = rxq_index;
 492 
 493                 if (test_bit(QEDE_FLTR_VALID, &n->state)) {
 494                         if (n->rxq_id != rxq_index)
 495                                 qede_configure_arfs_fltr(edev, n, n->rxq_id,
 496                                                          false);
 497                 } else {
 498                         if (!n->used) {
 499                                 n->rxq_id = rxq_index;
 500                                 qede_configure_arfs_fltr(edev, n, n->rxq_id,
 501                                                          true);
 502                         }
 503                 }
 504 
 505                 rc = n->sw_id;
 506                 goto ret_unlock;
 507         }
 508 
 509         min_hlen = ETH_HLEN + skb_headlen(skb);
 510 
 511         n = qede_alloc_filter(edev, min_hlen);
 512         if (!n) {
 513                 rc = -ENOMEM;
 514                 goto ret_unlock;
 515         }
 516 
 517         n->buf_len = min_hlen;
 518         n->rxq_id = rxq_index;
 519         n->next_rxq_id = rxq_index;
 520         n->tuple.src_port = ports[0];
 521         n->tuple.dst_port = ports[1];
 522         n->flow_id = flow_id;
 523 
 524         if (skb->protocol == htons(ETH_P_IP)) {
 525                 n->tuple.src_ipv4 = ip_hdr(skb)->saddr;
 526                 n->tuple.dst_ipv4 = ip_hdr(skb)->daddr;
 527         } else {
 528                 memcpy(&n->tuple.src_ipv6, &ipv6_hdr(skb)->saddr,
 529                        sizeof(struct in6_addr));
 530                 memcpy(&n->tuple.dst_ipv6, &ipv6_hdr(skb)->daddr,
 531                        sizeof(struct in6_addr));
 532         }
 533 
 534         eth = (struct ethhdr *)n->data;
 535         eth->h_proto = skb->protocol;
 536         n->tuple.eth_proto = skb->protocol;
 537         n->tuple.ip_proto = ip_proto;
 538         n->tuple.mode = QED_FILTER_CONFIG_MODE_5_TUPLE;
 539         memcpy(n->data + ETH_HLEN, skb->data, skb_headlen(skb));
 540 
 541         rc = qede_enqueue_fltr_and_config_searcher(edev, n, tbl_idx);
 542         if (rc)
 543                 goto ret_unlock;
 544 
 545         qede_configure_arfs_fltr(edev, n, n->rxq_id, true);
 546 
 547         spin_unlock_bh(&edev->arfs->arfs_list_lock);
 548 
 549         set_bit(QEDE_SP_ARFS_CONFIG, &edev->sp_flags);
 550         schedule_delayed_work(&edev->sp_task, 0);
 551 
 552         return n->sw_id;
 553 
 554 ret_unlock:
 555         spin_unlock_bh(&edev->arfs->arfs_list_lock);
 556         return rc;
 557 }
 558 #endif
 559 
 560 void qede_udp_ports_update(void *dev, u16 vxlan_port, u16 geneve_port)
 561 {
 562         struct qede_dev *edev = dev;
 563 
 564         if (edev->vxlan_dst_port != vxlan_port)
 565                 edev->vxlan_dst_port = 0;
 566 
 567         if (edev->geneve_dst_port != geneve_port)
 568                 edev->geneve_dst_port = 0;
 569 }
 570 
 571 void qede_force_mac(void *dev, u8 *mac, bool forced)
 572 {
 573         struct qede_dev *edev = dev;
 574 
 575         __qede_lock(edev);
 576 
 577         if (!is_valid_ether_addr(mac)) {
 578                 __qede_unlock(edev);
 579                 return;
 580         }
 581 
 582         ether_addr_copy(edev->ndev->dev_addr, mac);
 583         __qede_unlock(edev);
 584 }
 585 
 586 void qede_fill_rss_params(struct qede_dev *edev,
 587                           struct qed_update_vport_rss_params *rss, u8 *update)
 588 {
 589         bool need_reset = false;
 590         int i;
 591 
 592         if (QEDE_RSS_COUNT(edev) <= 1) {
 593                 memset(rss, 0, sizeof(*rss));
 594                 *update = 0;
 595                 return;
 596         }
 597 
 598         /* Need to validate current RSS config uses valid entries */
 599         for (i = 0; i < QED_RSS_IND_TABLE_SIZE; i++) {
 600                 if (edev->rss_ind_table[i] >= QEDE_RSS_COUNT(edev)) {
 601                         need_reset = true;
 602                         break;
 603                 }
 604         }
 605 
 606         if (!(edev->rss_params_inited & QEDE_RSS_INDIR_INITED) || need_reset) {
 607                 for (i = 0; i < QED_RSS_IND_TABLE_SIZE; i++) {
 608                         u16 indir_val, val;
 609 
 610                         val = QEDE_RSS_COUNT(edev);
 611                         indir_val = ethtool_rxfh_indir_default(i, val);
 612                         edev->rss_ind_table[i] = indir_val;
 613                 }
 614                 edev->rss_params_inited |= QEDE_RSS_INDIR_INITED;
 615         }
 616 
 617         /* Now that we have the queue-indirection, prepare the handles */
 618         for (i = 0; i < QED_RSS_IND_TABLE_SIZE; i++) {
 619                 u16 idx = QEDE_RX_QUEUE_IDX(edev, edev->rss_ind_table[i]);
 620 
 621                 rss->rss_ind_table[i] = edev->fp_array[idx].rxq->handle;
 622         }
 623 
 624         if (!(edev->rss_params_inited & QEDE_RSS_KEY_INITED)) {
 625                 netdev_rss_key_fill(edev->rss_key, sizeof(edev->rss_key));
 626                 edev->rss_params_inited |= QEDE_RSS_KEY_INITED;
 627         }
 628         memcpy(rss->rss_key, edev->rss_key, sizeof(rss->rss_key));
 629 
 630         if (!(edev->rss_params_inited & QEDE_RSS_CAPS_INITED)) {
 631                 edev->rss_caps = QED_RSS_IPV4 | QED_RSS_IPV6 |
 632                     QED_RSS_IPV4_TCP | QED_RSS_IPV6_TCP;
 633                 edev->rss_params_inited |= QEDE_RSS_CAPS_INITED;
 634         }
 635         rss->rss_caps = edev->rss_caps;
 636 
 637         *update = 1;
 638 }
 639 
 640 static int qede_set_ucast_rx_mac(struct qede_dev *edev,
 641                                  enum qed_filter_xcast_params_type opcode,
 642                                  unsigned char mac[ETH_ALEN])
 643 {
 644         struct qed_filter_params filter_cmd;
 645 
 646         memset(&filter_cmd, 0, sizeof(filter_cmd));
 647         filter_cmd.type = QED_FILTER_TYPE_UCAST;
 648         filter_cmd.filter.ucast.type = opcode;
 649         filter_cmd.filter.ucast.mac_valid = 1;
 650         ether_addr_copy(filter_cmd.filter.ucast.mac, mac);
 651 
 652         return edev->ops->filter_config(edev->cdev, &filter_cmd);
 653 }
 654 
 655 static int qede_set_ucast_rx_vlan(struct qede_dev *edev,
 656                                   enum qed_filter_xcast_params_type opcode,
 657                                   u16 vid)
 658 {
 659         struct qed_filter_params filter_cmd;
 660 
 661         memset(&filter_cmd, 0, sizeof(filter_cmd));
 662         filter_cmd.type = QED_FILTER_TYPE_UCAST;
 663         filter_cmd.filter.ucast.type = opcode;
 664         filter_cmd.filter.ucast.vlan_valid = 1;
 665         filter_cmd.filter.ucast.vlan = vid;
 666 
 667         return edev->ops->filter_config(edev->cdev, &filter_cmd);
 668 }
 669 
 670 static int qede_config_accept_any_vlan(struct qede_dev *edev, bool action)
 671 {
 672         struct qed_update_vport_params *params;
 673         int rc;
 674 
 675         /* Proceed only if action actually needs to be performed */
 676         if (edev->accept_any_vlan == action)
 677                 return 0;
 678 
 679         params = vzalloc(sizeof(*params));
 680         if (!params)
 681                 return -ENOMEM;
 682 
 683         params->vport_id = 0;
 684         params->accept_any_vlan = action;
 685         params->update_accept_any_vlan_flg = 1;
 686 
 687         rc = edev->ops->vport_update(edev->cdev, params);
 688         if (rc) {
 689                 DP_ERR(edev, "Failed to %s accept-any-vlan\n",
 690                        action ? "enable" : "disable");
 691         } else {
 692                 DP_INFO(edev, "%s accept-any-vlan\n",
 693                         action ? "enabled" : "disabled");
 694                 edev->accept_any_vlan = action;
 695         }
 696 
 697         vfree(params);
 698         return 0;
 699 }
 700 
 701 int qede_vlan_rx_add_vid(struct net_device *dev, __be16 proto, u16 vid)
 702 {
 703         struct qede_dev *edev = netdev_priv(dev);
 704         struct qede_vlan *vlan, *tmp;
 705         int rc = 0;
 706 
 707         DP_VERBOSE(edev, NETIF_MSG_IFUP, "Adding vlan 0x%04x\n", vid);
 708 
 709         vlan = kzalloc(sizeof(*vlan), GFP_KERNEL);
 710         if (!vlan) {
 711                 DP_INFO(edev, "Failed to allocate struct for vlan\n");
 712                 return -ENOMEM;
 713         }
 714         INIT_LIST_HEAD(&vlan->list);
 715         vlan->vid = vid;
 716         vlan->configured = false;
 717 
 718         /* Verify vlan isn't already configured */
 719         list_for_each_entry(tmp, &edev->vlan_list, list) {
 720                 if (tmp->vid == vlan->vid) {
 721                         DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
 722                                    "vlan already configured\n");
 723                         kfree(vlan);
 724                         return -EEXIST;
 725                 }
 726         }
 727 
 728         /* If interface is down, cache this VLAN ID and return */
 729         __qede_lock(edev);
 730         if (edev->state != QEDE_STATE_OPEN) {
 731                 DP_VERBOSE(edev, NETIF_MSG_IFDOWN,
 732                            "Interface is down, VLAN %d will be configured when interface is up\n",
 733                            vid);
 734                 if (vid != 0)
 735                         edev->non_configured_vlans++;
 736                 list_add(&vlan->list, &edev->vlan_list);
 737                 goto out;
 738         }
 739 
 740         /* Check for the filter limit.
 741          * Note - vlan0 has a reserved filter and can be added without
 742          * worrying about quota
 743          */
 744         if ((edev->configured_vlans < edev->dev_info.num_vlan_filters) ||
 745             (vlan->vid == 0)) {
 746                 rc = qede_set_ucast_rx_vlan(edev,
 747                                             QED_FILTER_XCAST_TYPE_ADD,
 748                                             vlan->vid);
 749                 if (rc) {
 750                         DP_ERR(edev, "Failed to configure VLAN %d\n",
 751                                vlan->vid);
 752                         kfree(vlan);
 753                         goto out;
 754                 }
 755                 vlan->configured = true;
 756 
 757                 /* vlan0 filter isn't consuming out of our quota */
 758                 if (vlan->vid != 0)
 759                         edev->configured_vlans++;
 760         } else {
 761                 /* Out of quota; Activate accept-any-VLAN mode */
 762                 if (!edev->non_configured_vlans) {
 763                         rc = qede_config_accept_any_vlan(edev, true);
 764                         if (rc) {
 765                                 kfree(vlan);
 766                                 goto out;
 767                         }
 768                 }
 769 
 770                 edev->non_configured_vlans++;
 771         }
 772 
 773         list_add(&vlan->list, &edev->vlan_list);
 774 
 775 out:
 776         __qede_unlock(edev);
 777         return rc;
 778 }
 779 
 780 static void qede_del_vlan_from_list(struct qede_dev *edev,
 781                                     struct qede_vlan *vlan)
 782 {
 783         /* vlan0 filter isn't consuming out of our quota */
 784         if (vlan->vid != 0) {
 785                 if (vlan->configured)
 786                         edev->configured_vlans--;
 787                 else
 788                         edev->non_configured_vlans--;
 789         }
 790 
 791         list_del(&vlan->list);
 792         kfree(vlan);
 793 }
 794 
 795 int qede_configure_vlan_filters(struct qede_dev *edev)
 796 {
 797         int rc = 0, real_rc = 0, accept_any_vlan = 0;
 798         struct qed_dev_eth_info *dev_info;
 799         struct qede_vlan *vlan = NULL;
 800 
 801         if (list_empty(&edev->vlan_list))
 802                 return 0;
 803 
 804         dev_info = &edev->dev_info;
 805 
 806         /* Configure non-configured vlans */
 807         list_for_each_entry(vlan, &edev->vlan_list, list) {
 808                 if (vlan->configured)
 809                         continue;
 810 
 811                 /* We have used all our credits, now enable accept_any_vlan */
 812                 if ((vlan->vid != 0) &&
 813                     (edev->configured_vlans == dev_info->num_vlan_filters)) {
 814                         accept_any_vlan = 1;
 815                         continue;
 816                 }
 817 
 818                 DP_VERBOSE(edev, NETIF_MSG_IFUP, "Adding vlan %d\n", vlan->vid);
 819 
 820                 rc = qede_set_ucast_rx_vlan(edev, QED_FILTER_XCAST_TYPE_ADD,
 821                                             vlan->vid);
 822                 if (rc) {
 823                         DP_ERR(edev, "Failed to configure VLAN %u\n",
 824                                vlan->vid);
 825                         real_rc = rc;
 826                         continue;
 827                 }
 828 
 829                 vlan->configured = true;
 830                 /* vlan0 filter doesn't consume our VLAN filter's quota */
 831                 if (vlan->vid != 0) {
 832                         edev->non_configured_vlans--;
 833                         edev->configured_vlans++;
 834                 }
 835         }
 836 
 837         /* enable accept_any_vlan mode if we have more VLANs than credits,
 838          * or remove accept_any_vlan mode if we've actually removed
 839          * a non-configured vlan, and all remaining vlans are truly configured.
 840          */
 841 
 842         if (accept_any_vlan)
 843                 rc = qede_config_accept_any_vlan(edev, true);
 844         else if (!edev->non_configured_vlans)
 845                 rc = qede_config_accept_any_vlan(edev, false);
 846 
 847         if (rc && !real_rc)
 848                 real_rc = rc;
 849 
 850         return real_rc;
 851 }
 852 
 853 int qede_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, u16 vid)
 854 {
 855         struct qede_dev *edev = netdev_priv(dev);
 856         struct qede_vlan *vlan = NULL;
 857         int rc = 0;
 858 
 859         DP_VERBOSE(edev, NETIF_MSG_IFDOWN, "Removing vlan 0x%04x\n", vid);
 860 
 861         /* Find whether entry exists */
 862         __qede_lock(edev);
 863         list_for_each_entry(vlan, &edev->vlan_list, list)
 864                 if (vlan->vid == vid)
 865                         break;
 866 
 867         if (!vlan || (vlan->vid != vid)) {
 868                 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
 869                            "Vlan isn't configured\n");
 870                 goto out;
 871         }
 872 
 873         if (edev->state != QEDE_STATE_OPEN) {
 874                 /* As interface is already down, we don't have a VPORT
 875                  * instance to remove vlan filter. So just update vlan list
 876                  */
 877                 DP_VERBOSE(edev, NETIF_MSG_IFDOWN,
 878                            "Interface is down, removing VLAN from list only\n");
 879                 qede_del_vlan_from_list(edev, vlan);
 880                 goto out;
 881         }
 882 
 883         /* Remove vlan */
 884         if (vlan->configured) {
 885                 rc = qede_set_ucast_rx_vlan(edev, QED_FILTER_XCAST_TYPE_DEL,
 886                                             vid);
 887                 if (rc) {
 888                         DP_ERR(edev, "Failed to remove VLAN %d\n", vid);
 889                         goto out;
 890                 }
 891         }
 892 
 893         qede_del_vlan_from_list(edev, vlan);
 894 
 895         /* We have removed a VLAN - try to see if we can
 896          * configure non-configured VLAN from the list.
 897          */
 898         rc = qede_configure_vlan_filters(edev);
 899 
 900 out:
 901         __qede_unlock(edev);
 902         return rc;
 903 }
 904 
 905 void qede_vlan_mark_nonconfigured(struct qede_dev *edev)
 906 {
 907         struct qede_vlan *vlan = NULL;
 908 
 909         if (list_empty(&edev->vlan_list))
 910                 return;
 911 
 912         list_for_each_entry(vlan, &edev->vlan_list, list) {
 913                 if (!vlan->configured)
 914                         continue;
 915 
 916                 vlan->configured = false;
 917 
 918                 /* vlan0 filter isn't consuming out of our quota */
 919                 if (vlan->vid != 0) {
 920                         edev->non_configured_vlans++;
 921                         edev->configured_vlans--;
 922                 }
 923 
 924                 DP_VERBOSE(edev, NETIF_MSG_IFDOWN,
 925                            "marked vlan %d as non-configured\n", vlan->vid);
 926         }
 927 
 928         edev->accept_any_vlan = false;
 929 }
 930 
 931 static void qede_set_features_reload(struct qede_dev *edev,
 932                                      struct qede_reload_args *args)
 933 {
 934         edev->ndev->features = args->u.features;
 935 }
 936 
 937 netdev_features_t qede_fix_features(struct net_device *dev,
 938                                     netdev_features_t features)
 939 {
 940         struct qede_dev *edev = netdev_priv(dev);
 941 
 942         if (edev->xdp_prog || edev->ndev->mtu > PAGE_SIZE ||
 943             !(features & NETIF_F_GRO))
 944                 features &= ~NETIF_F_GRO_HW;
 945 
 946         return features;
 947 }
 948 
 949 int qede_set_features(struct net_device *dev, netdev_features_t features)
 950 {
 951         struct qede_dev *edev = netdev_priv(dev);
 952         netdev_features_t changes = features ^ dev->features;
 953         bool need_reload = false;
 954 
 955         if (changes & NETIF_F_GRO_HW)
 956                 need_reload = true;
 957 
 958         if (need_reload) {
 959                 struct qede_reload_args args;
 960 
 961                 args.u.features = features;
 962                 args.func = &qede_set_features_reload;
 963 
 964                 /* Make sure that we definitely need to reload.
 965                  * In case of an eBPF attached program, there will be no FW
 966                  * aggregations, so no need to actually reload.
 967                  */
 968                 __qede_lock(edev);
 969                 if (edev->xdp_prog)
 970                         args.func(edev, &args);
 971                 else
 972                         qede_reload(edev, &args, true);
 973                 __qede_unlock(edev);
 974 
 975                 return 1;
 976         }
 977 
 978         return 0;
 979 }
 980 
 981 void qede_udp_tunnel_add(struct net_device *dev, struct udp_tunnel_info *ti)
 982 {
 983         struct qede_dev *edev = netdev_priv(dev);
 984         struct qed_tunn_params tunn_params;
 985         u16 t_port = ntohs(ti->port);
 986         int rc;
 987 
 988         memset(&tunn_params, 0, sizeof(tunn_params));
 989 
 990         switch (ti->type) {
 991         case UDP_TUNNEL_TYPE_VXLAN:
 992                 if (!edev->dev_info.common.vxlan_enable)
 993                         return;
 994 
 995                 if (edev->vxlan_dst_port)
 996                         return;
 997 
 998                 tunn_params.update_vxlan_port = 1;
 999                 tunn_params.vxlan_port = t_port;
1000 
1001                 __qede_lock(edev);
1002                 rc = edev->ops->tunn_config(edev->cdev, &tunn_params);
1003                 __qede_unlock(edev);
1004 
1005                 if (!rc) {
1006                         edev->vxlan_dst_port = t_port;
1007                         DP_VERBOSE(edev, QED_MSG_DEBUG, "Added vxlan port=%d\n",
1008                                    t_port);
1009                 } else {
1010                         DP_NOTICE(edev, "Failed to add vxlan UDP port=%d\n",
1011                                   t_port);
1012                 }
1013 
1014                 break;
1015         case UDP_TUNNEL_TYPE_GENEVE:
1016                 if (!edev->dev_info.common.geneve_enable)
1017                         return;
1018 
1019                 if (edev->geneve_dst_port)
1020                         return;
1021 
1022                 tunn_params.update_geneve_port = 1;
1023                 tunn_params.geneve_port = t_port;
1024 
1025                 __qede_lock(edev);
1026                 rc = edev->ops->tunn_config(edev->cdev, &tunn_params);
1027                 __qede_unlock(edev);
1028 
1029                 if (!rc) {
1030                         edev->geneve_dst_port = t_port;
1031                         DP_VERBOSE(edev, QED_MSG_DEBUG,
1032                                    "Added geneve port=%d\n", t_port);
1033                 } else {
1034                         DP_NOTICE(edev, "Failed to add geneve UDP port=%d\n",
1035                                   t_port);
1036                 }
1037 
1038                 break;
1039         default:
1040                 return;
1041         }
1042 }
1043 
1044 void qede_udp_tunnel_del(struct net_device *dev,
1045                          struct udp_tunnel_info *ti)
1046 {
1047         struct qede_dev *edev = netdev_priv(dev);
1048         struct qed_tunn_params tunn_params;
1049         u16 t_port = ntohs(ti->port);
1050 
1051         memset(&tunn_params, 0, sizeof(tunn_params));
1052 
1053         switch (ti->type) {
1054         case UDP_TUNNEL_TYPE_VXLAN:
1055                 if (t_port != edev->vxlan_dst_port)
1056                         return;
1057 
1058                 tunn_params.update_vxlan_port = 1;
1059                 tunn_params.vxlan_port = 0;
1060 
1061                 __qede_lock(edev);
1062                 edev->ops->tunn_config(edev->cdev, &tunn_params);
1063                 __qede_unlock(edev);
1064 
1065                 edev->vxlan_dst_port = 0;
1066 
1067                 DP_VERBOSE(edev, QED_MSG_DEBUG, "Deleted vxlan port=%d\n",
1068                            t_port);
1069 
1070                 break;
1071         case UDP_TUNNEL_TYPE_GENEVE:
1072                 if (t_port != edev->geneve_dst_port)
1073                         return;
1074 
1075                 tunn_params.update_geneve_port = 1;
1076                 tunn_params.geneve_port = 0;
1077 
1078                 __qede_lock(edev);
1079                 edev->ops->tunn_config(edev->cdev, &tunn_params);
1080                 __qede_unlock(edev);
1081 
1082                 edev->geneve_dst_port = 0;
1083 
1084                 DP_VERBOSE(edev, QED_MSG_DEBUG, "Deleted geneve port=%d\n",
1085                            t_port);
1086                 break;
1087         default:
1088                 return;
1089         }
1090 }
1091 
1092 static void qede_xdp_reload_func(struct qede_dev *edev,
1093                                  struct qede_reload_args *args)
1094 {
1095         struct bpf_prog *old;
1096 
1097         old = xchg(&edev->xdp_prog, args->u.new_prog);
1098         if (old)
1099                 bpf_prog_put(old);
1100 }
1101 
1102 static int qede_xdp_set(struct qede_dev *edev, struct bpf_prog *prog)
1103 {
1104         struct qede_reload_args args;
1105 
1106         /* If we're called, there was already a bpf reference increment */
1107         args.func = &qede_xdp_reload_func;
1108         args.u.new_prog = prog;
1109         qede_reload(edev, &args, false);
1110 
1111         return 0;
1112 }
1113 
1114 int qede_xdp(struct net_device *dev, struct netdev_bpf *xdp)
1115 {
1116         struct qede_dev *edev = netdev_priv(dev);
1117 
1118         switch (xdp->command) {
1119         case XDP_SETUP_PROG:
1120                 return qede_xdp_set(edev, xdp->prog);
1121         case XDP_QUERY_PROG:
1122                 xdp->prog_id = edev->xdp_prog ? edev->xdp_prog->aux->id : 0;
1123                 return 0;
1124         default:
1125                 return -EINVAL;
1126         }
1127 }
1128 
1129 static int qede_set_mcast_rx_mac(struct qede_dev *edev,
1130                                  enum qed_filter_xcast_params_type opcode,
1131                                  unsigned char *mac, int num_macs)
1132 {
1133         struct qed_filter_params filter_cmd;
1134         int i;
1135 
1136         memset(&filter_cmd, 0, sizeof(filter_cmd));
1137         filter_cmd.type = QED_FILTER_TYPE_MCAST;
1138         filter_cmd.filter.mcast.type = opcode;
1139         filter_cmd.filter.mcast.num = num_macs;
1140 
1141         for (i = 0; i < num_macs; i++, mac += ETH_ALEN)
1142                 ether_addr_copy(filter_cmd.filter.mcast.mac[i], mac);
1143 
1144         return edev->ops->filter_config(edev->cdev, &filter_cmd);
1145 }
1146 
1147 int qede_set_mac_addr(struct net_device *ndev, void *p)
1148 {
1149         struct qede_dev *edev = netdev_priv(ndev);
1150         struct sockaddr *addr = p;
1151         int rc = 0;
1152 
1153         /* Make sure the state doesn't transition while changing the MAC.
1154          * Also, all flows accessing the dev_addr field are doing that under
1155          * this lock.
1156          */
1157         __qede_lock(edev);
1158 
1159         if (!is_valid_ether_addr(addr->sa_data)) {
1160                 DP_NOTICE(edev, "The MAC address is not valid\n");
1161                 rc = -EFAULT;
1162                 goto out;
1163         }
1164 
1165         if (!edev->ops->check_mac(edev->cdev, addr->sa_data)) {
1166                 DP_NOTICE(edev, "qed prevents setting MAC %pM\n",
1167                           addr->sa_data);
1168                 rc = -EINVAL;
1169                 goto out;
1170         }
1171 
1172         if (edev->state == QEDE_STATE_OPEN) {
1173                 /* Remove the previous primary mac */
1174                 rc = qede_set_ucast_rx_mac(edev, QED_FILTER_XCAST_TYPE_DEL,
1175                                            ndev->dev_addr);
1176                 if (rc)
1177                         goto out;
1178         }
1179 
1180         ether_addr_copy(ndev->dev_addr, addr->sa_data);
1181         DP_INFO(edev, "Setting device MAC to %pM\n", addr->sa_data);
1182 
1183         if (edev->state != QEDE_STATE_OPEN) {
1184                 DP_VERBOSE(edev, NETIF_MSG_IFDOWN,
1185                            "The device is currently down\n");
1186                 /* Ask PF to explicitly update a copy in bulletin board */
1187                 if (IS_VF(edev) && edev->ops->req_bulletin_update_mac)
1188                         edev->ops->req_bulletin_update_mac(edev->cdev,
1189                                                            ndev->dev_addr);
1190                 goto out;
1191         }
1192 
1193         edev->ops->common->update_mac(edev->cdev, ndev->dev_addr);
1194 
1195         rc = qede_set_ucast_rx_mac(edev, QED_FILTER_XCAST_TYPE_ADD,
1196                                    ndev->dev_addr);
1197 out:
1198         __qede_unlock(edev);
1199         return rc;
1200 }
1201 
1202 static int
1203 qede_configure_mcast_filtering(struct net_device *ndev,
1204                                enum qed_filter_rx_mode_type *accept_flags)
1205 {
1206         struct qede_dev *edev = netdev_priv(ndev);
1207         unsigned char *mc_macs, *temp;
1208         struct netdev_hw_addr *ha;
1209         int rc = 0, mc_count;
1210         size_t size;
1211 
1212         size = 64 * ETH_ALEN;
1213 
1214         mc_macs = kzalloc(size, GFP_KERNEL);
1215         if (!mc_macs) {
1216                 DP_NOTICE(edev,
1217                           "Failed to allocate memory for multicast MACs\n");
1218                 rc = -ENOMEM;
1219                 goto exit;
1220         }
1221 
1222         temp = mc_macs;
1223 
1224         /* Remove all previously configured MAC filters */
1225         rc = qede_set_mcast_rx_mac(edev, QED_FILTER_XCAST_TYPE_DEL,
1226                                    mc_macs, 1);
1227         if (rc)
1228                 goto exit;
1229 
1230         netif_addr_lock_bh(ndev);
1231 
1232         mc_count = netdev_mc_count(ndev);
1233         if (mc_count <= 64) {
1234                 netdev_for_each_mc_addr(ha, ndev) {
1235                         ether_addr_copy(temp, ha->addr);
1236                         temp += ETH_ALEN;
1237                 }
1238         }
1239 
1240         netif_addr_unlock_bh(ndev);
1241 
1242         /* Check for all multicast @@@TBD resource allocation */
1243         if ((ndev->flags & IFF_ALLMULTI) || (mc_count > 64)) {
1244                 if (*accept_flags == QED_FILTER_RX_MODE_TYPE_REGULAR)
1245                         *accept_flags = QED_FILTER_RX_MODE_TYPE_MULTI_PROMISC;
1246         } else {
1247                 /* Add all multicast MAC filters */
1248                 rc = qede_set_mcast_rx_mac(edev, QED_FILTER_XCAST_TYPE_ADD,
1249                                            mc_macs, mc_count);
1250         }
1251 
1252 exit:
1253         kfree(mc_macs);
1254         return rc;
1255 }
1256 
1257 void qede_set_rx_mode(struct net_device *ndev)
1258 {
1259         struct qede_dev *edev = netdev_priv(ndev);
1260 
1261         set_bit(QEDE_SP_RX_MODE, &edev->sp_flags);
1262         schedule_delayed_work(&edev->sp_task, 0);
1263 }
1264 
1265 /* Must be called with qede_lock held */
1266 void qede_config_rx_mode(struct net_device *ndev)
1267 {
1268         enum qed_filter_rx_mode_type accept_flags;
1269         struct qede_dev *edev = netdev_priv(ndev);
1270         struct qed_filter_params rx_mode;
1271         unsigned char *uc_macs, *temp;
1272         struct netdev_hw_addr *ha;
1273         int rc, uc_count;
1274         size_t size;
1275 
1276         netif_addr_lock_bh(ndev);
1277 
1278         uc_count = netdev_uc_count(ndev);
1279         size = uc_count * ETH_ALEN;
1280 
1281         uc_macs = kzalloc(size, GFP_ATOMIC);
1282         if (!uc_macs) {
1283                 DP_NOTICE(edev, "Failed to allocate memory for unicast MACs\n");
1284                 netif_addr_unlock_bh(ndev);
1285                 return;
1286         }
1287 
1288         temp = uc_macs;
1289         netdev_for_each_uc_addr(ha, ndev) {
1290                 ether_addr_copy(temp, ha->addr);
1291                 temp += ETH_ALEN;
1292         }
1293 
1294         netif_addr_unlock_bh(ndev);
1295 
1296         /* Configure the struct for the Rx mode */
1297         memset(&rx_mode, 0, sizeof(struct qed_filter_params));
1298         rx_mode.type = QED_FILTER_TYPE_RX_MODE;
1299 
1300         /* Remove all previous unicast secondary macs and multicast macs
1301          * (configrue / leave the primary mac)
1302          */
1303         rc = qede_set_ucast_rx_mac(edev, QED_FILTER_XCAST_TYPE_REPLACE,
1304                                    edev->ndev->dev_addr);
1305         if (rc)
1306                 goto out;
1307 
1308         /* Check for promiscuous */
1309         if (ndev->flags & IFF_PROMISC)
1310                 accept_flags = QED_FILTER_RX_MODE_TYPE_PROMISC;
1311         else
1312                 accept_flags = QED_FILTER_RX_MODE_TYPE_REGULAR;
1313 
1314         /* Configure all filters regardless, in case promisc is rejected */
1315         if (uc_count < edev->dev_info.num_mac_filters) {
1316                 int i;
1317 
1318                 temp = uc_macs;
1319                 for (i = 0; i < uc_count; i++) {
1320                         rc = qede_set_ucast_rx_mac(edev,
1321                                                    QED_FILTER_XCAST_TYPE_ADD,
1322                                                    temp);
1323                         if (rc)
1324                                 goto out;
1325 
1326                         temp += ETH_ALEN;
1327                 }
1328         } else {
1329                 accept_flags = QED_FILTER_RX_MODE_TYPE_PROMISC;
1330         }
1331 
1332         rc = qede_configure_mcast_filtering(ndev, &accept_flags);
1333         if (rc)
1334                 goto out;
1335 
1336         /* take care of VLAN mode */
1337         if (ndev->flags & IFF_PROMISC) {
1338                 qede_config_accept_any_vlan(edev, true);
1339         } else if (!edev->non_configured_vlans) {
1340                 /* It's possible that accept_any_vlan mode is set due to a
1341                  * previous setting of IFF_PROMISC. If vlan credits are
1342                  * sufficient, disable accept_any_vlan.
1343                  */
1344                 qede_config_accept_any_vlan(edev, false);
1345         }
1346 
1347         rx_mode.filter.accept_flags = accept_flags;
1348         edev->ops->filter_config(edev->cdev, &rx_mode);
1349 out:
1350         kfree(uc_macs);
1351 }
1352 
1353 static struct qede_arfs_fltr_node *
1354 qede_get_arfs_fltr_by_loc(struct hlist_head *head, u64 location)
1355 {
1356         struct qede_arfs_fltr_node *fltr;
1357 
1358         hlist_for_each_entry(fltr, head, node)
1359                 if (location == fltr->sw_id)
1360                         return fltr;
1361 
1362         return NULL;
1363 }
1364 
1365 int qede_get_cls_rule_all(struct qede_dev *edev, struct ethtool_rxnfc *info,
1366                           u32 *rule_locs)
1367 {
1368         struct qede_arfs_fltr_node *fltr;
1369         struct hlist_head *head;
1370         int cnt = 0, rc = 0;
1371 
1372         info->data = QEDE_RFS_MAX_FLTR;
1373 
1374         __qede_lock(edev);
1375 
1376         if (!edev->arfs) {
1377                 rc = -EPERM;
1378                 goto unlock;
1379         }
1380 
1381         head = QEDE_ARFS_BUCKET_HEAD(edev, 0);
1382 
1383         hlist_for_each_entry(fltr, head, node) {
1384                 if (cnt == info->rule_cnt) {
1385                         rc = -EMSGSIZE;
1386                         goto unlock;
1387                 }
1388 
1389                 rule_locs[cnt] = fltr->sw_id;
1390                 cnt++;
1391         }
1392 
1393         info->rule_cnt = cnt;
1394 
1395 unlock:
1396         __qede_unlock(edev);
1397         return rc;
1398 }
1399 
1400 int qede_get_cls_rule_entry(struct qede_dev *edev, struct ethtool_rxnfc *cmd)
1401 {
1402         struct ethtool_rx_flow_spec *fsp = &cmd->fs;
1403         struct qede_arfs_fltr_node *fltr = NULL;
1404         int rc = 0;
1405 
1406         cmd->data = QEDE_RFS_MAX_FLTR;
1407 
1408         __qede_lock(edev);
1409 
1410         if (!edev->arfs) {
1411                 rc = -EPERM;
1412                 goto unlock;
1413         }
1414 
1415         fltr = qede_get_arfs_fltr_by_loc(QEDE_ARFS_BUCKET_HEAD(edev, 0),
1416                                          fsp->location);
1417         if (!fltr) {
1418                 DP_NOTICE(edev, "Rule not found - location=0x%x\n",
1419                           fsp->location);
1420                 rc = -EINVAL;
1421                 goto unlock;
1422         }
1423 
1424         if (fltr->tuple.eth_proto == htons(ETH_P_IP)) {
1425                 if (fltr->tuple.ip_proto == IPPROTO_TCP)
1426                         fsp->flow_type = TCP_V4_FLOW;
1427                 else
1428                         fsp->flow_type = UDP_V4_FLOW;
1429 
1430                 fsp->h_u.tcp_ip4_spec.psrc = fltr->tuple.src_port;
1431                 fsp->h_u.tcp_ip4_spec.pdst = fltr->tuple.dst_port;
1432                 fsp->h_u.tcp_ip4_spec.ip4src = fltr->tuple.src_ipv4;
1433                 fsp->h_u.tcp_ip4_spec.ip4dst = fltr->tuple.dst_ipv4;
1434         } else {
1435                 if (fltr->tuple.ip_proto == IPPROTO_TCP)
1436                         fsp->flow_type = TCP_V6_FLOW;
1437                 else
1438                         fsp->flow_type = UDP_V6_FLOW;
1439                 fsp->h_u.tcp_ip6_spec.psrc = fltr->tuple.src_port;
1440                 fsp->h_u.tcp_ip6_spec.pdst = fltr->tuple.dst_port;
1441                 memcpy(&fsp->h_u.tcp_ip6_spec.ip6src,
1442                        &fltr->tuple.src_ipv6, sizeof(struct in6_addr));
1443                 memcpy(&fsp->h_u.tcp_ip6_spec.ip6dst,
1444                        &fltr->tuple.dst_ipv6, sizeof(struct in6_addr));
1445         }
1446 
1447         fsp->ring_cookie = fltr->rxq_id;
1448 
1449         if (fltr->vfid) {
1450                 fsp->ring_cookie |= ((u64)fltr->vfid) <<
1451                                         ETHTOOL_RX_FLOW_SPEC_RING_VF_OFF;
1452         }
1453 
1454         if (fltr->b_is_drop)
1455                 fsp->ring_cookie = RX_CLS_FLOW_DISC;
1456 unlock:
1457         __qede_unlock(edev);
1458         return rc;
1459 }
1460 
1461 static int
1462 qede_poll_arfs_filter_config(struct qede_dev *edev,
1463                              struct qede_arfs_fltr_node *fltr)
1464 {
1465         int count = QEDE_ARFS_POLL_COUNT;
1466 
1467         while (fltr->used && count) {
1468                 msleep(20);
1469                 count--;
1470         }
1471 
1472         if (count == 0 || fltr->fw_rc) {
1473                 DP_NOTICE(edev, "Timeout in polling filter config\n");
1474                 qede_dequeue_fltr_and_config_searcher(edev, fltr);
1475                 return -EIO;
1476         }
1477 
1478         return fltr->fw_rc;
1479 }
1480 
1481 static int qede_flow_get_min_header_size(struct qede_arfs_tuple *t)
1482 {
1483         int size = ETH_HLEN;
1484 
1485         if (t->eth_proto == htons(ETH_P_IP))
1486                 size += sizeof(struct iphdr);
1487         else
1488                 size += sizeof(struct ipv6hdr);
1489 
1490         if (t->ip_proto == IPPROTO_TCP)
1491                 size += sizeof(struct tcphdr);
1492         else
1493                 size += sizeof(struct udphdr);
1494 
1495         return size;
1496 }
1497 
1498 static bool qede_flow_spec_ipv4_cmp(struct qede_arfs_tuple *a,
1499                                     struct qede_arfs_tuple *b)
1500 {
1501         if (a->eth_proto != htons(ETH_P_IP) ||
1502             b->eth_proto != htons(ETH_P_IP))
1503                 return false;
1504 
1505         return (a->src_ipv4 == b->src_ipv4) &&
1506                (a->dst_ipv4 == b->dst_ipv4);
1507 }
1508 
1509 static void qede_flow_build_ipv4_hdr(struct qede_arfs_tuple *t,
1510                                      void *header)
1511 {
1512         __be16 *ports = (__be16 *)(header + ETH_HLEN + sizeof(struct iphdr));
1513         struct iphdr *ip = (struct iphdr *)(header + ETH_HLEN);
1514         struct ethhdr *eth = (struct ethhdr *)header;
1515 
1516         eth->h_proto = t->eth_proto;
1517         ip->saddr = t->src_ipv4;
1518         ip->daddr = t->dst_ipv4;
1519         ip->version = 0x4;
1520         ip->ihl = 0x5;
1521         ip->protocol = t->ip_proto;
1522         ip->tot_len = cpu_to_be16(qede_flow_get_min_header_size(t) - ETH_HLEN);
1523 
1524         /* ports is weakly typed to suit both TCP and UDP ports */
1525         ports[0] = t->src_port;
1526         ports[1] = t->dst_port;
1527 }
1528 
1529 static void qede_flow_stringify_ipv4_hdr(struct qede_arfs_tuple *t,
1530                                          void *buffer)
1531 {
1532         const char *prefix = t->ip_proto == IPPROTO_TCP ? "TCP" : "UDP";
1533 
1534         snprintf(buffer, QEDE_FILTER_PRINT_MAX_LEN,
1535                  "%s %pI4 (%04x) -> %pI4 (%04x)",
1536                  prefix, &t->src_ipv4, t->src_port,
1537                  &t->dst_ipv4, t->dst_port);
1538 }
1539 
1540 static bool qede_flow_spec_ipv6_cmp(struct qede_arfs_tuple *a,
1541                                     struct qede_arfs_tuple *b)
1542 {
1543         if (a->eth_proto != htons(ETH_P_IPV6) ||
1544             b->eth_proto != htons(ETH_P_IPV6))
1545                 return false;
1546 
1547         if (memcmp(&a->src_ipv6, &b->src_ipv6, sizeof(struct in6_addr)))
1548                 return false;
1549 
1550         if (memcmp(&a->dst_ipv6, &b->dst_ipv6, sizeof(struct in6_addr)))
1551                 return false;
1552 
1553         return true;
1554 }
1555 
1556 static void qede_flow_build_ipv6_hdr(struct qede_arfs_tuple *t,
1557                                      void *header)
1558 {
1559         __be16 *ports = (__be16 *)(header + ETH_HLEN + sizeof(struct ipv6hdr));
1560         struct ipv6hdr *ip6 = (struct ipv6hdr *)(header + ETH_HLEN);
1561         struct ethhdr *eth = (struct ethhdr *)header;
1562 
1563         eth->h_proto = t->eth_proto;
1564         memcpy(&ip6->saddr, &t->src_ipv6, sizeof(struct in6_addr));
1565         memcpy(&ip6->daddr, &t->dst_ipv6, sizeof(struct in6_addr));
1566         ip6->version = 0x6;
1567 
1568         if (t->ip_proto == IPPROTO_TCP) {
1569                 ip6->nexthdr = NEXTHDR_TCP;
1570                 ip6->payload_len = cpu_to_be16(sizeof(struct tcphdr));
1571         } else {
1572                 ip6->nexthdr = NEXTHDR_UDP;
1573                 ip6->payload_len = cpu_to_be16(sizeof(struct udphdr));
1574         }
1575 
1576         /* ports is weakly typed to suit both TCP and UDP ports */
1577         ports[0] = t->src_port;
1578         ports[1] = t->dst_port;
1579 }
1580 
1581 /* Validate fields which are set and not accepted by the driver */
1582 static int qede_flow_spec_validate_unused(struct qede_dev *edev,
1583                                           struct ethtool_rx_flow_spec *fs)
1584 {
1585         if (fs->flow_type & FLOW_MAC_EXT) {
1586                 DP_INFO(edev, "Don't support MAC extensions\n");
1587                 return -EOPNOTSUPP;
1588         }
1589 
1590         if ((fs->flow_type & FLOW_EXT) &&
1591             (fs->h_ext.vlan_etype || fs->h_ext.vlan_tci)) {
1592                 DP_INFO(edev, "Don't support vlan-based classification\n");
1593                 return -EOPNOTSUPP;
1594         }
1595 
1596         if ((fs->flow_type & FLOW_EXT) &&
1597             (fs->h_ext.data[0] || fs->h_ext.data[1])) {
1598                 DP_INFO(edev, "Don't support user defined data\n");
1599                 return -EOPNOTSUPP;
1600         }
1601 
1602         return 0;
1603 }
1604 
1605 static int qede_set_v4_tuple_to_profile(struct qede_dev *edev,
1606                                         struct qede_arfs_tuple *t)
1607 {
1608         /* We must have Only 4-tuples/l4 port/src ip/dst ip
1609          * as an input.
1610          */
1611         if (t->src_port && t->dst_port && t->src_ipv4 && t->dst_ipv4) {
1612                 t->mode = QED_FILTER_CONFIG_MODE_5_TUPLE;
1613         } else if (!t->src_port && t->dst_port &&
1614                    !t->src_ipv4 && !t->dst_ipv4) {
1615                 t->mode = QED_FILTER_CONFIG_MODE_L4_PORT;
1616         } else if (!t->src_port && !t->dst_port &&
1617                    !t->dst_ipv4 && t->src_ipv4) {
1618                 t->mode = QED_FILTER_CONFIG_MODE_IP_SRC;
1619         } else if (!t->src_port && !t->dst_port &&
1620                    t->dst_ipv4 && !t->src_ipv4) {
1621                 t->mode = QED_FILTER_CONFIG_MODE_IP_DEST;
1622         } else {
1623                 DP_INFO(edev, "Invalid N-tuple\n");
1624                 return -EOPNOTSUPP;
1625         }
1626 
1627         t->ip_comp = qede_flow_spec_ipv4_cmp;
1628         t->build_hdr = qede_flow_build_ipv4_hdr;
1629         t->stringify = qede_flow_stringify_ipv4_hdr;
1630 
1631         return 0;
1632 }
1633 
1634 static int qede_set_v6_tuple_to_profile(struct qede_dev *edev,
1635                                         struct qede_arfs_tuple *t,
1636                                         struct in6_addr *zaddr)
1637 {
1638         /* We must have Only 4-tuples/l4 port/src ip/dst ip
1639          * as an input.
1640          */
1641         if (t->src_port && t->dst_port &&
1642             memcmp(&t->src_ipv6, zaddr, sizeof(struct in6_addr)) &&
1643             memcmp(&t->dst_ipv6, zaddr, sizeof(struct in6_addr))) {
1644                 t->mode = QED_FILTER_CONFIG_MODE_5_TUPLE;
1645         } else if (!t->src_port && t->dst_port &&
1646                    !memcmp(&t->src_ipv6, zaddr, sizeof(struct in6_addr)) &&
1647                    !memcmp(&t->dst_ipv6, zaddr, sizeof(struct in6_addr))) {
1648                 t->mode = QED_FILTER_CONFIG_MODE_L4_PORT;
1649         } else if (!t->src_port && !t->dst_port &&
1650                    !memcmp(&t->dst_ipv6, zaddr, sizeof(struct in6_addr)) &&
1651                    memcmp(&t->src_ipv6, zaddr, sizeof(struct in6_addr))) {
1652                 t->mode = QED_FILTER_CONFIG_MODE_IP_SRC;
1653         } else if (!t->src_port && !t->dst_port &&
1654                    memcmp(&t->dst_ipv6, zaddr, sizeof(struct in6_addr)) &&
1655                    !memcmp(&t->src_ipv6, zaddr, sizeof(struct in6_addr))) {
1656                 t->mode = QED_FILTER_CONFIG_MODE_IP_DEST;
1657         } else {
1658                 DP_INFO(edev, "Invalid N-tuple\n");
1659                 return -EOPNOTSUPP;
1660         }
1661 
1662         t->ip_comp = qede_flow_spec_ipv6_cmp;
1663         t->build_hdr = qede_flow_build_ipv6_hdr;
1664 
1665         return 0;
1666 }
1667 
1668 /* Must be called while qede lock is held */
1669 static struct qede_arfs_fltr_node *
1670 qede_flow_find_fltr(struct qede_dev *edev, struct qede_arfs_tuple *t)
1671 {
1672         struct qede_arfs_fltr_node *fltr;
1673         struct hlist_node *temp;
1674         struct hlist_head *head;
1675 
1676         head = QEDE_ARFS_BUCKET_HEAD(edev, 0);
1677 
1678         hlist_for_each_entry_safe(fltr, temp, head, node) {
1679                 if (fltr->tuple.ip_proto == t->ip_proto &&
1680                     fltr->tuple.src_port == t->src_port &&
1681                     fltr->tuple.dst_port == t->dst_port &&
1682                     t->ip_comp(&fltr->tuple, t))
1683                         return fltr;
1684         }
1685 
1686         return NULL;
1687 }
1688 
1689 static void qede_flow_set_destination(struct qede_dev *edev,
1690                                       struct qede_arfs_fltr_node *n,
1691                                       struct ethtool_rx_flow_spec *fs)
1692 {
1693         if (fs->ring_cookie == RX_CLS_FLOW_DISC) {
1694                 n->b_is_drop = true;
1695                 return;
1696         }
1697 
1698         n->vfid = ethtool_get_flow_spec_ring_vf(fs->ring_cookie);
1699         n->rxq_id = ethtool_get_flow_spec_ring(fs->ring_cookie);
1700         n->next_rxq_id = n->rxq_id;
1701 
1702         if (n->vfid)
1703                 DP_VERBOSE(edev, QED_MSG_SP,
1704                            "Configuring N-tuple for VF 0x%02x\n", n->vfid - 1);
1705 }
1706 
1707 int qede_delete_flow_filter(struct qede_dev *edev, u64 cookie)
1708 {
1709         struct qede_arfs_fltr_node *fltr = NULL;
1710         int rc = -EPERM;
1711 
1712         __qede_lock(edev);
1713         if (!edev->arfs)
1714                 goto unlock;
1715 
1716         fltr = qede_get_arfs_fltr_by_loc(QEDE_ARFS_BUCKET_HEAD(edev, 0),
1717                                          cookie);
1718         if (!fltr)
1719                 goto unlock;
1720 
1721         qede_configure_arfs_fltr(edev, fltr, fltr->rxq_id, false);
1722 
1723         rc = qede_poll_arfs_filter_config(edev, fltr);
1724         if (rc == 0)
1725                 qede_dequeue_fltr_and_config_searcher(edev, fltr);
1726 
1727 unlock:
1728         __qede_unlock(edev);
1729         return rc;
1730 }
1731 
1732 int qede_get_arfs_filter_count(struct qede_dev *edev)
1733 {
1734         int count = 0;
1735 
1736         __qede_lock(edev);
1737 
1738         if (!edev->arfs)
1739                 goto unlock;
1740 
1741         count = edev->arfs->filter_count;
1742 
1743 unlock:
1744         __qede_unlock(edev);
1745         return count;
1746 }
1747 
1748 static int qede_parse_actions(struct qede_dev *edev,
1749                               struct flow_action *flow_action)
1750 {
1751         const struct flow_action_entry *act;
1752         int i;
1753 
1754         if (!flow_action_has_entries(flow_action)) {
1755                 DP_NOTICE(edev, "No actions received\n");
1756                 return -EINVAL;
1757         }
1758 
1759         flow_action_for_each(i, act, flow_action) {
1760                 switch (act->id) {
1761                 case FLOW_ACTION_DROP:
1762                         break;
1763                 case FLOW_ACTION_QUEUE:
1764                         if (act->queue.vf)
1765                                 break;
1766 
1767                         if (act->queue.index >= QEDE_RSS_COUNT(edev)) {
1768                                 DP_INFO(edev, "Queue out-of-bounds\n");
1769                                 return -EINVAL;
1770                         }
1771                         break;
1772                 default:
1773                         return -EINVAL;
1774                 }
1775         }
1776 
1777         return 0;
1778 }
1779 
1780 static int
1781 qede_flow_parse_ports(struct qede_dev *edev, struct flow_rule *rule,
1782                       struct qede_arfs_tuple *t)
1783 {
1784         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_PORTS)) {
1785                 struct flow_match_ports match;
1786 
1787                 flow_rule_match_ports(rule, &match);
1788                 if ((match.key->src && match.mask->src != U16_MAX) ||
1789                     (match.key->dst && match.mask->dst != U16_MAX)) {
1790                         DP_NOTICE(edev, "Do not support ports masks\n");
1791                         return -EINVAL;
1792                 }
1793 
1794                 t->src_port = match.key->src;
1795                 t->dst_port = match.key->dst;
1796         }
1797 
1798         return 0;
1799 }
1800 
1801 static int
1802 qede_flow_parse_v6_common(struct qede_dev *edev, struct flow_rule *rule,
1803                           struct qede_arfs_tuple *t)
1804 {
1805         struct in6_addr zero_addr, addr;
1806 
1807         memset(&zero_addr, 0, sizeof(addr));
1808         memset(&addr, 0xff, sizeof(addr));
1809 
1810         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_IPV6_ADDRS)) {
1811                 struct flow_match_ipv6_addrs match;
1812 
1813                 flow_rule_match_ipv6_addrs(rule, &match);
1814                 if ((memcmp(&match.key->src, &zero_addr, sizeof(addr)) &&
1815                      memcmp(&match.mask->src, &addr, sizeof(addr))) ||
1816                     (memcmp(&match.key->dst, &zero_addr, sizeof(addr)) &&
1817                      memcmp(&match.mask->dst, &addr, sizeof(addr)))) {
1818                         DP_NOTICE(edev,
1819                                   "Do not support IPv6 address prefix/mask\n");
1820                         return -EINVAL;
1821                 }
1822 
1823                 memcpy(&t->src_ipv6, &match.key->src, sizeof(addr));
1824                 memcpy(&t->dst_ipv6, &match.key->dst, sizeof(addr));
1825         }
1826 
1827         if (qede_flow_parse_ports(edev, rule, t))
1828                 return -EINVAL;
1829 
1830         return qede_set_v6_tuple_to_profile(edev, t, &zero_addr);
1831 }
1832 
1833 static int
1834 qede_flow_parse_v4_common(struct qede_dev *edev, struct flow_rule *rule,
1835                         struct qede_arfs_tuple *t)
1836 {
1837         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_IPV4_ADDRS)) {
1838                 struct flow_match_ipv4_addrs match;
1839 
1840                 flow_rule_match_ipv4_addrs(rule, &match);
1841                 if ((match.key->src && match.mask->src != U32_MAX) ||
1842                     (match.key->dst && match.mask->dst != U32_MAX)) {
1843                         DP_NOTICE(edev, "Do not support ipv4 prefix/masks\n");
1844                         return -EINVAL;
1845                 }
1846 
1847                 t->src_ipv4 = match.key->src;
1848                 t->dst_ipv4 = match.key->dst;
1849         }
1850 
1851         if (qede_flow_parse_ports(edev, rule, t))
1852                 return -EINVAL;
1853 
1854         return qede_set_v4_tuple_to_profile(edev, t);
1855 }
1856 
1857 static int
1858 qede_flow_parse_tcp_v6(struct qede_dev *edev, struct flow_rule *rule,
1859                      struct qede_arfs_tuple *tuple)
1860 {
1861         tuple->ip_proto = IPPROTO_TCP;
1862         tuple->eth_proto = htons(ETH_P_IPV6);
1863 
1864         return qede_flow_parse_v6_common(edev, rule, tuple);
1865 }
1866 
1867 static int
1868 qede_flow_parse_tcp_v4(struct qede_dev *edev, struct flow_rule *rule,
1869                      struct qede_arfs_tuple *tuple)
1870 {
1871         tuple->ip_proto = IPPROTO_TCP;
1872         tuple->eth_proto = htons(ETH_P_IP);
1873 
1874         return qede_flow_parse_v4_common(edev, rule, tuple);
1875 }
1876 
1877 static int
1878 qede_flow_parse_udp_v6(struct qede_dev *edev, struct flow_rule *rule,
1879                      struct qede_arfs_tuple *tuple)
1880 {
1881         tuple->ip_proto = IPPROTO_UDP;
1882         tuple->eth_proto = htons(ETH_P_IPV6);
1883 
1884         return qede_flow_parse_v6_common(edev, rule, tuple);
1885 }
1886 
1887 static int
1888 qede_flow_parse_udp_v4(struct qede_dev *edev, struct flow_rule *rule,
1889                      struct qede_arfs_tuple *tuple)
1890 {
1891         tuple->ip_proto = IPPROTO_UDP;
1892         tuple->eth_proto = htons(ETH_P_IP);
1893 
1894         return qede_flow_parse_v4_common(edev, rule, tuple);
1895 }
1896 
1897 static int
1898 qede_parse_flow_attr(struct qede_dev *edev, __be16 proto,
1899                      struct flow_rule *rule, struct qede_arfs_tuple *tuple)
1900 {
1901         struct flow_dissector *dissector = rule->match.dissector;
1902         int rc = -EINVAL;
1903         u8 ip_proto = 0;
1904 
1905         memset(tuple, 0, sizeof(*tuple));
1906 
1907         if (dissector->used_keys &
1908             ~(BIT(FLOW_DISSECTOR_KEY_CONTROL) |
1909               BIT(FLOW_DISSECTOR_KEY_IPV4_ADDRS) |
1910               BIT(FLOW_DISSECTOR_KEY_BASIC) |
1911               BIT(FLOW_DISSECTOR_KEY_IPV6_ADDRS) |
1912               BIT(FLOW_DISSECTOR_KEY_PORTS))) {
1913                 DP_NOTICE(edev, "Unsupported key set:0x%x\n",
1914                           dissector->used_keys);
1915                 return -EOPNOTSUPP;
1916         }
1917 
1918         if (proto != htons(ETH_P_IP) &&
1919             proto != htons(ETH_P_IPV6)) {
1920                 DP_NOTICE(edev, "Unsupported proto=0x%x\n", proto);
1921                 return -EPROTONOSUPPORT;
1922         }
1923 
1924         if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_BASIC)) {
1925                 struct flow_match_basic match;
1926 
1927                 flow_rule_match_basic(rule, &match);
1928                 ip_proto = match.key->ip_proto;
1929         }
1930 
1931         if (ip_proto == IPPROTO_TCP && proto == htons(ETH_P_IP))
1932                 rc = qede_flow_parse_tcp_v4(edev, rule, tuple);
1933         else if (ip_proto == IPPROTO_TCP && proto == htons(ETH_P_IPV6))
1934                 rc = qede_flow_parse_tcp_v6(edev, rule, tuple);
1935         else if (ip_proto == IPPROTO_UDP && proto == htons(ETH_P_IP))
1936                 rc = qede_flow_parse_udp_v4(edev, rule, tuple);
1937         else if (ip_proto == IPPROTO_UDP && proto == htons(ETH_P_IPV6))
1938                 rc = qede_flow_parse_udp_v6(edev, rule, tuple);
1939         else
1940                 DP_NOTICE(edev, "Invalid protocol request\n");
1941 
1942         return rc;
1943 }
1944 
1945 int qede_add_tc_flower_fltr(struct qede_dev *edev, __be16 proto,
1946                             struct flow_cls_offload *f)
1947 {
1948         struct qede_arfs_fltr_node *n;
1949         int min_hlen, rc = -EINVAL;
1950         struct qede_arfs_tuple t;
1951 
1952         __qede_lock(edev);
1953 
1954         if (!edev->arfs) {
1955                 rc = -EPERM;
1956                 goto unlock;
1957         }
1958 
1959         /* parse flower attribute and prepare filter */
1960         if (qede_parse_flow_attr(edev, proto, f->rule, &t))
1961                 goto unlock;
1962 
1963         /* Validate profile mode and number of filters */
1964         if ((edev->arfs->filter_count && edev->arfs->mode != t.mode) ||
1965             edev->arfs->filter_count == QEDE_RFS_MAX_FLTR) {
1966                 DP_NOTICE(edev,
1967                           "Filter configuration invalidated, filter mode=0x%x, configured mode=0x%x, filter count=0x%x\n",
1968                           t.mode, edev->arfs->mode, edev->arfs->filter_count);
1969                 goto unlock;
1970         }
1971 
1972         /* parse tc actions and get the vf_id */
1973         if (qede_parse_actions(edev, &f->rule->action))
1974                 goto unlock;
1975 
1976         if (qede_flow_find_fltr(edev, &t)) {
1977                 rc = -EEXIST;
1978                 goto unlock;
1979         }
1980 
1981         n = kzalloc(sizeof(*n), GFP_KERNEL);
1982         if (!n) {
1983                 rc = -ENOMEM;
1984                 goto unlock;
1985         }
1986 
1987         min_hlen = qede_flow_get_min_header_size(&t);
1988 
1989         n->data = kzalloc(min_hlen, GFP_KERNEL);
1990         if (!n->data) {
1991                 kfree(n);
1992                 rc = -ENOMEM;
1993                 goto unlock;
1994         }
1995 
1996         memcpy(&n->tuple, &t, sizeof(n->tuple));
1997 
1998         n->buf_len = min_hlen;
1999         n->b_is_drop = true;
2000         n->sw_id = f->cookie;
2001 
2002         n->tuple.build_hdr(&n->tuple, n->data);
2003 
2004         rc = qede_enqueue_fltr_and_config_searcher(edev, n, 0);
2005         if (rc)
2006                 goto unlock;
2007 
2008         qede_configure_arfs_fltr(edev, n, n->rxq_id, true);
2009         rc = qede_poll_arfs_filter_config(edev, n);
2010 
2011 unlock:
2012         __qede_unlock(edev);
2013         return rc;
2014 }
2015 
2016 static int qede_flow_spec_validate(struct qede_dev *edev,
2017                                    struct flow_action *flow_action,
2018                                    struct qede_arfs_tuple *t,
2019                                    __u32 location)
2020 {
2021         if (location >= QEDE_RFS_MAX_FLTR) {
2022                 DP_INFO(edev, "Location out-of-bounds\n");
2023                 return -EINVAL;
2024         }
2025 
2026         /* Check location isn't already in use */
2027         if (test_bit(location, edev->arfs->arfs_fltr_bmap)) {
2028                 DP_INFO(edev, "Location already in use\n");
2029                 return -EINVAL;
2030         }
2031 
2032         /* Check if the filtering-mode could support the filter */
2033         if (edev->arfs->filter_count &&
2034             edev->arfs->mode != t->mode) {
2035                 DP_INFO(edev,
2036                         "flow_spec would require filtering mode %08x, but %08x is configured\n",
2037                         t->mode, edev->arfs->filter_count);
2038                 return -EINVAL;
2039         }
2040 
2041         if (qede_parse_actions(edev, flow_action))
2042                 return -EINVAL;
2043 
2044         return 0;
2045 }
2046 
2047 static int qede_flow_spec_to_rule(struct qede_dev *edev,
2048                                   struct qede_arfs_tuple *t,
2049                                   struct ethtool_rx_flow_spec *fs)
2050 {
2051         struct ethtool_rx_flow_spec_input input = {};
2052         struct ethtool_rx_flow_rule *flow;
2053         __be16 proto;
2054         int err = 0;
2055 
2056         if (qede_flow_spec_validate_unused(edev, fs))
2057                 return -EOPNOTSUPP;
2058 
2059         switch ((fs->flow_type & ~FLOW_EXT)) {
2060         case TCP_V4_FLOW:
2061         case UDP_V4_FLOW:
2062                 proto = htons(ETH_P_IP);
2063                 break;
2064         case TCP_V6_FLOW:
2065         case UDP_V6_FLOW:
2066                 proto = htons(ETH_P_IPV6);
2067                 break;
2068         default:
2069                 DP_VERBOSE(edev, NETIF_MSG_IFUP,
2070                            "Can't support flow of type %08x\n", fs->flow_type);
2071                 return -EOPNOTSUPP;
2072         }
2073 
2074         input.fs = fs;
2075         flow = ethtool_rx_flow_rule_create(&input);
2076         if (IS_ERR(flow))
2077                 return PTR_ERR(flow);
2078 
2079         if (qede_parse_flow_attr(edev, proto, flow->rule, t)) {
2080                 err = -EINVAL;
2081                 goto err_out;
2082         }
2083 
2084         /* Make sure location is valid and filter isn't already set */
2085         err = qede_flow_spec_validate(edev, &flow->rule->action, t,
2086                                       fs->location);
2087 err_out:
2088         ethtool_rx_flow_rule_destroy(flow);
2089         return err;
2090 
2091 }
2092 
2093 int qede_add_cls_rule(struct qede_dev *edev, struct ethtool_rxnfc *info)
2094 {
2095         struct ethtool_rx_flow_spec *fsp = &info->fs;
2096         struct qede_arfs_fltr_node *n;
2097         struct qede_arfs_tuple t;
2098         int min_hlen, rc;
2099 
2100         __qede_lock(edev);
2101 
2102         if (!edev->arfs) {
2103                 rc = -EPERM;
2104                 goto unlock;
2105         }
2106 
2107         /* Translate the flow specification into something fittign our DB */
2108         rc = qede_flow_spec_to_rule(edev, &t, fsp);
2109         if (rc)
2110                 goto unlock;
2111 
2112         if (qede_flow_find_fltr(edev, &t)) {
2113                 rc = -EINVAL;
2114                 goto unlock;
2115         }
2116 
2117         n = kzalloc(sizeof(*n), GFP_KERNEL);
2118         if (!n) {
2119                 rc = -ENOMEM;
2120                 goto unlock;
2121         }
2122 
2123         min_hlen = qede_flow_get_min_header_size(&t);
2124         n->data = kzalloc(min_hlen, GFP_KERNEL);
2125         if (!n->data) {
2126                 kfree(n);
2127                 rc = -ENOMEM;
2128                 goto unlock;
2129         }
2130 
2131         n->sw_id = fsp->location;
2132         set_bit(n->sw_id, edev->arfs->arfs_fltr_bmap);
2133         n->buf_len = min_hlen;
2134 
2135         memcpy(&n->tuple, &t, sizeof(n->tuple));
2136 
2137         qede_flow_set_destination(edev, n, fsp);
2138 
2139         /* Build a minimal header according to the flow */
2140         n->tuple.build_hdr(&n->tuple, n->data);
2141 
2142         rc = qede_enqueue_fltr_and_config_searcher(edev, n, 0);
2143         if (rc)
2144                 goto unlock;
2145 
2146         qede_configure_arfs_fltr(edev, n, n->rxq_id, true);
2147         rc = qede_poll_arfs_filter_config(edev, n);
2148 unlock:
2149         __qede_unlock(edev);
2150 
2151         return rc;
2152 }
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/net/ethernet/qlogic/qede/qede_filter.c

DEFINITIONS
