bnxt_en: bnxt: add TC flower filter offload support
authorSathya Perla <sathya.perla@broadcom.com>
Mon, 28 Aug 2017 17:40:33 +0000 (13:40 -0400)
committerDavid S. Miller <davem@davemloft.net>
Mon, 28 Aug 2017 23:57:10 +0000 (16:57 -0700)
This patch adds support for offloading TC based flow
rules and actions for the 'flower' classifier in the bnxt_en driver.
It includes logic to parse flow rules and actions received from the
TC subsystem, store them and issue the corresponding
hwrm_cfa_flow_alloc/free FW cmds. L2/IPv4/IPv6 flows and drop,
redir, vlan push/pop actions are supported in this patch.

In this patch the hwrm_cfa_flow_xxx routines are just stubs.
The code for these routines is introduced in the next patch for easier
review. Also, the code to query the TC/flower action stats will
be introduced in a subsequent patch.

Signed-off-by: Sathya Perla <sathya.perla@broadcom.com>
Signed-off-by: Michael Chan <michael.chan@broadcom.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
drivers/net/ethernet/broadcom/Kconfig
drivers/net/ethernet/broadcom/bnxt/Makefile
drivers/net/ethernet/broadcom/bnxt/bnxt.c
drivers/net/ethernet/broadcom/bnxt/bnxt.h
drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c [new file with mode: 0644]
drivers/net/ethernet/broadcom/bnxt/bnxt_tc.h [new file with mode: 0644]
drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c
drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.h

index 1456cb18f830bfc5e71b2bff3d4637191497b272..67134ece110772e9e74480759f88c1d42fecff7d 100644 (file)
@@ -212,6 +212,15 @@ config BNXT_SRIOV
          Virtualization support in the NetXtreme-C/E products. This
          allows for virtual function acceleration in virtual environments.
 
+config BNXT_FLOWER_OFFLOAD
+       bool "TC Flower offload support for NetXtreme-C/E"
+       depends on BNXT
+       default y
+       ---help---
+         This configuration parameter enables TC Flower packet classifier
+         offload for eswitch.  This option enables SR-IOV switchdev eswitch
+         offload.
+
 config BNXT_DCB
        bool "Data Center Bridging (DCB) Support"
        default n
index d141a22ac50b89d283be29f32003376dd61a8114..4f0cb8e1ffc0706e39baea637c789fddb61ca845 100644 (file)
@@ -1,3 +1,3 @@
 obj-$(CONFIG_BNXT) += bnxt_en.o
 
-bnxt_en-y := bnxt.o bnxt_sriov.o bnxt_ethtool.o bnxt_dcb.o bnxt_ulp.o bnxt_xdp.o bnxt_vfr.o
+bnxt_en-y := bnxt.o bnxt_sriov.o bnxt_ethtool.o bnxt_dcb.o bnxt_ulp.o bnxt_xdp.o bnxt_vfr.o bnxt_tc.o
index 4406f9195851f19f2b3e51daac70c0f2094f963a..d6367c10afb56f3daa9d938b896f49e3d7593575 100644 (file)
@@ -50,6 +50,7 @@
 #include <linux/bitmap.h>
 #include <linux/cpu_rmap.h>
 #include <linux/cpumask.h>
+#include <net/pkt_cls.h>
 
 #include "bnxt_hsi.h"
 #include "bnxt.h"
@@ -59,6 +60,7 @@
 #include "bnxt_dcb.h"
 #include "bnxt_xdp.h"
 #include "bnxt_vfr.h"
+#include "bnxt_tc.h"
 
 #define BNXT_TX_TIMEOUT                (5 * HZ)
 
@@ -7305,17 +7307,33 @@ int bnxt_setup_mq_tc(struct net_device *dev, u8 tc)
        return 0;
 }
 
-static int bnxt_setup_tc(struct net_device *dev, enum tc_setup_type type,
-                        void *type_data)
+static int bnxt_setup_flower(struct net_device *dev,
+                            struct tc_cls_flower_offload *cls_flower)
 {
-       struct tc_mqprio_qopt *mqprio = type_data;
+       struct bnxt *bp = netdev_priv(dev);
 
-       if (type != TC_SETUP_MQPRIO)
+       if (BNXT_VF(bp))
                return -EOPNOTSUPP;
 
-       mqprio->hw = TC_MQPRIO_HW_OFFLOAD_TCS;
+       return bnxt_tc_setup_flower(bp, bp->pf.fw_fid, cls_flower);
+}
+
+static int bnxt_setup_tc(struct net_device *dev, enum tc_setup_type type,
+                        void *type_data)
+{
+       switch (type) {
+       case TC_SETUP_CLSFLOWER:
+               return bnxt_setup_flower(dev, type_data);
+       case TC_SETUP_MQPRIO: {
+               struct tc_mqprio_qopt *mqprio = type_data;
+
+               mqprio->hw = TC_MQPRIO_HW_OFFLOAD_TCS;
 
-       return bnxt_setup_mq_tc(dev, mqprio->num_tc);
+               return bnxt_setup_mq_tc(dev, mqprio->num_tc);
+       }
+       default:
+               return -EOPNOTSUPP;
+       }
 }
 
 #ifdef CONFIG_RFS_ACCEL
@@ -7711,6 +7729,7 @@ static void bnxt_remove_one(struct pci_dev *pdev)
 
        pci_disable_pcie_error_reporting(pdev);
        unregister_netdev(dev);
+       bnxt_shutdown_tc(bp);
        cancel_work_sync(&bp->sp_task);
        bp->sp_event = 0;
 
@@ -8102,9 +8121,12 @@ static int bnxt_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
        else
                device_set_wakeup_capable(&pdev->dev, false);
 
+       if (BNXT_PF(bp))
+               bnxt_init_tc(bp);
+
        rc = register_netdev(dev);
        if (rc)
-               goto init_err_clr_int;
+               goto init_err_cleanup_tc;
 
        if (BNXT_PF(bp))
                bnxt_dl_register(bp);
@@ -8117,7 +8139,8 @@ static int bnxt_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
        return 0;
 
-init_err_clr_int:
+init_err_cleanup_tc:
+       bnxt_shutdown_tc(bp);
        bnxt_clear_int_mode(bp);
 
 init_err_pci_clean:
index 86af8ead7e5bf20b59d6c7bed0c243fe39e42324..7b888d4b2b552a406b8157b3f037a299dc7645a4 100644 (file)
@@ -19,6 +19,7 @@
 #define DRV_VER_UPD    0
 
 #include <linux/interrupt.h>
+#include <linux/rhashtable.h>
 #include <net/devlink.h>
 #include <net/dst_metadata.h>
 #include <net/switchdev.h>
@@ -943,6 +944,27 @@ struct bnxt_test_info {
 #define BNXT_CAG_REG_LEGACY_INT_STATUS 0x4014
 #define BNXT_CAG_REG_BASE              0x300000
 
+struct bnxt_tc_info {
+       bool                            enabled;
+
+       /* hash table to store TC offloaded flows */
+       struct rhashtable               flow_table;
+       struct rhashtable_params        flow_ht_params;
+
+       /* hash table to store L2 keys of TC flows */
+       struct rhashtable               l2_table;
+       struct rhashtable_params        l2_ht_params;
+
+       /* lock to atomically add/del an l2 node when a flow is
+        * added or deleted.
+        */
+       struct mutex                    lock;
+
+       /* Stat counter mask (width) */
+       u64                             bytes_mask;
+       u64                             packets_mask;
+};
+
 struct bnxt_vf_rep_stats {
        u64                     packets;
        u64                     bytes;
@@ -1289,6 +1311,7 @@ struct bnxt {
        enum devlink_eswitch_mode eswitch_mode;
        struct bnxt_vf_rep      **vf_reps; /* array of vf-rep ptrs */
        u16                     *cfa_code_map; /* cfa_code -> vf_idx map */
+       struct bnxt_tc_info     tc_info;
 };
 
 #define BNXT_RX_STATS_OFFSET(counter)                  \
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c
new file mode 100644 (file)
index 0000000..a10df27
--- /dev/null
@@ -0,0 +1,602 @@
+/* Broadcom NetXtreme-C/E network driver.
+ *
+ * Copyright (c) 2017 Broadcom Limited
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation.
+ */
+
+#include <linux/netdevice.h>
+#include <linux/inetdevice.h>
+#include <linux/if_vlan.h>
+#include <net/flow_dissector.h>
+#include <net/pkt_cls.h>
+#include <net/tc_act/tc_gact.h>
+#include <net/tc_act/tc_skbedit.h>
+#include <net/tc_act/tc_mirred.h>
+#include <net/tc_act/tc_vlan.h>
+
+#include "bnxt_hsi.h"
+#include "bnxt.h"
+#include "bnxt_sriov.h"
+#include "bnxt_tc.h"
+#include "bnxt_vfr.h"
+
+#ifdef CONFIG_BNXT_FLOWER_OFFLOAD
+
+#define BNXT_FID_INVALID                       0xffff
+#define VLAN_TCI(vid, prio)    ((vid) | ((prio) << VLAN_PRIO_SHIFT))
+
+/* Return the dst fid of the func for flow forwarding
+ * For PFs: src_fid is the fid of the PF
+ * For VF-reps: src_fid the fid of the VF
+ */
+static u16 bnxt_flow_get_dst_fid(struct bnxt *pf_bp, struct net_device *dev)
+{
+       struct bnxt *bp;
+
+       /* check if dev belongs to the same switch */
+       if (!switchdev_port_same_parent_id(pf_bp->dev, dev)) {
+               netdev_info(pf_bp->dev, "dev(ifindex=%d) not on same switch",
+                           dev->ifindex);
+               return BNXT_FID_INVALID;
+       }
+
+       /* Is dev a VF-rep? */
+       if (dev != pf_bp->dev)
+               return bnxt_vf_rep_get_fid(dev);
+
+       bp = netdev_priv(dev);
+       return bp->pf.fw_fid;
+}
+
+static int bnxt_tc_parse_redir(struct bnxt *bp,
+                              struct bnxt_tc_actions *actions,
+                              const struct tc_action *tc_act)
+{
+       int ifindex = tcf_mirred_ifindex(tc_act);
+       struct net_device *dev;
+       u16 dst_fid;
+
+       dev = __dev_get_by_index(dev_net(bp->dev), ifindex);
+       if (!dev) {
+               netdev_info(bp->dev, "no dev for ifindex=%d", ifindex);
+               return -EINVAL;
+       }
+
+       /* find the FID from dev */
+       dst_fid = bnxt_flow_get_dst_fid(bp, dev);
+       if (dst_fid == BNXT_FID_INVALID) {
+               netdev_info(bp->dev, "can't get fid for ifindex=%d", ifindex);
+               return -EINVAL;
+       }
+
+       actions->flags |= BNXT_TC_ACTION_FLAG_FWD;
+       actions->dst_fid = dst_fid;
+       actions->dst_dev = dev;
+       return 0;
+}
+
+static void bnxt_tc_parse_vlan(struct bnxt *bp,
+                              struct bnxt_tc_actions *actions,
+                              const struct tc_action *tc_act)
+{
+       if (tcf_vlan_action(tc_act) == TCA_VLAN_ACT_POP) {
+               actions->flags |= BNXT_TC_ACTION_FLAG_POP_VLAN;
+       } else if (tcf_vlan_action(tc_act) == TCA_VLAN_ACT_PUSH) {
+               actions->flags |= BNXT_TC_ACTION_FLAG_PUSH_VLAN;
+               actions->push_vlan_tci = htons(tcf_vlan_push_vid(tc_act));
+               actions->push_vlan_tpid = tcf_vlan_push_proto(tc_act);
+       }
+}
+
+static int bnxt_tc_parse_actions(struct bnxt *bp,
+                                struct bnxt_tc_actions *actions,
+                                struct tcf_exts *tc_exts)
+{
+       const struct tc_action *tc_act;
+       LIST_HEAD(tc_actions);
+       int rc;
+
+       if (!tcf_exts_has_actions(tc_exts)) {
+               netdev_info(bp->dev, "no actions");
+               return -EINVAL;
+       }
+
+       tcf_exts_to_list(tc_exts, &tc_actions);
+       list_for_each_entry(tc_act, &tc_actions, list) {
+               /* Drop action */
+               if (is_tcf_gact_shot(tc_act)) {
+                       actions->flags |= BNXT_TC_ACTION_FLAG_DROP;
+                       return 0; /* don't bother with other actions */
+               }
+
+               /* Redirect action */
+               if (is_tcf_mirred_egress_redirect(tc_act)) {
+                       rc = bnxt_tc_parse_redir(bp, actions, tc_act);
+                       if (rc)
+                               return rc;
+                       continue;
+               }
+
+               /* Push/pop VLAN */
+               if (is_tcf_vlan(tc_act)) {
+                       bnxt_tc_parse_vlan(bp, actions, tc_act);
+                       continue;
+               }
+       }
+
+       return 0;
+}
+
+#define GET_KEY(flow_cmd, key_type)                                    \
+               skb_flow_dissector_target((flow_cmd)->dissector, key_type,\
+                                         (flow_cmd)->key)
+#define GET_MASK(flow_cmd, key_type)                                   \
+               skb_flow_dissector_target((flow_cmd)->dissector, key_type,\
+                                         (flow_cmd)->mask)
+
+static int bnxt_tc_parse_flow(struct bnxt *bp,
+                             struct tc_cls_flower_offload *tc_flow_cmd,
+                             struct bnxt_tc_flow *flow)
+{
+       struct flow_dissector *dissector = tc_flow_cmd->dissector;
+       u16 addr_type = 0;
+
+       /* KEY_CONTROL and KEY_BASIC are needed for forming a meaningful key */
+       if ((dissector->used_keys & BIT(FLOW_DISSECTOR_KEY_CONTROL)) == 0 ||
+           (dissector->used_keys & BIT(FLOW_DISSECTOR_KEY_BASIC)) == 0) {
+               netdev_info(bp->dev, "cannot form TC key: used_keys = 0x%x",
+                           dissector->used_keys);
+               return -EOPNOTSUPP;
+       }
+
+       if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_CONTROL)) {
+               struct flow_dissector_key_control *key =
+                       GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_CONTROL);
+
+               addr_type = key->addr_type;
+       }
+
+       if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_BASIC)) {
+               struct flow_dissector_key_basic *key =
+                       GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_BASIC);
+               struct flow_dissector_key_basic *mask =
+                       GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_BASIC);
+
+               flow->l2_key.ether_type = key->n_proto;
+               flow->l2_mask.ether_type = mask->n_proto;
+
+               if (key->n_proto == htons(ETH_P_IP) ||
+                   key->n_proto == htons(ETH_P_IPV6)) {
+                       flow->l4_key.ip_proto = key->ip_proto;
+                       flow->l4_mask.ip_proto = mask->ip_proto;
+               }
+       }
+
+       if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_ETH_ADDRS)) {
+               struct flow_dissector_key_eth_addrs *key =
+                       GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_ETH_ADDRS);
+               struct flow_dissector_key_eth_addrs *mask =
+                       GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_ETH_ADDRS);
+
+               flow->flags |= BNXT_TC_FLOW_FLAGS_ETH_ADDRS;
+               ether_addr_copy(flow->l2_key.dmac, key->dst);
+               ether_addr_copy(flow->l2_mask.dmac, mask->dst);
+               ether_addr_copy(flow->l2_key.smac, key->src);
+               ether_addr_copy(flow->l2_mask.smac, mask->src);
+       }
+
+       if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_VLAN)) {
+               struct flow_dissector_key_vlan *key =
+                       GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_VLAN);
+               struct flow_dissector_key_vlan *mask =
+                       GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_VLAN);
+
+               flow->l2_key.inner_vlan_tci =
+                  cpu_to_be16(VLAN_TCI(key->vlan_id, key->vlan_priority));
+               flow->l2_mask.inner_vlan_tci =
+                  cpu_to_be16((VLAN_TCI(mask->vlan_id, mask->vlan_priority)));
+               flow->l2_key.inner_vlan_tpid = htons(ETH_P_8021Q);
+               flow->l2_mask.inner_vlan_tpid = htons(0xffff);
+               flow->l2_key.num_vlans = 1;
+       }
+
+       if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_IPV4_ADDRS)) {
+               struct flow_dissector_key_ipv4_addrs *key =
+                       GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_IPV4_ADDRS);
+               struct flow_dissector_key_ipv4_addrs *mask =
+                       GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_IPV4_ADDRS);
+
+               flow->flags |= BNXT_TC_FLOW_FLAGS_IPV4_ADDRS;
+               flow->l3_key.ipv4.daddr.s_addr = key->dst;
+               flow->l3_mask.ipv4.daddr.s_addr = mask->dst;
+               flow->l3_key.ipv4.saddr.s_addr = key->src;
+               flow->l3_mask.ipv4.saddr.s_addr = mask->src;
+       } else if (dissector_uses_key(dissector,
+                                     FLOW_DISSECTOR_KEY_IPV6_ADDRS)) {
+               struct flow_dissector_key_ipv6_addrs *key =
+                       GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_IPV6_ADDRS);
+               struct flow_dissector_key_ipv6_addrs *mask =
+                       GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_IPV6_ADDRS);
+
+               flow->flags |= BNXT_TC_FLOW_FLAGS_IPV6_ADDRS;
+               flow->l3_key.ipv6.daddr = key->dst;
+               flow->l3_mask.ipv6.daddr = mask->dst;
+               flow->l3_key.ipv6.saddr = key->src;
+               flow->l3_mask.ipv6.saddr = mask->src;
+       }
+
+       if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_PORTS)) {
+               struct flow_dissector_key_ports *key =
+                       GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_PORTS);
+               struct flow_dissector_key_ports *mask =
+                       GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_PORTS);
+
+               flow->flags |= BNXT_TC_FLOW_FLAGS_PORTS;
+               flow->l4_key.ports.dport = key->dst;
+               flow->l4_mask.ports.dport = mask->dst;
+               flow->l4_key.ports.sport = key->src;
+               flow->l4_mask.ports.sport = mask->src;
+       }
+
+       if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_ICMP)) {
+               struct flow_dissector_key_icmp *key =
+                       GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_ICMP);
+               struct flow_dissector_key_icmp *mask =
+                       GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_ICMP);
+
+               flow->flags |= BNXT_TC_FLOW_FLAGS_ICMP;
+               flow->l4_key.icmp.type = key->type;
+               flow->l4_key.icmp.code = key->code;
+               flow->l4_mask.icmp.type = mask->type;
+               flow->l4_mask.icmp.code = mask->code;
+       }
+
+       return bnxt_tc_parse_actions(bp, &flow->actions, tc_flow_cmd->exts);
+}
+
+static int bnxt_hwrm_cfa_flow_free(struct bnxt *bp, __le16 flow_handle)
+{
+       return 0;
+}
+
+static int bnxt_hwrm_cfa_flow_alloc(struct bnxt *bp, struct bnxt_tc_flow *flow,
+                                   __le16 ref_flow_handle, __le16 *flow_handle)
+{
+       return 0;
+}
+
+static int bnxt_tc_put_l2_node(struct bnxt *bp,
+                              struct bnxt_tc_flow_node *flow_node)
+{
+       struct bnxt_tc_l2_node *l2_node = flow_node->l2_node;
+       struct bnxt_tc_info *tc_info = &bp->tc_info;
+       int rc;
+
+       /* remove flow_node from the L2 shared flow list */
+       list_del(&flow_node->l2_list_node);
+       if (--l2_node->refcount == 0) {
+               rc =  rhashtable_remove_fast(&tc_info->l2_table, &l2_node->node,
+                                            tc_info->l2_ht_params);
+               if (rc)
+                       netdev_err(bp->dev,
+                                  "Error: %s: rhashtable_remove_fast: %d",
+                                  __func__, rc);
+               kfree_rcu(l2_node, rcu);
+       }
+       return 0;
+}
+
+static struct bnxt_tc_l2_node *
+bnxt_tc_get_l2_node(struct bnxt *bp, struct rhashtable *l2_table,
+                   struct rhashtable_params ht_params,
+                   struct bnxt_tc_l2_key *l2_key)
+{
+       struct bnxt_tc_l2_node *l2_node;
+       int rc;
+
+       l2_node = rhashtable_lookup_fast(l2_table, l2_key, ht_params);
+       if (!l2_node) {
+               l2_node = kzalloc(sizeof(*l2_node), GFP_KERNEL);
+               if (!l2_node) {
+                       rc = -ENOMEM;
+                       return NULL;
+               }
+
+               l2_node->key = *l2_key;
+               rc = rhashtable_insert_fast(l2_table, &l2_node->node,
+                                           ht_params);
+               if (rc) {
+                       kfree(l2_node);
+                       netdev_err(bp->dev,
+                                  "Error: %s: rhashtable_insert_fast: %d",
+                                  __func__, rc);
+                       return NULL;
+               }
+               INIT_LIST_HEAD(&l2_node->common_l2_flows);
+       }
+       return l2_node;
+}
+
+/* Get the ref_flow_handle for a flow by checking if there are any other
+ * flows that share the same L2 key as this flow.
+ */
+static int
+bnxt_tc_get_ref_flow_handle(struct bnxt *bp, struct bnxt_tc_flow *flow,
+                           struct bnxt_tc_flow_node *flow_node,
+                           __le16 *ref_flow_handle)
+{
+       struct bnxt_tc_info *tc_info = &bp->tc_info;
+       struct bnxt_tc_flow_node *ref_flow_node;
+       struct bnxt_tc_l2_node *l2_node;
+
+       l2_node = bnxt_tc_get_l2_node(bp, &tc_info->l2_table,
+                                     tc_info->l2_ht_params,
+                                     &flow->l2_key);
+       if (!l2_node)
+               return -1;
+
+       /* If any other flow is using this l2_node, use it's flow_handle
+        * as the ref_flow_handle
+        */
+       if (l2_node->refcount > 0) {
+               ref_flow_node = list_first_entry(&l2_node->common_l2_flows,
+                                                struct bnxt_tc_flow_node,
+                                                l2_list_node);
+               *ref_flow_handle = ref_flow_node->flow_handle;
+       } else {
+               *ref_flow_handle = cpu_to_le16(0xffff);
+       }
+
+       /* Insert the l2_node into the flow_node so that subsequent flows
+        * with a matching l2 key can use the flow_handle of this flow
+        * as their ref_flow_handle
+        */
+       flow_node->l2_node = l2_node;
+       list_add(&flow_node->l2_list_node, &l2_node->common_l2_flows);
+       l2_node->refcount++;
+       return 0;
+}
+
+/* After the flow parsing is done, this routine is used for checking
+ * if there are any aspects of the flow that prevent it from being
+ * offloaded.
+ */
+static bool bnxt_tc_can_offload(struct bnxt *bp, struct bnxt_tc_flow *flow)
+{
+       /* If L4 ports are specified then ip_proto must be TCP or UDP */
+       if ((flow->flags & BNXT_TC_FLOW_FLAGS_PORTS) &&
+           (flow->l4_key.ip_proto != IPPROTO_TCP &&
+            flow->l4_key.ip_proto != IPPROTO_UDP)) {
+               netdev_info(bp->dev, "Cannot offload non-TCP/UDP (%d) ports",
+                           flow->l4_key.ip_proto);
+               return false;
+       }
+
+       return true;
+}
+
+static int __bnxt_tc_del_flow(struct bnxt *bp,
+                             struct bnxt_tc_flow_node *flow_node)
+{
+       struct bnxt_tc_info *tc_info = &bp->tc_info;
+       int rc;
+
+       /* send HWRM cmd to free the flow-id */
+       bnxt_hwrm_cfa_flow_free(bp, flow_node->flow_handle);
+
+       mutex_lock(&tc_info->lock);
+
+       /* release reference to l2 node */
+       bnxt_tc_put_l2_node(bp, flow_node);
+
+       mutex_unlock(&tc_info->lock);
+
+       rc = rhashtable_remove_fast(&tc_info->flow_table, &flow_node->node,
+                                   tc_info->flow_ht_params);
+       if (rc)
+               netdev_err(bp->dev, "Error: %s: rhashtable_remove_fast rc=%d",
+                          __func__, rc);
+
+       kfree_rcu(flow_node, rcu);
+       return 0;
+}
+
+/* Add a new flow or replace an existing flow.
+ * Notes on locking:
+ * There are essentially two critical sections here.
+ * 1. while adding a new flow
+ *    a) lookup l2-key
+ *    b) issue HWRM cmd and get flow_handle
+ *    c) link l2-key with flow
+ * 2. while deleting a flow
+ *    a) unlinking l2-key from flow
+ * A lock is needed to protect these two critical sections.
+ *
+ * The hash-tables are already protected by the rhashtable API.
+ */
+static int bnxt_tc_add_flow(struct bnxt *bp, u16 src_fid,
+                           struct tc_cls_flower_offload *tc_flow_cmd)
+{
+       struct bnxt_tc_flow_node *new_node, *old_node;
+       struct bnxt_tc_info *tc_info = &bp->tc_info;
+       struct bnxt_tc_flow *flow;
+       __le16 ref_flow_handle;
+       int rc;
+
+       /* allocate memory for the new flow and it's node */
+       new_node = kzalloc(sizeof(*new_node), GFP_KERNEL);
+       if (!new_node) {
+               rc = -ENOMEM;
+               goto done;
+       }
+       new_node->cookie = tc_flow_cmd->cookie;
+       flow = &new_node->flow;
+
+       rc = bnxt_tc_parse_flow(bp, tc_flow_cmd, flow);
+       if (rc)
+               goto free_node;
+       flow->src_fid = src_fid;
+
+       if (!bnxt_tc_can_offload(bp, flow)) {
+               rc = -ENOSPC;
+               goto free_node;
+       }
+
+       /* If a flow exists with the same cookie, delete it */
+       old_node = rhashtable_lookup_fast(&tc_info->flow_table,
+                                         &tc_flow_cmd->cookie,
+                                         tc_info->flow_ht_params);
+       if (old_node)
+               __bnxt_tc_del_flow(bp, old_node);
+
+       /* Check if the L2 part of the flow has been offloaded already.
+        * If so, bump up it's refcnt and get it's reference handle.
+        */
+       mutex_lock(&tc_info->lock);
+       rc = bnxt_tc_get_ref_flow_handle(bp, flow, new_node, &ref_flow_handle);
+       if (rc)
+               goto unlock;
+
+       /* send HWRM cmd to alloc the flow */
+       rc = bnxt_hwrm_cfa_flow_alloc(bp, flow, ref_flow_handle,
+                                     &new_node->flow_handle);
+       if (rc)
+               goto put_l2;
+
+       /* add new flow to flow-table */
+       rc = rhashtable_insert_fast(&tc_info->flow_table, &new_node->node,
+                                   tc_info->flow_ht_params);
+       if (rc)
+               goto hwrm_flow_free;
+
+       mutex_unlock(&tc_info->lock);
+       return 0;
+
+hwrm_flow_free:
+       bnxt_hwrm_cfa_flow_free(bp, new_node->flow_handle);
+put_l2:
+       bnxt_tc_put_l2_node(bp, new_node);
+unlock:
+       mutex_unlock(&tc_info->lock);
+free_node:
+       kfree(new_node);
+done:
+       netdev_err(bp->dev, "Error: %s: cookie=0x%lx error=%d",
+                  __func__, tc_flow_cmd->cookie, rc);
+       return rc;
+}
+
+static int bnxt_tc_del_flow(struct bnxt *bp,
+                           struct tc_cls_flower_offload *tc_flow_cmd)
+{
+       struct bnxt_tc_info *tc_info = &bp->tc_info;
+       struct bnxt_tc_flow_node *flow_node;
+
+       flow_node = rhashtable_lookup_fast(&tc_info->flow_table,
+                                          &tc_flow_cmd->cookie,
+                                          tc_info->flow_ht_params);
+       if (!flow_node) {
+               netdev_info(bp->dev, "ERROR: no flow_node for cookie %lx",
+                           tc_flow_cmd->cookie);
+               return -EINVAL;
+       }
+
+       return __bnxt_tc_del_flow(bp, flow_node);
+}
+
+static int bnxt_tc_get_flow_stats(struct bnxt *bp,
+                                 struct tc_cls_flower_offload *tc_flow_cmd)
+{
+       return 0;
+}
+
+int bnxt_tc_setup_flower(struct bnxt *bp, u16 src_fid,
+                        struct tc_cls_flower_offload *cls_flower)
+{
+       int rc = 0;
+
+       switch (cls_flower->command) {
+       case TC_CLSFLOWER_REPLACE:
+               rc = bnxt_tc_add_flow(bp, src_fid, cls_flower);
+               break;
+
+       case TC_CLSFLOWER_DESTROY:
+               rc = bnxt_tc_del_flow(bp, cls_flower);
+               break;
+
+       case TC_CLSFLOWER_STATS:
+               rc = bnxt_tc_get_flow_stats(bp, cls_flower);
+               break;
+       }
+       return rc;
+}
+
+static const struct rhashtable_params bnxt_tc_flow_ht_params = {
+       .head_offset = offsetof(struct bnxt_tc_flow_node, node),
+       .key_offset = offsetof(struct bnxt_tc_flow_node, cookie),
+       .key_len = sizeof(((struct bnxt_tc_flow_node *)0)->cookie),
+       .automatic_shrinking = true
+};
+
+static const struct rhashtable_params bnxt_tc_l2_ht_params = {
+       .head_offset = offsetof(struct bnxt_tc_l2_node, node),
+       .key_offset = offsetof(struct bnxt_tc_l2_node, key),
+       .key_len = BNXT_TC_L2_KEY_LEN,
+       .automatic_shrinking = true
+};
+
+/* convert counter width in bits to a mask */
+#define mask(width)            ((u64)~0 >> (64 - (width)))
+
+int bnxt_init_tc(struct bnxt *bp)
+{
+       struct bnxt_tc_info *tc_info = &bp->tc_info;
+       int rc;
+
+       if (bp->hwrm_spec_code < 0x10800) {
+               netdev_warn(bp->dev,
+                           "Firmware does not support TC flower offload.\n");
+               return -ENOTSUPP;
+       }
+       mutex_init(&tc_info->lock);
+
+       /* Counter widths are programmed by FW */
+       tc_info->bytes_mask = mask(36);
+       tc_info->packets_mask = mask(28);
+
+       tc_info->flow_ht_params = bnxt_tc_flow_ht_params;
+       rc = rhashtable_init(&tc_info->flow_table, &tc_info->flow_ht_params);
+       if (rc)
+               return rc;
+
+       tc_info->l2_ht_params = bnxt_tc_l2_ht_params;
+       rc = rhashtable_init(&tc_info->l2_table, &tc_info->l2_ht_params);
+       if (rc)
+               goto destroy_flow_table;
+
+       tc_info->enabled = true;
+       bp->dev->hw_features |= NETIF_F_HW_TC;
+       bp->dev->features |= NETIF_F_HW_TC;
+       return 0;
+
+destroy_flow_table:
+       rhashtable_destroy(&tc_info->flow_table);
+       return rc;
+}
+
+void bnxt_shutdown_tc(struct bnxt *bp)
+{
+       struct bnxt_tc_info *tc_info = &bp->tc_info;
+
+       if (!tc_info->enabled)
+               return;
+
+       rhashtable_destroy(&tc_info->flow_table);
+       rhashtable_destroy(&tc_info->l2_table);
+}
+
+#else
+#endif
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_tc.h b/drivers/net/ethernet/broadcom/bnxt/bnxt_tc.h
new file mode 100644 (file)
index 0000000..6c4c1ed
--- /dev/null
@@ -0,0 +1,158 @@
+/* Broadcom NetXtreme-C/E network driver.
+ *
+ * Copyright (c) 2017 Broadcom Limited
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation.
+ */
+
+#ifndef BNXT_TC_H
+#define BNXT_TC_H
+
+#ifdef CONFIG_BNXT_FLOWER_OFFLOAD
+
+/* Structs used for storing the filter/actions of the TC cmd.
+ */
+struct bnxt_tc_l2_key {
+       u8              dmac[ETH_ALEN];
+       u8              smac[ETH_ALEN];
+       __be16          inner_vlan_tpid;
+       __be16          inner_vlan_tci;
+       __be16          ether_type;
+       u8              num_vlans;
+};
+
+struct bnxt_tc_l3_key {
+       union {
+               struct {
+                       struct in_addr daddr;
+                       struct in_addr saddr;
+               } ipv4;
+               struct {
+                       struct in6_addr daddr;
+                       struct in6_addr saddr;
+               } ipv6;
+       };
+};
+
+struct bnxt_tc_l4_key {
+       u8  ip_proto;
+       union {
+               struct {
+                       __be16 sport;
+                       __be16 dport;
+               } ports;
+               struct {
+                       u8 type;
+                       u8 code;
+               } icmp;
+       };
+};
+
+struct bnxt_tc_actions {
+       u32                             flags;
+#define BNXT_TC_ACTION_FLAG_FWD                        BIT(0)
+#define BNXT_TC_ACTION_FLAG_FWD_VXLAN          BIT(1)
+#define BNXT_TC_ACTION_FLAG_PUSH_VLAN          BIT(3)
+#define BNXT_TC_ACTION_FLAG_POP_VLAN           BIT(4)
+#define BNXT_TC_ACTION_FLAG_DROP               BIT(5)
+
+       u16                             dst_fid;
+       struct net_device               *dst_dev;
+       __be16                          push_vlan_tpid;
+       __be16                          push_vlan_tci;
+};
+
+struct bnxt_tc_flow_stats {
+       u64             packets;
+       u64             bytes;
+};
+
+struct bnxt_tc_flow {
+       u32                             flags;
+#define BNXT_TC_FLOW_FLAGS_ETH_ADDRS           BIT(1)
+#define BNXT_TC_FLOW_FLAGS_IPV4_ADDRS          BIT(2)
+#define BNXT_TC_FLOW_FLAGS_IPV6_ADDRS          BIT(3)
+#define BNXT_TC_FLOW_FLAGS_PORTS               BIT(4)
+#define BNXT_TC_FLOW_FLAGS_ICMP                        BIT(5)
+
+       /* flow applicable to pkts ingressing on this fid */
+       u16                             src_fid;
+       struct bnxt_tc_l2_key           l2_key;
+       struct bnxt_tc_l2_key           l2_mask;
+       struct bnxt_tc_l3_key           l3_key;
+       struct bnxt_tc_l3_key           l3_mask;
+       struct bnxt_tc_l4_key           l4_key;
+       struct bnxt_tc_l4_key           l4_mask;
+
+       struct bnxt_tc_actions          actions;
+
+       /* updated stats accounting for hw-counter wrap-around */
+       struct bnxt_tc_flow_stats       stats;
+       /* previous snap-shot of stats */
+       struct bnxt_tc_flow_stats       prev_stats;
+       unsigned long                   lastused; /* jiffies */
+};
+
+/* L2 hash table
+ * This data-struct is used for L2-flow table.
+ * The L2 part of a flow is stored in a hash table.
+ * A flow that shares the same L2 key/mask with an
+ * already existing flow must refer to it's flow handle.
+ */
+struct bnxt_tc_l2_node {
+       /* hash key: first 16b of key */
+#define BNXT_TC_L2_KEY_LEN                     16
+       struct bnxt_tc_l2_key   key;
+       struct rhash_head       node;
+
+       /* a linked list of flows that share the same l2 key */
+       struct list_head        common_l2_flows;
+
+       /* number of flows sharing the l2 key */
+       u16                     refcount;
+
+       struct rcu_head         rcu;
+};
+
+struct bnxt_tc_flow_node {
+       /* hash key: provided by TC */
+       unsigned long                   cookie;
+       struct rhash_head               node;
+
+       struct bnxt_tc_flow             flow;
+
+       __le16                          flow_handle;
+
+       /* L2 node in l2 hashtable that shares flow's l2 key */
+       struct bnxt_tc_l2_node          *l2_node;
+       /* for the shared_flows list maintained in l2_node */
+       struct list_head                l2_list_node;
+
+       struct rcu_head                 rcu;
+};
+
+int bnxt_tc_setup_flower(struct bnxt *bp, u16 src_fid,
+                        struct tc_cls_flower_offload *cls_flower);
+int bnxt_init_tc(struct bnxt *bp);
+void bnxt_shutdown_tc(struct bnxt *bp);
+
+#else /* CONFIG_BNXT_FLOWER_OFFLOAD */
+
+static inline int bnxt_tc_setup_flower(struct bnxt *bp, u16 src_fid,
+                                      struct tc_cls_flower_offload *cls_flower)
+{
+       return -EOPNOTSUPP;
+}
+
+static inline int bnxt_init_tc(struct bnxt *bp)
+{
+       return 0;
+}
+
+static inline void bnxt_shutdown_tc(struct bnxt *bp)
+{
+}
+#endif /* CONFIG_BNXT_FLOWER_OFFLOAD */
+#endif /* BNXT_TC_H */
index c365d3cf8e51888d02f56a2e3a31a9286e0f7332..e75db04c6cdc768743a41b4c3fffb93b227714b0 100644 (file)
 #include <linux/etherdevice.h>
 #include <linux/rtnetlink.h>
 #include <linux/jhash.h>
+#include <net/pkt_cls.h>
 
 #include "bnxt_hsi.h"
 #include "bnxt.h"
 #include "bnxt_vfr.h"
+#include "bnxt_tc.h"
 
 #ifdef CONFIG_BNXT_SRIOV
 
@@ -113,6 +115,21 @@ bnxt_vf_rep_get_stats64(struct net_device *dev,
        stats->tx_bytes = vf_rep->tx_stats.bytes;
 }
 
+static int bnxt_vf_rep_setup_tc(struct net_device *dev, enum tc_setup_type type,
+                               void *type_data)
+{
+       struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
+       struct bnxt *bp = vf_rep->bp;
+       int vf_fid = bp->pf.vf[vf_rep->vf_idx].fw_fid;
+
+       switch (type) {
+       case TC_SETUP_CLSFLOWER:
+               return bnxt_tc_setup_flower(bp, vf_fid, type_data);
+       default:
+               return -EOPNOTSUPP;
+       }
+}
+
 struct net_device *bnxt_get_vf_rep(struct bnxt *bp, u16 cfa_code)
 {
        u16 vf_idx;
@@ -182,6 +199,7 @@ static const struct net_device_ops bnxt_vf_rep_netdev_ops = {
        .ndo_stop               = bnxt_vf_rep_close,
        .ndo_start_xmit         = bnxt_vf_rep_xmit,
        .ndo_get_stats64        = bnxt_vf_rep_get_stats64,
+       .ndo_setup_tc           = bnxt_vf_rep_setup_tc,
        .ndo_get_phys_port_name = bnxt_vf_rep_get_phys_port_name
 };
 
index 3e997c9e2580949eadd3f2cd1ef6c73585416dee..d8b5f89427fab98abdd5aef7349432c1a50e404b 100644 (file)
@@ -45,6 +45,14 @@ void bnxt_vf_reps_open(struct bnxt *bp);
 void bnxt_vf_rep_rx(struct bnxt *bp, struct sk_buff *skb);
 struct net_device *bnxt_get_vf_rep(struct bnxt *bp, u16 cfa_code);
 
+static inline u16 bnxt_vf_rep_get_fid(struct net_device *dev)
+{
+       struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
+       struct bnxt *bp = vf_rep->bp;
+
+       return bp->pf.vf[vf_rep->vf_idx].fw_fid;
+}
+
 #else
 
 static inline int bnxt_dl_register(struct bnxt *bp)