Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Conflicts:
	drivers/net/usb/asix_common.c
	drivers/net/usb/sr9800.c
	drivers/net/usb/usbnet.c
	include/linux/usb/usbnet.h
	net/ipv4/tcp_ipv4.c
	net/ipv6/tcp_ipv6.c

The TCP conflicts were overlapping changes.  In 'net' we added a
READ_ONCE() to the socket cached RX route read, whilst in 'net-next'
Eric Dumazet touched the surrounding code dealing with how mini
sockets are handled.

With USB, it's a case of the same bug fix first going into net-next
and then I cherry picked it back into net.

Signed-off-by: David S. Miller <davem@davemloft.net>

10 files changed, 225 insertions, 62 deletions

diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
index bf46ca935e2a..6c80eb2e61f4 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
@@ -376,8 +376,6 @@ enum {
 enum {
         INGQ_EXTRAS = 2,        /* firmware event queue and */
                                 /*   forwarded interrupts */
-        MAX_EGRQ = MAX_ETH_QSETS*2 + MAX_OFLD_QSETS*2
-                   + MAX_CTRL_QUEUES + MAX_RDMA_QUEUES + MAX_ISCSI_QUEUES,
         MAX_INGQ = MAX_ETH_QSETS + MAX_OFLD_QSETS + MAX_RDMA_QUEUES
                    + MAX_RDMA_CIQS + MAX_ISCSI_QUEUES + INGQ_EXTRAS,
 };
@@ -623,11 +621,13 @@ struct sge {
         unsigned int idma_qid[2];   /* SGE IDMA Hung Ingress Queue ID */
 
         unsigned int egr_start;
+        unsigned int egr_sz;
         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);
-        DECLARE_BITMAP(txq_maperr, MAX_EGRQ);
+        unsigned int ingr_sz;
+        void **egr_map;    /* qid->queue egress queue map */
+        struct sge_rspq **ingr_map; /* qid->queue ingress queue map */
+        unsigned long *starving_fl;
+        unsigned long *txq_maperr;
         struct timer_list rx_timer; /* refills starving FLs */
         struct timer_list tx_timer; /* checks Tx queues */
 };
@@ -1143,6 +1143,8 @@ int cxgb4_t4_bar2_sge_qregs(struct adapter *adapter,
 
 unsigned int qtimer_val(const struct adapter *adap,
                         const struct sge_rspq *q);
+
+int t4_init_devlog_params(struct adapter *adapter);
 int t4_init_sge_params(struct adapter *adapter);
 int t4_init_tp_params(struct adapter *adap);
 int t4_filter_field_shift(const struct adapter *adap, int filter_sel);
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c
index 0918c16bb154..f0285bcbe598 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c
@@ -670,9 +670,13 @@ static int cctrl_tbl_show(struct seq_file *seq, void *v)
                 "0.9375" };
 
         int i;
-        u16 incr[NMTUS][NCCTRL_WIN];
+        u16 (*incr)[NCCTRL_WIN];
         struct adapter *adap = seq->private;
 
+        incr = kmalloc(sizeof(*incr) * NMTUS, GFP_KERNEL);
+        if (!incr)
+                return -ENOMEM;
+
         t4_read_cong_tbl(adap, incr);
 
         for (i = 0; i < NCCTRL_WIN; ++i) {
@@ -685,6 +689,8 @@ static int cctrl_tbl_show(struct seq_file *seq, void *v)
                            adap->params.a_wnd[i],
                            dec_fac[adap->params.b_wnd[i]]);
         }
+
+        kfree(incr);
         return 0;
 }
 
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
index e40e283ff36c..58c537f16763 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
@@ -920,7 +920,7 @@ static void quiesce_rx(struct adapter *adap)
 {
         int i;
 
-        for (i = 0; i < ARRAY_SIZE(adap->sge.ingr_map); i++) {
+        for (i = 0; i < adap->sge.ingr_sz; i++) {
                 struct sge_rspq *q = adap->sge.ingr_map[i];
 
                 if (q && q->handler) {
@@ -934,6 +934,21 @@ static void quiesce_rx(struct adapter *adap)
         }
 }
 
+/* Disable interrupt and napi handler */
+static void disable_interrupts(struct adapter *adap)
+{
+        if (adap->flags & FULL_INIT_DONE) {
+                t4_intr_disable(adap);
+                if (adap->flags & USING_MSIX) {
+                        free_msix_queue_irqs(adap);
+                        free_irq(adap->msix_info[0].vec, adap);
+                } else {
+                        free_irq(adap->pdev->irq, adap);
+                }
+                quiesce_rx(adap);
+        }
+}
+
 /*
  * Enable NAPI scheduling and interrupt generation for all Rx queues.
  */
@@ -941,7 +956,7 @@ static void enable_rx(struct adapter *adap)
 {
         int i;
 
-        for (i = 0; i < ARRAY_SIZE(adap->sge.ingr_map); i++) {
+        for (i = 0; i < adap->sge.ingr_sz; i++) {
                 struct sge_rspq *q = adap->sge.ingr_map[i];
 
                 if (!q)
@@ -992,8 +1007,8 @@ static int setup_sge_queues(struct adapter *adap)
         int err, msi_idx, i, j;
         struct sge *s = &adap->sge;
 
-        bitmap_zero(s->starving_fl, MAX_EGRQ);
-        bitmap_zero(s->txq_maperr, MAX_EGRQ);
+        bitmap_zero(s->starving_fl, s->egr_sz);
+        bitmap_zero(s->txq_maperr, s->egr_sz);
 
         if (adap->flags & USING_MSIX)
                 msi_idx = 1;         /* vector 0 is for non-queue interrupts */
@@ -1005,6 +1020,19 @@ static int setup_sge_queues(struct adapter *adap)
                 msi_idx = -((int)s->intrq.abs_id + 1);
         }
 
+        /* NOTE: If you add/delete any Ingress/Egress Queue allocations in here,
+         * don't forget to update the following which need to be
+         * synchronized to and changes here.
+         *
+         * 1. The calculations of MAX_INGQ in cxgb4.h.
+         *
+         * 2. Update enable_msix/name_msix_vecs/request_msix_queue_irqs
+         *    to accommodate any new/deleted Ingress Queues
+         *    which need MSI-X Vectors.
+         *
+         * 3. Update sge_qinfo_show() to include information on the
+         *    new/deleted queues.
+         */
         err = t4_sge_alloc_rxq(adap, &s->fw_evtq, true, adap->port[0],
                                msi_idx, NULL, fwevtq_handler);
         if (err) {
@@ -4246,19 +4274,12 @@ static int cxgb_up(struct adapter *adap)
 
 static void cxgb_down(struct adapter *adapter)
 {
-        t4_intr_disable(adapter);
         cancel_work_sync(&adapter->tid_release_task);
         cancel_work_sync(&adapter->db_full_task);
         cancel_work_sync(&adapter->db_drop_task);
         adapter->tid_release_task_busy = false;
         adapter->tid_release_head = NULL;
 
-        if (adapter->flags & USING_MSIX) {
-                free_msix_queue_irqs(adapter);
-                free_irq(adapter->msix_info[0].vec, adapter);
-        } else
-                free_irq(adapter->pdev->irq, adapter);
-        quiesce_rx(adapter);
         t4_sge_stop(adapter);
         t4_free_sge_resources(adapter);
         adapter->flags &= ~FULL_INIT_DONE;
@@ -4739,8 +4760,9 @@ static int adap_init1(struct adapter *adap, struct fw_caps_config_cmd *c)
         if (ret < 0)
                 return ret;
 
-        ret = t4_cfg_pfvf(adap, adap->fn, adap->fn, 0, MAX_EGRQ, 64, MAX_INGQ,
-                          0, 0, 4, 0xf, 0xf, 16, FW_CMD_CAP_PF, FW_CMD_CAP_PF);
+        ret = t4_cfg_pfvf(adap, adap->fn, adap->fn, 0, adap->sge.egr_sz, 64,
+                          MAX_INGQ, 0, 0, 4, 0xf, 0xf, 16, FW_CMD_CAP_PF,
+                          FW_CMD_CAP_PF);
         if (ret < 0)
                 return ret;
 
@@ -5094,10 +5116,15 @@ static int adap_init0(struct adapter *adap)
         enum dev_state state;
         u32 params[7], val[7];
         struct fw_caps_config_cmd caps_cmd;
-        struct fw_devlog_cmd devlog_cmd;
-        u32 devlog_meminfo;
         int reset = 1;
 
+        /* Grab Firmware Device Log parameters as early as possible so we have
+         * access to it for debugging, etc.
+         */
+        ret = t4_init_devlog_params(adap);
+        if (ret < 0)
+                return ret;
+
         /* Contact FW, advertising Master capability */
         ret = t4_fw_hello(adap, adap->mbox, adap->mbox, MASTER_MAY, &state);
         if (ret < 0) {
@@ -5175,30 +5202,6 @@ static int adap_init0(struct adapter *adap)
         if (ret < 0)
                 goto bye;
 
-        /* Read firmware device log parameters.  We really need to find a way
-         * to get these parameters initialized with some default values (which
-         * are likely to be correct) for the case where we either don't
-         * attache to the firmware or it's crashed when we probe the adapter.
-         * That way we'll still be able to perform early firmware startup
-         * debugging ...  If the request to get the Firmware's Device Log
-         * parameters fails, we'll live so we don't make that a fatal error.
-         */
-        memset(&devlog_cmd, 0, sizeof(devlog_cmd));
-        devlog_cmd.op_to_write = htonl(FW_CMD_OP_V(FW_DEVLOG_CMD) |
-                                       FW_CMD_REQUEST_F | FW_CMD_READ_F);
-        devlog_cmd.retval_len16 = htonl(FW_LEN16(devlog_cmd));
-        ret = t4_wr_mbox(adap, adap->mbox, &devlog_cmd, sizeof(devlog_cmd),
-                         &devlog_cmd);
-        if (ret == 0) {
-                devlog_meminfo =
-                        ntohl(devlog_cmd.memtype_devlog_memaddr16_devlog);
-                adap->params.devlog.memtype =
-                        FW_DEVLOG_CMD_MEMTYPE_DEVLOG_G(devlog_meminfo);
-                adap->params.devlog.start =
-                        FW_DEVLOG_CMD_MEMADDR16_DEVLOG_G(devlog_meminfo) << 4;
-                adap->params.devlog.size = ntohl(devlog_cmd.memsize_devlog);
-        }
-
         /*
          * Find out what ports are available to us.  Note that we need to do
          * this before calling adap_init0_no_config() since it needs nports
@@ -5299,6 +5302,51 @@ static int adap_init0(struct adapter *adap)
         adap->tids.nftids = val[4] - val[3] + 1;
         adap->sge.ingr_start = val[5];
 
+        /* qids (ingress/egress) returned from firmware can be anywhere
+         * in the range from EQ(IQFLINT)_START to EQ(IQFLINT)_END.
+         * Hence driver needs to allocate memory for this range to
+         * store the queue info. Get the highest IQFLINT/EQ index returned
+         * in FW_EQ_*_CMD.alloc command.
+         */
+        params[0] = FW_PARAM_PFVF(EQ_END);
+        params[1] = FW_PARAM_PFVF(IQFLINT_END);
+        ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 2, params, val);
+        if (ret < 0)
+                goto bye;
+        adap->sge.egr_sz = val[0] - adap->sge.egr_start + 1;
+        adap->sge.ingr_sz = val[1] - adap->sge.ingr_start + 1;
+
+        adap->sge.egr_map = kcalloc(adap->sge.egr_sz,
+                                    sizeof(*adap->sge.egr_map), GFP_KERNEL);
+        if (!adap->sge.egr_map) {
+                ret = -ENOMEM;
+                goto bye;
+        }
+
+        adap->sge.ingr_map = kcalloc(adap->sge.ingr_sz,
+                                     sizeof(*adap->sge.ingr_map), GFP_KERNEL);
+        if (!adap->sge.ingr_map) {
+                ret = -ENOMEM;
+                goto bye;
+        }
+
+        /* Allocate the memory for the vaious egress queue bitmaps
+         * ie starving_fl and txq_maperr.
+         */
+        adap->sge.starving_fl = kcalloc(BITS_TO_LONGS(adap->sge.egr_sz),
+                                        sizeof(long), GFP_KERNEL);
+        if (!adap->sge.starving_fl) {
+                ret = -ENOMEM;
+                goto bye;
+        }
+
+        adap->sge.txq_maperr = kcalloc(BITS_TO_LONGS(adap->sge.egr_sz),
+                                       sizeof(long), GFP_KERNEL);
+        if (!adap->sge.txq_maperr) {
+                ret = -ENOMEM;
+                goto bye;
+        }
+
         params[0] = FW_PARAM_PFVF(CLIP_START);
         params[1] = FW_PARAM_PFVF(CLIP_END);
         ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 2, params, val);
@@ -5507,6 +5555,10 @@ static int adap_init0(struct adapter *adap)
          * happened to HW/FW, stop issuing commands.
          */
 bye:
+        kfree(adap->sge.egr_map);
+        kfree(adap->sge.ingr_map);
+        kfree(adap->sge.starving_fl);
+        kfree(adap->sge.txq_maperr);
         if (ret != -ETIMEDOUT && ret != -EIO)
                 t4_fw_bye(adap, adap->mbox);
         return ret;
@@ -5534,6 +5586,7 @@ static pci_ers_result_t eeh_err_detected(struct pci_dev *pdev,
                 netif_carrier_off(dev);
         }
         spin_unlock(&adap->stats_lock);
+        disable_interrupts(adap);
         if (adap->flags & FULL_INIT_DONE)
                 cxgb_down(adap);
         rtnl_unlock();
@@ -5942,6 +5995,10 @@ static void free_some_resources(struct adapter *adapter)
 
         t4_free_mem(adapter->l2t);
         t4_free_mem(adapter->tids.tid_tab);
+        kfree(adapter->sge.egr_map);
+        kfree(adapter->sge.ingr_map);
+        kfree(adapter->sge.starving_fl);
+        kfree(adapter->sge.txq_maperr);
         disable_msi(adapter);
 
         for_each_port(adapter, i)
@@ -6267,6 +6324,8 @@ static void remove_one(struct pci_dev *pdev)
                 if (is_offload(adapter))
                         detach_ulds(adapter);
 
+                disable_interrupts(adapter);
+
                 for_each_port(adapter, i)
                         if (adapter->port[i]->reg_state == NETREG_REGISTERED)
                                 unregister_netdev(adapter->port[i]);
diff --git a/drivers/net/ethernet/chelsio/cxgb4/sge.c b/drivers/net/ethernet/chelsio/cxgb4/sge.c
index c46e7a938317..c438f3895c40 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/sge.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/sge.c
@@ -2239,7 +2239,7 @@ static void sge_rx_timer_cb(unsigned long data)
         struct adapter *adap = (struct adapter *)data;
         struct sge *s = &adap->sge;
 
-        for (i = 0; i < ARRAY_SIZE(s->starving_fl); i++)
+        for (i = 0; i < BITS_TO_LONGS(s->egr_sz); i++)
                 for (m = s->starving_fl[i]; m; m &= m - 1) {
                         struct sge_eth_rxq *rxq;
                         unsigned int id = __ffs(m) + i * BITS_PER_LONG;
@@ -2327,7 +2327,7 @@ static void sge_tx_timer_cb(unsigned long data)
         struct adapter *adap = (struct adapter *)data;
         struct sge *s = &adap->sge;
 
-        for (i = 0; i < ARRAY_SIZE(s->txq_maperr); i++)
+        for (i = 0; i < BITS_TO_LONGS(s->egr_sz); i++)
                 for (m = s->txq_maperr[i]; m; m &= m - 1) {
                         unsigned long id = __ffs(m) + i * BITS_PER_LONG;
                         struct sge_ofld_txq *txq = s->egr_map[id];
@@ -2809,7 +2809,8 @@ void t4_free_sge_resources(struct adapter *adap)
                 free_rspq_fl(adap, &adap->sge.intrq, NULL);
 
         /* clear the reverse egress queue map */
-        memset(adap->sge.egr_map, 0, sizeof(adap->sge.egr_map));
+        memset(adap->sge.egr_map, 0,
+               adap->sge.egr_sz * sizeof(*adap->sge.egr_map));
 }
 
 void t4_sge_start(struct adapter *adap)
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
index afbe1682ff48..5ed8db977432 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
@@ -4459,6 +4459,59 @@ int cxgb4_t4_bar2_sge_qregs(struct adapter *adapter,
 }
 
 /**
+ *      t4_init_devlog_params - initialize adapter->params.devlog
+ *      @adap: the adapter
+ *
+ *      Initialize various fields of the adapter's Firmware Device Log
+ *      Parameters structure.
+ */
+int t4_init_devlog_params(struct adapter *adap)
+{
+        struct devlog_params *dparams = &adap->params.devlog;
+        u32 pf_dparams;
+        unsigned int devlog_meminfo;
+        struct fw_devlog_cmd devlog_cmd;
+        int ret;
+
+        /* If we're dealing with newer firmware, the Device Log Paramerters
+         * are stored in a designated register which allows us to access the
+         * Device Log even if we can't talk to the firmware.
+         */
+        pf_dparams =
+                t4_read_reg(adap, PCIE_FW_REG(PCIE_FW_PF_A, PCIE_FW_PF_DEVLOG));
+        if (pf_dparams) {
+                unsigned int nentries, nentries128;
+
+                dparams->memtype = PCIE_FW_PF_DEVLOG_MEMTYPE_G(pf_dparams);
+                dparams->start = PCIE_FW_PF_DEVLOG_ADDR16_G(pf_dparams) << 4;
+
+                nentries128 = PCIE_FW_PF_DEVLOG_NENTRIES128_G(pf_dparams);
+                nentries = (nentries128 + 1) * 128;
+                dparams->size = nentries * sizeof(struct fw_devlog_e);
+
+                return 0;
+        }
+
+        /* Otherwise, ask the firmware for it's Device Log Parameters.
+         */
+        memset(&devlog_cmd, 0, sizeof(devlog_cmd));
+        devlog_cmd.op_to_write = htonl(FW_CMD_OP_V(FW_DEVLOG_CMD) |
+                                       FW_CMD_REQUEST_F | FW_CMD_READ_F);
+        devlog_cmd.retval_len16 = htonl(FW_LEN16(devlog_cmd));
+        ret = t4_wr_mbox(adap, adap->mbox, &devlog_cmd, sizeof(devlog_cmd),
+                         &devlog_cmd);
+        if (ret)
+                return ret;
+
+        devlog_meminfo = ntohl(devlog_cmd.memtype_devlog_memaddr16_devlog);
+        dparams->memtype = FW_DEVLOG_CMD_MEMTYPE_DEVLOG_G(devlog_meminfo);
+        dparams->start = FW_DEVLOG_CMD_MEMADDR16_DEVLOG_G(devlog_meminfo) << 4;
+        dparams->size = ntohl(devlog_cmd.memsize_devlog);
+
+        return 0;
+}
+
+/**
  *      t4_init_sge_params - initialize adap->params.sge
  *      @adapter: the adapter
  *
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_regs.h b/drivers/net/ethernet/chelsio/cxgb4/t4_regs.h
index 231a725f6d5d..326674b19983 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_regs.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_regs.h
@@ -63,6 +63,8 @@
 #define MC_BIST_STATUS_REG(reg_addr, idx) ((reg_addr) + (idx) * 4)
 #define EDC_BIST_STATUS_REG(reg_addr, idx) ((reg_addr) + (idx) * 4)
 
+#define PCIE_FW_REG(reg_addr, idx) ((reg_addr) + (idx) * 4)
+
 #define SGE_PF_KDOORBELL_A 0x0
 
 #define QID_S    15
@@ -707,6 +709,7 @@
 #define PFNUM_V(x) ((x) << PFNUM_S)
 
 #define PCIE_FW_A 0x30b8
+#define PCIE_FW_PF_A 0x30bc
 
 #define PCIE_CORE_UTL_SYSTEM_BUS_AGENT_STATUS_A 0x5908
 
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h b/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
index d136ca6a0c8a..03fbfd1fb3df 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
@@ -101,7 +101,7 @@ enum fw_wr_opcodes {
         FW_RI_BIND_MW_WR               = 0x18,
         FW_RI_FR_NSMR_WR               = 0x19,
         FW_RI_INV_LSTAG_WR             = 0x1a,
-        FW_LASTC2E_WR                  = 0x40
+        FW_LASTC2E_WR                  = 0x70
 };
 
 struct fw_wr_hdr {
@@ -993,6 +993,7 @@ enum fw_memtype_cf {
         FW_MEMTYPE_CF_EXTMEM            = 0x2,
         FW_MEMTYPE_CF_FLASH             = 0x4,
         FW_MEMTYPE_CF_INTERNAL          = 0x5,
+        FW_MEMTYPE_CF_EXTMEM1           = 0x6,
 };
 
 struct fw_caps_config_cmd {
@@ -1035,6 +1036,7 @@ enum fw_params_mnem {
         FW_PARAMS_MNEM_PFVF             = 2,    /* function params */
         FW_PARAMS_MNEM_REG              = 3,    /* limited register access */
         FW_PARAMS_MNEM_DMAQ             = 4,    /* dma queue params */
+        FW_PARAMS_MNEM_CHNET            = 5,    /* chnet params */
         FW_PARAMS_MNEM_LAST
 };
 
@@ -3102,7 +3104,8 @@ enum fw_devlog_facility {
         FW_DEVLOG_FACILITY_FCOE         = 0x2E,
         FW_DEVLOG_FACILITY_FOISCSI      = 0x30,
         FW_DEVLOG_FACILITY_FOFCOE       = 0x32,
-        FW_DEVLOG_FACILITY_MAX          = 0x32,
+        FW_DEVLOG_FACILITY_CHNET        = 0x34,
+        FW_DEVLOG_FACILITY_MAX          = 0x34,
 };
 
 /* log message format */
@@ -3139,4 +3142,36 @@ struct fw_devlog_cmd {
         (((x) >> FW_DEVLOG_CMD_MEMADDR16_DEVLOG_S) & \
          FW_DEVLOG_CMD_MEMADDR16_DEVLOG_M)
 
+/* P C I E   F W   P F 7   R E G I S T E R */
+
+/* PF7 stores the Firmware Device Log parameters which allows Host Drivers to
+ * access the "devlog" which needing to contact firmware.  The encoding is
+ * mostly the same as that returned by the DEVLOG command except for the size
+ * which is encoded as the number of entries in multiples-1 of 128 here rather
+ * than the memory size as is done in the DEVLOG command.  Thus, 0 means 128
+ * and 15 means 2048.  This of course in turn constrains the allowed values
+ * for the devlog size ...
+ */
+#define PCIE_FW_PF_DEVLOG               7
+
+#define PCIE_FW_PF_DEVLOG_NENTRIES128_S 28
+#define PCIE_FW_PF_DEVLOG_NENTRIES128_M 0xf
+#define PCIE_FW_PF_DEVLOG_NENTRIES128_V(x) \
+        ((x) << PCIE_FW_PF_DEVLOG_NENTRIES128_S)
+#define PCIE_FW_PF_DEVLOG_NENTRIES128_G(x) \
+        (((x) >> PCIE_FW_PF_DEVLOG_NENTRIES128_S) & \
+         PCIE_FW_PF_DEVLOG_NENTRIES128_M)
+
+#define PCIE_FW_PF_DEVLOG_ADDR16_S      4
+#define PCIE_FW_PF_DEVLOG_ADDR16_M      0xffffff
+#define PCIE_FW_PF_DEVLOG_ADDR16_V(x)   ((x) << PCIE_FW_PF_DEVLOG_ADDR16_S)
+#define PCIE_FW_PF_DEVLOG_ADDR16_G(x) \
+        (((x) >> PCIE_FW_PF_DEVLOG_ADDR16_S) & PCIE_FW_PF_DEVLOG_ADDR16_M)
+
+#define PCIE_FW_PF_DEVLOG_MEMTYPE_S     0
+#define PCIE_FW_PF_DEVLOG_MEMTYPE_M     0xf
+#define PCIE_FW_PF_DEVLOG_MEMTYPE_V(x)  ((x) << PCIE_FW_PF_DEVLOG_MEMTYPE_S)
+#define PCIE_FW_PF_DEVLOG_MEMTYPE_G(x) \
+        (((x) >> PCIE_FW_PF_DEVLOG_MEMTYPE_S) & PCIE_FW_PF_DEVLOG_MEMTYPE_M)
+
 #endif /* _T4FW_INTERFACE_H_ */
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4fw_version.h b/drivers/net/ethernet/chelsio/cxgb4/t4fw_version.h
index e2bd3f747858..b9d1cbac0eee 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4fw_version.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4fw_version.h
@@ -36,13 +36,13 @@
 #define __T4FW_VERSION_H__
 
 #define T4FW_VERSION_MAJOR 0x01
-#define T4FW_VERSION_MINOR 0x0C
-#define T4FW_VERSION_MICRO 0x19
+#define T4FW_VERSION_MINOR 0x0D
+#define T4FW_VERSION_MICRO 0x20
 #define T4FW_VERSION_BUILD 0x00
 
 #define T5FW_VERSION_MAJOR 0x01
-#define T5FW_VERSION_MINOR 0x0C
-#define T5FW_VERSION_MICRO 0x19
+#define T5FW_VERSION_MINOR 0x0D
+#define T5FW_VERSION_MICRO 0x20
 #define T5FW_VERSION_BUILD 0x00
 
 #endif
diff --git a/drivers/net/ethernet/chelsio/cxgb4vf/sge.c b/drivers/net/ethernet/chelsio/cxgb4vf/sge.c
index 5ba14b32c370..7715982230e5 100644
--- a/drivers/net/ethernet/chelsio/cxgb4vf/sge.c
+++ b/drivers/net/ethernet/chelsio/cxgb4vf/sge.c
@@ -1004,7 +1004,7 @@ static inline void ring_tx_db(struct adapter *adapter, struct sge_txq *tq,
                                               ? (tq->pidx - 1)
                                               : (tq->size - 1));
                         __be64 *src = (__be64 *)&tq->desc[index];
-                        __be64 __iomem *dst = (__be64 *)(tq->bar2_addr +
+                        __be64 __iomem *dst = (__be64 __iomem *)(tq->bar2_addr +
                                                          SGE_UDB_WCDOORBELL);
                         unsigned int count = EQ_UNIT / sizeof(__be64);
 
@@ -1018,7 +1018,11 @@ static inline void ring_tx_db(struct adapter *adapter, struct sge_txq *tq,
                          * DMA.
                          */
                         while (count) {
-                                writeq(*src, dst);
+                                /* the (__force u64) is because the compiler
+                                 * doesn't understand the endian swizzling
+                                 * going on
+                                 */
+                                writeq((__force u64)*src, dst);
                                 src++;
                                 dst++;
                                 count--;
@@ -1252,8 +1256,8 @@ int t4vf_eth_xmit(struct sk_buff *skb, struct net_device *dev)
         BUG_ON(DIV_ROUND_UP(ETHTXQ_MAX_HDR, TXD_PER_EQ_UNIT) > 1);
         wr = (void *)&txq->q.desc[txq->q.pidx];
         wr->equiq_to_len16 = cpu_to_be32(wr_mid);
-        wr->r3[0] = cpu_to_be64(0);
-        wr->r3[1] = cpu_to_be64(0);
+        wr->r3[0] = cpu_to_be32(0);
+        wr->r3[1] = cpu_to_be32(0);
         skb_copy_from_linear_data(skb, (void *)wr->ethmacdst, fw_hdr_copy_len);
         end = (u64 *)wr + flits;
 
diff --git a/drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c b/drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c
index c21e2e954ad8..966ee900ed00 100644
--- a/drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c
+++ b/drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c
@@ -210,10 +210,10 @@ int t4vf_wr_mbox_core(struct adapter *adapter, const void *cmd, int size,
 
                         if (rpl) {
                                 /* request bit in high-order BE word */
-                                WARN_ON((be32_to_cpu(*(const u32 *)cmd)
+                                WARN_ON((be32_to_cpu(*(const __be32 *)cmd)
                                          & FW_CMD_REQUEST_F) == 0);
                                 get_mbox_rpl(adapter, rpl, size, mbox_data);
-                                WARN_ON((be32_to_cpu(*(u32 *)rpl)
+                                WARN_ON((be32_to_cpu(*(__be32 *)rpl)
                                          & FW_CMD_REQUEST_F) != 0);
                         }
                         t4_write_reg(adapter, mbox_ctl,
@@ -484,7 +484,7 @@ int t4_bar2_sge_qregs(struct adapter *adapter,
          *  o The BAR2 Queue ID.
          *  o The BAR2 Queue ID Offset into the BAR2 page.
          */
-        bar2_page_offset = ((qid >> qpp_shift) << page_shift);
+        bar2_page_offset = ((u64)(qid >> qpp_shift) << page_shift);
         bar2_qid = qid & qpp_mask;
         bar2_qid_offset = bar2_qid * SGE_UDB_SIZE;