cxgb4: move common filter code to separate file
authorRahul Lakkireddy <rahul.lakkireddy@chelsio.com>
Tue, 20 Sep 2016 11:43:06 +0000 (17:13 +0530)
committerDavid S. Miller <davem@davemloft.net>
Thu, 22 Sep 2016 05:40:01 +0000 (01:40 -0400)
Move common filter code to separate files.  Also fix the following
checkpatch checks.

CHECK: Comparison to NULL could be written "!f->l2t"
+               if (f->l2t == NULL) {

CHECK: spaces preferred around that '/' (ctx:VxV)
+       fwr->len16_pkd = htonl(FW_WR_LEN16_V(sizeof(*fwr)/16));

Signed-off-by: Rahul Lakkireddy <rahul.lakkireddy@chelsio.com>
Signed-off-by: Hariprasad Shenai <hariprasad@chelsio.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
drivers/net/ethernet/chelsio/cxgb4/Makefile
drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
drivers/net/ethernet/chelsio/cxgb4/cxgb4_filter.c [new file with mode: 0644]
drivers/net/ethernet/chelsio/cxgb4/cxgb4_filter.h [new file with mode: 0644]
drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

index 246129650967c025a2bfdd31307f465c10209c6d..da889817ec274f9046fb5a5f0e71795bd79a481e 100644 (file)
@@ -4,7 +4,7 @@
 
 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-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-$(CONFIG_CHELSIO_T4_DCB) +=  cxgb4_dcb.o
 cxgb4-$(CONFIG_CHELSIO_T4_FCOE) +=  cxgb4_fcoe.o
 cxgb4-$(CONFIG_DEBUG_FS) += cxgb4_debugfs.o
index 1f9867db3b783e7c8a243e754db609293013561f..a844fd25c214246f3f41ee18178687cffcef1b68 100644 (file)
@@ -1025,6 +1025,29 @@ enum {
        VLAN_REWRITE
 };
 
+/* 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;
+};
+
 static inline int is_offload(const struct adapter *adap)
 {
        return adap->params.offload;
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_filter.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_filter.c
new file mode 100644 (file)
index 0000000..8a26a54
--- /dev/null
@@ -0,0 +1,274 @@
+/*
+ * This file is part of the Chelsio T4 Ethernet driver for Linux.
+ *
+ * Copyright (c) 2003-2016 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 "cxgb4.h"
+#include "l2t.h"
+#include "t4fw_api.h"
+#include "cxgb4_filter.h"
+
+/* 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 fw_filter_wr *fwr;
+       unsigned int len, ftid;
+       struct sk_buff *skb;
+
+       len = sizeof(*fwr);
+       ftid = adapter->tids.ftid_base + fidx;
+
+       skb = alloc_skb(len, GFP_KERNEL);
+       if (!skb)
+               return -ENOMEM;
+
+       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;
+}
+
+/* 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.
+ */
+int set_filter_wr(struct adapter *adapter, int fidx)
+{
+       struct filter_entry *f = &adapter->tids.ftid_tab[fidx];
+       struct fw_filter_wr *fwr;
+       struct sk_buff *skb;
+       unsigned int ftid;
+
+       skb = alloc_skb(sizeof(*fwr), GFP_KERNEL);
+       if (!skb)
+               return -ENOMEM;
+
+       /* 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, f->fs.vlan,
+                                               f->fs.eport, f->fs.dmac);
+               if (!f->l2t) {
+                       kfree_skb(skb);
+                       return -ENOMEM;
+               }
+       }
+
+       ftid = adapter->tids.ftid_base + fidx;
+
+       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_V(FW_FILTER_WR));
+       fwr->len16_pkd = htonl(FW_WR_LEN16_V(sizeof(*fwr) / 16));
+       fwr->tid_to_iq =
+               htonl(FW_FILTER_WR_TID_V(ftid) |
+                     FW_FILTER_WR_RQTYPE_V(f->fs.type) |
+                     FW_FILTER_WR_NOREPLY_V(0) |
+                     FW_FILTER_WR_IQ_V(f->fs.iq));
+       fwr->del_filter_to_l2tix =
+               htonl(FW_FILTER_WR_RPTTID_V(f->fs.rpttid) |
+                     FW_FILTER_WR_DROP_V(f->fs.action == FILTER_DROP) |
+                     FW_FILTER_WR_DIRSTEER_V(f->fs.dirsteer) |
+                     FW_FILTER_WR_MASKHASH_V(f->fs.maskhash) |
+                     FW_FILTER_WR_DIRSTEERHASH_V(f->fs.dirsteerhash) |
+                     FW_FILTER_WR_LPBK_V(f->fs.action == FILTER_SWITCH) |
+                     FW_FILTER_WR_DMAC_V(f->fs.newdmac) |
+                     FW_FILTER_WR_SMAC_V(f->fs.newsmac) |
+                     FW_FILTER_WR_INSVLAN_V(f->fs.newvlan == VLAN_INSERT ||
+                                            f->fs.newvlan == VLAN_REWRITE) |
+                     FW_FILTER_WR_RMVLAN_V(f->fs.newvlan == VLAN_REMOVE ||
+                                           f->fs.newvlan == VLAN_REWRITE) |
+                     FW_FILTER_WR_HITCNTS_V(f->fs.hitcnts) |
+                     FW_FILTER_WR_TXCHAN_V(f->fs.eport) |
+                     FW_FILTER_WR_PRIO_V(f->fs.prio) |
+                     FW_FILTER_WR_L2TIX_V(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 =
+               (FW_FILTER_WR_FRAG_V(f->fs.val.frag) |
+                FW_FILTER_WR_FRAGM_V(f->fs.mask.frag) |
+                FW_FILTER_WR_IVLAN_VLD_V(f->fs.val.ivlan_vld) |
+                FW_FILTER_WR_OVLAN_VLD_V(f->fs.val.ovlan_vld) |
+                FW_FILTER_WR_IVLAN_VLDM_V(f->fs.mask.ivlan_vld) |
+                FW_FILTER_WR_OVLAN_VLDM_V(f->fs.mask.ovlan_vld));
+       fwr->smac_sel = 0;
+       fwr->rx_chan_rx_rpl_iq =
+               htons(FW_FILTER_WR_RX_CHAN_V(0) |
+                     FW_FILTER_WR_RX_RPL_IQ_V(adapter->sge.fw_evtq.abs_id));
+       fwr->maci_to_matchtypem =
+               htonl(FW_FILTER_WR_MACI_V(f->fs.val.macidx) |
+                     FW_FILTER_WR_MACIM_V(f->fs.mask.macidx) |
+                     FW_FILTER_WR_FCOE_V(f->fs.val.fcoe) |
+                     FW_FILTER_WR_FCOEM_V(f->fs.mask.fcoe) |
+                     FW_FILTER_WR_PORT_V(f->fs.val.iport) |
+                     FW_FILTER_WR_PORTM_V(f->fs.mask.iport) |
+                     FW_FILTER_WR_MATCHTYPE_V(f->fs.val.matchtype) |
+                     FW_FILTER_WR_MATCHTYPEM_V(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;
+}
+
+/* Return an error number if the indicated filter isn't writable ... */
+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.
+ */
+int delete_filter(struct adapter *adapter, unsigned int fidx)
+{
+       struct filter_entry *f;
+       int ret;
+
+       if (fidx >= adapter->tids.nftids + adapter->tids.nsftids)
+               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;
+}
+
+/* Clear a filter and release any of its resources that we own.  This also
+ * clears the filter's "pending" status.
+ */
+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. */
+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;
+       struct filter_entry *f;
+       unsigned int ret;
+
+       if (idx >= adap->tids.ftid_base && nidx <
+          (adap->tids.nftids + adap->tids.nsftids)) {
+               idx = nidx;
+               ret = TCB_COOKIE_G(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);
+               }
+       }
+}
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_filter.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_filter.h
new file mode 100644 (file)
index 0000000..f6bd0bf
--- /dev/null
@@ -0,0 +1,47 @@
+/*
+ * This file is part of the Chelsio T4 Ethernet driver for Linux.
+ *
+ * Copyright (c) 2003-2016 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.
+ */
+
+#ifndef __CXGB4_FILTER_H
+#define __CXGB4_FILTER_H
+
+#include "t4_msg.h"
+
+void filter_rpl(struct adapter *adap, const struct cpl_set_tcb_rpl *rpl);
+void clear_filter(struct adapter *adap, struct filter_entry *f);
+
+int set_filter_wr(struct adapter *adapter, int fidx);
+int delete_filter(struct adapter *adapter, unsigned int fidx);
+
+int writable_filter(struct filter_entry *f);
+#endif /* __CXGB4_FILTER_H */
index d1ebb84c073e320d78f44008c839c07f1fb9de6b..5cdcfe871c12e935e551bd90afae439eccbb58d3 100644 (file)
@@ -67,6 +67,7 @@
 #include <linux/crash_dump.h>
 
 #include "cxgb4.h"
+#include "cxgb4_filter.h"
 #include "t4_regs.h"
 #include "t4_values.h"
 #include "t4_msg.h"
@@ -87,30 +88,6 @@ char cxgb4_driver_name[] = KBUILD_MODNAME;
 const char cxgb4_driver_version[] = DRV_VERSION;
 #define DRV_DESC "Chelsio T4/T5/T6 Network Driver"
 
-/* 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)
@@ -527,66 +504,6 @@ static void dcb_rpl(struct adapter *adap, const struct fw_port_cmd *pcmd)
 }
 #endif /* CONFIG_CHELSIO_T4_DCB */
 
-/* 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 = TCB_COOKIE_G(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,
@@ -1026,151 +943,6 @@ void t4_free_mem(void *addr)
        kvfree(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;
-
-       skb = alloc_skb(sizeof(*fwr), GFP_KERNEL);
-       if (!skb)
-               return -ENOMEM;
-
-       /* 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, f->fs.vlan,
-                                               f->fs.eport, f->fs.dmac);
-               if (f->l2t == NULL) {
-                       kfree_skb(skb);
-                       return -ENOMEM;
-               }
-       }
-
-       ftid = adapter->tids.ftid_base + fidx;
-
-       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_V(FW_FILTER_WR));
-       fwr->len16_pkd = htonl(FW_WR_LEN16_V(sizeof(*fwr)/16));
-       fwr->tid_to_iq =
-               htonl(FW_FILTER_WR_TID_V(ftid) |
-                     FW_FILTER_WR_RQTYPE_V(f->fs.type) |
-                     FW_FILTER_WR_NOREPLY_V(0) |
-                     FW_FILTER_WR_IQ_V(f->fs.iq));
-       fwr->del_filter_to_l2tix =
-               htonl(FW_FILTER_WR_RPTTID_V(f->fs.rpttid) |
-                     FW_FILTER_WR_DROP_V(f->fs.action == FILTER_DROP) |
-                     FW_FILTER_WR_DIRSTEER_V(f->fs.dirsteer) |
-                     FW_FILTER_WR_MASKHASH_V(f->fs.maskhash) |
-                     FW_FILTER_WR_DIRSTEERHASH_V(f->fs.dirsteerhash) |
-                     FW_FILTER_WR_LPBK_V(f->fs.action == FILTER_SWITCH) |
-                     FW_FILTER_WR_DMAC_V(f->fs.newdmac) |
-                     FW_FILTER_WR_SMAC_V(f->fs.newsmac) |
-                     FW_FILTER_WR_INSVLAN_V(f->fs.newvlan == VLAN_INSERT ||
-                                            f->fs.newvlan == VLAN_REWRITE) |
-                     FW_FILTER_WR_RMVLAN_V(f->fs.newvlan == VLAN_REMOVE ||
-                                           f->fs.newvlan == VLAN_REWRITE) |
-                     FW_FILTER_WR_HITCNTS_V(f->fs.hitcnts) |
-                     FW_FILTER_WR_TXCHAN_V(f->fs.eport) |
-                     FW_FILTER_WR_PRIO_V(f->fs.prio) |
-                     FW_FILTER_WR_L2TIX_V(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 =
-               (FW_FILTER_WR_FRAG_V(f->fs.val.frag) |
-                FW_FILTER_WR_FRAGM_V(f->fs.mask.frag) |
-                FW_FILTER_WR_IVLAN_VLD_V(f->fs.val.ivlan_vld) |
-                FW_FILTER_WR_OVLAN_VLD_V(f->fs.val.ovlan_vld) |
-                FW_FILTER_WR_IVLAN_VLDM_V(f->fs.mask.ivlan_vld) |
-                FW_FILTER_WR_OVLAN_VLDM_V(f->fs.mask.ovlan_vld));
-       fwr->smac_sel = 0;
-       fwr->rx_chan_rx_rpl_iq =
-               htons(FW_FILTER_WR_RX_CHAN_V(0) |
-                     FW_FILTER_WR_RX_RPL_IQ_V(adapter->sge.fw_evtq.abs_id));
-       fwr->maci_to_matchtypem =
-               htonl(FW_FILTER_WR_MACI_V(f->fs.val.macidx) |
-                     FW_FILTER_WR_MACIM_V(f->fs.mask.macidx) |
-                     FW_FILTER_WR_FCOE_V(f->fs.val.fcoe) |
-                     FW_FILTER_WR_FCOEM_V(f->fs.mask.fcoe) |
-                     FW_FILTER_WR_PORT_V(f->fs.val.iport) |
-                     FW_FILTER_WR_PORTM_V(f->fs.mask.iport) |
-                     FW_FILTER_WR_MATCHTYPE_V(f->fs.val.matchtype) |
-                     FW_FILTER_WR_MATCHTYPEM_V(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);
-       if (!skb)
-               return -ENOMEM;
-
-       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 u16 cxgb_select_queue(struct net_device *dev, struct sk_buff *skb,
                             void *accel_priv, select_queue_fallback_t fallback)
 {
@@ -2514,40 +2286,6 @@ static int cxgb_close(struct net_device *dev)
        return t4_enable_vi(adapter, adapter->pf, 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 + adapter->tids.nsftids)
-               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;
-}
-
 int cxgb4_create_server_filter(const struct net_device *dev, unsigned int stid,
                __be32 sip, __be16 sport, __be16 vlan,
                unsigned int queue, unsigned char port, unsigned char mask)