8 files changed, 757 insertions, 7 deletions

diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
index 378988b5709a..24ce797ddbbd 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
@@ -545,6 +545,129 @@ struct adapter {
         spinlock_t stats_lock;
 };
 
+/* Defined bit width of user definable filter tuples
+ */
+#define ETHTYPE_BITWIDTH 16
+#define FRAG_BITWIDTH 1
+#define MACIDX_BITWIDTH 9
+#define FCOE_BITWIDTH 1
+#define IPORT_BITWIDTH 3
+#define MATCHTYPE_BITWIDTH 3
+#define PROTO_BITWIDTH 8
+#define TOS_BITWIDTH 8
+#define PF_BITWIDTH 8
+#define VF_BITWIDTH 8
+#define IVLAN_BITWIDTH 16
+#define OVLAN_BITWIDTH 16
+
+/* Filter matching rules.  These consist of a set of ingress packet field
+ * (value, mask) tuples.  The associated ingress packet field matches the
+ * tuple when ((field & mask) == value).  (Thus a wildcard "don't care" field
+ * rule can be constructed by specifying a tuple of (0, 0).)  A filter rule
+ * matches an ingress packet when all of the individual individual field
+ * matching rules are true.
+ *
+ * Partial field masks are always valid, however, while it may be easy to
+ * understand their meanings for some fields (e.g. IP address to match a
+ * subnet), for others making sensible partial masks is less intuitive (e.g.
+ * MPS match type) ...
+ *
+ * Most of the following data structures are modeled on T4 capabilities.
+ * Drivers for earlier chips use the subsets which make sense for those chips.
+ * We really need to come up with a hardware-independent mechanism to
+ * represent hardware filter capabilities ...
+ */
+struct ch_filter_tuple {
+        /* Compressed header matching field rules.  The TP_VLAN_PRI_MAP
+         * register selects which of these fields will participate in the
+         * filter match rules -- up to a maximum of 36 bits.  Because
+         * TP_VLAN_PRI_MAP is a global register, all filters must use the same
+         * set of fields.
+         */
+        uint32_t ethtype:ETHTYPE_BITWIDTH;      /* Ethernet type */
+        uint32_t frag:FRAG_BITWIDTH;            /* IP fragmentation header */
+        uint32_t ivlan_vld:1;                   /* inner VLAN valid */
+        uint32_t ovlan_vld:1;                   /* outer VLAN valid */
+        uint32_t pfvf_vld:1;                    /* PF/VF valid */
+        uint32_t macidx:MACIDX_BITWIDTH;        /* exact match MAC index */
+        uint32_t fcoe:FCOE_BITWIDTH;            /* FCoE packet */
+        uint32_t iport:IPORT_BITWIDTH;          /* ingress port */
+        uint32_t matchtype:MATCHTYPE_BITWIDTH;  /* MPS match type */
+        uint32_t proto:PROTO_BITWIDTH;          /* protocol type */
+        uint32_t tos:TOS_BITWIDTH;              /* TOS/Traffic Type */
+        uint32_t pf:PF_BITWIDTH;                /* PCI-E PF ID */
+        uint32_t vf:VF_BITWIDTH;                /* PCI-E VF ID */
+        uint32_t ivlan:IVLAN_BITWIDTH;          /* inner VLAN */
+        uint32_t ovlan:OVLAN_BITWIDTH;          /* outer VLAN */
+
+        /* Uncompressed header matching field rules.  These are always
+         * available for field rules.
+         */
+        uint8_t lip[16];        /* local IP address (IPv4 in [3:0]) */
+        uint8_t fip[16];        /* foreign IP address (IPv4 in [3:0]) */
+        uint16_t lport;         /* local port */
+        uint16_t fport;         /* foreign port */
+};
+
+/* A filter ioctl command.
+ */
+struct ch_filter_specification {
+        /* Administrative fields for filter.
+         */
+        uint32_t hitcnts:1;     /* count filter hits in TCB */
+        uint32_t prio:1;        /* filter has priority over active/server */
+
+        /* Fundamental filter typing.  This is the one element of filter
+         * matching that doesn't exist as a (value, mask) tuple.
+         */
+        uint32_t type:1;        /* 0 => IPv4, 1 => IPv6 */
+
+        /* Packet dispatch information.  Ingress packets which match the
+         * filter rules will be dropped, passed to the host or switched back
+         * out as egress packets.
+         */
+        uint32_t action:2;      /* drop, pass, switch */
+
+        uint32_t rpttid:1;      /* report TID in RSS hash field */
+
+        uint32_t dirsteer:1;    /* 0 => RSS, 1 => steer to iq */
+        uint32_t iq:10;         /* ingress queue */
+
+        uint32_t maskhash:1;    /* dirsteer=0: store RSS hash in TCB */
+        uint32_t dirsteerhash:1;/* dirsteer=1: 0 => TCB contains RSS hash */
+                                /*             1 => TCB contains IQ ID */
+
+        /* Switch proxy/rewrite fields.  An ingress packet which matches a
+         * filter with "switch" set will be looped back out as an egress
+         * packet -- potentially with some Ethernet header rewriting.
+         */
+        uint32_t eport:2;       /* egress port to switch packet out */
+        uint32_t newdmac:1;     /* rewrite destination MAC address */
+        uint32_t newsmac:1;     /* rewrite source MAC address */
+        uint32_t newvlan:2;     /* rewrite VLAN Tag */
+        uint8_t dmac[ETH_ALEN]; /* new destination MAC address */
+        uint8_t smac[ETH_ALEN]; /* new source MAC address */
+        uint16_t vlan;          /* VLAN Tag to insert */
+
+        /* Filter rule value/mask pairs.
+         */
+        struct ch_filter_tuple val;
+        struct ch_filter_tuple mask;
+};
+
+enum {
+        FILTER_PASS = 0,        /* default */
+        FILTER_DROP,
+        FILTER_SWITCH
+};
+
+enum {
+        VLAN_NOCHANGE = 0,      /* default */
+        VLAN_REMOVE,
+        VLAN_INSERT,
+        VLAN_REWRITE
+};
+
 static inline u32 t4_read_reg(struct adapter *adap, u32 reg_addr)
 {
         return readl(adap->regs + reg_addr);
@@ -701,6 +824,12 @@ static inline int t4_wr_mbox_ns(struct adapter *adap, int mbox, const void *cmd,
 void t4_write_indirect(struct adapter *adap, unsigned int addr_reg,
                        unsigned int data_reg, const u32 *vals,
                        unsigned int nregs, unsigned int start_idx);
+void t4_read_indirect(struct adapter *adap, unsigned int addr_reg,
+                      unsigned int data_reg, u32 *vals, unsigned int nregs,
+                      unsigned int start_idx);
+
+struct fw_filter_wr;
+
 void t4_intr_enable(struct adapter *adapter);
 void t4_intr_disable(struct adapter *adapter);
 int t4_slow_intr_handler(struct adapter *adapter);
@@ -737,6 +866,8 @@ void t4_tp_get_tcp_stats(struct adapter *adap, struct tp_tcp_stats *v4,
 void t4_load_mtus(struct adapter *adap, const unsigned short *mtus,
                   const unsigned short *alpha, const unsigned short *beta);
 
+void t4_mk_filtdelwr(unsigned int ftid, struct fw_filter_wr *wr, int qid);
+
 void t4_wol_magic_enable(struct adapter *adap, unsigned int port,
                          const u8 *addr);
 int t4_wol_pat_enable(struct adapter *adap, unsigned int port, unsigned int map,
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
index a27b4ae20f43..41537a403eef 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
@@ -175,6 +175,30 @@ enum {
         MIN_FL_ENTRIES       = 16
 };
 
+/* Host shadow copy of ingress filter entry.  This is in host native format
+ * and doesn't match the ordering or bit order, etc. of the hardware of the
+ * firmware command.  The use of bit-field structure elements is purely to
+ * remind ourselves of the field size limitations and save memory in the case
+ * where the filter table is large.
+ */
+struct filter_entry {
+        /* Administrative fields for filter.
+         */
+        u32 valid:1;            /* filter allocated and valid */
+        u32 locked:1;           /* filter is administratively locked */
+
+        u32 pending:1;          /* filter action is pending firmware reply */
+        u32 smtidx:8;           /* Source MAC Table index for smac */
+        struct l2t_entry *l2t;  /* Layer Two Table entry for dmac */
+
+        /* The filter itself.  Most of this is a straight copy of information
+         * provided by the extended ioctl().  Some fields are translated to
+         * internal forms -- for instance the Ingress Queue ID passed in from
+         * the ioctl() is translated into the Absolute Ingress Queue ID.
+         */
+        struct ch_filter_specification fs;
+};
+
 #define DFLT_MSG_ENABLE (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK | \
                          NETIF_MSG_TIMER | NETIF_MSG_IFDOWN | NETIF_MSG_IFUP |\
                          NETIF_MSG_RX_ERR | NETIF_MSG_TX_ERR)
@@ -325,6 +349,9 @@ enum {
 
 static unsigned int tp_vlan_pri_map = TP_VLAN_PRI_MAP_DEFAULT;
 
+module_param(tp_vlan_pri_map, uint, 0644);
+MODULE_PARM_DESC(tp_vlan_pri_map, "global compressed filter configuration");
+
 static struct dentry *cxgb4_debugfs_root;
 
 static LIST_HEAD(adapter_list);
@@ -506,8 +533,67 @@ static int link_start(struct net_device *dev)
         return ret;
 }
 
-/*
- * Response queue handler for the FW event queue.
+/* Clear a filter and release any of its resources that we own.  This also
+ * clears the filter's "pending" status.
+ */
+static void clear_filter(struct adapter *adap, struct filter_entry *f)
+{
+        /* If the new or old filter have loopback rewriteing rules then we'll
+         * need to free any existing Layer Two Table (L2T) entries of the old
+         * filter rule.  The firmware will handle freeing up any Source MAC
+         * Table (SMT) entries used for rewriting Source MAC Addresses in
+         * loopback rules.
+         */
+        if (f->l2t)
+                cxgb4_l2t_release(f->l2t);
+
+        /* The zeroing of the filter rule below clears the filter valid,
+         * pending, locked flags, l2t pointer, etc. so it's all we need for
+         * this operation.
+         */
+        memset(f, 0, sizeof(*f));
+}
+
+/* Handle a filter write/deletion reply.
+ */
+static void filter_rpl(struct adapter *adap, const struct cpl_set_tcb_rpl *rpl)
+{
+        unsigned int idx = GET_TID(rpl);
+        unsigned int nidx = idx - adap->tids.ftid_base;
+        unsigned int ret;
+        struct filter_entry *f;
+
+        if (idx >= adap->tids.ftid_base && nidx <
+           (adap->tids.nftids + adap->tids.nsftids)) {
+                idx = nidx;
+                ret = GET_TCB_COOKIE(rpl->cookie);
+                f = &adap->tids.ftid_tab[idx];
+
+                if (ret == FW_FILTER_WR_FLT_DELETED) {
+                        /* Clear the filter when we get confirmation from the
+                         * hardware that the filter has been deleted.
+                         */
+                        clear_filter(adap, f);
+                } else if (ret == FW_FILTER_WR_SMT_TBL_FULL) {
+                        dev_err(adap->pdev_dev, "filter %u setup failed due to full SMT\n",
+                                idx);
+                        clear_filter(adap, f);
+                } else if (ret == FW_FILTER_WR_FLT_ADDED) {
+                        f->smtidx = (be64_to_cpu(rpl->oldval) >> 24) & 0xff;
+                        f->pending = 0;  /* asynchronous setup completed */
+                        f->valid = 1;
+                } else {
+                        /* Something went wrong.  Issue a warning about the
+                         * problem and clear everything out.
+                         */
+                        dev_err(adap->pdev_dev, "filter %u setup failed with error %u\n",
+                                idx, ret);
+                        clear_filter(adap, f);
+                }
+        }
+}
+
+/* Response queue handler for the FW event queue.
  */
 static int fwevtq_handler(struct sge_rspq *q, const __be64 *rsp,
                           const struct pkt_gl *gl)
@@ -542,6 +628,10 @@ static int fwevtq_handler(struct sge_rspq *q, const __be64 *rsp,
                 const struct cpl_l2t_write_rpl *p = (void *)rsp;
 
                 do_l2t_write_rpl(q->adap, p);
+        } else if (opcode == CPL_SET_TCB_RPL) {
+                const struct cpl_set_tcb_rpl *p = (void *)rsp;
+
+                filter_rpl(q->adap, p);
         } else
                 dev_err(q->adap->pdev_dev,
                         "unexpected CPL %#x on FW event queue\n", opcode);
@@ -983,6 +1073,148 @@ static void t4_free_mem(void *addr)
                 kfree(addr);
 }
 
+/* Send a Work Request to write the filter at a specified index.  We construct
+ * a Firmware Filter Work Request to have the work done and put the indicated
+ * filter into "pending" mode which will prevent any further actions against
+ * it till we get a reply from the firmware on the completion status of the
+ * request.
+ */
+static int set_filter_wr(struct adapter *adapter, int fidx)
+{
+        struct filter_entry *f = &adapter->tids.ftid_tab[fidx];
+        struct sk_buff *skb;
+        struct fw_filter_wr *fwr;
+        unsigned int ftid;
+
+        /* If the new filter requires loopback Destination MAC and/or VLAN
+         * rewriting then we need to allocate a Layer 2 Table (L2T) entry for
+         * the filter.
+         */
+        if (f->fs.newdmac || f->fs.newvlan) {
+                /* allocate L2T entry for new filter */
+                f->l2t = t4_l2t_alloc_switching(adapter->l2t);
+                if (f->l2t == NULL)
+                        return -EAGAIN;
+                if (t4_l2t_set_switching(adapter, f->l2t, f->fs.vlan,
+                                        f->fs.eport, f->fs.dmac)) {
+                        cxgb4_l2t_release(f->l2t);
+                        f->l2t = NULL;
+                        return -ENOMEM;
+                }
+        }
+
+        ftid = adapter->tids.ftid_base + fidx;
+
+        skb = alloc_skb(sizeof(*fwr), GFP_KERNEL | __GFP_NOFAIL);
+        fwr = (struct fw_filter_wr *)__skb_put(skb, sizeof(*fwr));
+        memset(fwr, 0, sizeof(*fwr));
+
+        /* It would be nice to put most of the following in t4_hw.c but most
+         * of the work is translating the cxgbtool ch_filter_specification
+         * into the Work Request and the definition of that structure is
+         * currently in cxgbtool.h which isn't appropriate to pull into the
+         * common code.  We may eventually try to come up with a more neutral
+         * filter specification structure but for now it's easiest to simply
+         * put this fairly direct code in line ...
+         */
+        fwr->op_pkd = htonl(FW_WR_OP(FW_FILTER_WR));
+        fwr->len16_pkd = htonl(FW_WR_LEN16(sizeof(*fwr)/16));
+        fwr->tid_to_iq =
+                htonl(V_FW_FILTER_WR_TID(ftid) |
+                      V_FW_FILTER_WR_RQTYPE(f->fs.type) |
+                      V_FW_FILTER_WR_NOREPLY(0) |
+                      V_FW_FILTER_WR_IQ(f->fs.iq));
+        fwr->del_filter_to_l2tix =
+                htonl(V_FW_FILTER_WR_RPTTID(f->fs.rpttid) |
+                      V_FW_FILTER_WR_DROP(f->fs.action == FILTER_DROP) |
+                      V_FW_FILTER_WR_DIRSTEER(f->fs.dirsteer) |
+                      V_FW_FILTER_WR_MASKHASH(f->fs.maskhash) |
+                      V_FW_FILTER_WR_DIRSTEERHASH(f->fs.dirsteerhash) |
+                      V_FW_FILTER_WR_LPBK(f->fs.action == FILTER_SWITCH) |
+                      V_FW_FILTER_WR_DMAC(f->fs.newdmac) |
+                      V_FW_FILTER_WR_SMAC(f->fs.newsmac) |
+                      V_FW_FILTER_WR_INSVLAN(f->fs.newvlan == VLAN_INSERT ||
+                                             f->fs.newvlan == VLAN_REWRITE) |
+                      V_FW_FILTER_WR_RMVLAN(f->fs.newvlan == VLAN_REMOVE ||
+                                            f->fs.newvlan == VLAN_REWRITE) |
+                      V_FW_FILTER_WR_HITCNTS(f->fs.hitcnts) |
+                      V_FW_FILTER_WR_TXCHAN(f->fs.eport) |
+                      V_FW_FILTER_WR_PRIO(f->fs.prio) |
+                      V_FW_FILTER_WR_L2TIX(f->l2t ? f->l2t->idx : 0));
+        fwr->ethtype = htons(f->fs.val.ethtype);
+        fwr->ethtypem = htons(f->fs.mask.ethtype);
+        fwr->frag_to_ovlan_vldm =
+                (V_FW_FILTER_WR_FRAG(f->fs.val.frag) |
+                 V_FW_FILTER_WR_FRAGM(f->fs.mask.frag) |
+                 V_FW_FILTER_WR_IVLAN_VLD(f->fs.val.ivlan_vld) |
+                 V_FW_FILTER_WR_OVLAN_VLD(f->fs.val.ovlan_vld) |
+                 V_FW_FILTER_WR_IVLAN_VLDM(f->fs.mask.ivlan_vld) |
+                 V_FW_FILTER_WR_OVLAN_VLDM(f->fs.mask.ovlan_vld));
+        fwr->smac_sel = 0;
+        fwr->rx_chan_rx_rpl_iq =
+                htons(V_FW_FILTER_WR_RX_CHAN(0) |
+                      V_FW_FILTER_WR_RX_RPL_IQ(adapter->sge.fw_evtq.abs_id));
+        fwr->maci_to_matchtypem =
+                htonl(V_FW_FILTER_WR_MACI(f->fs.val.macidx) |
+                      V_FW_FILTER_WR_MACIM(f->fs.mask.macidx) |
+                      V_FW_FILTER_WR_FCOE(f->fs.val.fcoe) |
+                      V_FW_FILTER_WR_FCOEM(f->fs.mask.fcoe) |
+                      V_FW_FILTER_WR_PORT(f->fs.val.iport) |
+                      V_FW_FILTER_WR_PORTM(f->fs.mask.iport) |
+                      V_FW_FILTER_WR_MATCHTYPE(f->fs.val.matchtype) |
+                      V_FW_FILTER_WR_MATCHTYPEM(f->fs.mask.matchtype));
+        fwr->ptcl = f->fs.val.proto;
+        fwr->ptclm = f->fs.mask.proto;
+        fwr->ttyp = f->fs.val.tos;
+        fwr->ttypm = f->fs.mask.tos;
+        fwr->ivlan = htons(f->fs.val.ivlan);
+        fwr->ivlanm = htons(f->fs.mask.ivlan);
+        fwr->ovlan = htons(f->fs.val.ovlan);
+        fwr->ovlanm = htons(f->fs.mask.ovlan);
+        memcpy(fwr->lip, f->fs.val.lip, sizeof(fwr->lip));
+        memcpy(fwr->lipm, f->fs.mask.lip, sizeof(fwr->lipm));
+        memcpy(fwr->fip, f->fs.val.fip, sizeof(fwr->fip));
+        memcpy(fwr->fipm, f->fs.mask.fip, sizeof(fwr->fipm));
+        fwr->lp = htons(f->fs.val.lport);
+        fwr->lpm = htons(f->fs.mask.lport);
+        fwr->fp = htons(f->fs.val.fport);
+        fwr->fpm = htons(f->fs.mask.fport);
+        if (f->fs.newsmac)
+                memcpy(fwr->sma, f->fs.smac, sizeof(fwr->sma));
+
+        /* Mark the filter as "pending" and ship off the Filter Work Request.
+         * When we get the Work Request Reply we'll clear the pending status.
+         */
+        f->pending = 1;
+        set_wr_txq(skb, CPL_PRIORITY_CONTROL, f->fs.val.iport & 0x3);
+        t4_ofld_send(adapter, skb);
+        return 0;
+}
+
+/* Delete the filter at a specified index.
+ */
+static int del_filter_wr(struct adapter *adapter, int fidx)
+{
+        struct filter_entry *f = &adapter->tids.ftid_tab[fidx];
+        struct sk_buff *skb;
+        struct fw_filter_wr *fwr;
+        unsigned int len, ftid;
+
+        len = sizeof(*fwr);
+        ftid = adapter->tids.ftid_base + fidx;
+
+        skb = alloc_skb(len, GFP_KERNEL | __GFP_NOFAIL);
+        fwr = (struct fw_filter_wr *)__skb_put(skb, len);
+        t4_mk_filtdelwr(ftid, fwr, adapter->sge.fw_evtq.abs_id);
+
+        /* Mark the filter as "pending" and ship off the Filter Work Request.
+         * When we get the Work Request Reply we'll clear the pending status.
+         */
+        f->pending = 1;
+        t4_mgmt_tx(adapter, skb);
+        return 0;
+}
+
 static inline int is_offload(const struct adapter *adap)
 {
         return adap->params.offload;
@@ -2195,7 +2427,7 @@ int cxgb4_alloc_atid(struct tid_info *t, void *data)
         if (t->afree) {
                 union aopen_entry *p = t->afree;
 
-                atid = p - t->atid_tab;
+                atid = (p - t->atid_tab) + t->atid_base;
                 t->afree = p->next;
                 p->data = data;
                 t->atids_in_use++;
@@ -2210,7 +2442,7 @@ EXPORT_SYMBOL(cxgb4_alloc_atid);
  */
 void cxgb4_free_atid(struct tid_info *t, unsigned int atid)
 {
-        union aopen_entry *p = &t->atid_tab[atid];
+        union aopen_entry *p = &t->atid_tab[atid - t->atid_base];
 
         spin_lock_bh(&t->atid_lock);
         p->next = t->afree;
@@ -2362,11 +2594,16 @@ EXPORT_SYMBOL(cxgb4_remove_tid);
 static int tid_init(struct tid_info *t)
 {
         size_t size;
+        unsigned int stid_bmap_size;
         unsigned int natids = t->natids;
 
-        size = t->ntids * sizeof(*t->tid_tab) + natids * sizeof(*t->atid_tab) +
+        stid_bmap_size = BITS_TO_LONGS(t->nstids);
+        size = t->ntids * sizeof(*t->tid_tab) +
+               natids * sizeof(*t->atid_tab) +
                t->nstids * sizeof(*t->stid_tab) +
-               BITS_TO_LONGS(t->nstids) * sizeof(long);
+               stid_bmap_size * sizeof(long) +
+               t->nftids * sizeof(*t->ftid_tab);
+
         t->tid_tab = t4_alloc_mem(size);
         if (!t->tid_tab)
                 return -ENOMEM;
@@ -2374,6 +2611,7 @@ static int tid_init(struct tid_info *t)
         t->atid_tab = (union aopen_entry *)&t->tid_tab[t->ntids];
         t->stid_tab = (struct serv_entry *)&t->atid_tab[natids];
         t->stid_bmap = (unsigned long *)&t->stid_tab[t->nstids];
+        t->ftid_tab = (struct filter_entry *)&t->stid_bmap[stid_bmap_size];
         spin_lock_init(&t->stid_lock);
         spin_lock_init(&t->atid_lock);
 
@@ -2999,6 +3237,40 @@ static int cxgb_close(struct net_device *dev)
         return t4_enable_vi(adapter, adapter->fn, pi->viid, false, false);
 }
 
+/* Return an error number if the indicated filter isn't writable ...
+ */
+static int writable_filter(struct filter_entry *f)
+{
+        if (f->locked)
+                return -EPERM;
+        if (f->pending)
+                return -EBUSY;
+
+        return 0;
+}
+
+/* Delete the filter at the specified index (if valid).  The checks for all
+ * the common problems with doing this like the filter being locked, currently
+ * pending in another operation, etc.
+ */
+static int delete_filter(struct adapter *adapter, unsigned int fidx)
+{
+        struct filter_entry *f;
+        int ret;
+
+        if (fidx >= adapter->tids.nftids)
+                return -EINVAL;
+
+        f = &adapter->tids.ftid_tab[fidx];
+        ret = writable_filter(f);
+        if (ret)
+                return ret;
+        if (f->valid)
+                return del_filter_wr(adapter, fidx);
+
+        return 0;
+}
+
 static struct rtnl_link_stats64 *cxgb_get_stats(struct net_device *dev,
                                                 struct rtnl_link_stats64 *ns)
 {
@@ -4661,6 +4933,16 @@ static void remove_one(struct pci_dev *pdev)
                 if (adapter->debugfs_root)
                         debugfs_remove_recursive(adapter->debugfs_root);
 
+                /* If we allocated filters, free up state associated with any
+                 * valid filters ...
+                 */
+                if (adapter->tids.ftid_tab) {
+                        struct filter_entry *f = &adapter->tids.ftid_tab[0];
+                        for (i = 0; i < adapter->tids.nftids; i++, f++)
+                                if (f->valid)
+                                        clear_filter(adapter, f);
+                }
+
                 if (adapter->flags & FULL_INIT_DONE)
                         cxgb_down(adapter);
 
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h
index 39bec73ff87c..59a61332b78c 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h
@@ -97,7 +97,9 @@ struct tid_info {
 
         union aopen_entry *atid_tab;
         unsigned int natids;
+        unsigned int atid_base;
 
+        struct filter_entry *ftid_tab;
         unsigned int nftids;
         unsigned int ftid_base;
         unsigned int aftid_base;
diff --git a/drivers/net/ethernet/chelsio/cxgb4/l2t.c b/drivers/net/ethernet/chelsio/cxgb4/l2t.c
index 6ac77a62f361..29878098101e 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/l2t.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/l2t.c
@@ -484,6 +484,38 @@ void t4_l2t_update(struct adapter *adap, struct neighbour *neigh)
                 handle_failed_resolution(adap, arpq);
 }
 
+/* Allocate an L2T entry for use by a switching rule.  Such need to be
+ * explicitly freed and while busy they are not on any hash chain, so normal
+ * address resolution updates do not see them.
+ */
+struct l2t_entry *t4_l2t_alloc_switching(struct l2t_data *d)
+{
+        struct l2t_entry *e;
+
+        write_lock_bh(&d->lock);
+        e = alloc_l2e(d);
+        if (e) {
+                spin_lock(&e->lock);          /* avoid race with t4_l2t_free */
+                e->state = L2T_STATE_SWITCHING;
+                atomic_set(&e->refcnt, 1);
+                spin_unlock(&e->lock);
+        }
+        write_unlock_bh(&d->lock);
+        return e;
+}
+
+/* Sets/updates the contents of a switching L2T entry that has been allocated
+ * with an earlier call to @t4_l2t_alloc_switching.
+ */
+int t4_l2t_set_switching(struct adapter *adap, struct l2t_entry *e, u16 vlan,
+                u8 port, u8 *eth_addr)
+{
+        e->vlan = vlan;
+        e->lport = port;
+        memcpy(e->dmac, eth_addr, ETH_ALEN);
+        return write_l2e(adap, e, 0);
+}
+
 struct l2t_data *t4_init_l2t(void)
 {
         int i;
diff --git a/drivers/net/ethernet/chelsio/cxgb4/l2t.h b/drivers/net/ethernet/chelsio/cxgb4/l2t.h
index 02b31d0c6410..108c0f1fce1c 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/l2t.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/l2t.h
@@ -100,6 +100,9 @@ struct l2t_entry *cxgb4_l2t_get(struct l2t_data *d, struct neighbour *neigh,
                                 unsigned int priority);
 
 void t4_l2t_update(struct adapter *adap, struct neighbour *neigh);
+struct l2t_entry *t4_l2t_alloc_switching(struct l2t_data *d);
+int t4_l2t_set_switching(struct adapter *adap, struct l2t_entry *e, u16 vlan,
+                         u8 port, u8 *eth_addr);
 struct l2t_data *t4_init_l2t(void);
 void do_l2t_write_rpl(struct adapter *p, const struct cpl_l2t_write_rpl *rpl);
 
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
index 8d9c7547b070..22f3af5166bf 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
@@ -109,7 +109,7 @@ void t4_set_reg_field(struct adapter *adapter, unsigned int addr, u32 mask,
  *      Reads registers that are accessed indirectly through an address/data
  *      register pair.
  */
-static void t4_read_indirect(struct adapter *adap, unsigned int addr_reg,
+void t4_read_indirect(struct adapter *adap, unsigned int addr_reg,
                              unsigned int data_reg, u32 *vals,
                              unsigned int nregs, unsigned int start_idx)
 {
@@ -2268,6 +2268,26 @@ int t4_wol_pat_enable(struct adapter *adap, unsigned int port, unsigned int map,
         return 0;
 }
 
+/*     t4_mk_filtdelwr - create a delete filter WR
+ *     @ftid: the filter ID
+ *     @wr: the filter work request to populate
+ *     @qid: ingress queue to receive the delete notification
+ *
+ *     Creates a filter work request to delete the supplied filter.  If @qid is
+ *     negative the delete notification is suppressed.
+ */
+void t4_mk_filtdelwr(unsigned int ftid, struct fw_filter_wr *wr, int qid)
+{
+        memset(wr, 0, sizeof(*wr));
+        wr->op_pkd = htonl(FW_WR_OP(FW_FILTER_WR));
+        wr->len16_pkd = htonl(FW_WR_LEN16(sizeof(*wr) / 16));
+        wr->tid_to_iq = htonl(V_FW_FILTER_WR_TID(ftid) |
+                        V_FW_FILTER_WR_NOREPLY(qid < 0));
+        wr->del_filter_to_l2tix = htonl(F_FW_FILTER_WR_DEL_FILTER);
+        if (qid >= 0)
+                wr->rx_chan_rx_rpl_iq = htons(V_FW_FILTER_WR_RX_RPL_IQ(qid));
+}
+
 #define INIT_CMD(var, cmd, rd_wr) do { \
         (var).op_to_write = htonl(FW_CMD_OP(FW_##cmd##_CMD) | \
                                   FW_CMD_REQUEST | FW_CMD_##rd_wr); \
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h b/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h
index b760808fd6d9..99ff71764499 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h
@@ -332,6 +332,7 @@ struct cpl_set_tcb_field {
         __be16 word_cookie;
 #define TCB_WORD(x)   ((x) << 0)
 #define TCB_COOKIE(x) ((x) << 5)
+#define GET_TCB_COOKIE(x) (((x) >> 5) & 7)
         __be64 mask;
         __be64 val;
 };
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h b/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
index 0abc864cdd3a..e98b6fff2c96 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
@@ -35,6 +35,10 @@
 #ifndef _T4FW_INTERFACE_H_
 #define _T4FW_INTERFACE_H_
 
+enum fw_ret_val {
+        FW_ENOEXEC      = 8,            /* Exec format error; inv microcode */
+};
+
 #define FW_T4VF_SGE_BASE_ADDR      0x0000
 #define FW_T4VF_MPS_BASE_ADDR      0x0100
 #define FW_T4VF_PL_BASE_ADDR       0x0200
@@ -82,6 +86,281 @@ struct fw_wr_hdr {
 
 #define HW_TPL_FR_MT_PR_IV_P_FC         0X32B
 
+/* filter wr reply code in cookie in CPL_SET_TCB_RPL */
+enum fw_filter_wr_cookie {
+        FW_FILTER_WR_SUCCESS,
+        FW_FILTER_WR_FLT_ADDED,
+        FW_FILTER_WR_FLT_DELETED,
+        FW_FILTER_WR_SMT_TBL_FULL,
+        FW_FILTER_WR_EINVAL,
+};
+
+struct fw_filter_wr {
+        __be32 op_pkd;
+        __be32 len16_pkd;
+        __be64 r3;
+        __be32 tid_to_iq;
+        __be32 del_filter_to_l2tix;
+        __be16 ethtype;
+        __be16 ethtypem;
+        __u8   frag_to_ovlan_vldm;
+        __u8   smac_sel;
+        __be16 rx_chan_rx_rpl_iq;
+        __be32 maci_to_matchtypem;
+        __u8   ptcl;
+        __u8   ptclm;
+        __u8   ttyp;
+        __u8   ttypm;
+        __be16 ivlan;
+        __be16 ivlanm;
+        __be16 ovlan;
+        __be16 ovlanm;
+        __u8   lip[16];
+        __u8   lipm[16];
+        __u8   fip[16];
+        __u8   fipm[16];
+        __be16 lp;
+        __be16 lpm;
+        __be16 fp;
+        __be16 fpm;
+        __be16 r7;
+        __u8   sma[6];
+};
+
+#define S_FW_FILTER_WR_TID      12
+#define M_FW_FILTER_WR_TID      0xfffff
+#define V_FW_FILTER_WR_TID(x)   ((x) << S_FW_FILTER_WR_TID)
+#define G_FW_FILTER_WR_TID(x)   \
+        (((x) >> S_FW_FILTER_WR_TID) & M_FW_FILTER_WR_TID)
+
+#define S_FW_FILTER_WR_RQTYPE           11
+#define M_FW_FILTER_WR_RQTYPE           0x1
+#define V_FW_FILTER_WR_RQTYPE(x)        ((x) << S_FW_FILTER_WR_RQTYPE)
+#define G_FW_FILTER_WR_RQTYPE(x)        \
+        (((x) >> S_FW_FILTER_WR_RQTYPE) & M_FW_FILTER_WR_RQTYPE)
+#define F_FW_FILTER_WR_RQTYPE   V_FW_FILTER_WR_RQTYPE(1U)
+
+#define S_FW_FILTER_WR_NOREPLY          10
+#define M_FW_FILTER_WR_NOREPLY          0x1
+#define V_FW_FILTER_WR_NOREPLY(x)       ((x) << S_FW_FILTER_WR_NOREPLY)
+#define G_FW_FILTER_WR_NOREPLY(x)       \
+        (((x) >> S_FW_FILTER_WR_NOREPLY) & M_FW_FILTER_WR_NOREPLY)
+#define F_FW_FILTER_WR_NOREPLY  V_FW_FILTER_WR_NOREPLY(1U)
+
+#define S_FW_FILTER_WR_IQ       0
+#define M_FW_FILTER_WR_IQ       0x3ff
+#define V_FW_FILTER_WR_IQ(x)    ((x) << S_FW_FILTER_WR_IQ)
+#define G_FW_FILTER_WR_IQ(x)    \
+        (((x) >> S_FW_FILTER_WR_IQ) & M_FW_FILTER_WR_IQ)
+
+#define S_FW_FILTER_WR_DEL_FILTER       31
+#define M_FW_FILTER_WR_DEL_FILTER       0x1
+#define V_FW_FILTER_WR_DEL_FILTER(x)    ((x) << S_FW_FILTER_WR_DEL_FILTER)
+#define G_FW_FILTER_WR_DEL_FILTER(x)    \
+        (((x) >> S_FW_FILTER_WR_DEL_FILTER) & M_FW_FILTER_WR_DEL_FILTER)
+#define F_FW_FILTER_WR_DEL_FILTER       V_FW_FILTER_WR_DEL_FILTER(1U)
+
+#define S_FW_FILTER_WR_RPTTID           25
+#define M_FW_FILTER_WR_RPTTID           0x1
+#define V_FW_FILTER_WR_RPTTID(x)        ((x) << S_FW_FILTER_WR_RPTTID)
+#define G_FW_FILTER_WR_RPTTID(x)        \
+        (((x) >> S_FW_FILTER_WR_RPTTID) & M_FW_FILTER_WR_RPTTID)
+#define F_FW_FILTER_WR_RPTTID   V_FW_FILTER_WR_RPTTID(1U)
+
+#define S_FW_FILTER_WR_DROP     24
+#define M_FW_FILTER_WR_DROP     0x1
+#define V_FW_FILTER_WR_DROP(x)  ((x) << S_FW_FILTER_WR_DROP)
+#define G_FW_FILTER_WR_DROP(x)  \
+        (((x) >> S_FW_FILTER_WR_DROP) & M_FW_FILTER_WR_DROP)
+#define F_FW_FILTER_WR_DROP     V_FW_FILTER_WR_DROP(1U)
+
+#define S_FW_FILTER_WR_DIRSTEER         23
+#define M_FW_FILTER_WR_DIRSTEER         0x1
+#define V_FW_FILTER_WR_DIRSTEER(x)      ((x) << S_FW_FILTER_WR_DIRSTEER)
+#define G_FW_FILTER_WR_DIRSTEER(x)      \
+        (((x) >> S_FW_FILTER_WR_DIRSTEER) & M_FW_FILTER_WR_DIRSTEER)
+#define F_FW_FILTER_WR_DIRSTEER V_FW_FILTER_WR_DIRSTEER(1U)
+
+#define S_FW_FILTER_WR_MASKHASH         22
+#define M_FW_FILTER_WR_MASKHASH         0x1
+#define V_FW_FILTER_WR_MASKHASH(x)      ((x) << S_FW_FILTER_WR_MASKHASH)
+#define G_FW_FILTER_WR_MASKHASH(x)      \
+        (((x) >> S_FW_FILTER_WR_MASKHASH) & M_FW_FILTER_WR_MASKHASH)
+#define F_FW_FILTER_WR_MASKHASH V_FW_FILTER_WR_MASKHASH(1U)
+
+#define S_FW_FILTER_WR_DIRSTEERHASH     21
+#define M_FW_FILTER_WR_DIRSTEERHASH     0x1
+#define V_FW_FILTER_WR_DIRSTEERHASH(x)  ((x) << S_FW_FILTER_WR_DIRSTEERHASH)
+#define G_FW_FILTER_WR_DIRSTEERHASH(x)  \
+        (((x) >> S_FW_FILTER_WR_DIRSTEERHASH) & M_FW_FILTER_WR_DIRSTEERHASH)
+#define F_FW_FILTER_WR_DIRSTEERHASH     V_FW_FILTER_WR_DIRSTEERHASH(1U)
+
+#define S_FW_FILTER_WR_LPBK     20
+#define M_FW_FILTER_WR_LPBK     0x1
+#define V_FW_FILTER_WR_LPBK(x)  ((x) << S_FW_FILTER_WR_LPBK)
+#define G_FW_FILTER_WR_LPBK(x)  \
+        (((x) >> S_FW_FILTER_WR_LPBK) & M_FW_FILTER_WR_LPBK)
+#define F_FW_FILTER_WR_LPBK     V_FW_FILTER_WR_LPBK(1U)
+
+#define S_FW_FILTER_WR_DMAC     19
+#define M_FW_FILTER_WR_DMAC     0x1
+#define V_FW_FILTER_WR_DMAC(x)  ((x) << S_FW_FILTER_WR_DMAC)
+#define G_FW_FILTER_WR_DMAC(x)  \
+        (((x) >> S_FW_FILTER_WR_DMAC) & M_FW_FILTER_WR_DMAC)
+#define F_FW_FILTER_WR_DMAC     V_FW_FILTER_WR_DMAC(1U)
+
+#define S_FW_FILTER_WR_SMAC     18
+#define M_FW_FILTER_WR_SMAC     0x1
+#define V_FW_FILTER_WR_SMAC(x)  ((x) << S_FW_FILTER_WR_SMAC)
+#define G_FW_FILTER_WR_SMAC(x)  \
+        (((x) >> S_FW_FILTER_WR_SMAC) & M_FW_FILTER_WR_SMAC)
+#define F_FW_FILTER_WR_SMAC     V_FW_FILTER_WR_SMAC(1U)
+
+#define S_FW_FILTER_WR_INSVLAN          17
+#define M_FW_FILTER_WR_INSVLAN          0x1
+#define V_FW_FILTER_WR_INSVLAN(x)       ((x) << S_FW_FILTER_WR_INSVLAN)
+#define G_FW_FILTER_WR_INSVLAN(x)       \
+        (((x) >> S_FW_FILTER_WR_INSVLAN) & M_FW_FILTER_WR_INSVLAN)
+#define F_FW_FILTER_WR_INSVLAN  V_FW_FILTER_WR_INSVLAN(1U)
+
+#define S_FW_FILTER_WR_RMVLAN           16
+#define M_FW_FILTER_WR_RMVLAN           0x1
+#define V_FW_FILTER_WR_RMVLAN(x)        ((x) << S_FW_FILTER_WR_RMVLAN)
+#define G_FW_FILTER_WR_RMVLAN(x)        \
+        (((x) >> S_FW_FILTER_WR_RMVLAN) & M_FW_FILTER_WR_RMVLAN)
+#define F_FW_FILTER_WR_RMVLAN   V_FW_FILTER_WR_RMVLAN(1U)
+
+#define S_FW_FILTER_WR_HITCNTS          15
+#define M_FW_FILTER_WR_HITCNTS          0x1
+#define V_FW_FILTER_WR_HITCNTS(x)       ((x) << S_FW_FILTER_WR_HITCNTS)
+#define G_FW_FILTER_WR_HITCNTS(x)       \
+        (((x) >> S_FW_FILTER_WR_HITCNTS) & M_FW_FILTER_WR_HITCNTS)
+#define F_FW_FILTER_WR_HITCNTS  V_FW_FILTER_WR_HITCNTS(1U)
+
+#define S_FW_FILTER_WR_TXCHAN           13
+#define M_FW_FILTER_WR_TXCHAN           0x3
+#define V_FW_FILTER_WR_TXCHAN(x)        ((x) << S_FW_FILTER_WR_TXCHAN)
+#define G_FW_FILTER_WR_TXCHAN(x)        \
+        (((x) >> S_FW_FILTER_WR_TXCHAN) & M_FW_FILTER_WR_TXCHAN)
+
+#define S_FW_FILTER_WR_PRIO     12
+#define M_FW_FILTER_WR_PRIO     0x1
+#define V_FW_FILTER_WR_PRIO(x)  ((x) << S_FW_FILTER_WR_PRIO)
+#define G_FW_FILTER_WR_PRIO(x)  \
+        (((x) >> S_FW_FILTER_WR_PRIO) & M_FW_FILTER_WR_PRIO)
+#define F_FW_FILTER_WR_PRIO     V_FW_FILTER_WR_PRIO(1U)
+
+#define S_FW_FILTER_WR_L2TIX    0
+#define M_FW_FILTER_WR_L2TIX    0xfff
+#define V_FW_FILTER_WR_L2TIX(x) ((x) << S_FW_FILTER_WR_L2TIX)
+#define G_FW_FILTER_WR_L2TIX(x) \
+        (((x) >> S_FW_FILTER_WR_L2TIX) & M_FW_FILTER_WR_L2TIX)
+
+#define S_FW_FILTER_WR_FRAG     7
+#define M_FW_FILTER_WR_FRAG     0x1
+#define V_FW_FILTER_WR_FRAG(x)  ((x) << S_FW_FILTER_WR_FRAG)
+#define G_FW_FILTER_WR_FRAG(x)  \
+        (((x) >> S_FW_FILTER_WR_FRAG) & M_FW_FILTER_WR_FRAG)
+#define F_FW_FILTER_WR_FRAG     V_FW_FILTER_WR_FRAG(1U)
+
+#define S_FW_FILTER_WR_FRAGM    6
+#define M_FW_FILTER_WR_FRAGM    0x1
+#define V_FW_FILTER_WR_FRAGM(x) ((x) << S_FW_FILTER_WR_FRAGM)
+#define G_FW_FILTER_WR_FRAGM(x) \
+        (((x) >> S_FW_FILTER_WR_FRAGM) & M_FW_FILTER_WR_FRAGM)
+#define F_FW_FILTER_WR_FRAGM    V_FW_FILTER_WR_FRAGM(1U)
+
+#define S_FW_FILTER_WR_IVLAN_VLD        5
+#define M_FW_FILTER_WR_IVLAN_VLD        0x1
+#define V_FW_FILTER_WR_IVLAN_VLD(x)     ((x) << S_FW_FILTER_WR_IVLAN_VLD)
+#define G_FW_FILTER_WR_IVLAN_VLD(x)     \
+        (((x) >> S_FW_FILTER_WR_IVLAN_VLD) & M_FW_FILTER_WR_IVLAN_VLD)
+#define F_FW_FILTER_WR_IVLAN_VLD        V_FW_FILTER_WR_IVLAN_VLD(1U)
+
+#define S_FW_FILTER_WR_OVLAN_VLD        4
+#define M_FW_FILTER_WR_OVLAN_VLD        0x1
+#define V_FW_FILTER_WR_OVLAN_VLD(x)     ((x) << S_FW_FILTER_WR_OVLAN_VLD)
+#define G_FW_FILTER_WR_OVLAN_VLD(x)     \
+        (((x) >> S_FW_FILTER_WR_OVLAN_VLD) & M_FW_FILTER_WR_OVLAN_VLD)
+#define F_FW_FILTER_WR_OVLAN_VLD        V_FW_FILTER_WR_OVLAN_VLD(1U)
+
+#define S_FW_FILTER_WR_IVLAN_VLDM       3
+#define M_FW_FILTER_WR_IVLAN_VLDM       0x1
+#define V_FW_FILTER_WR_IVLAN_VLDM(x)    ((x) << S_FW_FILTER_WR_IVLAN_VLDM)
+#define G_FW_FILTER_WR_IVLAN_VLDM(x)    \
+        (((x) >> S_FW_FILTER_WR_IVLAN_VLDM) & M_FW_FILTER_WR_IVLAN_VLDM)
+#define F_FW_FILTER_WR_IVLAN_VLDM       V_FW_FILTER_WR_IVLAN_VLDM(1U)
+
+#define S_FW_FILTER_WR_OVLAN_VLDM       2
+#define M_FW_FILTER_WR_OVLAN_VLDM       0x1
+#define V_FW_FILTER_WR_OVLAN_VLDM(x)    ((x) << S_FW_FILTER_WR_OVLAN_VLDM)
+#define G_FW_FILTER_WR_OVLAN_VLDM(x)    \
+        (((x) >> S_FW_FILTER_WR_OVLAN_VLDM) & M_FW_FILTER_WR_OVLAN_VLDM)
+#define F_FW_FILTER_WR_OVLAN_VLDM       V_FW_FILTER_WR_OVLAN_VLDM(1U)
+
+#define S_FW_FILTER_WR_RX_CHAN          15
+#define M_FW_FILTER_WR_RX_CHAN          0x1
+#define V_FW_FILTER_WR_RX_CHAN(x)       ((x) << S_FW_FILTER_WR_RX_CHAN)
+#define G_FW_FILTER_WR_RX_CHAN(x)       \
+        (((x) >> S_FW_FILTER_WR_RX_CHAN) & M_FW_FILTER_WR_RX_CHAN)
+#define F_FW_FILTER_WR_RX_CHAN  V_FW_FILTER_WR_RX_CHAN(1U)
+
+#define S_FW_FILTER_WR_RX_RPL_IQ        0
+#define M_FW_FILTER_WR_RX_RPL_IQ        0x3ff
+#define V_FW_FILTER_WR_RX_RPL_IQ(x)     ((x) << S_FW_FILTER_WR_RX_RPL_IQ)
+#define G_FW_FILTER_WR_RX_RPL_IQ(x)     \
+        (((x) >> S_FW_FILTER_WR_RX_RPL_IQ) & M_FW_FILTER_WR_RX_RPL_IQ)
+
+#define S_FW_FILTER_WR_MACI     23
+#define M_FW_FILTER_WR_MACI     0x1ff
+#define V_FW_FILTER_WR_MACI(x)  ((x) << S_FW_FILTER_WR_MACI)
+#define G_FW_FILTER_WR_MACI(x)  \
+        (((x) >> S_FW_FILTER_WR_MACI) & M_FW_FILTER_WR_MACI)
+
+#define S_FW_FILTER_WR_MACIM    14
+#define M_FW_FILTER_WR_MACIM    0x1ff
+#define V_FW_FILTER_WR_MACIM(x) ((x) << S_FW_FILTER_WR_MACIM)
+#define G_FW_FILTER_WR_MACIM(x) \
+        (((x) >> S_FW_FILTER_WR_MACIM) & M_FW_FILTER_WR_MACIM)
+
+#define S_FW_FILTER_WR_FCOE     13
+#define M_FW_FILTER_WR_FCOE     0x1
+#define V_FW_FILTER_WR_FCOE(x)  ((x) << S_FW_FILTER_WR_FCOE)
+#define G_FW_FILTER_WR_FCOE(x)  \
+        (((x) >> S_FW_FILTER_WR_FCOE) & M_FW_FILTER_WR_FCOE)
+#define F_FW_FILTER_WR_FCOE     V_FW_FILTER_WR_FCOE(1U)
+
+#define S_FW_FILTER_WR_FCOEM    12
+#define M_FW_FILTER_WR_FCOEM    0x1
+#define V_FW_FILTER_WR_FCOEM(x) ((x) << S_FW_FILTER_WR_FCOEM)
+#define G_FW_FILTER_WR_FCOEM(x) \
+        (((x) >> S_FW_FILTER_WR_FCOEM) & M_FW_FILTER_WR_FCOEM)
+#define F_FW_FILTER_WR_FCOEM    V_FW_FILTER_WR_FCOEM(1U)
+
+#define S_FW_FILTER_WR_PORT     9
+#define M_FW_FILTER_WR_PORT     0x7
+#define V_FW_FILTER_WR_PORT(x)  ((x) << S_FW_FILTER_WR_PORT)
+#define G_FW_FILTER_WR_PORT(x)  \
+        (((x) >> S_FW_FILTER_WR_PORT) & M_FW_FILTER_WR_PORT)
+
+#define S_FW_FILTER_WR_PORTM    6
+#define M_FW_FILTER_WR_PORTM    0x7
+#define V_FW_FILTER_WR_PORTM(x) ((x) << S_FW_FILTER_WR_PORTM)
+#define G_FW_FILTER_WR_PORTM(x) \
+        (((x) >> S_FW_FILTER_WR_PORTM) & M_FW_FILTER_WR_PORTM)
+
+#define S_FW_FILTER_WR_MATCHTYPE        3
+#define M_FW_FILTER_WR_MATCHTYPE        0x7
+#define V_FW_FILTER_WR_MATCHTYPE(x)     ((x) << S_FW_FILTER_WR_MATCHTYPE)
+#define G_FW_FILTER_WR_MATCHTYPE(x)     \
+        (((x) >> S_FW_FILTER_WR_MATCHTYPE) & M_FW_FILTER_WR_MATCHTYPE)
+
+#define S_FW_FILTER_WR_MATCHTYPEM       0
+#define M_FW_FILTER_WR_MATCHTYPEM       0x7
+#define V_FW_FILTER_WR_MATCHTYPEM(x)    ((x) << S_FW_FILTER_WR_MATCHTYPEM)
+#define G_FW_FILTER_WR_MATCHTYPEM(x)    \
+        (((x) >> S_FW_FILTER_WR_MATCHTYPEM) & M_FW_FILTER_WR_MATCHTYPEM)
+
 struct fw_ulptx_wr {
         __be32 op_to_compl;
         __be32 flowid_len16;