10 files changed, 274 insertions, 712 deletions

diff --git a/drivers/net/cxgb4/cxgb4.h b/drivers/net/cxgb4/cxgb4.h
index 6e562c0dad7d..bc9982a4c1f4 100644
--- a/drivers/net/cxgb4/cxgb4.h
+++ b/drivers/net/cxgb4/cxgb4.h
@@ -281,7 +281,6 @@ struct sge_rspq;
 
 struct port_info {
         struct adapter *adapter;
-        struct vlan_group *vlan_grp;
         u16    viid;
         s16    xact_addr_filt;        /* index of exact MAC address filter */
         u16    rss_size;              /* size of VI's RSS table slice */
@@ -291,7 +290,6 @@ struct port_info {
         u8     port_id;
         u8     tx_chan;
         u8     lport;                 /* associated offload logical port */
-        u8     rx_offload;            /* CSO, etc */
         u8     nqsets;                /* # of qsets */
         u8     first_qset;            /* index of first qset */
         u8     rss_mode;
@@ -299,11 +297,6 @@ struct port_info {
         u16   *rss;
 };
 
-/* port_info.rx_offload flags */
-enum {
-        RX_CSO = 1 << 0,
-};
-
 struct dentry;
 struct work_struct;
 
@@ -463,6 +456,8 @@ struct sge {
         u8 counter_val[SGE_NCOUNTERS];
         unsigned int starve_thres;
         u8 idma_state[2];
+        unsigned int egr_start;
+        unsigned int ingr_start;
         void *egr_map[MAX_EGRQ];    /* qid->queue egress queue map */
         struct sge_rspq *ingr_map[MAX_INGQ]; /* qid->queue ingress queue map */
         DECLARE_BITMAP(starving_fl, MAX_EGRQ);
@@ -481,11 +476,9 @@ struct adapter {
         void __iomem *regs;
         struct pci_dev *pdev;
         struct device *pdev_dev;
-        unsigned long registered_device_map;
         unsigned int fn;
         unsigned int flags;
 
-        const char *name;
         int msg_enable;
 
         struct adapter_params params;
@@ -496,7 +489,7 @@ struct adapter {
 
         struct {
                 unsigned short vec;
-                char desc[14];
+                char desc[IFNAMSIZ + 10];
         } msix_info[MAX_INGQ + 1];
 
         struct sge sge;
@@ -590,7 +583,6 @@ void t4_os_portmod_changed(const struct adapter *adap, int port_id);
 void t4_os_link_changed(struct adapter *adap, int port_id, int link_stat);
 
 void *t4_alloc_mem(size_t size);
-void t4_free_mem(void *addr);
 
 void t4_free_sge_resources(struct adapter *adap);
 irq_handler_t t4_intr_handler(struct adapter *adap);
@@ -649,7 +641,6 @@ static inline int t4_wr_mbox_ns(struct adapter *adap, int mbox, const void *cmd,
 
 void t4_intr_enable(struct adapter *adapter);
 void t4_intr_disable(struct adapter *adapter);
-void t4_intr_clear(struct adapter *adapter);
 int t4_slow_intr_handler(struct adapter *adapter);
 
 int t4_wait_dev_ready(struct adapter *adap);
@@ -662,24 +653,16 @@ int t4_check_fw_version(struct adapter *adapter);
 int t4_prep_adapter(struct adapter *adapter);
 int t4_port_init(struct adapter *adap, int mbox, int pf, int vf);
 void t4_fatal_err(struct adapter *adapter);
-int t4_set_trace_filter(struct adapter *adapter, const struct trace_params *tp,
-                        int filter_index, int enable);
-void t4_get_trace_filter(struct adapter *adapter, struct trace_params *tp,
-                         int filter_index, int *enabled);
 int t4_config_rss_range(struct adapter *adapter, int mbox, unsigned int viid,
                         int start, int n, const u16 *rspq, unsigned int nrspq);
 int t4_config_glbl_rss(struct adapter *adapter, int mbox, unsigned int mode,
                        unsigned int flags);
-int t4_read_rss(struct adapter *adapter, u16 *entries);
 int t4_mc_read(struct adapter *adap, u32 addr, __be32 *data, u64 *parity);
 int t4_edc_read(struct adapter *adap, int idx, u32 addr, __be32 *data,
                 u64 *parity);
 
 void t4_get_port_stats(struct adapter *adap, int idx, struct port_stats *p);
-void t4_get_lb_stats(struct adapter *adap, int idx, struct lb_port_stats *p);
-
 void t4_read_mtu_tbl(struct adapter *adap, u16 *mtus, u8 *mtu_log);
-void t4_tp_get_err_stats(struct adapter *adap, struct tp_err_stats *st);
 void t4_tp_get_tcp_stats(struct adapter *adap, struct tp_tcp_stats *v4,
                          struct tp_tcp_stats *v6);
 void t4_load_mtus(struct adapter *adap, const unsigned short *mtus,
@@ -709,8 +692,6 @@ int t4_cfg_pfvf(struct adapter *adap, unsigned int mbox, unsigned int pf,
 int t4_alloc_vi(struct adapter *adap, unsigned int mbox, unsigned int port,
                 unsigned int pf, unsigned int vf, unsigned int nmac, u8 *mac,
                 unsigned int *rss_size);
-int t4_free_vi(struct adapter *adap, unsigned int mbox, unsigned int pf,
-               unsigned int vf, unsigned int viid);
 int t4_set_rxmode(struct adapter *adap, unsigned int mbox, unsigned int viid,
                 int mtu, int promisc, int all_multi, int bcast, int vlanex,
                 bool sleep_ok);
@@ -729,9 +710,6 @@ int t4_mdio_rd(struct adapter *adap, unsigned int mbox, unsigned int phy_addr,
                unsigned int mmd, unsigned int reg, u16 *valp);
 int t4_mdio_wr(struct adapter *adap, unsigned int mbox, unsigned int phy_addr,
                unsigned int mmd, unsigned int reg, u16 val);
-int t4_iq_start_stop(struct adapter *adap, unsigned int mbox, bool start,
-                     unsigned int pf, unsigned int vf, unsigned int iqid,
-                     unsigned int fl0id, unsigned int fl1id);
 int t4_iq_free(struct adapter *adap, unsigned int mbox, unsigned int pf,
                unsigned int vf, unsigned int iqtype, unsigned int iqid,
                unsigned int fl0id, unsigned int fl1id);
diff --git a/drivers/net/cxgb4/cxgb4_main.c b/drivers/net/cxgb4/cxgb4_main.c
index c327527fbbc8..7e3cfbe89e3b 100644
--- a/drivers/net/cxgb4/cxgb4_main.c
+++ b/drivers/net/cxgb4/cxgb4_main.c
@@ -175,16 +175,26 @@ enum {
 
 static DEFINE_PCI_DEVICE_TABLE(cxgb4_pci_tbl) = {
         CH_DEVICE(0xa000, 0),  /* PE10K */
-        CH_DEVICE(0x4001, 0),
-        CH_DEVICE(0x4002, 0),
-        CH_DEVICE(0x4003, 0),
-        CH_DEVICE(0x4004, 0),
-        CH_DEVICE(0x4005, 0),
-        CH_DEVICE(0x4006, 0),
-        CH_DEVICE(0x4007, 0),
-        CH_DEVICE(0x4008, 0),
-        CH_DEVICE(0x4009, 0),
-        CH_DEVICE(0x400a, 0),
+        CH_DEVICE(0x4001, -1),
+        CH_DEVICE(0x4002, -1),
+        CH_DEVICE(0x4003, -1),
+        CH_DEVICE(0x4004, -1),
+        CH_DEVICE(0x4005, -1),
+        CH_DEVICE(0x4006, -1),
+        CH_DEVICE(0x4007, -1),
+        CH_DEVICE(0x4008, -1),
+        CH_DEVICE(0x4009, -1),
+        CH_DEVICE(0x400a, -1),
+        CH_DEVICE(0x4401, 4),
+        CH_DEVICE(0x4402, 4),
+        CH_DEVICE(0x4403, 4),
+        CH_DEVICE(0x4404, 4),
+        CH_DEVICE(0x4405, 4),
+        CH_DEVICE(0x4406, 4),
+        CH_DEVICE(0x4407, 4),
+        CH_DEVICE(0x4408, 4),
+        CH_DEVICE(0x4409, 4),
+        CH_DEVICE(0x440a, 4),
         { 0, }
 };
 
@@ -393,7 +403,7 @@ static int link_start(struct net_device *dev)
          * that step explicitly.
          */
         ret = t4_set_rxmode(pi->adapter, mb, pi->viid, dev->mtu, -1, -1, -1,
-                            pi->vlan_grp != NULL, true);
+                            !!(dev->features & NETIF_F_HW_VLAN_RX), true);
         if (ret == 0) {
                 ret = t4_change_mac(pi->adapter, mb, pi->viid,
                                     pi->xact_addr_filt, dev->dev_addr, true,
@@ -423,10 +433,11 @@ static int fwevtq_handler(struct sge_rspq *q, const __be64 *rsp,
         if (likely(opcode == CPL_SGE_EGR_UPDATE)) {
                 const struct cpl_sge_egr_update *p = (void *)rsp;
                 unsigned int qid = EGR_QID(ntohl(p->opcode_qid));
-                struct sge_txq *txq = q->adap->sge.egr_map[qid];
+                struct sge_txq *txq;
 
+                txq = q->adap->sge.egr_map[qid - q->adap->sge.egr_start];
                 txq->restarts++;
-                if ((u8 *)txq < (u8 *)q->adap->sge.ethrxq) {
+                if ((u8 *)txq < (u8 *)q->adap->sge.ofldtxq) {
                         struct sge_eth_txq *eq;
 
                         eq = container_of(txq, struct sge_eth_txq, q);
@@ -511,39 +522,33 @@ static irqreturn_t t4_nondata_intr(int irq, void *cookie)
  */
 static void name_msix_vecs(struct adapter *adap)
 {
-        int i, j, msi_idx = 2, n = sizeof(adap->msix_info[0].desc) - 1;
+        int i, j, msi_idx = 2, n = sizeof(adap->msix_info[0].desc);
 
         /* non-data interrupts */
-        snprintf(adap->msix_info[0].desc, n, "%s", adap->name);
-        adap->msix_info[0].desc[n] = 0;
+        snprintf(adap->msix_info[0].desc, n, "%s", adap->port[0]->name);
 
         /* FW events */
-        snprintf(adap->msix_info[1].desc, n, "%s-FWeventq", adap->name);
-        adap->msix_info[1].desc[n] = 0;
+        snprintf(adap->msix_info[1].desc, n, "%s-FWeventq",
+                 adap->port[0]->name);
 
         /* Ethernet queues */
         for_each_port(adap, j) {
                 struct net_device *d = adap->port[j];
                 const struct port_info *pi = netdev_priv(d);
 
-                for (i = 0; i < pi->nqsets; i++, msi_idx++) {
+                for (i = 0; i < pi->nqsets; i++, msi_idx++)
                         snprintf(adap->msix_info[msi_idx].desc, n, "%s-Rx%d",
                                  d->name, i);
-                        adap->msix_info[msi_idx].desc[n] = 0;
-                }
         }
 
         /* offload queues */
-        for_each_ofldrxq(&adap->sge, i) {
-                snprintf(adap->msix_info[msi_idx].desc, n, "%s-ofld%d",
-                         adap->name, i);
-                adap->msix_info[msi_idx++].desc[n] = 0;
-        }
-        for_each_rdmarxq(&adap->sge, i) {
-                snprintf(adap->msix_info[msi_idx].desc, n, "%s-rdma%d",
-                         adap->name, i);
-                adap->msix_info[msi_idx++].desc[n] = 0;
-        }
+        for_each_ofldrxq(&adap->sge, i)
+                snprintf(adap->msix_info[msi_idx++].desc, n, "%s-ofld%d",
+                         adap->port[0]->name, i);
+
+        for_each_rdmarxq(&adap->sge, i)
+                snprintf(adap->msix_info[msi_idx++].desc, n, "%s-rdma%d",
+                         adap->port[0]->name, i);
 }
 
 static int request_msix_queue_irqs(struct adapter *adap)
@@ -658,6 +663,15 @@ static int setup_rss(struct adapter *adap)
 }
 
 /*
+ * Return the channel of the ingress queue with the given qid.
+ */
+static unsigned int rxq_to_chan(const struct sge *p, unsigned int qid)
+{
+        qid -= p->ingr_start;
+        return netdev2pinfo(p->ingr_map[qid]->netdev)->tx_chan;
+}
+
+/*
  * Wait until all NAPI handlers are descheduled.
  */
 static void quiesce_rx(struct adapter *adap)
@@ -848,19 +862,17 @@ out:	release_firmware(fw);
  */
 void *t4_alloc_mem(size_t size)
 {
-        void *p = kmalloc(size, GFP_KERNEL);
+        void *p = kzalloc(size, GFP_KERNEL);
 
         if (!p)
-                p = vmalloc(size);
-        if (p)
-                memset(p, 0, size);
+                p = vzalloc(size);
         return p;
 }
 
 /*
  * Free memory allocated through alloc_mem().
  */
-void t4_free_mem(void *addr)
+static void t4_free_mem(void *addr)
 {
         if (is_vmalloc_addr(addr))
                 vfree(addr);
@@ -1324,15 +1336,20 @@ static int restart_autoneg(struct net_device *dev)
         return 0;
 }
 
-static int identify_port(struct net_device *dev, u32 data)
+static int identify_port(struct net_device *dev,
+                         enum ethtool_phys_id_state state)
 {
+        unsigned int val;
         struct adapter *adap = netdev2adap(dev);
 
-        if (data == 0)
-                data = 2;     /* default to 2 seconds */
+        if (state == ETHTOOL_ID_ACTIVE)
+                val = 0xffff;
+        else if (state == ETHTOOL_ID_INACTIVE)
+                val = 0;
+        else
+                return -EINVAL;
 
-        return t4_identify_port(adap, adap->fn, netdev2pinfo(dev)->viid,
-                                data * 5);
+        return t4_identify_port(adap, adap->fn, netdev2pinfo(dev)->viid, val);
 }
 
 static unsigned int from_fw_linkcaps(unsigned int type, unsigned int caps)
@@ -1357,7 +1374,12 @@ static unsigned int from_fw_linkcaps(unsigned int type, unsigned int caps)
         } else if (type == FW_PORT_TYPE_KR)
                 v |= SUPPORTED_Backplane | SUPPORTED_10000baseKR_Full;
         else if (type == FW_PORT_TYPE_BP_AP)
-                v |= SUPPORTED_Backplane | SUPPORTED_10000baseR_FEC;
+                v |= SUPPORTED_Backplane | SUPPORTED_10000baseR_FEC |
+                     SUPPORTED_10000baseKR_Full | SUPPORTED_1000baseKX_Full;
+        else if (type == FW_PORT_TYPE_BP4_AP)
+                v |= SUPPORTED_Backplane | SUPPORTED_10000baseR_FEC |
+                     SUPPORTED_10000baseKR_Full | SUPPORTED_1000baseKX_Full |
+                     SUPPORTED_10000baseKX4_Full;
         else if (type == FW_PORT_TYPE_FIBER_XFI ||
                  type == FW_PORT_TYPE_FIBER_XAUI || type == FW_PORT_TYPE_SFP)
                 v |= SUPPORTED_FIBRE;
@@ -1414,7 +1436,8 @@ static int get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
         cmd->supported = from_fw_linkcaps(p->port_type, p->link_cfg.supported);
         cmd->advertising = from_fw_linkcaps(p->port_type,
                                             p->link_cfg.advertising);
-        cmd->speed = netif_carrier_ok(dev) ? p->link_cfg.speed : 0;
+        ethtool_cmd_speed_set(cmd,
+                              netif_carrier_ok(dev) ? p->link_cfg.speed : 0);
         cmd->duplex = DUPLEX_FULL;
         cmd->autoneg = p->link_cfg.autoneg;
         cmd->maxtxpkt = 0;
@@ -1438,6 +1461,7 @@ static int set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
         unsigned int cap;
         struct port_info *p = netdev_priv(dev);
         struct link_config *lc = &p->link_cfg;
+        u32 speed = ethtool_cmd_speed(cmd);
 
         if (cmd->duplex != DUPLEX_FULL)     /* only full-duplex supported */
                 return -EINVAL;
@@ -1448,16 +1472,16 @@ static int set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                  * being requested.
                  */
                 if (cmd->autoneg == AUTONEG_DISABLE &&
-                    (lc->supported & speed_to_caps(cmd->speed)))
-                                return 0;
+                    (lc->supported & speed_to_caps(speed)))
+                        return 0;
                 return -EINVAL;
         }
 
         if (cmd->autoneg == AUTONEG_DISABLE) {
-                cap = speed_to_caps(cmd->speed);
+                cap = speed_to_caps(speed);
 
-                if (!(lc->supported & cap) || cmd->speed == SPEED_1000 ||
-                    cmd->speed == SPEED_10000)
+                if (!(lc->supported & cap) || (speed == SPEED_1000) ||
+                    (speed == SPEED_10000))
                         return -EINVAL;
                 lc->requested_speed = cap;
                 lc->advertising = 0;
@@ -1509,24 +1533,6 @@ static int set_pauseparam(struct net_device *dev,
         return 0;
 }
 
-static u32 get_rx_csum(struct net_device *dev)
-{
-        struct port_info *p = netdev_priv(dev);
-
-        return p->rx_offload & RX_CSO;
-}
-
-static int set_rx_csum(struct net_device *dev, u32 data)
-{
-        struct port_info *p = netdev_priv(dev);
-
-        if (data)
-                p->rx_offload |= RX_CSO;
-        else
-                p->rx_offload &= ~RX_CSO;
-        return 0;
-}
-
 static void get_sge_param(struct net_device *dev, struct ethtool_ringparam *e)
 {
         const struct port_info *pi = netdev_priv(dev);
@@ -1671,27 +1677,41 @@ static int get_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
         return 0;
 }
 
-/*
- * Translate a physical EEPROM address to virtual.  The first 1K is accessed
- * through virtual addresses starting at 31K, the rest is accessed through
- * virtual addresses starting at 0.  This mapping is correct only for PF0.
+/**
+ *      eeprom_ptov - translate a physical EEPROM address to virtual
+ *      @phys_addr: the physical EEPROM address
+ *      @fn: the PCI function number
+ *      @sz: size of function-specific area
+ *
+ *      Translate a physical EEPROM address to virtual.  The first 1K is
+ *      accessed through virtual addresses starting at 31K, the rest is
+ *      accessed through virtual addresses starting at 0.
+ *
+ *      The mapping is as follows:
+ *      [0..1K) -> [31K..32K)
+ *      [1K..1K+A) -> [31K-A..31K)
+ *      [1K+A..ES) -> [0..ES-A-1K)
+ *
+ *      where A = @fn * @sz, and ES = EEPROM size.
  */
-static int eeprom_ptov(unsigned int phys_addr)
+static int eeprom_ptov(unsigned int phys_addr, unsigned int fn, unsigned int sz)
 {
+        fn *= sz;
         if (phys_addr < 1024)
                 return phys_addr + (31 << 10);
+        if (phys_addr < 1024 + fn)
+                return 31744 - fn + phys_addr - 1024;
         if (phys_addr < EEPROMSIZE)
-                return phys_addr - 1024;
+                return phys_addr - 1024 - fn;
         return -EINVAL;
 }
 
 /*
  * The next two routines implement eeprom read/write from physical addresses.
- * The physical->virtual translation is correct only for PF0.
  */
 static int eeprom_rd_phys(struct adapter *adap, unsigned int phys_addr, u32 *v)
 {
-        int vaddr = eeprom_ptov(phys_addr);
+        int vaddr = eeprom_ptov(phys_addr, adap->fn, EEPROMPFSIZE);
 
         if (vaddr >= 0)
                 vaddr = pci_read_vpd(adap->pdev, vaddr, sizeof(u32), v);
@@ -1700,7 +1720,7 @@ static int eeprom_rd_phys(struct adapter *adap, unsigned int phys_addr, u32 *v)
 
 static int eeprom_wr_phys(struct adapter *adap, unsigned int phys_addr, u32 v)
 {
-        int vaddr = eeprom_ptov(phys_addr);
+        int vaddr = eeprom_ptov(phys_addr, adap->fn, EEPROMPFSIZE);
 
         if (vaddr >= 0)
                 vaddr = pci_write_vpd(adap->pdev, vaddr, sizeof(u32), &v);
@@ -1743,6 +1763,14 @@ static int set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
         aligned_offset = eeprom->offset & ~3;
         aligned_len = (eeprom->len + (eeprom->offset & 3) + 3) & ~3;
 
+        if (adapter->fn > 0) {
+                u32 start = 1024 + adapter->fn * EEPROMPFSIZE;
+
+                if (aligned_offset < start ||
+                    aligned_offset + aligned_len > start + EEPROMPFSIZE)
+                        return -EPERM;
+        }
+
         if (aligned_offset != eeprom->offset || aligned_len != eeprom->len) {
                 /*
                  * RMW possibly needed for first or last words.
@@ -1826,20 +1854,21 @@ static int set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
         return err;
 }
 
-#define TSO_FLAGS (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN)
-
-static int set_tso(struct net_device *dev, u32 value)
+static int cxgb_set_features(struct net_device *dev, u32 features)
 {
-        if (value)
-                dev->features |= TSO_FLAGS;
-        else
-                dev->features &= ~TSO_FLAGS;
-        return 0;
-}
+        const struct port_info *pi = netdev_priv(dev);
+        u32 changed = dev->features ^ features;
+        int err;
 
-static int set_flags(struct net_device *dev, u32 flags)
-{
-        return ethtool_op_set_flags(dev, flags, ETH_FLAG_RXHASH);
+        if (!(changed & NETIF_F_HW_VLAN_RX))
+                return 0;
+
+        err = t4_set_rxmode(pi->adapter, pi->adapter->fn, pi->viid, -1,
+                            -1, -1, -1,
+                            !!(features & NETIF_F_HW_VLAN_RX), true);
+        if (unlikely(err))
+                dev->features = features ^ NETIF_F_HW_VLAN_RX;
+        return err;
 }
 
 static int get_rss_table(struct net_device *dev, struct ethtool_rxfh_indir *p)
@@ -1949,13 +1978,9 @@ static struct ethtool_ops cxgb_ethtool_ops = {
         .set_eeprom        = set_eeprom,
         .get_pauseparam    = get_pauseparam,
         .set_pauseparam    = set_pauseparam,
-        .get_rx_csum       = get_rx_csum,
-        .set_rx_csum       = set_rx_csum,
-        .set_tx_csum       = ethtool_op_set_tx_ipv6_csum,
-        .set_sg            = ethtool_op_set_sg,
         .get_link          = ethtool_op_get_link,
         .get_strings       = get_strings,
-        .phys_id           = identify_port,
+        .set_phys_id       = identify_port,
         .nway_reset        = restart_autoneg,
         .get_sset_count    = get_sset_count,
         .get_ethtool_stats = get_stats,
@@ -1963,8 +1988,6 @@ static struct ethtool_ops cxgb_ethtool_ops = {
         .get_regs          = get_regs,
         .get_wol           = get_wol,
         .set_wol           = set_wol,
-        .set_tso           = set_tso,
-        .set_flags         = set_flags,
         .get_rxnfc         = get_rxnfc,
         .get_rxfh_indir    = get_rss_table,
         .set_rxfh_indir    = set_rss_table,
@@ -2026,6 +2049,7 @@ static const struct file_operations mem_debugfs_fops = {
         .owner   = THIS_MODULE,
         .open    = mem_open,
         .read    = mem_read,
+        .llseek  = default_llseek,
 };
 
 static void __devinit add_debugfs_mem(struct adapter *adap, const char *name,
@@ -2164,8 +2188,8 @@ static void mk_tid_release(struct sk_buff *skb, unsigned int chan,
  * Queue a TID release request and if necessary schedule a work queue to
  * process it.
  */
-void cxgb4_queue_tid_release(struct tid_info *t, unsigned int chan,
-                             unsigned int tid)
+static void cxgb4_queue_tid_release(struct tid_info *t, unsigned int chan,
+                                    unsigned int tid)
 {
         void **p = &t->tid_tab[tid];
         struct adapter *adap = container_of(t, struct adapter, tids);
@@ -2180,7 +2204,6 @@ void cxgb4_queue_tid_release(struct tid_info *t, unsigned int chan,
         }
         spin_unlock_bh(&adap->tid_release_lock);
 }
-EXPORT_SYMBOL(cxgb4_queue_tid_release);
 
 /*
  * Process the list of pending TID release requests.
@@ -2304,7 +2327,7 @@ int cxgb4_create_server(const struct net_device *dev, unsigned int stid,
         req->peer_port = htons(0);
         req->local_ip = sip;
         req->peer_ip = htonl(0);
-        chan = netdev2pinfo(adap->sge.ingr_map[queue]->netdev)->tx_chan;
+        chan = rxq_to_chan(&adap->sge, queue);
         req->opt0 = cpu_to_be64(TX_CHAN(chan));
         req->opt1 = cpu_to_be64(CONN_POLICY_ASK |
                                 SYN_RSS_ENABLE | SYN_RSS_QUEUE(queue));
@@ -2313,48 +2336,6 @@ int cxgb4_create_server(const struct net_device *dev, unsigned int stid,
 EXPORT_SYMBOL(cxgb4_create_server);
 
 /**
- *      cxgb4_create_server6 - create an IPv6 server
- *      @dev: the device
- *      @stid: the server TID
- *      @sip: local IPv6 address to bind server to
- *      @sport: the server's TCP port
- *      @queue: queue to direct messages from this server to
- *
- *      Create an IPv6 server for the given port and address.
- *      Returns <0 on error and one of the %NET_XMIT_* values on success.
- */
-int cxgb4_create_server6(const struct net_device *dev, unsigned int stid,
-                         const struct in6_addr *sip, __be16 sport,
-                         unsigned int queue)
-{
-        unsigned int chan;
-        struct sk_buff *skb;
-        struct adapter *adap;
-        struct cpl_pass_open_req6 *req;
-
-        skb = alloc_skb(sizeof(*req), GFP_KERNEL);
-        if (!skb)
-                return -ENOMEM;
-
-        adap = netdev2adap(dev);
-        req = (struct cpl_pass_open_req6 *)__skb_put(skb, sizeof(*req));
-        INIT_TP_WR(req, 0);
-        OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_PASS_OPEN_REQ6, stid));
-        req->local_port = sport;
-        req->peer_port = htons(0);
-        req->local_ip_hi = *(__be64 *)(sip->s6_addr);
-        req->local_ip_lo = *(__be64 *)(sip->s6_addr + 8);
-        req->peer_ip_hi = cpu_to_be64(0);
-        req->peer_ip_lo = cpu_to_be64(0);
-        chan = netdev2pinfo(adap->sge.ingr_map[queue]->netdev)->tx_chan;
-        req->opt0 = cpu_to_be64(TX_CHAN(chan));
-        req->opt1 = cpu_to_be64(CONN_POLICY_ASK |
-                                SYN_RSS_ENABLE | SYN_RSS_QUEUE(queue));
-        return t4_mgmt_tx(adap, skb);
-}
-EXPORT_SYMBOL(cxgb4_create_server6);
-
-/**
  *      cxgb4_best_mtu - find the entry in the MTU table closest to an MTU
  *      @mtus: the HW MTU table
  *      @mtu: the target MTU
@@ -2413,25 +2394,6 @@ unsigned int cxgb4_port_idx(const struct net_device *dev)
 }
 EXPORT_SYMBOL(cxgb4_port_idx);
 
-/**
- *      cxgb4_netdev_by_hwid - return the net device of a HW port
- *      @pdev: identifies the adapter
- *      @id: the HW port id
- *
- *      Return the net device associated with the interface with the given HW
- *      id.
- */
-struct net_device *cxgb4_netdev_by_hwid(struct pci_dev *pdev, unsigned int id)
-{
-        const struct adapter *adap = pci_get_drvdata(pdev);
-
-        if (!adap || id >= NCHAN)
-                return NULL;
-        id = adap->chan_map[id];
-        return id < MAX_NPORTS ? adap->port[id] : NULL;
-}
-EXPORT_SYMBOL(cxgb4_netdev_by_hwid);
-
 void cxgb4_get_tcp_stats(struct pci_dev *pdev, struct tp_tcp_stats *v4,
                          struct tp_tcp_stats *v6)
 {
@@ -2476,7 +2438,6 @@ static int netevent_cb(struct notifier_block *nb, unsigned long event,
         case NETEVENT_NEIGH_UPDATE:
                 check_neigh_update(data);
                 break;
-        case NETEVENT_PMTU_UPDATE:
         case NETEVENT_REDIRECT:
         default:
                 break;
@@ -2670,7 +2631,7 @@ static int cxgb_up(struct adapter *adap)
         } else {
                 err = request_irq(adap->pdev->irq, t4_intr_handler(adap),
                                   (adap->flags & USING_MSI) ? 0 : IRQF_SHARED,
-                                  adap->name, adap);
+                                  adap->port[0]->name, adap);
                 if (err)
                         goto irq_err;
         }
@@ -2715,13 +2676,14 @@ static int cxgb_open(struct net_device *dev)
         struct port_info *pi = netdev_priv(dev);
         struct adapter *adapter = pi->adapter;
 
+        netif_carrier_off(dev);
+
         if (!(adapter->flags & FULL_INIT_DONE)) {
                 err = cxgb_up(adapter);
                 if (err < 0)
                         return err;
         }
 
-        dev->real_num_tx_queues = pi->nqsets;
         err = link_start(dev);
         if (!err)
                 netif_tx_start_all_queues(dev);
@@ -2858,15 +2820,6 @@ static int cxgb_set_mac_addr(struct net_device *dev, void *p)
         return 0;
 }
 
-static void vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
-{
-        struct port_info *pi = netdev_priv(dev);
-
-        pi->vlan_grp = grp;
-        t4_set_rxmode(pi->adapter, pi->adapter->fn, pi->viid, -1, -1, -1, -1,
-                      grp != NULL, true);
-}
-
 #ifdef CONFIG_NET_POLL_CONTROLLER
 static void cxgb_netpoll(struct net_device *dev)
 {
@@ -2891,10 +2844,10 @@ static const struct net_device_ops cxgb4_netdev_ops = {
         .ndo_get_stats64      = cxgb_get_stats,
         .ndo_set_rx_mode      = cxgb_set_rxmode,
         .ndo_set_mac_address  = cxgb_set_mac_addr,
+        .ndo_set_features     = cxgb_set_features,
         .ndo_validate_addr    = eth_validate_addr,
         .ndo_do_ioctl         = cxgb_ioctl,
         .ndo_change_mtu       = cxgb_change_mtu,
-        .ndo_vlan_rx_register = vlan_rx_register,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller  = cxgb_netpoll,
 #endif
@@ -3061,12 +3014,16 @@ static int adap_init0(struct adapter *adap)
         params[2] = FW_PARAM_PFVF(L2T_END);
         params[3] = FW_PARAM_PFVF(FILTER_START);
         params[4] = FW_PARAM_PFVF(FILTER_END);
-        ret = t4_query_params(adap, adap->fn, adap->fn, 0, 5, params, val);
+        params[5] = FW_PARAM_PFVF(IQFLINT_START);
+        params[6] = FW_PARAM_PFVF(EQ_START);
+        ret = t4_query_params(adap, adap->fn, adap->fn, 0, 7, params, val);
         if (ret < 0)
                 goto bye;
         port_vec = val[0];
         adap->tids.ftid_base = val[3];
         adap->tids.nftids = val[4] - val[3] + 1;
+        adap->sge.ingr_start = val[5];
+        adap->sge.egr_start = val[6];
 
         if (c.ofldcaps) {
                 /* query offload-related parameters */
@@ -3496,49 +3453,53 @@ static int __devinit init_rss(struct adapter *adap)
         return 0;
 }
 
-static void __devinit print_port_info(struct adapter *adap)
+static void __devinit print_port_info(const struct net_device *dev)
 {
         static const char *base[] = {
                 "R XFI", "R XAUI", "T SGMII", "T XFI", "T XAUI", "KX4", "CX4",
-                "KX", "KR", "KR SFP+", "KR FEC"
+                "KX", "KR", "R SFP+", "KR/KX", "KR/KX/KX4"
         };
 
-        int i;
         char buf[80];
+        char *bufp = buf;
         const char *spd = "";
+        const struct port_info *pi = netdev_priv(dev);
+        const struct adapter *adap = pi->adapter;
 
         if (adap->params.pci.speed == PCI_EXP_LNKSTA_CLS_2_5GB)
                 spd = " 2.5 GT/s";
         else if (adap->params.pci.speed == PCI_EXP_LNKSTA_CLS_5_0GB)
                 spd = " 5 GT/s";
 
-        for_each_port(adap, i) {
-                struct net_device *dev = adap->port[i];
-                const struct port_info *pi = netdev_priv(dev);
-                char *bufp = buf;
+        if (pi->link_cfg.supported & FW_PORT_CAP_SPEED_100M)
+                bufp += sprintf(bufp, "100/");
+        if (pi->link_cfg.supported & FW_PORT_CAP_SPEED_1G)
+                bufp += sprintf(bufp, "1000/");
+        if (pi->link_cfg.supported & FW_PORT_CAP_SPEED_10G)
+                bufp += sprintf(bufp, "10G/");
+        if (bufp != buf)
+                --bufp;
+        sprintf(bufp, "BASE-%s", base[pi->port_type]);
 
-                if (!test_bit(i, &adap->registered_device_map))
-                        continue;
+        netdev_info(dev, "Chelsio %s rev %d %s %sNIC PCIe x%d%s%s\n",
+                    adap->params.vpd.id, adap->params.rev, buf,
+                    is_offload(adap) ? "R" : "", adap->params.pci.width, spd,
+                    (adap->flags & USING_MSIX) ? " MSI-X" :
+                    (adap->flags & USING_MSI) ? " MSI" : "");
+        netdev_info(dev, "S/N: %s, E/C: %s\n",
+                    adap->params.vpd.sn, adap->params.vpd.ec);
+}
 
-                if (pi->link_cfg.supported & FW_PORT_CAP_SPEED_100M)
-                        bufp += sprintf(bufp, "100/");
-                if (pi->link_cfg.supported & FW_PORT_CAP_SPEED_1G)
-                        bufp += sprintf(bufp, "1000/");
-                if (pi->link_cfg.supported & FW_PORT_CAP_SPEED_10G)
-                        bufp += sprintf(bufp, "10G/");
-                if (bufp != buf)
-                        --bufp;
-                sprintf(bufp, "BASE-%s", base[pi->port_type]);
+static void __devinit enable_pcie_relaxed_ordering(struct pci_dev *dev)
+{
+        u16 v;
+        int pos;
 
-                netdev_info(dev, "Chelsio %s rev %d %s %sNIC PCIe x%d%s%s\n",
-                            adap->params.vpd.id, adap->params.rev,
-                            buf, is_offload(adap) ? "R" : "",
-                            adap->params.pci.width, spd,
-                            (adap->flags & USING_MSIX) ? " MSI-X" :
-                            (adap->flags & USING_MSI) ? " MSI" : "");
-                if (adap->name == dev->name)
-                        netdev_info(dev, "S/N: %s, E/C: %s\n",
-                                    adap->params.vpd.sn, adap->params.vpd.ec);
+        pos = pci_pcie_cap(dev);
+        if (pos > 0) {
+                pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &v);
+                v |= PCI_EXP_DEVCTL_RELAX_EN;
+                pci_write_config_word(dev, pos + PCI_EXP_DEVCTL, v);
         }
 }
 
@@ -3566,6 +3527,7 @@ static void free_some_resources(struct adapter *adapter)
                 t4_fw_bye(adapter, adapter->fn);
 }
 
+#define TSO_FLAGS (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN)
 #define VLAN_FEAT (NETIF_F_SG | NETIF_F_IP_CSUM | TSO_FLAGS | \
                    NETIF_F_IPV6_CSUM | NETIF_F_HIGHDMA)
 
@@ -3616,6 +3578,7 @@ static int __devinit init_one(struct pci_dev *pdev,
         }
 
         pci_enable_pcie_error_reporting(pdev);
+        enable_pcie_relaxed_ordering(pdev);
         pci_set_master(pdev);
         pci_save_state(pdev);
 
@@ -3635,7 +3598,6 @@ static int __devinit init_one(struct pci_dev *pdev,
         adapter->pdev = pdev;
         adapter->pdev_dev = &pdev->dev;
         adapter->fn = func;
-        adapter->name = pci_name(pdev);
         adapter->msg_enable = dflt_msg_enable;
         memset(adapter->chan_map, 0xff, sizeof(adapter->chan_map));
 
@@ -3667,16 +3629,14 @@ static int __devinit init_one(struct pci_dev *pdev,
                 pi = netdev_priv(netdev);
                 pi->adapter = adapter;
                 pi->xact_addr_filt = -1;
-                pi->rx_offload = RX_CSO;
                 pi->port_id = i;
-                netif_carrier_off(netdev);
-                netif_tx_stop_all_queues(netdev);
                 netdev->irq = pdev->irq;
 
-                netdev->features |= NETIF_F_SG | TSO_FLAGS;
-                netdev->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
-                netdev->features |= NETIF_F_GRO | NETIF_F_RXHASH | highdma;
-                netdev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
+                netdev->hw_features = NETIF_F_SG | TSO_FLAGS |
+                        NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
+                        NETIF_F_RXCSUM | NETIF_F_RXHASH |
+                        NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
+                netdev->features |= netdev->hw_features | highdma;
                 netdev->vlan_features = netdev->features & VLAN_FEAT;
 
                 netdev->netdev_ops = &cxgb4_netdev_ops;
@@ -3727,27 +3687,24 @@ static int __devinit init_one(struct pci_dev *pdev,
          * register at least one net device.
          */
         for_each_port(adapter, i) {
+                pi = adap2pinfo(adapter, i);
+                netif_set_real_num_tx_queues(adapter->port[i], pi->nqsets);
+                netif_set_real_num_rx_queues(adapter->port[i], pi->nqsets);
+
                 err = register_netdev(adapter->port[i]);
                 if (err)
-                        dev_warn(&pdev->dev,
-                                 "cannot register net device %s, skipping\n",
-                                 adapter->port[i]->name);
-                else {
-                        /*
-                         * Change the name we use for messages to the name of
-                         * the first successfully registered interface.
-                         */
-                        if (!adapter->registered_device_map)
-                                adapter->name = adapter->port[i]->name;
-
-                        __set_bit(i, &adapter->registered_device_map);
-                        adapter->chan_map[adap2pinfo(adapter, i)->tx_chan] = i;
-                }
+                        break;
+                adapter->chan_map[pi->tx_chan] = i;
+                print_port_info(adapter->port[i]);
         }
-        if (!adapter->registered_device_map) {
+        if (i == 0) {
                 dev_err(&pdev->dev, "could not register any net devices\n");
                 goto out_free_dev;
         }
+        if (err) {
+                dev_warn(&pdev->dev, "only %d net devices registered\n", i);
+                err = 0;
+        };
 
         if (cxgb4_debugfs_root) {
                 adapter->debugfs_root = debugfs_create_dir(pci_name(pdev),
@@ -3758,8 +3715,6 @@ static int __devinit init_one(struct pci_dev *pdev,
         if (is_offload(adapter))
                 attach_ulds(adapter);
 
-        print_port_info(adapter);
-
 sriov:
 #ifdef CONFIG_PCI_IOV
         if (func < ARRAY_SIZE(num_vf) && num_vf[func] > 0)
@@ -3798,7 +3753,7 @@ static void __devexit remove_one(struct pci_dev *pdev)
                         detach_ulds(adapter);
 
                 for_each_port(adapter, i)
-                        if (test_bit(i, &adapter->registered_device_map))
+                        if (adapter->port[i]->reg_state == NETREG_REGISTERED)
                                 unregister_netdev(adapter->port[i]);
 
                 if (adapter->debugfs_root)
@@ -3814,7 +3769,7 @@ static void __devexit remove_one(struct pci_dev *pdev)
                 pci_disable_device(pdev);
                 pci_release_regions(pdev);
                 pci_set_drvdata(pdev, NULL);
-        } else if (PCI_FUNC(pdev->devfn) > 0)
+        } else
                 pci_release_regions(pdev);
 }
 
diff --git a/drivers/net/cxgb4/cxgb4_uld.h b/drivers/net/cxgb4/cxgb4_uld.h
index 85d74e751ce0..1b48c0170145 100644
--- a/drivers/net/cxgb4/cxgb4_uld.h
+++ b/drivers/net/cxgb4/cxgb4_uld.h
@@ -139,16 +139,11 @@ int cxgb4_alloc_stid(struct tid_info *t, int family, void *data);
 void cxgb4_free_atid(struct tid_info *t, unsigned int atid);
 void cxgb4_free_stid(struct tid_info *t, unsigned int stid, int family);
 void cxgb4_remove_tid(struct tid_info *t, unsigned int qid, unsigned int tid);
-void cxgb4_queue_tid_release(struct tid_info *t, unsigned int chan,
-                             unsigned int tid);
 
 struct in6_addr;
 
 int cxgb4_create_server(const struct net_device *dev, unsigned int stid,
                         __be32 sip, __be16 sport, unsigned int queue);
-int cxgb4_create_server6(const struct net_device *dev, unsigned int stid,
-                         const struct in6_addr *sip, __be16 sport,
-                         unsigned int queue);
 
 static inline void set_wr_txq(struct sk_buff *skb, int prio, int queue)
 {
@@ -233,7 +228,6 @@ int cxgb4_ofld_send(struct net_device *dev, struct sk_buff *skb);
 unsigned int cxgb4_port_chan(const struct net_device *dev);
 unsigned int cxgb4_port_viid(const struct net_device *dev);
 unsigned int cxgb4_port_idx(const struct net_device *dev);
-struct net_device *cxgb4_netdev_by_hwid(struct pci_dev *pdev, unsigned int id);
 unsigned int cxgb4_best_mtu(const unsigned short *mtus, unsigned short mtu,
                             unsigned int *idx);
 void cxgb4_get_tcp_stats(struct pci_dev *pdev, struct tp_tcp_stats *v4,
diff --git a/drivers/net/cxgb4/l2t.c b/drivers/net/cxgb4/l2t.c
index e8f0f55e9d08..a2d323c473f8 100644
--- a/drivers/net/cxgb4/l2t.c
+++ b/drivers/net/cxgb4/l2t.c
@@ -481,40 +481,6 @@ 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 entries 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/cxgb4/l2t.h b/drivers/net/cxgb4/l2t.h
index 643f27ed3cf4..7bd8f42378ff 100644
--- a/drivers/net/cxgb4/l2t.h
+++ b/drivers/net/cxgb4/l2t.h
@@ -100,9 +100,6 @@ 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/cxgb4/sge.c b/drivers/net/cxgb4/sge.c
index bf38cfc57565..56adf448b9fe 100644
--- a/drivers/net/cxgb4/sge.c
+++ b/drivers/net/cxgb4/sge.c
@@ -39,6 +39,7 @@
 #include <linux/ip.h>
 #include <linux/dma-mapping.h>
 #include <linux/jiffies.h>
+#include <linux/prefetch.h>
 #include <net/ipv6.h>
 #include <net/tcp.h>
 #include "cxgb4.h"
@@ -557,7 +558,8 @@ out:	cred = q->avail - cred;
 
         if (unlikely(fl_starving(q))) {
                 smp_wmb();
-                set_bit(q->cntxt_id, adap->sge.starving_fl);
+                set_bit(q->cntxt_id - adap->sge.egr_start,
+                        adap->sge.starving_fl);
         }
 
         return cred;
@@ -578,6 +580,7 @@ static inline void __refill_fl(struct adapter *adap, struct sge_fl *fl)
  *      @phys: the physical address of the allocated ring
  *      @metadata: address of the array holding the SW state for the ring
  *      @stat_size: extra space in HW ring for status information
+ *      @node: preferred node for memory allocations
  *
  *      Allocates resources for an SGE descriptor ring, such as Tx queues,
  *      free buffer lists, or response queues.  Each SGE ring requires
@@ -589,7 +592,7 @@ static inline void __refill_fl(struct adapter *adap, struct sge_fl *fl)
  */
 static void *alloc_ring(struct device *dev, size_t nelem, size_t elem_size,
                         size_t sw_size, dma_addr_t *phys, void *metadata,
-                        size_t stat_size)
+                        size_t stat_size, int node)
 {
         size_t len = nelem * elem_size + stat_size;
         void *s = NULL;
@@ -598,7 +601,7 @@ static void *alloc_ring(struct device *dev, size_t nelem, size_t elem_size,
         if (!p)
                 return NULL;
         if (sw_size) {
-                s = kcalloc(nelem, sw_size, GFP_KERNEL);
+                s = kzalloc_node(nelem * sw_size, GFP_KERNEL, node);
 
                 if (!s) {
                         dma_free_coherent(dev, len, p, *phys);
@@ -974,7 +977,7 @@ out_free:	dev_kfree_skb(skb);
         }
 
         cpl->ctrl0 = htonl(TXPKT_OPCODE(CPL_TX_PKT_XT) |
-                           TXPKT_INTF(pi->tx_chan) | TXPKT_PF(0));
+                           TXPKT_INTF(pi->tx_chan) | TXPKT_PF(adap->fn));
         cpl->pack = htons(0);
         cpl->len = htons(skb->len);
         cpl->ctrl1 = cpu_to_be64(cntrl);
@@ -1213,7 +1216,8 @@ static void txq_stop_maperr(struct sge_ofld_txq *q)
 {
         q->mapping_err++;
         q->q.stops++;
-        set_bit(q->q.cntxt_id, q->adap->sge.txq_maperr);
+        set_bit(q->q.cntxt_id - q->adap->sge.egr_start,
+                q->adap->sge.txq_maperr);
 }
 
 /**
@@ -1528,18 +1532,11 @@ static void do_gro(struct sge_eth_rxq *rxq, const struct pkt_gl *gl,
                 skb->rxhash = (__force u32)pkt->rsshdr.hash_val;
 
         if (unlikely(pkt->vlan_ex)) {
-                struct port_info *pi = netdev_priv(rxq->rspq.netdev);
-                struct vlan_group *grp = pi->vlan_grp;
-
+                __vlan_hwaccel_put_tag(skb, ntohs(pkt->vlan));
                 rxq->stats.vlan_ex++;
-                if (likely(grp)) {
-                        ret = vlan_gro_frags(&rxq->rspq.napi, grp,
-                                             ntohs(pkt->vlan));
-                        goto stats;
-                }
         }
         ret = napi_gro_frags(&rxq->rspq.napi);
-stats:  if (ret == GRO_HELD)
+        if (ret == GRO_HELD)
                 rxq->stats.lro_pkts++;
         else if (ret == GRO_MERGED || ret == GRO_MERGED_FREE)
                 rxq->stats.lro_merged++;
@@ -1560,7 +1557,6 @@ int t4_ethrx_handler(struct sge_rspq *q, const __be64 *rsp,
 {
         bool csum_ok;
         struct sk_buff *skb;
-        struct port_info *pi;
         const struct cpl_rx_pkt *pkt;
         struct sge_eth_rxq *rxq = container_of(q, struct sge_eth_rxq, rspq);
 
@@ -1588,10 +1584,9 @@ int t4_ethrx_handler(struct sge_rspq *q, const __be64 *rsp,
         if (skb->dev->features & NETIF_F_RXHASH)
                 skb->rxhash = (__force u32)pkt->rsshdr.hash_val;
 
-        pi = netdev_priv(skb->dev);
         rxq->stats.pkts++;
 
-        if (csum_ok && (pi->rx_offload & RX_CSO) &&
+        if (csum_ok && (q->netdev->features & NETIF_F_RXCSUM) &&
             (pkt->l2info & htonl(RXF_UDP | RXF_TCP))) {
                 if (!pkt->ip_frag) {
                         skb->ip_summed = CHECKSUM_UNNECESSARY;
@@ -1603,19 +1598,13 @@ int t4_ethrx_handler(struct sge_rspq *q, const __be64 *rsp,
                         rxq->stats.rx_cso++;
                 }
         } else
-                skb->ip_summed = CHECKSUM_NONE;
+                skb_checksum_none_assert(skb);
 
         if (unlikely(pkt->vlan_ex)) {
-                struct vlan_group *grp = pi->vlan_grp;
-
+                __vlan_hwaccel_put_tag(skb, ntohs(pkt->vlan));
                 rxq->stats.vlan_ex++;
-                if (likely(grp))
-                        vlan_hwaccel_receive_skb(skb, grp, ntohs(pkt->vlan));
-                else
-                        dev_kfree_skb_any(skb);
-        } else
-                netif_receive_skb(skb);
-
+        }
+        netif_receive_skb(skb);
         return 0;
 }
 
@@ -1835,6 +1824,7 @@ static unsigned int process_intrq(struct adapter *adap)
                 if (RSPD_TYPE(rc->type_gen) == RSP_TYPE_INTR) {
                         unsigned int qid = ntohl(rc->pldbuflen_qid);
 
+                        qid -= adap->sge.ingr_start;
                         napi_schedule(&adap->sge.ingr_map[qid]->napi);
                 }
 
@@ -1992,7 +1982,7 @@ int t4_sge_alloc_rxq(struct adapter *adap, struct sge_rspq *iq, bool fwevtq,
         iq->size = roundup(iq->size, 16);
 
         iq->desc = alloc_ring(adap->pdev_dev, iq->size, iq->iqe_len, 0,
-                              &iq->phys_addr, NULL, 0);
+                              &iq->phys_addr, NULL, 0, NUMA_NO_NODE);
         if (!iq->desc)
                 return -ENOMEM;
 
@@ -2018,12 +2008,14 @@ int t4_sge_alloc_rxq(struct adapter *adap, struct sge_rspq *iq, bool fwevtq,
                 fl->size = roundup(fl->size, 8);
                 fl->desc = alloc_ring(adap->pdev_dev, fl->size, sizeof(__be64),
                                       sizeof(struct rx_sw_desc), &fl->addr,
-                                      &fl->sdesc, STAT_LEN);
+                                      &fl->sdesc, STAT_LEN, NUMA_NO_NODE);
                 if (!fl->desc)
                         goto fl_nomem;
 
                 flsz = fl->size / 8 + STAT_LEN / sizeof(struct tx_desc);
                 c.iqns_to_fl0congen = htonl(FW_IQ_CMD_FL0PACKEN |
+                                            FW_IQ_CMD_FL0FETCHRO(1) |
+                                            FW_IQ_CMD_FL0DATARO(1) |
                                             FW_IQ_CMD_FL0PADEN);
                 c.fl0dcaen_to_fl0cidxfthresh = htons(FW_IQ_CMD_FL0FBMIN(2) |
                                 FW_IQ_CMD_FL0FBMAX(3));
@@ -2050,14 +2042,14 @@ int t4_sge_alloc_rxq(struct adapter *adap, struct sge_rspq *iq, bool fwevtq,
         /* set offset to -1 to distinguish ingress queues without FL */
         iq->offset = fl ? 0 : -1;
 
-        adap->sge.ingr_map[iq->cntxt_id] = iq;
+        adap->sge.ingr_map[iq->cntxt_id - adap->sge.ingr_start] = iq;
 
         if (fl) {
                 fl->cntxt_id = ntohs(c.fl0id);
                 fl->avail = fl->pend_cred = 0;
                 fl->pidx = fl->cidx = 0;
                 fl->alloc_failed = fl->large_alloc_failed = fl->starving = 0;
-                adap->sge.egr_map[fl->cntxt_id] = fl;
+                adap->sge.egr_map[fl->cntxt_id - adap->sge.egr_start] = fl;
                 refill_fl(adap, fl, fl_cap(fl), GFP_KERNEL);
         }
         return 0;
@@ -2087,7 +2079,7 @@ static void init_txq(struct adapter *adap, struct sge_txq *q, unsigned int id)
         q->stops = q->restarts = 0;
         q->stat = (void *)&q->desc[q->size];
         q->cntxt_id = id;
-        adap->sge.egr_map[id] = q;
+        adap->sge.egr_map[id - adap->sge.egr_start] = q;
 }
 
 int t4_sge_alloc_eth_txq(struct adapter *adap, struct sge_eth_txq *txq,
@@ -2103,7 +2095,8 @@ int t4_sge_alloc_eth_txq(struct adapter *adap, struct sge_eth_txq *txq,
 
         txq->q.desc = alloc_ring(adap->pdev_dev, txq->q.size,
                         sizeof(struct tx_desc), sizeof(struct tx_sw_desc),
-                        &txq->q.phys_addr, &txq->q.sdesc, STAT_LEN);
+                        &txq->q.phys_addr, &txq->q.sdesc, STAT_LEN,
+                        netdev_queue_numa_node_read(netdevq));
         if (!txq->q.desc)
                 return -ENOMEM;
 
@@ -2116,6 +2109,7 @@ int t4_sge_alloc_eth_txq(struct adapter *adap, struct sge_eth_txq *txq,
         c.viid_pkd = htonl(FW_EQ_ETH_CMD_VIID(pi->viid));
         c.fetchszm_to_iqid = htonl(FW_EQ_ETH_CMD_HOSTFCMODE(2) |
                                    FW_EQ_ETH_CMD_PCIECHN(pi->tx_chan) |
+                                   FW_EQ_ETH_CMD_FETCHRO(1) |
                                    FW_EQ_ETH_CMD_IQID(iqid));
         c.dcaen_to_eqsize = htonl(FW_EQ_ETH_CMD_FBMIN(2) |
                                   FW_EQ_ETH_CMD_FBMAX(3) |
@@ -2154,7 +2148,7 @@ int t4_sge_alloc_ctrl_txq(struct adapter *adap, struct sge_ctrl_txq *txq,
 
         txq->q.desc = alloc_ring(adap->pdev_dev, nentries,
                                  sizeof(struct tx_desc), 0, &txq->q.phys_addr,
-                                 NULL, 0);
+                                 NULL, 0, NUMA_NO_NODE);
         if (!txq->q.desc)
                 return -ENOMEM;
 
@@ -2168,6 +2162,7 @@ int t4_sge_alloc_ctrl_txq(struct adapter *adap, struct sge_ctrl_txq *txq,
         c.physeqid_pkd = htonl(0);
         c.fetchszm_to_iqid = htonl(FW_EQ_CTRL_CMD_HOSTFCMODE(2) |
                                    FW_EQ_CTRL_CMD_PCIECHN(pi->tx_chan) |
+                                   FW_EQ_CTRL_CMD_FETCHRO |
                                    FW_EQ_CTRL_CMD_IQID(iqid));
         c.dcaen_to_eqsize = htonl(FW_EQ_CTRL_CMD_FBMIN(2) |
                                   FW_EQ_CTRL_CMD_FBMAX(3) |
@@ -2204,7 +2199,8 @@ int t4_sge_alloc_ofld_txq(struct adapter *adap, struct sge_ofld_txq *txq,
 
         txq->q.desc = alloc_ring(adap->pdev_dev, txq->q.size,
                         sizeof(struct tx_desc), sizeof(struct tx_sw_desc),
-                        &txq->q.phys_addr, &txq->q.sdesc, STAT_LEN);
+                        &txq->q.phys_addr, &txq->q.sdesc, STAT_LEN,
+                        NUMA_NO_NODE);
         if (!txq->q.desc)
                 return -ENOMEM;
 
@@ -2217,6 +2213,7 @@ int t4_sge_alloc_ofld_txq(struct adapter *adap, struct sge_ofld_txq *txq,
                                  FW_EQ_OFLD_CMD_EQSTART | FW_LEN16(c));
         c.fetchszm_to_iqid = htonl(FW_EQ_OFLD_CMD_HOSTFCMODE(2) |
                                    FW_EQ_OFLD_CMD_PCIECHN(pi->tx_chan) |
+                                   FW_EQ_OFLD_CMD_FETCHRO(1) |
                                    FW_EQ_OFLD_CMD_IQID(iqid));
         c.dcaen_to_eqsize = htonl(FW_EQ_OFLD_CMD_FBMIN(2) |
                                   FW_EQ_OFLD_CMD_FBMAX(3) |
@@ -2259,7 +2256,7 @@ static void free_rspq_fl(struct adapter *adap, struct sge_rspq *rq,
 {
         unsigned int fl_id = fl ? fl->cntxt_id : 0xffff;
 
-        adap->sge.ingr_map[rq->cntxt_id] = NULL;
+        adap->sge.ingr_map[rq->cntxt_id - adap->sge.ingr_start] = NULL;
         t4_iq_free(adap, adap->fn, adap->fn, 0, FW_IQ_TYPE_FL_INT_CAP,
                    rq->cntxt_id, fl_id, 0xffff);
         dma_free_coherent(adap->pdev_dev, (rq->size + 1) * rq->iqe_len,
diff --git a/drivers/net/cxgb4/t4_hw.c b/drivers/net/cxgb4/t4_hw.c
index 9e1a4b49b47a..d1ec111aebd8 100644
--- a/drivers/net/cxgb4/t4_hw.c
+++ b/drivers/net/cxgb4/t4_hw.c
@@ -120,30 +120,6 @@ static void t4_read_indirect(struct adapter *adap, unsigned int addr_reg,
         }
 }
 
-#if 0
-/**
- *      t4_write_indirect - write indirectly addressed registers
- *      @adap: the adapter
- *      @addr_reg: register holding the indirect addresses
- *      @data_reg: register holding the value for the indirect registers
- *      @vals: values to write
- *      @nregs: how many indirect registers to write
- *      @start_idx: address of first indirect register to write
- *
- *      Writes a sequential block of registers that are accessed indirectly
- *      through an address/data register pair.
- */
-static 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)
-{
-        while (nregs--) {
-                t4_write_reg(adap, addr_reg, start_idx++);
-                t4_write_reg(adap, data_reg, *vals++);
-        }
-}
-#endif
-
 /*
  * Get the reply to a mailbox command and store it in @rpl in big-endian order.
  */
@@ -207,7 +183,7 @@ static void dump_mbox(struct adapter *adap, int mbox, u32 data_reg)
 int t4_wr_mbox_meat(struct adapter *adap, int mbox, const void *cmd, int size,
                     void *rpl, bool sleep_ok)
 {
-        static int delay[] = {
+        static const int delay[] = {
                 1, 1, 3, 5, 10, 10, 20, 50, 100, 200
         };
 
@@ -354,18 +330,6 @@ int t4_edc_read(struct adapter *adap, int idx, u32 addr, __be32 *data, u64 *ecc)
         return 0;
 }
 
-/*
- * Partial EEPROM Vital Product Data structure.  Includes only the ID and
- * VPD-R header.
- */
-struct t4_vpd_hdr {
-        u8  id_tag;
-        u8  id_len[2];
-        u8  id_data[ID_LEN];
-        u8  vpdr_tag;
-        u8  vpdr_len[2];
-};
-
 #define EEPROM_STAT_ADDR   0x7bfc
 #define VPD_BASE           0
 #define VPD_LEN            512
@@ -394,25 +358,38 @@ int t4_seeprom_wp(struct adapter *adapter, bool enable)
 static int get_vpd_params(struct adapter *adapter, struct vpd_params *p)
 {
         int i, ret;
-        int ec, sn, v2;
+        int ec, sn;
         u8 vpd[VPD_LEN], csum;
-        unsigned int vpdr_len;
-        const struct t4_vpd_hdr *v;
+        unsigned int vpdr_len, kw_offset, id_len;
 
         ret = pci_read_vpd(adapter->pdev, VPD_BASE, sizeof(vpd), vpd);
         if (ret < 0)
                 return ret;
 
-        v = (const struct t4_vpd_hdr *)vpd;
-        vpdr_len = pci_vpd_lrdt_size(&v->vpdr_tag);
-        if (vpdr_len + sizeof(struct t4_vpd_hdr) > VPD_LEN) {
+        if (vpd[0] != PCI_VPD_LRDT_ID_STRING) {
+                dev_err(adapter->pdev_dev, "missing VPD ID string\n");
+                return -EINVAL;
+        }
+
+        id_len = pci_vpd_lrdt_size(vpd);
+        if (id_len > ID_LEN)
+                id_len = ID_LEN;
+
+        i = pci_vpd_find_tag(vpd, 0, VPD_LEN, PCI_VPD_LRDT_RO_DATA);
+        if (i < 0) {
+                dev_err(adapter->pdev_dev, "missing VPD-R section\n");
+                return -EINVAL;
+        }
+
+        vpdr_len = pci_vpd_lrdt_size(&vpd[i]);
+        kw_offset = i + PCI_VPD_LRDT_TAG_SIZE;
+        if (vpdr_len + kw_offset > VPD_LEN) {
                 dev_err(adapter->pdev_dev, "bad VPD-R length %u\n", vpdr_len);
                 return -EINVAL;
         }
 
 #define FIND_VPD_KW(var, name) do { \
-        var = pci_vpd_find_info_keyword(&v->id_tag, sizeof(struct t4_vpd_hdr), \
-                                        vpdr_len, name); \
+        var = pci_vpd_find_info_keyword(vpd, kw_offset, vpdr_len, name); \
         if (var < 0) { \
                 dev_err(adapter->pdev_dev, "missing VPD keyword " name "\n"); \
                 return -EINVAL; \
@@ -432,11 +409,9 @@ static int get_vpd_params(struct adapter *adapter, struct vpd_params *p)
 
         FIND_VPD_KW(ec, "EC");
         FIND_VPD_KW(sn, "SN");
-        FIND_VPD_KW(v2, "V2");
 #undef FIND_VPD_KW
 
-        p->cclk = simple_strtoul(vpd + v2, NULL, 10);
-        memcpy(p->id, v->id_data, ID_LEN);
+        memcpy(p->id, vpd + PCI_VPD_LRDT_TAG_SIZE, id_len);
         strim(p->id);
         memcpy(p->ec, vpd + ec, EC_LEN);
         strim(p->ec);
@@ -908,7 +883,7 @@ struct intr_info {
  *
  *      A table driven interrupt handler that applies a set of masks to an
  *      interrupt status word and performs the corresponding actions if the
- *      interrupts described by the mask have occured.  The actions include
+ *      interrupts described by the mask have occurred.  The actions include
  *      optionally emitting a warning or alert message.  The table is terminated
  *      by an entry specifying mask 0.  Returns the number of fatal interrupt
  *      conditions.
@@ -943,7 +918,7 @@ static int t4_handle_intr_status(struct adapter *adapter, unsigned int reg,
  */
 static void pcie_intr_handler(struct adapter *adapter)
 {
-        static struct intr_info sysbus_intr_info[] = {
+        static const struct intr_info sysbus_intr_info[] = {
                 { RNPP, "RXNP array parity error", -1, 1 },
                 { RPCP, "RXPC array parity error", -1, 1 },
                 { RCIP, "RXCIF array parity error", -1, 1 },
@@ -951,7 +926,7 @@ static void pcie_intr_handler(struct adapter *adapter)
                 { RFTP, "RXFT array parity error", -1, 1 },
                 { 0 }
         };
-        static struct intr_info pcie_port_intr_info[] = {
+        static const struct intr_info pcie_port_intr_info[] = {
                 { TPCP, "TXPC array parity error", -1, 1 },
                 { TNPP, "TXNP array parity error", -1, 1 },
                 { TFTP, "TXFT array parity error", -1, 1 },
@@ -963,7 +938,7 @@ static void pcie_intr_handler(struct adapter *adapter)
                 { TDUE, "Tx uncorrectable data error", -1, 1 },
                 { 0 }
         };
-        static struct intr_info pcie_intr_info[] = {
+        static const struct intr_info pcie_intr_info[] = {
                 { MSIADDRLPERR, "MSI AddrL parity error", -1, 1 },
                 { MSIADDRHPERR, "MSI AddrH parity error", -1, 1 },
                 { MSIDATAPERR, "MSI data parity error", -1, 1 },
@@ -1015,7 +990,7 @@ static void pcie_intr_handler(struct adapter *adapter)
  */
 static void tp_intr_handler(struct adapter *adapter)
 {
-        static struct intr_info tp_intr_info[] = {
+        static const struct intr_info tp_intr_info[] = {
                 { 0x3fffffff, "TP parity error", -1, 1 },
                 { FLMTXFLSTEMPTY, "TP out of Tx pages", -1, 1 },
                 { 0 }
@@ -1032,7 +1007,7 @@ static void sge_intr_handler(struct adapter *adapter)
 {
         u64 v;
 
-        static struct intr_info sge_intr_info[] = {
+        static const struct intr_info sge_intr_info[] = {
                 { ERR_CPL_EXCEED_IQE_SIZE,
                   "SGE received CPL exceeding IQE size", -1, 1 },
                 { ERR_INVALID_CIDX_INC,
@@ -1077,7 +1052,7 @@ static void sge_intr_handler(struct adapter *adapter)
  */
 static void cim_intr_handler(struct adapter *adapter)
 {
-        static struct intr_info cim_intr_info[] = {
+        static const struct intr_info cim_intr_info[] = {
                 { PREFDROPINT, "CIM control register prefetch drop", -1, 1 },
                 { OBQPARERR, "CIM OBQ parity error", -1, 1 },
                 { IBQPARERR, "CIM IBQ parity error", -1, 1 },
@@ -1087,7 +1062,7 @@ static void cim_intr_handler(struct adapter *adapter)
                 { TIEQOUTPARERRINT, "CIM TIEQ incoming parity error", -1, 1 },
                 { 0 }
         };
-        static struct intr_info cim_upintr_info[] = {
+        static const struct intr_info cim_upintr_info[] = {
                 { RSVDSPACEINT, "CIM reserved space access", -1, 1 },
                 { ILLTRANSINT, "CIM illegal transaction", -1, 1 },
                 { ILLWRINT, "CIM illegal write", -1, 1 },
@@ -1134,7 +1109,7 @@ static void cim_intr_handler(struct adapter *adapter)
  */
 static void ulprx_intr_handler(struct adapter *adapter)
 {
-        static struct intr_info ulprx_intr_info[] = {
+        static const struct intr_info ulprx_intr_info[] = {
                 { 0x1800000, "ULPRX context error", -1, 1 },
                 { 0x7fffff, "ULPRX parity error", -1, 1 },
                 { 0 }
@@ -1149,7 +1124,7 @@ static void ulprx_intr_handler(struct adapter *adapter)
  */
 static void ulptx_intr_handler(struct adapter *adapter)
 {
-        static struct intr_info ulptx_intr_info[] = {
+        static const struct intr_info ulptx_intr_info[] = {
                 { PBL_BOUND_ERR_CH3, "ULPTX channel 3 PBL out of bounds", -1,
                   0 },
                 { PBL_BOUND_ERR_CH2, "ULPTX channel 2 PBL out of bounds", -1,
@@ -1171,7 +1146,7 @@ static void ulptx_intr_handler(struct adapter *adapter)
  */
 static void pmtx_intr_handler(struct adapter *adapter)
 {
-        static struct intr_info pmtx_intr_info[] = {
+        static const struct intr_info pmtx_intr_info[] = {
                 { PCMD_LEN_OVFL0, "PMTX channel 0 pcmd too large", -1, 1 },
                 { PCMD_LEN_OVFL1, "PMTX channel 1 pcmd too large", -1, 1 },
                 { PCMD_LEN_OVFL2, "PMTX channel 2 pcmd too large", -1, 1 },
@@ -1193,7 +1168,7 @@ static void pmtx_intr_handler(struct adapter *adapter)
  */
 static void pmrx_intr_handler(struct adapter *adapter)
 {
-        static struct intr_info pmrx_intr_info[] = {
+        static const struct intr_info pmrx_intr_info[] = {
                 { ZERO_E_CMD_ERROR, "PMRX 0-length pcmd", -1, 1 },
                 { PMRX_FRAMING_ERROR, "PMRX framing error", -1, 1 },
                 { OCSPI_PAR_ERROR, "PMRX ocspi parity error", -1, 1 },
@@ -1212,7 +1187,7 @@ static void pmrx_intr_handler(struct adapter *adapter)
  */
 static void cplsw_intr_handler(struct adapter *adapter)
 {
-        static struct intr_info cplsw_intr_info[] = {
+        static const struct intr_info cplsw_intr_info[] = {
                 { CIM_OP_MAP_PERR, "CPLSW CIM op_map parity error", -1, 1 },
                 { CIM_OVFL_ERROR, "CPLSW CIM overflow", -1, 1 },
                 { TP_FRAMING_ERROR, "CPLSW TP framing error", -1, 1 },
@@ -1231,7 +1206,7 @@ static void cplsw_intr_handler(struct adapter *adapter)
  */
 static void le_intr_handler(struct adapter *adap)
 {
-        static struct intr_info le_intr_info[] = {
+        static const struct intr_info le_intr_info[] = {
                 { LIPMISS, "LE LIP miss", -1, 0 },
                 { LIP0, "LE 0 LIP error", -1, 0 },
                 { PARITYERR, "LE parity error", -1, 1 },
@@ -1249,11 +1224,11 @@ static void le_intr_handler(struct adapter *adap)
  */
 static void mps_intr_handler(struct adapter *adapter)
 {
-        static struct intr_info mps_rx_intr_info[] = {
+        static const struct intr_info mps_rx_intr_info[] = {
                 { 0xffffff, "MPS Rx parity error", -1, 1 },
                 { 0 }
         };
-        static struct intr_info mps_tx_intr_info[] = {
+        static const struct intr_info mps_tx_intr_info[] = {
                 { TPFIFO, "MPS Tx TP FIFO parity error", -1, 1 },
                 { NCSIFIFO, "MPS Tx NC-SI FIFO parity error", -1, 1 },
                 { TXDATAFIFO, "MPS Tx data FIFO parity error", -1, 1 },
@@ -1263,25 +1238,25 @@ static void mps_intr_handler(struct adapter *adapter)
                 { FRMERR, "MPS Tx framing error", -1, 1 },
                 { 0 }
         };
-        static struct intr_info mps_trc_intr_info[] = {
+        static const struct intr_info mps_trc_intr_info[] = {
                 { FILTMEM, "MPS TRC filter parity error", -1, 1 },
                 { PKTFIFO, "MPS TRC packet FIFO parity error", -1, 1 },
                 { MISCPERR, "MPS TRC misc parity error", -1, 1 },
                 { 0 }
         };
-        static struct intr_info mps_stat_sram_intr_info[] = {
+        static const struct intr_info mps_stat_sram_intr_info[] = {
                 { 0x1fffff, "MPS statistics SRAM parity error", -1, 1 },
                 { 0 }
         };
-        static struct intr_info mps_stat_tx_intr_info[] = {
+        static const struct intr_info mps_stat_tx_intr_info[] = {
                 { 0xfffff, "MPS statistics Tx FIFO parity error", -1, 1 },
                 { 0 }
         };
-        static struct intr_info mps_stat_rx_intr_info[] = {
+        static const struct intr_info mps_stat_rx_intr_info[] = {
                 { 0xffffff, "MPS statistics Rx FIFO parity error", -1, 1 },
                 { 0 }
         };
-        static struct intr_info mps_cls_intr_info[] = {
+        static const struct intr_info mps_cls_intr_info[] = {
                 { MATCHSRAM, "MPS match SRAM parity error", -1, 1 },
                 { MATCHTCAM, "MPS match TCAM parity error", -1, 1 },
                 { HASHSRAM, "MPS hash SRAM parity error", -1, 1 },
@@ -1380,7 +1355,7 @@ static void ma_intr_handler(struct adapter *adap)
  */
 static void smb_intr_handler(struct adapter *adap)
 {
-        static struct intr_info smb_intr_info[] = {
+        static const struct intr_info smb_intr_info[] = {
                 { MSTTXFIFOPARINT, "SMB master Tx FIFO parity error", -1, 1 },
                 { MSTRXFIFOPARINT, "SMB master Rx FIFO parity error", -1, 1 },
                 { SLVFIFOPARINT, "SMB slave FIFO parity error", -1, 1 },
@@ -1396,7 +1371,7 @@ static void smb_intr_handler(struct adapter *adap)
  */
 static void ncsi_intr_handler(struct adapter *adap)
 {
-        static struct intr_info ncsi_intr_info[] = {
+        static const struct intr_info ncsi_intr_info[] = {
                 { CIM_DM_PRTY_ERR, "NC-SI CIM parity error", -1, 1 },
                 { MPS_DM_PRTY_ERR, "NC-SI MPS parity error", -1, 1 },
                 { TXFIFO_PRTY_ERR, "NC-SI Tx FIFO parity error", -1, 1 },
@@ -1434,7 +1409,7 @@ static void xgmac_intr_handler(struct adapter *adap, int port)
  */
 static void pl_intr_handler(struct adapter *adap)
 {
-        static struct intr_info pl_intr_info[] = {
+        static const struct intr_info pl_intr_info[] = {
                 { FATALPERR, "T4 fatal parity error", -1, 1 },
                 { PERRVFID, "PL VFID_MAP parity error", -1, 1 },
                 { 0 }
@@ -1560,44 +1535,6 @@ void t4_intr_disable(struct adapter *adapter)
 }
 
 /**
- *      t4_intr_clear - clear all interrupts
- *      @adapter: the adapter whose interrupts should be cleared
- *
- *      Clears all interrupts.  The caller must be a PCI function managing
- *      global interrupts.
- */
-void t4_intr_clear(struct adapter *adapter)
-{
-        static const unsigned int cause_reg[] = {
-                SGE_INT_CAUSE1, SGE_INT_CAUSE2, SGE_INT_CAUSE3,
-                PCIE_CORE_UTL_SYSTEM_BUS_AGENT_STATUS,
-                PCIE_CORE_UTL_PCI_EXPRESS_PORT_STATUS,
-                PCIE_NONFAT_ERR, PCIE_INT_CAUSE,
-                MC_INT_CAUSE,
-                MA_INT_WRAP_STATUS, MA_PARITY_ERROR_STATUS, MA_INT_CAUSE,
-                EDC_INT_CAUSE, EDC_REG(EDC_INT_CAUSE, 1),
-                CIM_HOST_INT_CAUSE, CIM_HOST_UPACC_INT_CAUSE,
-                MYPF_REG(CIM_PF_HOST_INT_CAUSE),
-                TP_INT_CAUSE,
-                ULP_RX_INT_CAUSE, ULP_TX_INT_CAUSE,
-                PM_RX_INT_CAUSE, PM_TX_INT_CAUSE,
-                MPS_RX_PERR_INT_CAUSE,
-                CPL_INTR_CAUSE,
-                MYPF_REG(PL_PF_INT_CAUSE),
-                PL_PL_INT_CAUSE,
-                LE_DB_INT_CAUSE,
-        };
-
-        unsigned int i;
-
-        for (i = 0; i < ARRAY_SIZE(cause_reg); ++i)
-                t4_write_reg(adapter, cause_reg[i], 0xffffffff);
-
-        t4_write_reg(adapter, PL_INT_CAUSE, GLBL_INTR_MASK);
-        (void) t4_read_reg(adapter, PL_INT_CAUSE);          /* flush */
-}
-
-/**
  *      hash_mac_addr - return the hash value of a MAC address
  *      @addr: the 48-bit Ethernet MAC address
  *
@@ -1709,36 +1646,6 @@ int t4_config_glbl_rss(struct adapter *adapter, int mbox, unsigned int mode,
         return t4_wr_mbox(adapter, mbox, &c, sizeof(c), NULL);
 }
 
-/* Read an RSS table row */
-static int rd_rss_row(struct adapter *adap, int row, u32 *val)
-{
-        t4_write_reg(adap, TP_RSS_LKP_TABLE, 0xfff00000 | row);
-        return t4_wait_op_done_val(adap, TP_RSS_LKP_TABLE, LKPTBLROWVLD, 1,
-                                   5, 0, val);
-}
-
-/**
- *      t4_read_rss - read the contents of the RSS mapping table
- *      @adapter: the adapter
- *      @map: holds the contents of the RSS mapping table
- *
- *      Reads the contents of the RSS hash->queue mapping table.
- */
-int t4_read_rss(struct adapter *adapter, u16 *map)
-{
-        u32 val;
-        int i, ret;
-
-        for (i = 0; i < RSS_NENTRIES / 2; ++i) {
-                ret = rd_rss_row(adapter, i, &val);
-                if (ret)
-                        return ret;
-                *map++ = LKPTBLQUEUE0_GET(val);
-                *map++ = LKPTBLQUEUE1_GET(val);
-        }
-        return 0;
-}
-
 /**
  *      t4_tp_get_tcp_stats - read TP's TCP MIB counters
  *      @adap: the adapter
@@ -1779,29 +1686,6 @@ void t4_tp_get_tcp_stats(struct adapter *adap, struct tp_tcp_stats *v4,
 }
 
 /**
- *      t4_tp_get_err_stats - read TP's error MIB counters
- *      @adap: the adapter
- *      @st: holds the counter values
- *
- *      Returns the values of TP's error counters.
- */
-void t4_tp_get_err_stats(struct adapter *adap, struct tp_err_stats *st)
-{
-        t4_read_indirect(adap, TP_MIB_INDEX, TP_MIB_DATA, st->macInErrs,
-                         12, TP_MIB_MAC_IN_ERR_0);
-        t4_read_indirect(adap, TP_MIB_INDEX, TP_MIB_DATA, st->tnlCongDrops,
-                         8, TP_MIB_TNL_CNG_DROP_0);
-        t4_read_indirect(adap, TP_MIB_INDEX, TP_MIB_DATA, st->tnlTxDrops,
-                         4, TP_MIB_TNL_DROP_0);
-        t4_read_indirect(adap, TP_MIB_INDEX, TP_MIB_DATA, st->ofldVlanDrops,
-                         4, TP_MIB_OFD_VLN_DROP_0);
-        t4_read_indirect(adap, TP_MIB_INDEX, TP_MIB_DATA, st->tcp6InErrs,
-                         4, TP_MIB_TCP_V6IN_ERR_0);
-        t4_read_indirect(adap, TP_MIB_INDEX, TP_MIB_DATA, &st->ofldNoNeigh,
-                         2, TP_MIB_OFD_ARP_DROP);
-}
-
-/**
  *      t4_read_mtu_tbl - returns the values in the HW path MTU table
  *      @adap: the adapter
  *      @mtus: where to store the MTU values
@@ -1916,122 +1800,6 @@ void t4_load_mtus(struct adapter *adap, const unsigned short *mtus,
 }
 
 /**
- *      t4_set_trace_filter - configure one of the tracing filters
- *      @adap: the adapter
- *      @tp: the desired trace filter parameters
- *      @idx: which filter to configure
- *      @enable: whether to enable or disable the filter
- *
- *      Configures one of the tracing filters available in HW.  If @enable is
- *      %0 @tp is not examined and may be %NULL.
- */
-int t4_set_trace_filter(struct adapter *adap, const struct trace_params *tp,
-                        int idx, int enable)
-{
-        int i, ofst = idx * 4;
-        u32 data_reg, mask_reg, cfg;
-        u32 multitrc = TRCMULTIFILTER;
-
-        if (!enable) {
-                t4_write_reg(adap, MPS_TRC_FILTER_MATCH_CTL_A + ofst, 0);
-                goto out;
-        }
-
-        if (tp->port > 11 || tp->invert > 1 || tp->skip_len > 0x1f ||
-            tp->skip_ofst > 0x1f || tp->min_len > 0x1ff ||
-            tp->snap_len > 9600 || (idx && tp->snap_len > 256))
-                return -EINVAL;
-
-        if (tp->snap_len > 256) {            /* must be tracer 0 */
-                if ((t4_read_reg(adap, MPS_TRC_FILTER_MATCH_CTL_A + 4) |
-                     t4_read_reg(adap, MPS_TRC_FILTER_MATCH_CTL_A + 8) |
-                     t4_read_reg(adap, MPS_TRC_FILTER_MATCH_CTL_A + 12)) & TFEN)
-                        return -EINVAL;  /* other tracers are enabled */
-                multitrc = 0;
-        } else if (idx) {
-                i = t4_read_reg(adap, MPS_TRC_FILTER_MATCH_CTL_B);
-                if (TFCAPTUREMAX_GET(i) > 256 &&
-                    (t4_read_reg(adap, MPS_TRC_FILTER_MATCH_CTL_A) & TFEN))
-                        return -EINVAL;
-        }
-
-        /* stop the tracer we'll be changing */
-        t4_write_reg(adap, MPS_TRC_FILTER_MATCH_CTL_A + ofst, 0);
-
-        /* disable tracing globally if running in the wrong single/multi mode */
-        cfg = t4_read_reg(adap, MPS_TRC_CFG);
-        if ((cfg & TRCEN) && multitrc != (cfg & TRCMULTIFILTER)) {
-                t4_write_reg(adap, MPS_TRC_CFG, cfg ^ TRCEN);
-                t4_read_reg(adap, MPS_TRC_CFG);                  /* flush */
-                msleep(1);
-                if (!(t4_read_reg(adap, MPS_TRC_CFG) & TRCFIFOEMPTY))
-                        return -ETIMEDOUT;
-        }
-        /*
-         * At this point either the tracing is enabled and in the right mode or
-         * disabled.
-         */
-
-        idx *= (MPS_TRC_FILTER1_MATCH - MPS_TRC_FILTER0_MATCH);
-        data_reg = MPS_TRC_FILTER0_MATCH + idx;
-        mask_reg = MPS_TRC_FILTER0_DONT_CARE + idx;
-
-        for (i = 0; i < TRACE_LEN / 4; i++, data_reg += 4, mask_reg += 4) {
-                t4_write_reg(adap, data_reg, tp->data[i]);
-                t4_write_reg(adap, mask_reg, ~tp->mask[i]);
-        }
-        t4_write_reg(adap, MPS_TRC_FILTER_MATCH_CTL_B + ofst,
-                     TFCAPTUREMAX(tp->snap_len) |
-                     TFMINPKTSIZE(tp->min_len));
-        t4_write_reg(adap, MPS_TRC_FILTER_MATCH_CTL_A + ofst,
-                     TFOFFSET(tp->skip_ofst) | TFLENGTH(tp->skip_len) |
-                     TFPORT(tp->port) | TFEN |
-                     (tp->invert ? TFINVERTMATCH : 0));
-
-        cfg &= ~TRCMULTIFILTER;
-        t4_write_reg(adap, MPS_TRC_CFG, cfg | TRCEN | multitrc);
-out:    t4_read_reg(adap, MPS_TRC_CFG);  /* flush */
-        return 0;
-}
-
-/**
- *      t4_get_trace_filter - query one of the tracing filters
- *      @adap: the adapter
- *      @tp: the current trace filter parameters
- *      @idx: which trace filter to query
- *      @enabled: non-zero if the filter is enabled
- *
- *      Returns the current settings of one of the HW tracing filters.
- */
-void t4_get_trace_filter(struct adapter *adap, struct trace_params *tp, int idx,
-                         int *enabled)
-{
-        u32 ctla, ctlb;
-        int i, ofst = idx * 4;
-        u32 data_reg, mask_reg;
-
-        ctla = t4_read_reg(adap, MPS_TRC_FILTER_MATCH_CTL_A + ofst);
-        ctlb = t4_read_reg(adap, MPS_TRC_FILTER_MATCH_CTL_B + ofst);
-
-        *enabled = !!(ctla & TFEN);
-        tp->snap_len = TFCAPTUREMAX_GET(ctlb);
-        tp->min_len = TFMINPKTSIZE_GET(ctlb);
-        tp->skip_ofst = TFOFFSET_GET(ctla);
-        tp->skip_len = TFLENGTH_GET(ctla);
-        tp->invert = !!(ctla & TFINVERTMATCH);
-        tp->port = TFPORT_GET(ctla);
-
-        ofst = (MPS_TRC_FILTER1_MATCH - MPS_TRC_FILTER0_MATCH) * idx;
-        data_reg = MPS_TRC_FILTER0_MATCH + ofst;
-        mask_reg = MPS_TRC_FILTER0_DONT_CARE + ofst;
-
-        for (i = 0; i < TRACE_LEN / 4; i++, data_reg += 4, mask_reg += 4) {
-                tp->mask[i] = ~t4_read_reg(adap, mask_reg);
-                tp->data[i] = t4_read_reg(adap, data_reg) & tp->mask[i];
-        }
-}
-
-/**
  *      get_mps_bg_map - return the buffer groups associated with a port
  *      @adap: the adapter
  *      @idx: the port index
@@ -2133,52 +1901,6 @@ void t4_get_port_stats(struct adapter *adap, int idx, struct port_stats *p)
 }
 
 /**
- *      t4_get_lb_stats - collect loopback port statistics
- *      @adap: the adapter
- *      @idx: the loopback port index
- *      @p: the stats structure to fill
- *
- *      Return HW statistics for the given loopback port.
- */
-void t4_get_lb_stats(struct adapter *adap, int idx, struct lb_port_stats *p)
-{
-        u32 bgmap = get_mps_bg_map(adap, idx);
-
-#define GET_STAT(name) \
-        t4_read_reg64(adap, PORT_REG(idx, MPS_PORT_STAT_LB_PORT_##name##_L))
-#define GET_STAT_COM(name) t4_read_reg64(adap, MPS_STAT_##name##_L)
-
-        p->octets           = GET_STAT(BYTES);
-        p->frames           = GET_STAT(FRAMES);
-        p->bcast_frames     = GET_STAT(BCAST);
-        p->mcast_frames     = GET_STAT(MCAST);
-        p->ucast_frames     = GET_STAT(UCAST);
-        p->error_frames     = GET_STAT(ERROR);
-
-        p->frames_64        = GET_STAT(64B);
-        p->frames_65_127    = GET_STAT(65B_127B);
-        p->frames_128_255   = GET_STAT(128B_255B);
-        p->frames_256_511   = GET_STAT(256B_511B);
-        p->frames_512_1023  = GET_STAT(512B_1023B);
-        p->frames_1024_1518 = GET_STAT(1024B_1518B);
-        p->frames_1519_max  = GET_STAT(1519B_MAX);
-        p->drop             = t4_read_reg(adap, PORT_REG(idx,
-                                          MPS_PORT_STAT_LB_PORT_DROP_FRAMES));
-
-        p->ovflow0 = (bgmap & 1) ? GET_STAT_COM(RX_BG_0_LB_DROP_FRAME) : 0;
-        p->ovflow1 = (bgmap & 2) ? GET_STAT_COM(RX_BG_1_LB_DROP_FRAME) : 0;
-        p->ovflow2 = (bgmap & 4) ? GET_STAT_COM(RX_BG_2_LB_DROP_FRAME) : 0;
-        p->ovflow3 = (bgmap & 8) ? GET_STAT_COM(RX_BG_3_LB_DROP_FRAME) : 0;
-        p->trunc0 = (bgmap & 1) ? GET_STAT_COM(RX_BG_0_LB_TRUNC_FRAME) : 0;
-        p->trunc1 = (bgmap & 2) ? GET_STAT_COM(RX_BG_1_LB_TRUNC_FRAME) : 0;
-        p->trunc2 = (bgmap & 4) ? GET_STAT_COM(RX_BG_2_LB_TRUNC_FRAME) : 0;
-        p->trunc3 = (bgmap & 8) ? GET_STAT_COM(RX_BG_3_LB_TRUNC_FRAME) : 0;
-
-#undef GET_STAT
-#undef GET_STAT_COM
-}
-
-/**
  *      t4_wol_magic_enable - enable/disable magic packet WoL
  *      @adap: the adapter
  *      @port: the physical port index
@@ -2584,30 +2306,6 @@ int t4_alloc_vi(struct adapter *adap, unsigned int mbox, unsigned int port,
 }
 
 /**
- *      t4_free_vi - free a virtual interface
- *      @adap: the adapter
- *      @mbox: mailbox to use for the FW command
- *      @pf: the PF owning the VI
- *      @vf: the VF owning the VI
- *      @viid: virtual interface identifiler
- *
- *      Free a previously allocated virtual interface.
- */
-int t4_free_vi(struct adapter *adap, unsigned int mbox, unsigned int pf,
-               unsigned int vf, unsigned int viid)
-{
-        struct fw_vi_cmd c;
-
-        memset(&c, 0, sizeof(c));
-        c.op_to_vfn = htonl(FW_CMD_OP(FW_VI_CMD) | FW_CMD_REQUEST |
-                            FW_CMD_EXEC | FW_VI_CMD_PFN(pf) |
-                            FW_VI_CMD_VFN(vf));
-        c.alloc_to_len16 = htonl(FW_VI_CMD_FREE | FW_LEN16(c));
-        c.type_viid = htons(FW_VI_CMD_VIID(viid));
-        return t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
-}
-
-/**
  *      t4_set_rxmode - set Rx properties of a virtual interface
  *      @adap: the adapter
  *      @mbox: mailbox to use for the FW command
@@ -2709,7 +2407,7 @@ int t4_alloc_mac_filt(struct adapter *adap, unsigned int mbox,
                 if (index < NEXACT_MAC)
                         ret++;
                 else if (hash)
-                        *hash |= (1 << hash_mac_addr(addr[i]));
+                        *hash |= (1ULL << hash_mac_addr(addr[i]));
         }
         return ret;
 }
@@ -2833,37 +2531,6 @@ int t4_identify_port(struct adapter *adap, unsigned int mbox, unsigned int viid,
 }
 
 /**
- *      t4_iq_start_stop - enable/disable an ingress queue and its FLs
- *      @adap: the adapter
- *      @mbox: mailbox to use for the FW command
- *      @start: %true to enable the queues, %false to disable them
- *      @pf: the PF owning the queues
- *      @vf: the VF owning the queues
- *      @iqid: ingress queue id
- *      @fl0id: FL0 queue id or 0xffff if no attached FL0
- *      @fl1id: FL1 queue id or 0xffff if no attached FL1
- *
- *      Starts or stops an ingress queue and its associated FLs, if any.
- */
-int t4_iq_start_stop(struct adapter *adap, unsigned int mbox, bool start,
-                     unsigned int pf, unsigned int vf, unsigned int iqid,
-                     unsigned int fl0id, unsigned int fl1id)
-{
-        struct fw_iq_cmd c;
-
-        memset(&c, 0, sizeof(c));
-        c.op_to_vfn = htonl(FW_CMD_OP(FW_IQ_CMD) | FW_CMD_REQUEST |
-                            FW_CMD_EXEC | FW_IQ_CMD_PFN(pf) |
-                            FW_IQ_CMD_VFN(vf));
-        c.alloc_to_len16 = htonl(FW_IQ_CMD_IQSTART(start) |
-                                 FW_IQ_CMD_IQSTOP(!start) | FW_LEN16(c));
-        c.iqid = htons(iqid);
-        c.fl0id = htons(fl0id);
-        c.fl1id = htons(fl1id);
-        return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
-}
-
-/**
  *      t4_iq_free - free an ingress queue and its FLs
  *      @adap: the adapter
  *      @mbox: mailbox to use for the FW command
diff --git a/drivers/net/cxgb4/t4_hw.h b/drivers/net/cxgb4/t4_hw.h
index 10a055565776..c26b455f37de 100644
--- a/drivers/net/cxgb4/t4_hw.h
+++ b/drivers/net/cxgb4/t4_hw.h
@@ -42,6 +42,7 @@ enum {
         MAX_MTU        = 9600,  /* max MAC MTU, excluding header + FCS */
         EEPROMSIZE     = 17408, /* Serial EEPROM physical size */
         EEPROMVSIZE    = 32768, /* Serial EEPROM virtual address space size */
+        EEPROMPFSIZE   = 1024,  /* EEPROM writable area size for PFn, n>0 */
         RSS_NENTRIES   = 2048,  /* # of entries in RSS mapping table */
         TCB_SIZE       = 128,   /* TCB size */
         NMTUS          = 16,    /* size of MTU table */
diff --git a/drivers/net/cxgb4/t4_msg.h b/drivers/net/cxgb4/t4_msg.h
index a550d0c706f3..eb71b8250b91 100644
--- a/drivers/net/cxgb4/t4_msg.h
+++ b/drivers/net/cxgb4/t4_msg.h
@@ -123,6 +123,7 @@ enum {
         ULP_MODE_NONE          = 0,
         ULP_MODE_ISCSI         = 2,
         ULP_MODE_RDMA          = 4,
+        ULP_MODE_TCPDDP        = 5,
         ULP_MODE_FCOE          = 6,
 };
 
diff --git a/drivers/net/cxgb4/t4fw_api.h b/drivers/net/cxgb4/t4fw_api.h
index 0969f2fbc1b0..edcfd7ec7802 100644
--- a/drivers/net/cxgb4/t4fw_api.h
+++ b/drivers/net/cxgb4/t4fw_api.h
@@ -487,6 +487,11 @@ enum fw_params_param_pfvf {
         FW_PARAMS_PARAM_PFVF_CPMASK     = 0x25,
         FW_PARAMS_PARAM_PFVF_OCQ_START  = 0x26,
         FW_PARAMS_PARAM_PFVF_OCQ_END    = 0x27,
+        FW_PARAMS_PARAM_PFVF_CONM_MAP   = 0x28,
+        FW_PARAMS_PARAM_PFVF_IQFLINT_START = 0x29,
+        FW_PARAMS_PARAM_PFVF_IQFLINT_END = 0x2A,
+        FW_PARAMS_PARAM_PFVF_EQ_START   = 0x2B,
+        FW_PARAMS_PARAM_PFVF_EQ_END     = 0x2C,
 };
 
 /*
@@ -1234,6 +1239,7 @@ enum fw_port_type {
         FW_PORT_TYPE_KR,
         FW_PORT_TYPE_SFP,
         FW_PORT_TYPE_BP_AP,
+        FW_PORT_TYPE_BP4_AP,
 
         FW_PORT_TYPE_NONE = FW_PORT_CMD_PTYPE_MASK
 };