bnxt_en: bnxt: add TC flower filter offload support (2ae7408f) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/net/ethernet/broadcom/Kconfig

+9 −0

Original line number	Diff line number	Diff line
		@@ -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

drivers/net/ethernet/broadcom/bnxt/Makefile

+1 −1

Original line number	Diff line number	Diff line
		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

drivers/net/ethernet/broadcom/bnxt/bnxt.c

+31 −8

Original line number	Diff line number	Diff line
		@@ -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,18 +7307,34 @@ int bnxt_setup_mq_tc(struct net_device *dev, u8 tc)
		return 0;
		}

		static int bnxt_setup_flower(struct net_device *dev,
		struct tc_cls_flower_offload *cls_flower)
		{
		struct bnxt *bp = netdev_priv(dev);

		if (BNXT_VF(bp))
		return -EOPNOTSUPP;

		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;

		if (type != TC_SETUP_MQPRIO)
		return -EOPNOTSUPP;

		mqprio->hw = TC_MQPRIO_HW_OFFLOAD_TCS;

		return bnxt_setup_mq_tc(dev, mqprio->num_tc);
		}
		default:
		return -EOPNOTSUPP;
		}
		}

		#ifdef CONFIG_RFS_ACCEL
		static bool bnxt_fltr_match(struct bnxt_ntuple_filter *f1,
		@@ -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:

drivers/net/ethernet/broadcom/bnxt/bnxt.h

+23 −0

Original line number	Diff line number	Diff line
		@@ -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) \

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

0 → 100644

+602 −0

Original line number	Diff line number	Diff line
		/* 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