Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cddd9523 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'cxgb4-tc-flower' 



Rahul Lakkireddy says:

====================
cxgb4: add support to offload tc flower

This series of patches add support to offload tc flower onto Chelsio
NICs.

Patch 1 adds basic skeleton to prepare for offloading tc flower flows.

Patch 2 adds support to add/remove flows for offload.  Flows can have
accompanying masks.  Following match and action are currently supported
for offload:
Match:  ether-protocol, IPv4/IPv6 addresses, L4 ports (TCP/UDP)
Action: drop, redirect to another port on the device.

Patch 3 adds support to offload tc-flower flows having
vlan actions: pop, push, and modify.

Patch 4 adds support to fetch stats for the offloaded tc flower flows
from hardware.

Support for offloading more match and action types are to be followed
in subsequent series.

v2:
- Setting ftid to -1 not required after bitmap_find_free_region
  in cxgb4_get_free_ftid.
- Direct return can be used as jumping to error path is not needed
  if flower entry allocation failed in cxgb4_tc_flower_replace.
  Same applies if flower entry not found in cxgb4_tc_flower_destroy.
- Also, removed an extra return from cxgb4_tc_flower_destroy.
- Avoid wrapping line for netdev_err message. Also, use
  consistent error message string.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 52a59bd5 e0f911c8

drivers/net/ethernet/chelsio/cxgb4/Makefile

+3 −1
Original line number Diff line number Diff line
@@ -4,7 +4,9 @@ 


obj-$(CONFIG_CHELSIO_T4) += cxgb4.o



cxgb4-objs := cxgb4_main.o l2t.o t4_hw.o sge.o clip_tbl.o cxgb4_ethtool.o cxgb4_uld.o sched.o cxgb4_filter.o cxgb4_tc_u32.o cxgb4_ptp.o

cxgb4-objs := cxgb4_main.o l2t.o t4_hw.o sge.o clip_tbl.o cxgb4_ethtool.o \

	      cxgb4_uld.o sched.o cxgb4_filter.o cxgb4_tc_u32.o \

	      cxgb4_ptp.o cxgb4_tc_flower.o

cxgb4-$(CONFIG_CHELSIO_T4_DCB) +=  cxgb4_dcb.o

cxgb4-$(CONFIG_CHELSIO_T4_FCOE) +=  cxgb4_fcoe.o

cxgb4-$(CONFIG_DEBUG_FS) += cxgb4_debugfs.o

drivers/net/ethernet/chelsio/cxgb4/cxgb4.h

+4 −0
Original line number Diff line number Diff line
@@ -905,6 +905,10 @@ struct adapter { 
	/* TC u32 offload */

	struct cxgb4_tc_u32_table *tc_u32;

	struct chcr_stats_debug chcr_stats;



	/* TC flower offload */

	DECLARE_HASHTABLE(flower_anymatch_tbl, 9);

	struct timer_list flower_stats_timer;

};



/* Support for "sched-class" command to allow a TX Scheduling Class to be

drivers/net/ethernet/chelsio/cxgb4/cxgb4_filter.c

+100 −0
Original line number Diff line number Diff line
@@ -148,6 +148,106 @@ static int get_filter_steerq(struct net_device *dev, 
	return iq;

}



static int get_filter_count(struct adapter *adapter, unsigned int fidx,

			    u64 *pkts, u64 *bytes)

{

	unsigned int tcb_base, tcbaddr;

	unsigned int word_offset;

	struct filter_entry *f;

	__be64 be64_byte_count;

	int ret;



	tcb_base = t4_read_reg(adapter, TP_CMM_TCB_BASE_A);

	if ((fidx != (adapter->tids.nftids + adapter->tids.nsftids - 1)) &&

	    fidx >= adapter->tids.nftids)

		return -E2BIG;



	f = &adapter->tids.ftid_tab[fidx];

	if (!f->valid)

		return -EINVAL;



	tcbaddr = tcb_base + f->tid * TCB_SIZE;



	spin_lock(&adapter->win0_lock);

	if (is_t4(adapter->params.chip)) {

		__be64 be64_count;



		/* T4 doesn't maintain byte counts in hw */

		*bytes = 0;



		/* Get pkts */

		word_offset = 4;

		ret = t4_memory_rw(adapter, MEMWIN_NIC, MEM_EDC0,

				   tcbaddr + (word_offset * sizeof(__be32)),

				   sizeof(be64_count),

				   (__be32 *)&be64_count,

				   T4_MEMORY_READ);

		if (ret < 0)

			goto out;

		*pkts = be64_to_cpu(be64_count);

	} else {

		__be32 be32_count;



		/* Get bytes */

		word_offset = 4;

		ret = t4_memory_rw(adapter, MEMWIN_NIC, MEM_EDC0,

				   tcbaddr + (word_offset * sizeof(__be32)),

				   sizeof(be64_byte_count),

				   &be64_byte_count,

				   T4_MEMORY_READ);

		if (ret < 0)

			goto out;

		*bytes = be64_to_cpu(be64_byte_count);



		/* Get pkts */

		word_offset = 6;

		ret = t4_memory_rw(adapter, MEMWIN_NIC, MEM_EDC0,

				   tcbaddr + (word_offset * sizeof(__be32)),

				   sizeof(be32_count),

				   &be32_count,

				   T4_MEMORY_READ);

		if (ret < 0)

			goto out;

		*pkts = (u64)be32_to_cpu(be32_count);

	}



out:

	spin_unlock(&adapter->win0_lock);

	return ret;

}



int cxgb4_get_filter_counters(struct net_device *dev, unsigned int fidx,

			      u64 *hitcnt, u64 *bytecnt)

{

	struct adapter *adapter = netdev2adap(dev);



	return get_filter_count(adapter, fidx, hitcnt, bytecnt);

}



int cxgb4_get_free_ftid(struct net_device *dev, int family)

{

	struct adapter *adap = netdev2adap(dev);

	struct tid_info *t = &adap->tids;

	int ftid;



	spin_lock_bh(&t->ftid_lock);

	if (family == PF_INET) {

		ftid = find_first_zero_bit(t->ftid_bmap, t->nftids);

		if (ftid >= t->nftids)

			ftid = -1;

	} else {

		ftid = bitmap_find_free_region(t->ftid_bmap, t->nftids, 2);

		if (ftid < 0)

			goto out_unlock;



		/* this is only a lookup, keep the found region unallocated */

		bitmap_release_region(t->ftid_bmap, ftid, 2);

	}

out_unlock:

	spin_unlock_bh(&t->ftid_lock);

	return ftid;

}



static int cxgb4_set_ftid(struct tid_info *t, int fidx, int family)

{

	spin_lock_bh(&t->ftid_lock);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

+25 −0
Original line number Diff line number Diff line
@@ -79,6 +79,7 @@ 
#include "l2t.h"

#include "sched.h"

#include "cxgb4_tc_u32.h"

#include "cxgb4_tc_flower.h"

#include "cxgb4_ptp.h"



char cxgb4_driver_name[] = KBUILD_MODNAME;
@@ -2873,6 +2874,25 @@ static int cxgb_set_tx_maxrate(struct net_device *dev, int index, u32 rate) 
	return err;

}



static int cxgb_setup_tc_flower(struct net_device *dev,

				struct tc_cls_flower_offload *cls_flower)

{

	if (!is_classid_clsact_ingress(cls_flower->common.classid) ||

	    cls_flower->common.chain_index)

		return -EOPNOTSUPP;



	switch (cls_flower->command) {

	case TC_CLSFLOWER_REPLACE:

		return cxgb4_tc_flower_replace(dev, cls_flower);

	case TC_CLSFLOWER_DESTROY:

		return cxgb4_tc_flower_destroy(dev, cls_flower);

	case TC_CLSFLOWER_STATS:

		return cxgb4_tc_flower_stats(dev, cls_flower);

	default:

		return -EOPNOTSUPP;

	}

}



static int cxgb_setup_tc_cls_u32(struct net_device *dev,

				 struct tc_cls_u32_offload *cls_u32)

{
@@ -2907,6 +2927,8 @@ static int cxgb_setup_tc(struct net_device *dev, enum tc_setup_type type, 
	switch (type) {

	case TC_SETUP_CLSU32:

		return cxgb_setup_tc_cls_u32(dev, type_data);

	case TC_SETUP_CLSFLOWER:

		return cxgb_setup_tc_flower(dev, type_data);

	default:

		return -EOPNOTSUPP;

	}
@@ -4615,6 +4637,7 @@ static void free_some_resources(struct adapter *adapter) 
	kvfree(adapter->l2t);

	t4_cleanup_sched(adapter);

	kvfree(adapter->tids.tid_tab);

	cxgb4_cleanup_tc_flower(adapter);

	cxgb4_cleanup_tc_u32(adapter);

	kfree(adapter->sge.egr_map);

	kfree(adapter->sge.ingr_map);
@@ -5083,6 +5106,8 @@ static int init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 
		if (!adapter->tc_u32)

			dev_warn(&pdev->dev,

				 "could not offload tc u32, continuing\n");



		cxgb4_init_tc_flower(adapter);

	}



	if (is_offload(adapter)) {

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

0 → 100644
+452 −0
Original line number Diff line number Diff line 
/*

 * This file is part of the Chelsio T4/T5/T6 Ethernet driver for Linux.

 *

 * Copyright (c) 2017 Chelsio Communications, Inc. All rights reserved.

 *

 * This software is available to you under a choice of one of two

 * licenses.  You may choose to be licensed under the terms of the GNU

 * General Public License (GPL) Version 2, available from the file

 * COPYING in the main directory of this source tree, or the

 * OpenIB.org BSD license below:

 *

 *     Redistribution and use in source and binary forms, with or

 *     without modification, are permitted provided that the following

 *     conditions are met:

 *

 *      - Redistributions of source code must retain the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer.

 *

 *      - Redistributions in binary form must reproduce the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer in the documentation and/or other materials

 *        provided with the distribution.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 */



#include <net/tc_act/tc_gact.h>

#include <net/tc_act/tc_mirred.h>

#include <net/tc_act/tc_vlan.h>



#include "cxgb4.h"

#include "cxgb4_tc_flower.h"



#define STATS_CHECK_PERIOD (HZ / 2)



static struct ch_tc_flower_entry *allocate_flower_entry(void)

{

	struct ch_tc_flower_entry *new = kzalloc(sizeof(*new), GFP_KERNEL);

	spin_lock_init(&new->lock);

	return new;

}



/* Must be called with either RTNL or rcu_read_lock */

static struct ch_tc_flower_entry *ch_flower_lookup(struct adapter *adap,

						   unsigned long flower_cookie)

{

	struct ch_tc_flower_entry *flower_entry;



	hash_for_each_possible_rcu(adap->flower_anymatch_tbl, flower_entry,

				   link, flower_cookie)

		if (flower_entry->tc_flower_cookie == flower_cookie)

			return flower_entry;

	return NULL;

}



static void cxgb4_process_flow_match(struct net_device *dev,

				     struct tc_cls_flower_offload *cls,

				     struct ch_filter_specification *fs)

{

	u16 addr_type = 0;



	if (dissector_uses_key(cls->dissector, FLOW_DISSECTOR_KEY_CONTROL)) {

		struct flow_dissector_key_control *key =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_CONTROL,

						  cls->key);



		addr_type = key->addr_type;

	}



	if (dissector_uses_key(cls->dissector, FLOW_DISSECTOR_KEY_BASIC)) {

		struct flow_dissector_key_basic *key =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_BASIC,

						  cls->key);

		struct flow_dissector_key_basic *mask =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_BASIC,

						  cls->mask);

		u16 ethtype_key = ntohs(key->n_proto);

		u16 ethtype_mask = ntohs(mask->n_proto);



		if (ethtype_key == ETH_P_ALL) {

			ethtype_key = 0;

			ethtype_mask = 0;

		}



		fs->val.ethtype = ethtype_key;

		fs->mask.ethtype = ethtype_mask;

		fs->val.proto = key->ip_proto;

		fs->mask.proto = mask->ip_proto;

	}



	if (addr_type == FLOW_DISSECTOR_KEY_IPV4_ADDRS) {

		struct flow_dissector_key_ipv4_addrs *key =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_IPV4_ADDRS,

						  cls->key);

		struct flow_dissector_key_ipv4_addrs *mask =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_IPV4_ADDRS,

						  cls->mask);

		fs->type = 0;

		memcpy(&fs->val.lip[0], &key->dst, sizeof(key->dst));

		memcpy(&fs->val.fip[0], &key->src, sizeof(key->src));

		memcpy(&fs->mask.lip[0], &mask->dst, sizeof(mask->dst));

		memcpy(&fs->mask.fip[0], &mask->src, sizeof(mask->src));

	}



	if (addr_type == FLOW_DISSECTOR_KEY_IPV6_ADDRS) {

		struct flow_dissector_key_ipv6_addrs *key =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_IPV6_ADDRS,

						  cls->key);

		struct flow_dissector_key_ipv6_addrs *mask =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_IPV6_ADDRS,

						  cls->mask);



		fs->type = 1;

		memcpy(&fs->val.lip[0], key->dst.s6_addr, sizeof(key->dst));

		memcpy(&fs->val.fip[0], key->src.s6_addr, sizeof(key->src));

		memcpy(&fs->mask.lip[0], mask->dst.s6_addr, sizeof(mask->dst));

		memcpy(&fs->mask.fip[0], mask->src.s6_addr, sizeof(mask->src));

	}



	if (dissector_uses_key(cls->dissector, FLOW_DISSECTOR_KEY_PORTS)) {

		struct flow_dissector_key_ports *key, *mask;



		key = skb_flow_dissector_target(cls->dissector,

						FLOW_DISSECTOR_KEY_PORTS,

						cls->key);

		mask = skb_flow_dissector_target(cls->dissector,

						 FLOW_DISSECTOR_KEY_PORTS,

						 cls->mask);

		fs->val.lport = cpu_to_be16(key->dst);

		fs->mask.lport = cpu_to_be16(mask->dst);

		fs->val.fport = cpu_to_be16(key->src);

		fs->mask.fport = cpu_to_be16(mask->src);

	}



	/* Match only packets coming from the ingress port where this

	 * filter will be created.

	 */

	fs->val.iport = netdev2pinfo(dev)->port_id;

	fs->mask.iport = ~0;

}



static int cxgb4_validate_flow_match(struct net_device *dev,

				     struct tc_cls_flower_offload *cls)

{

	if (cls->dissector->used_keys &

	    ~(BIT(FLOW_DISSECTOR_KEY_CONTROL) |

	      BIT(FLOW_DISSECTOR_KEY_BASIC) |

	      BIT(FLOW_DISSECTOR_KEY_IPV4_ADDRS) |

	      BIT(FLOW_DISSECTOR_KEY_IPV6_ADDRS) |

	      BIT(FLOW_DISSECTOR_KEY_PORTS))) {

		netdev_warn(dev, "Unsupported key used: 0x%x\n",

			    cls->dissector->used_keys);

		return -EOPNOTSUPP;

	}

	return 0;

}



static void cxgb4_process_flow_actions(struct net_device *in,

				       struct tc_cls_flower_offload *cls,

				       struct ch_filter_specification *fs)

{

	const struct tc_action *a;

	LIST_HEAD(actions);



	tcf_exts_to_list(cls->exts, &actions);

	list_for_each_entry(a, &actions, list) {

		if (is_tcf_gact_shot(a)) {

			fs->action = FILTER_DROP;

		} else if (is_tcf_mirred_egress_redirect(a)) {

			int ifindex = tcf_mirred_ifindex(a);

			struct net_device *out = __dev_get_by_index(dev_net(in),

								    ifindex);

			struct port_info *pi = netdev_priv(out);



			fs->action = FILTER_SWITCH;

			fs->eport = pi->port_id;

		} else if (is_tcf_vlan(a)) {

			u32 vlan_action = tcf_vlan_action(a);

			u8 prio = tcf_vlan_push_prio(a);

			u16 vid = tcf_vlan_push_vid(a);

			u16 vlan_tci = (prio << VLAN_PRIO_SHIFT) | vid;



			switch (vlan_action) {

			case TCA_VLAN_ACT_POP:

				fs->newvlan |= VLAN_REMOVE;

				break;

			case TCA_VLAN_ACT_PUSH:

				fs->newvlan |= VLAN_INSERT;

				fs->vlan = vlan_tci;

				break;

			case TCA_VLAN_ACT_MODIFY:

				fs->newvlan |= VLAN_REWRITE;

				fs->vlan = vlan_tci;

				break;

			default:

				break;

			}

		}

	}

}



static int cxgb4_validate_flow_actions(struct net_device *dev,

				       struct tc_cls_flower_offload *cls)

{

	const struct tc_action *a;

	LIST_HEAD(actions);



	tcf_exts_to_list(cls->exts, &actions);

	list_for_each_entry(a, &actions, list) {

		if (is_tcf_gact_shot(a)) {

			/* Do nothing */

		} else if (is_tcf_mirred_egress_redirect(a)) {

			struct adapter *adap = netdev2adap(dev);

			struct net_device *n_dev;

			unsigned int i, ifindex;

			bool found = false;



			ifindex = tcf_mirred_ifindex(a);

			for_each_port(adap, i) {

				n_dev = adap->port[i];

				if (ifindex == n_dev->ifindex) {

					found = true;

					break;

				}

			}



			/* If interface doesn't belong to our hw, then

			 * the provided output port is not valid

			 */

			if (!found) {

				netdev_err(dev, "%s: Out port invalid\n",

					   __func__);

				return -EINVAL;

			}

		} else if (is_tcf_vlan(a)) {

			u16 proto = be16_to_cpu(tcf_vlan_push_proto(a));

			u32 vlan_action = tcf_vlan_action(a);



			switch (vlan_action) {

			case TCA_VLAN_ACT_POP:

				break;

			case TCA_VLAN_ACT_PUSH:

			case TCA_VLAN_ACT_MODIFY:

				if (proto != ETH_P_8021Q) {

					netdev_err(dev, "%s: Unsupported vlan proto\n",

						   __func__);

					return -EOPNOTSUPP;

				}

				break;

			default:

				netdev_err(dev, "%s: Unsupported vlan action\n",

					   __func__);

				return -EOPNOTSUPP;

			}

		} else {

			netdev_err(dev, "%s: Unsupported action\n", __func__);

			return -EOPNOTSUPP;

		}

	}

	return 0;

}



int cxgb4_tc_flower_replace(struct net_device *dev,

			    struct tc_cls_flower_offload *cls)

{

	struct adapter *adap = netdev2adap(dev);

	struct ch_tc_flower_entry *ch_flower;

	struct ch_filter_specification *fs;

	struct filter_ctx ctx;

	int fidx;

	int ret;



	if (cxgb4_validate_flow_actions(dev, cls))

		return -EOPNOTSUPP;



	if (cxgb4_validate_flow_match(dev, cls))

		return -EOPNOTSUPP;



	ch_flower = allocate_flower_entry();

	if (!ch_flower) {

		netdev_err(dev, "%s: ch_flower alloc failed.\n", __func__);

		return -ENOMEM;

	}



	fs = &ch_flower->fs;

	fs->hitcnts = 1;

	cxgb4_process_flow_actions(dev, cls, fs);

	cxgb4_process_flow_match(dev, cls, fs);



	fidx = cxgb4_get_free_ftid(dev, fs->type ? PF_INET6 : PF_INET);

	if (fidx < 0) {

		netdev_err(dev, "%s: No fidx for offload.\n", __func__);

		ret = -ENOMEM;

		goto free_entry;

	}



	init_completion(&ctx.completion);

	ret = __cxgb4_set_filter(dev, fidx, fs, &ctx);

	if (ret) {

		netdev_err(dev, "%s: filter creation err %d\n",

			   __func__, ret);

		goto free_entry;

	}



	/* Wait for reply */

	ret = wait_for_completion_timeout(&ctx.completion, 10 * HZ);

	if (!ret) {

		ret = -ETIMEDOUT;

		goto free_entry;

	}



	ret = ctx.result;

	/* Check if hw returned error for filter creation */

	if (ret) {

		netdev_err(dev, "%s: filter creation err %d\n",

			   __func__, ret);

		goto free_entry;

	}



	INIT_HLIST_NODE(&ch_flower->link);

	ch_flower->tc_flower_cookie = cls->cookie;

	ch_flower->filter_id = ctx.tid;

	hash_add_rcu(adap->flower_anymatch_tbl, &ch_flower->link, cls->cookie);



	return ret;



free_entry:

	kfree(ch_flower);

	return ret;

}



int cxgb4_tc_flower_destroy(struct net_device *dev,

			    struct tc_cls_flower_offload *cls)

{

	struct adapter *adap = netdev2adap(dev);

	struct ch_tc_flower_entry *ch_flower;

	int ret;



	ch_flower = ch_flower_lookup(adap, cls->cookie);

	if (!ch_flower)

		return -ENOENT;



	ret = cxgb4_del_filter(dev, ch_flower->filter_id);

	if (ret)

		goto err;



	hash_del_rcu(&ch_flower->link);

	kfree_rcu(ch_flower, rcu);



err:

	return ret;

}



void ch_flower_stats_cb(unsigned long data)

{

	struct adapter *adap = (struct adapter *)data;

	struct ch_tc_flower_entry *flower_entry;

	struct ch_tc_flower_stats *ofld_stats;

	unsigned int i;

	u64 packets;

	u64 bytes;

	int ret;



	rcu_read_lock();

	hash_for_each_rcu(adap->flower_anymatch_tbl, i, flower_entry, link) {

		ret = cxgb4_get_filter_counters(adap->port[0],

						flower_entry->filter_id,

						&packets, &bytes);

		if (!ret) {

			spin_lock(&flower_entry->lock);

			ofld_stats = &flower_entry->stats;



			if (ofld_stats->prev_packet_count != packets) {

				ofld_stats->prev_packet_count = packets;

				ofld_stats->last_used = jiffies;

			}

			spin_unlock(&flower_entry->lock);

		}

	}

	rcu_read_unlock();

	mod_timer(&adap->flower_stats_timer, jiffies + STATS_CHECK_PERIOD);

}



int cxgb4_tc_flower_stats(struct net_device *dev,

			  struct tc_cls_flower_offload *cls)

{

	struct adapter *adap = netdev2adap(dev);

	struct ch_tc_flower_stats *ofld_stats;

	struct ch_tc_flower_entry *ch_flower;

	u64 packets;

	u64 bytes;

	int ret;



	ch_flower = ch_flower_lookup(adap, cls->cookie);

	if (!ch_flower) {

		ret = -ENOENT;

		goto err;

	}



	ret = cxgb4_get_filter_counters(dev, ch_flower->filter_id,

					&packets, &bytes);

	if (ret < 0)

		goto err;



	spin_lock_bh(&ch_flower->lock);

	ofld_stats = &ch_flower->stats;

	if (ofld_stats->packet_count != packets) {

		if (ofld_stats->prev_packet_count != packets)

			ofld_stats->last_used = jiffies;

		tcf_exts_stats_update(cls->exts, bytes - ofld_stats->byte_count,

				      packets - ofld_stats->packet_count,

				      ofld_stats->last_used);



		ofld_stats->packet_count = packets;

		ofld_stats->byte_count = bytes;

		ofld_stats->prev_packet_count = packets;

	}

	spin_unlock_bh(&ch_flower->lock);

	return 0;



err:

	return ret;

}



void cxgb4_init_tc_flower(struct adapter *adap)

{

	hash_init(adap->flower_anymatch_tbl);

	setup_timer(&adap->flower_stats_timer, ch_flower_stats_cb,

		    (unsigned long)adap);

	mod_timer(&adap->flower_stats_timer, jiffies + STATS_CHECK_PERIOD);

}



void cxgb4_cleanup_tc_flower(struct adapter *adap)

{

	if (adap->flower_stats_timer.function)

		del_timer_sync(&adap->flower_stats_timer);

}