}
 
 static int get_filter_count(struct adapter *adapter, unsigned int fidx,
-                           u64 *pkts, u64 *bytes)
+                           u64 *pkts, u64 *bytes, bool hash)
 {
        unsigned int tcb_base, tcbaddr;
        unsigned int word_offset;
        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;
+       if (is_hashfilter(adapter) && hash) {
+               if (fidx < adapter->tids.ntids) {
+                       f = adapter->tids.tid_tab[fidx];
+                       if (!f)
+                               return -EINVAL;
+               } else {
+                       return -E2BIG;
+               }
+       } else {
+               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);
 }
 
 int cxgb4_get_filter_counters(struct net_device *dev, unsigned int fidx,
-                             u64 *hitcnt, u64 *bytecnt)
+                             u64 *hitcnt, u64 *bytecnt, bool hash)
 {
        struct adapter *adapter = netdev2adap(dev);
 
-       return get_filter_count(adapter, fidx, hitcnt, bytecnt);
+       return get_filter_count(adapter, fidx, hitcnt, bytecnt, hash);
 }
 
 int cxgb4_get_free_ftid(struct net_device *dev, int family)
 
        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);
+                                               &packets, &bytes,
+                                               flower_entry->fs.hash);
                if (!ret) {
                        spin_lock(&flower_entry->lock);
                        ofld_stats = &flower_entry->stats;
        }
 
        ret = cxgb4_get_filter_counters(dev, ch_flower->filter_id,
-                                       &packets, &bytes);
+                                       &packets, &bytes,
+                                       ch_flower->fs.hash);
        if (ret < 0)
                goto err;
 
 
 int cxgb4_del_filter(struct net_device *dev, int filter_id,
                     struct ch_filter_specification *fs);
 int cxgb4_get_filter_counters(struct net_device *dev, unsigned int fidx,
-                             u64 *hitcnt, u64 *bytecnt);
+                             u64 *hitcnt, u64 *bytecnt, bool hash);
 
 static inline void set_wr_txq(struct sk_buff *skb, int prio, int queue)
 {