Merge tag 'asoc-v4.2-2' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/sound into for-next

ASoC: Further updates for v4.2

There's a bunch of additional updates and fixes that came in since my
orignal pull request here, including DT support for rt5645 and fairly
large serieses of cleanups and improvements to tas2552 and rcar.

30 files changed, 275 insertions, 180 deletions

diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
index db84ddcfec84..9fd6c69a8bac 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
@@ -423,7 +423,7 @@ static void xgbe_tx_timer(unsigned long data)
         if (napi_schedule_prep(napi)) {
                 /* Disable Tx and Rx interrupts */
                 if (pdata->per_channel_irq)
-                        disable_irq(channel->dma_irq);
+                        disable_irq_nosync(channel->dma_irq);
                 else
                         xgbe_disable_rx_tx_ints(pdata);
 
diff --git a/drivers/net/ethernet/broadcom/b44.c b/drivers/net/ethernet/broadcom/b44.c
index 77363d680532..a3b1c07ae0af 100644
--- a/drivers/net/ethernet/broadcom/b44.c
+++ b/drivers/net/ethernet/broadcom/b44.c
@@ -2464,6 +2464,7 @@ err_out_powerdown:
         ssb_bus_may_powerdown(sdev->bus);
 
 err_out_free_dev:
+        netif_napi_del(&bp->napi);
         free_netdev(dev);
 
 out:
@@ -2480,6 +2481,7 @@ static void b44_remove_one(struct ssb_device *sdev)
                 b44_unregister_phy_one(bp);
         ssb_device_disable(sdev, 0);
         ssb_bus_may_powerdown(sdev->bus);
+        netif_napi_del(&bp->napi);
         free_netdev(dev);
         ssb_pcihost_set_power_state(sdev, PCI_D3hot);
         ssb_set_drvdata(sdev, NULL);
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
index a3b0f7a0c61e..1f82a04ce01a 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
@@ -1774,7 +1774,7 @@ struct bnx2x {
         int                     stats_state;
 
         /* used for synchronization of concurrent threads statistics handling */
-        struct mutex            stats_lock;
+        struct semaphore        stats_lock;
 
         /* used by dmae command loader */
         struct dmae_command     stats_dmae;
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
index fd52ce95127e..33501bcddc48 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
@@ -12054,7 +12054,7 @@ static int bnx2x_init_bp(struct bnx2x *bp)
         mutex_init(&bp->port.phy_mutex);
         mutex_init(&bp->fw_mb_mutex);
         mutex_init(&bp->drv_info_mutex);
-        mutex_init(&bp->stats_lock);
+        sema_init(&bp->stats_lock, 1);
         bp->drv_info_mng_owner = false;
 
         INIT_DELAYED_WORK(&bp->sp_task, bnx2x_sp_task);
@@ -13690,9 +13690,10 @@ static int bnx2x_eeh_nic_unload(struct bnx2x *bp)
         cancel_delayed_work_sync(&bp->sp_task);
         cancel_delayed_work_sync(&bp->period_task);
 
-        mutex_lock(&bp->stats_lock);
-        bp->stats_state = STATS_STATE_DISABLED;
-        mutex_unlock(&bp->stats_lock);
+        if (!down_timeout(&bp->stats_lock, HZ / 10)) {
+                bp->stats_state = STATS_STATE_DISABLED;
+                up(&bp->stats_lock);
+        }
 
         bnx2x_save_statistics(bp);
 
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.c
index 266b055c2360..69d699f0730a 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.c
@@ -1372,19 +1372,23 @@ void bnx2x_stats_handle(struct bnx2x *bp, enum bnx2x_stats_event event)
          * that context in case someone is in the middle of a transition.
          * For other events, wait a bit until lock is taken.
          */
-        if (!mutex_trylock(&bp->stats_lock)) {
+        if (down_trylock(&bp->stats_lock)) {
                 if (event == STATS_EVENT_UPDATE)
                         return;
 
                 DP(BNX2X_MSG_STATS,
                    "Unlikely stats' lock contention [event %d]\n", event);
-                mutex_lock(&bp->stats_lock);
+                if (unlikely(down_timeout(&bp->stats_lock, HZ / 10))) {
+                        BNX2X_ERR("Failed to take stats lock [event %d]\n",
+                                  event);
+                        return;
+                }
         }
 
         bnx2x_stats_stm[state][event].action(bp);
         bp->stats_state = bnx2x_stats_stm[state][event].next_state;
 
-        mutex_unlock(&bp->stats_lock);
+        up(&bp->stats_lock);
 
         if ((event != STATS_EVENT_UPDATE) || netif_msg_timer(bp))
                 DP(BNX2X_MSG_STATS, "state %d -> event %d -> state %d\n",
@@ -1970,7 +1974,11 @@ int bnx2x_stats_safe_exec(struct bnx2x *bp,
         /* Wait for statistics to end [while blocking further requests],
          * then run supplied function 'safely'.
          */
-        mutex_lock(&bp->stats_lock);
+        rc = down_timeout(&bp->stats_lock, HZ / 10);
+        if (unlikely(rc)) {
+                BNX2X_ERR("Failed to take statistics lock for safe execution\n");
+                goto out_no_lock;
+        }
 
         bnx2x_stats_comp(bp);
         while (bp->stats_pending && cnt--)
@@ -1988,7 +1996,7 @@ out:
         /* No need to restart statistics - if they're enabled, the timer
          * will restart the statistics.
          */
-        mutex_unlock(&bp->stats_lock);
-
+        up(&bp->stats_lock);
+out_no_lock:
         return rc;
 }
diff --git a/drivers/net/ethernet/broadcom/genet/bcmmii.c b/drivers/net/ethernet/broadcom/genet/bcmmii.c
index e7651b3c6c57..420949cc55aa 100644
--- a/drivers/net/ethernet/broadcom/genet/bcmmii.c
+++ b/drivers/net/ethernet/broadcom/genet/bcmmii.c
@@ -299,9 +299,6 @@ int bcmgenet_mii_config(struct net_device *dev, bool init)
                         phy_name = "external RGMII (no delay)";
                 else
                         phy_name = "external RGMII (TX delay)";
-                reg = bcmgenet_ext_readl(priv, EXT_RGMII_OOB_CTRL);
-                reg |= RGMII_MODE_EN | id_mode_dis;
-                bcmgenet_ext_writel(priv, reg, EXT_RGMII_OOB_CTRL);
                 bcmgenet_sys_writel(priv,
                                     PORT_MODE_EXT_GPHY, SYS_PORT_CTRL);
                 break;
@@ -310,6 +307,15 @@ int bcmgenet_mii_config(struct net_device *dev, bool init)
                 return -EINVAL;
         }
 
+        /* This is an external PHY (xMII), so we need to enable the RGMII
+         * block for the interface to work
+         */
+        if (priv->ext_phy) {
+                reg = bcmgenet_ext_readl(priv, EXT_RGMII_OOB_CTRL);
+                reg |= RGMII_MODE_EN | id_mode_dis;
+                bcmgenet_ext_writel(priv, reg, EXT_RGMII_OOB_CTRL);
+        }
+
         if (init)
                 dev_info(kdev, "configuring instance for %s\n", phy_name);
 
diff --git a/drivers/net/ethernet/brocade/bna/bfa_ioc.c b/drivers/net/ethernet/brocade/bna/bfa_ioc.c
index 594a2ab36d31..68f3c13c9ef6 100644
--- a/drivers/net/ethernet/brocade/bna/bfa_ioc.c
+++ b/drivers/net/ethernet/brocade/bna/bfa_ioc.c
@@ -2414,7 +2414,7 @@ bfa_ioc_boot(struct bfa_ioc *ioc, enum bfi_fwboot_type boot_type,
         if (status == BFA_STATUS_OK)
                 bfa_ioc_lpu_start(ioc);
         else
-                bfa_nw_iocpf_timeout(ioc);
+                bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_TIMEOUT);
 
         return status;
 }
@@ -3029,7 +3029,7 @@ bfa_ioc_poll_fwinit(struct bfa_ioc *ioc)
         }
 
         if (ioc->iocpf.poll_time >= BFA_IOC_TOV) {
-                bfa_nw_iocpf_timeout(ioc);
+                bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_TIMEOUT);
         } else {
                 ioc->iocpf.poll_time += BFA_IOC_POLL_TOV;
                 mod_timer(&ioc->iocpf_timer, jiffies +
diff --git a/drivers/net/ethernet/brocade/bna/bnad.c b/drivers/net/ethernet/brocade/bna/bnad.c
index 37072a83f9d6..caae6cb2bc1a 100644
--- a/drivers/net/ethernet/brocade/bna/bnad.c
+++ b/drivers/net/ethernet/brocade/bna/bnad.c
@@ -3701,10 +3701,6 @@ bnad_pci_probe(struct pci_dev *pdev,
         setup_timer(&bnad->bna.ioceth.ioc.sem_timer, bnad_iocpf_sem_timeout,
                                 ((unsigned long)bnad));
 
-        /* Now start the timer before calling IOC */
-        mod_timer(&bnad->bna.ioceth.ioc.iocpf_timer,
-                  jiffies + msecs_to_jiffies(BNA_IOC_TIMER_FREQ));
-
         /*
          * Start the chip
          * If the call back comes with error, we bail out.
diff --git a/drivers/net/ethernet/brocade/bna/cna_fwimg.c b/drivers/net/ethernet/brocade/bna/cna_fwimg.c
index ebf462d8082f..badea368bdc8 100644
--- a/drivers/net/ethernet/brocade/bna/cna_fwimg.c
+++ b/drivers/net/ethernet/brocade/bna/cna_fwimg.c
@@ -30,6 +30,7 @@ cna_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
                         u32 *bfi_image_size, char *fw_name)
 {
         const struct firmware *fw;
+        u32 n;
 
         if (request_firmware(&fw, fw_name, &pdev->dev)) {
                 pr_alert("Can't locate firmware %s\n", fw_name);
@@ -40,6 +41,12 @@ cna_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
         *bfi_image_size = fw->size/sizeof(u32);
         bfi_fw = fw;
 
+        /* Convert loaded firmware to host order as it is stored in file
+         * as sequence of LE32 integers.
+         */
+        for (n = 0; n < *bfi_image_size; n++)
+                le32_to_cpus(*bfi_image + n);
+
         return *bfi_image;
 error:
         return NULL;
diff --git a/drivers/net/ethernet/cisco/enic/enic_ethtool.c b/drivers/net/ethernet/cisco/enic/enic_ethtool.c
index 28d9ca675a27..68d47b196dae 100644
--- a/drivers/net/ethernet/cisco/enic/enic_ethtool.c
+++ b/drivers/net/ethernet/cisco/enic/enic_ethtool.c
@@ -131,8 +131,15 @@ static void enic_get_drvinfo(struct net_device *netdev,
 {
         struct enic *enic = netdev_priv(netdev);
         struct vnic_devcmd_fw_info *fw_info;
+        int err;
 
-        enic_dev_fw_info(enic, &fw_info);
+        err = enic_dev_fw_info(enic, &fw_info);
+        /* return only when pci_zalloc_consistent fails in vnic_dev_fw_info
+         * For other failures, like devcmd failure, we return previously
+         * recorded info.
+         */
+        if (err == -ENOMEM)
+                return;
 
         strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
         strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
@@ -181,8 +188,15 @@ static void enic_get_ethtool_stats(struct net_device *netdev,
         struct enic *enic = netdev_priv(netdev);
         struct vnic_stats *vstats;
         unsigned int i;
-
-        enic_dev_stats_dump(enic, &vstats);
+        int err;
+
+        err = enic_dev_stats_dump(enic, &vstats);
+        /* return only when pci_zalloc_consistent fails in vnic_dev_stats_dump
+         * For other failures, like devcmd failure, we return previously
+         * recorded stats.
+         */
+        if (err == -ENOMEM)
+                return;
 
         for (i = 0; i < enic_n_tx_stats; i++)
                 *(data++) = ((u64 *)&vstats->tx)[enic_tx_stats[i].index];
diff --git a/drivers/net/ethernet/cisco/enic/enic_main.c b/drivers/net/ethernet/cisco/enic/enic_main.c
index 204bd182473b..eadae1b412c6 100644
--- a/drivers/net/ethernet/cisco/enic/enic_main.c
+++ b/drivers/net/ethernet/cisco/enic/enic_main.c
@@ -615,8 +615,15 @@ static struct rtnl_link_stats64 *enic_get_stats(struct net_device *netdev,
 {
         struct enic *enic = netdev_priv(netdev);
         struct vnic_stats *stats;
+        int err;
 
-        enic_dev_stats_dump(enic, &stats);
+        err = enic_dev_stats_dump(enic, &stats);
+        /* return only when pci_zalloc_consistent fails in vnic_dev_stats_dump
+         * For other failures, like devcmd failure, we return previously
+         * recorded stats.
+         */
+        if (err == -ENOMEM)
+                return net_stats;
 
         net_stats->tx_packets = stats->tx.tx_frames_ok;
         net_stats->tx_bytes = stats->tx.tx_bytes_ok;
@@ -1407,6 +1414,7 @@ static int enic_poll_msix_rq(struct napi_struct *napi, int budget)
                  */
                 enic_calc_int_moderation(enic, &enic->rq[rq]);
 
+        enic_poll_unlock_napi(&enic->rq[rq]);
         if (work_done < work_to_do) {
 
                 /* Some work done, but not enough to stay in polling,
@@ -1418,7 +1426,6 @@ static int enic_poll_msix_rq(struct napi_struct *napi, int budget)
                         enic_set_int_moderation(enic, &enic->rq[rq]);
                 vnic_intr_unmask(&enic->intr[intr]);
         }
-        enic_poll_unlock_napi(&enic->rq[rq]);
 
         return work_done;
 }
diff --git a/drivers/net/ethernet/cisco/enic/vnic_rq.c b/drivers/net/ethernet/cisco/enic/vnic_rq.c
index 36a2ed606c91..c4b2183bf352 100644
--- a/drivers/net/ethernet/cisco/enic/vnic_rq.c
+++ b/drivers/net/ethernet/cisco/enic/vnic_rq.c
@@ -188,16 +188,15 @@ void vnic_rq_clean(struct vnic_rq *rq,
         struct vnic_rq_buf *buf;
         u32 fetch_index;
         unsigned int count = rq->ring.desc_count;
+        int i;
 
         buf = rq->to_clean;
 
-        while (vnic_rq_desc_used(rq) > 0) {
-
+        for (i = 0; i < rq->ring.desc_count; i++) {
                 (*buf_clean)(rq, buf);
-
-                buf = rq->to_clean = buf->next;
-                rq->ring.desc_avail++;
+                buf = buf->next;
         }
+        rq->ring.desc_avail = rq->ring.desc_count - 1;
 
         /* Use current fetch_index as the ring starting point */
         fetch_index = ioread32(&rq->ctrl->fetch_index);
diff --git a/drivers/net/ethernet/emulex/benet/be_cmds.c b/drivers/net/ethernet/emulex/benet/be_cmds.c
index fb140faeafb1..c5e1d0ac75f9 100644
--- a/drivers/net/ethernet/emulex/benet/be_cmds.c
+++ b/drivers/net/ethernet/emulex/benet/be_cmds.c
@@ -1720,9 +1720,9 @@ int be_cmd_get_regs(struct be_adapter *adapter, u32 buf_len, void *buf)
         total_size = buf_len;
 
         get_fat_cmd.size = sizeof(struct be_cmd_req_get_fat) + 60*1024;
-        get_fat_cmd.va = pci_alloc_consistent(adapter->pdev,
-                                              get_fat_cmd.size,
-                                              &get_fat_cmd.dma);
+        get_fat_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
+                                             get_fat_cmd.size,
+                                             &get_fat_cmd.dma, GFP_ATOMIC);
         if (!get_fat_cmd.va) {
                 dev_err(&adapter->pdev->dev,
                         "Memory allocation failure while reading FAT data\n");
@@ -1767,8 +1767,8 @@ int be_cmd_get_regs(struct be_adapter *adapter, u32 buf_len, void *buf)
                 log_offset += buf_size;
         }
 err:
-        pci_free_consistent(adapter->pdev, get_fat_cmd.size,
-                            get_fat_cmd.va, get_fat_cmd.dma);
+        dma_free_coherent(&adapter->pdev->dev, get_fat_cmd.size,
+                          get_fat_cmd.va, get_fat_cmd.dma);
         spin_unlock_bh(&adapter->mcc_lock);
         return status;
 }
@@ -2215,12 +2215,12 @@ int be_cmd_read_port_transceiver_data(struct be_adapter *adapter,
                 return -EINVAL;
 
         cmd.size = sizeof(struct be_cmd_resp_port_type);
-        cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);
+        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                     GFP_ATOMIC);
         if (!cmd.va) {
                 dev_err(&adapter->pdev->dev, "Memory allocation failed\n");
                 return -ENOMEM;
         }
-        memset(cmd.va, 0, cmd.size);
 
         spin_lock_bh(&adapter->mcc_lock);
 
@@ -2245,7 +2245,7 @@ int be_cmd_read_port_transceiver_data(struct be_adapter *adapter,
         }
 err:
         spin_unlock_bh(&adapter->mcc_lock);
-        pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);
+        dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va, cmd.dma);
         return status;
 }
 
@@ -2720,7 +2720,8 @@ int be_cmd_get_phy_info(struct be_adapter *adapter)
                 goto err;
         }
         cmd.size = sizeof(struct be_cmd_req_get_phy_info);
-        cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);
+        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                     GFP_ATOMIC);
         if (!cmd.va) {
                 dev_err(&adapter->pdev->dev, "Memory alloc failure\n");
                 status = -ENOMEM;
@@ -2754,7 +2755,7 @@ int be_cmd_get_phy_info(struct be_adapter *adapter)
                                 BE_SUPPORTED_SPEED_1GBPS;
                 }
         }
-        pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);
+        dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va, cmd.dma);
 err:
         spin_unlock_bh(&adapter->mcc_lock);
         return status;
@@ -2805,8 +2806,9 @@ int be_cmd_get_cntl_attributes(struct be_adapter *adapter)
 
         memset(&attribs_cmd, 0, sizeof(struct be_dma_mem));
         attribs_cmd.size = sizeof(struct be_cmd_resp_cntl_attribs);
-        attribs_cmd.va = pci_alloc_consistent(adapter->pdev, attribs_cmd.size,
-                                              &attribs_cmd.dma);
+        attribs_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
+                                             attribs_cmd.size,
+                                             &attribs_cmd.dma, GFP_ATOMIC);
         if (!attribs_cmd.va) {
                 dev_err(&adapter->pdev->dev, "Memory allocation failure\n");
                 status = -ENOMEM;
@@ -2833,8 +2835,8 @@ int be_cmd_get_cntl_attributes(struct be_adapter *adapter)
 err:
         mutex_unlock(&adapter->mbox_lock);
         if (attribs_cmd.va)
-                pci_free_consistent(adapter->pdev, attribs_cmd.size,
-                                    attribs_cmd.va, attribs_cmd.dma);
+                dma_free_coherent(&adapter->pdev->dev, attribs_cmd.size,
+                                  attribs_cmd.va, attribs_cmd.dma);
         return status;
 }
 
@@ -2972,9 +2974,10 @@ int be_cmd_get_mac_from_list(struct be_adapter *adapter, u8 *mac,
 
         memset(&get_mac_list_cmd, 0, sizeof(struct be_dma_mem));
         get_mac_list_cmd.size = sizeof(struct be_cmd_resp_get_mac_list);
-        get_mac_list_cmd.va = pci_alloc_consistent(adapter->pdev,
-                                                   get_mac_list_cmd.size,
-                                                   &get_mac_list_cmd.dma);
+        get_mac_list_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
+                                                  get_mac_list_cmd.size,
+                                                  &get_mac_list_cmd.dma,
+                                                  GFP_ATOMIC);
 
         if (!get_mac_list_cmd.va) {
                 dev_err(&adapter->pdev->dev,
@@ -3047,8 +3050,8 @@ int be_cmd_get_mac_from_list(struct be_adapter *adapter, u8 *mac,
 
 out:
         spin_unlock_bh(&adapter->mcc_lock);
-        pci_free_consistent(adapter->pdev, get_mac_list_cmd.size,
-                            get_mac_list_cmd.va, get_mac_list_cmd.dma);
+        dma_free_coherent(&adapter->pdev->dev, get_mac_list_cmd.size,
+                          get_mac_list_cmd.va, get_mac_list_cmd.dma);
         return status;
 }
 
@@ -3101,8 +3104,8 @@ int be_cmd_set_mac_list(struct be_adapter *adapter, u8 *mac_array,
 
         memset(&cmd, 0, sizeof(struct be_dma_mem));
         cmd.size = sizeof(struct be_cmd_req_set_mac_list);
-        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size,
-                                    &cmd.dma, GFP_KERNEL);
+        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                     GFP_KERNEL);
         if (!cmd.va)
                 return -ENOMEM;
 
@@ -3291,7 +3294,8 @@ int be_cmd_get_acpi_wol_cap(struct be_adapter *adapter)
 
         memset(&cmd, 0, sizeof(struct be_dma_mem));
         cmd.size = sizeof(struct be_cmd_resp_acpi_wol_magic_config_v1);
-        cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);
+        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                     GFP_ATOMIC);
         if (!cmd.va) {
                 dev_err(&adapter->pdev->dev, "Memory allocation failure\n");
                 status = -ENOMEM;
@@ -3326,7 +3330,8 @@ int be_cmd_get_acpi_wol_cap(struct be_adapter *adapter)
 err:
         mutex_unlock(&adapter->mbox_lock);
         if (cmd.va)
-                pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);
+                dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,
+                                  cmd.dma);
         return status;
 
 }
@@ -3340,8 +3345,9 @@ int be_cmd_set_fw_log_level(struct be_adapter *adapter, u32 level)
 
         memset(&extfat_cmd, 0, sizeof(struct be_dma_mem));
         extfat_cmd.size = sizeof(struct be_cmd_resp_get_ext_fat_caps);
-        extfat_cmd.va = pci_alloc_consistent(adapter->pdev, extfat_cmd.size,
-                                             &extfat_cmd.dma);
+        extfat_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
+                                            extfat_cmd.size, &extfat_cmd.dma,
+                                            GFP_ATOMIC);
         if (!extfat_cmd.va)
                 return -ENOMEM;
 
@@ -3363,8 +3369,8 @@ int be_cmd_set_fw_log_level(struct be_adapter *adapter, u32 level)
 
         status = be_cmd_set_ext_fat_capabilites(adapter, &extfat_cmd, cfgs);
 err:
-        pci_free_consistent(adapter->pdev, extfat_cmd.size, extfat_cmd.va,
-                            extfat_cmd.dma);
+        dma_free_coherent(&adapter->pdev->dev, extfat_cmd.size, extfat_cmd.va,
+                          extfat_cmd.dma);
         return status;
 }
 
@@ -3377,8 +3383,9 @@ int be_cmd_get_fw_log_level(struct be_adapter *adapter)
 
         memset(&extfat_cmd, 0, sizeof(struct be_dma_mem));
         extfat_cmd.size = sizeof(struct be_cmd_resp_get_ext_fat_caps);
-        extfat_cmd.va = pci_alloc_consistent(adapter->pdev, extfat_cmd.size,
-                                             &extfat_cmd.dma);
+        extfat_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
+                                            extfat_cmd.size, &extfat_cmd.dma,
+                                            GFP_ATOMIC);
 
         if (!extfat_cmd.va) {
                 dev_err(&adapter->pdev->dev, "%s: Memory allocation failure\n",
@@ -3396,8 +3403,8 @@ int be_cmd_get_fw_log_level(struct be_adapter *adapter)
                                 level = cfgs->module[0].trace_lvl[j].dbg_lvl;
                 }
         }
-        pci_free_consistent(adapter->pdev, extfat_cmd.size, extfat_cmd.va,
-                            extfat_cmd.dma);
+        dma_free_coherent(&adapter->pdev->dev, extfat_cmd.size, extfat_cmd.va,
+                          extfat_cmd.dma);
 err:
         return level;
 }
@@ -3595,7 +3602,8 @@ int be_cmd_get_func_config(struct be_adapter *adapter, struct be_resources *res)
 
         memset(&cmd, 0, sizeof(struct be_dma_mem));
         cmd.size = sizeof(struct be_cmd_resp_get_func_config);
-        cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);
+        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                     GFP_ATOMIC);
         if (!cmd.va) {
                 dev_err(&adapter->pdev->dev, "Memory alloc failure\n");
                 status = -ENOMEM;
@@ -3635,7 +3643,8 @@ int be_cmd_get_func_config(struct be_adapter *adapter, struct be_resources *res)
 err:
         mutex_unlock(&adapter->mbox_lock);
         if (cmd.va)
-                pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);
+                dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,
+                                  cmd.dma);
         return status;
 }
 
@@ -3656,7 +3665,8 @@ int be_cmd_get_profile_config(struct be_adapter *adapter,
 
         memset(&cmd, 0, sizeof(struct be_dma_mem));
         cmd.size = sizeof(struct be_cmd_resp_get_profile_config);
-        cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);
+        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                     GFP_ATOMIC);
         if (!cmd.va)
                 return -ENOMEM;
 
@@ -3702,7 +3712,8 @@ int be_cmd_get_profile_config(struct be_adapter *adapter,
                 res->vf_if_cap_flags = vf_res->cap_flags;
 err:
         if (cmd.va)
-                pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);
+                dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,
+                                  cmd.dma);
         return status;
 }
 
@@ -3717,7 +3728,8 @@ static int be_cmd_set_profile_config(struct be_adapter *adapter, void *desc,
 
         memset(&cmd, 0, sizeof(struct be_dma_mem));
         cmd.size = sizeof(struct be_cmd_req_set_profile_config);
-        cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);
+        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                     GFP_ATOMIC);
         if (!cmd.va)
                 return -ENOMEM;
 
@@ -3733,7 +3745,8 @@ static int be_cmd_set_profile_config(struct be_adapter *adapter, void *desc,
         status = be_cmd_notify_wait(adapter, &wrb);
 
         if (cmd.va)
-                pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);
+                dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,
+                                  cmd.dma);
         return status;
 }
 
diff --git a/drivers/net/ethernet/emulex/benet/be_ethtool.c b/drivers/net/ethernet/emulex/benet/be_ethtool.c
index b765c24625bf..2835dee5dc39 100644
--- a/drivers/net/ethernet/emulex/benet/be_ethtool.c
+++ b/drivers/net/ethernet/emulex/benet/be_ethtool.c
@@ -264,8 +264,8 @@ static int lancer_cmd_read_file(struct be_adapter *adapter, u8 *file_name,
         int status = 0;
 
         read_cmd.size = LANCER_READ_FILE_CHUNK;
-        read_cmd.va = pci_alloc_consistent(adapter->pdev, read_cmd.size,
-                                           &read_cmd.dma);
+        read_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, read_cmd.size,
+                                          &read_cmd.dma, GFP_ATOMIC);
 
         if (!read_cmd.va) {
                 dev_err(&adapter->pdev->dev,
@@ -289,8 +289,8 @@ static int lancer_cmd_read_file(struct be_adapter *adapter, u8 *file_name,
                         break;
                 }
         }
-        pci_free_consistent(adapter->pdev, read_cmd.size, read_cmd.va,
-                            read_cmd.dma);
+        dma_free_coherent(&adapter->pdev->dev, read_cmd.size, read_cmd.va,
+                          read_cmd.dma);
 
         return status;
 }
@@ -818,8 +818,9 @@ static int be_test_ddr_dma(struct be_adapter *adapter)
         };
 
         ddrdma_cmd.size = sizeof(struct be_cmd_req_ddrdma_test);
-        ddrdma_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, ddrdma_cmd.size,
-                                           &ddrdma_cmd.dma, GFP_KERNEL);
+        ddrdma_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
+                                            ddrdma_cmd.size, &ddrdma_cmd.dma,
+                                            GFP_KERNEL);
         if (!ddrdma_cmd.va)
                 return -ENOMEM;
 
@@ -941,8 +942,9 @@ static int be_read_eeprom(struct net_device *netdev,
 
         memset(&eeprom_cmd, 0, sizeof(struct be_dma_mem));
         eeprom_cmd.size = sizeof(struct be_cmd_req_seeprom_read);
-        eeprom_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, eeprom_cmd.size,
-                                           &eeprom_cmd.dma, GFP_KERNEL);
+        eeprom_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
+                                            eeprom_cmd.size, &eeprom_cmd.dma,
+                                            GFP_KERNEL);
 
         if (!eeprom_cmd.va)
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/emulex/benet/be_main.c b/drivers/net/ethernet/emulex/benet/be_main.c
index 6f9ffb9026cd..e43cc8a73ea7 100644
--- a/drivers/net/ethernet/emulex/benet/be_main.c
+++ b/drivers/net/ethernet/emulex/benet/be_main.c
@@ -4605,8 +4605,8 @@ static int lancer_fw_download(struct be_adapter *adapter,
 
         flash_cmd.size = sizeof(struct lancer_cmd_req_write_object)
                                 + LANCER_FW_DOWNLOAD_CHUNK;
-        flash_cmd.va = dma_alloc_coherent(dev, flash_cmd.size,
-                                          &flash_cmd.dma, GFP_KERNEL);
+        flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size,
+                                           &flash_cmd.dma, GFP_KERNEL);
         if (!flash_cmd.va)
                 return -ENOMEM;
 
@@ -4739,8 +4739,8 @@ static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)
         }
 
         flash_cmd.size = sizeof(struct be_cmd_write_flashrom);
-        flash_cmd.va = dma_alloc_coherent(dev, flash_cmd.size, &flash_cmd.dma,
-                                          GFP_KERNEL);
+        flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size, &flash_cmd.dma,
+                                           GFP_KERNEL);
         if (!flash_cmd.va)
                 return -ENOMEM;
 
@@ -5291,16 +5291,15 @@ static int be_drv_init(struct be_adapter *adapter)
         int status = 0;
 
         mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
-        mbox_mem_alloc->va = dma_alloc_coherent(dev, mbox_mem_alloc->size,
-                                                &mbox_mem_alloc->dma,
-                                                GFP_KERNEL);
+        mbox_mem_alloc->va = dma_zalloc_coherent(dev, mbox_mem_alloc->size,
+                                                 &mbox_mem_alloc->dma,
+                                                 GFP_KERNEL);
         if (!mbox_mem_alloc->va)
                 return -ENOMEM;
 
         mbox_mem_align->size = sizeof(struct be_mcc_mailbox);
         mbox_mem_align->va = PTR_ALIGN(mbox_mem_alloc->va, 16);
         mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);
-        memset(mbox_mem_align->va, 0, sizeof(struct be_mcc_mailbox));
 
         rx_filter->size = sizeof(struct be_cmd_req_rx_filter);
         rx_filter->va = dma_zalloc_coherent(dev, rx_filter->size,
diff --git a/drivers/net/ethernet/intel/i40e/i40e.h b/drivers/net/ethernet/intel/i40e/i40e.h
index 33c35d3b7420..5d47307121ab 100644
--- a/drivers/net/ethernet/intel/i40e/i40e.h
+++ b/drivers/net/ethernet/intel/i40e/i40e.h
@@ -317,6 +317,7 @@ struct i40e_pf {
 #endif
 #define I40E_FLAG_PORT_ID_VALID                (u64)(1 << 28)
 #define I40E_FLAG_DCB_CAPABLE                  (u64)(1 << 29)
+#define I40E_FLAG_VEB_MODE_ENABLED              BIT_ULL(40)
 
         /* tracks features that get auto disabled by errors */
         u64 auto_disable_flags;
diff --git a/drivers/net/ethernet/intel/i40e/i40e_debugfs.c b/drivers/net/ethernet/intel/i40e/i40e_debugfs.c
index 34170eabca7d..da0faf478af0 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_debugfs.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_debugfs.c
@@ -1021,6 +1021,15 @@ static ssize_t i40e_dbg_command_write(struct file *filp,
                         goto command_write_done;
                 }
 
+                /* By default we are in VEPA mode, if this is the first VF/VMDq
+                 * VSI to be added switch to VEB mode.
+                 */
+                if (!(pf->flags & I40E_FLAG_VEB_MODE_ENABLED)) {
+                        pf->flags |= I40E_FLAG_VEB_MODE_ENABLED;
+                        i40e_do_reset_safe(pf,
+                                           BIT_ULL(__I40E_PF_RESET_REQUESTED));
+                }
+
                 vsi = i40e_vsi_setup(pf, I40E_VSI_VMDQ2, vsi_seid, 0);
                 if (vsi)
                         dev_info(&pf->pdev->dev, "added VSI %d to relay %d\n",
diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c
index a54c14491e3b..5b5bea159bd5 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_main.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_main.c
@@ -6097,6 +6097,10 @@ static int i40e_reconstitute_veb(struct i40e_veb *veb)
         if (ret)
                 goto end_reconstitute;
 
+        if (pf->flags & I40E_FLAG_VEB_MODE_ENABLED)
+                veb->bridge_mode = BRIDGE_MODE_VEB;
+        else
+                veb->bridge_mode = BRIDGE_MODE_VEPA;
         i40e_config_bridge_mode(veb);
 
         /* create the remaining VSIs attached to this VEB */
@@ -8031,7 +8035,12 @@ static int i40e_ndo_bridge_setlink(struct net_device *dev,
                 } else if (mode != veb->bridge_mode) {
                         /* Existing HW bridge but different mode needs reset */
                         veb->bridge_mode = mode;
-                        i40e_do_reset(pf, (1 << __I40E_PF_RESET_REQUESTED));
+                        /* TODO: If no VFs or VMDq VSIs, disallow VEB mode */
+                        if (mode == BRIDGE_MODE_VEB)
+                                pf->flags |= I40E_FLAG_VEB_MODE_ENABLED;
+                        else
+                                pf->flags &= ~I40E_FLAG_VEB_MODE_ENABLED;
+                        i40e_do_reset(pf, BIT_ULL(__I40E_PF_RESET_REQUESTED));
                         break;
                 }
         }
@@ -8343,11 +8352,12 @@ static int i40e_add_vsi(struct i40e_vsi *vsi)
                 ctxt.uplink_seid = vsi->uplink_seid;
                 ctxt.connection_type = I40E_AQ_VSI_CONN_TYPE_NORMAL;
                 ctxt.flags = I40E_AQ_VSI_TYPE_PF;
-                if (i40e_is_vsi_uplink_mode_veb(vsi)) {
+                if ((pf->flags & I40E_FLAG_VEB_MODE_ENABLED) &&
+                    (i40e_is_vsi_uplink_mode_veb(vsi))) {
                         ctxt.info.valid_sections |=
-                                cpu_to_le16(I40E_AQ_VSI_PROP_SWITCH_VALID);
+                             cpu_to_le16(I40E_AQ_VSI_PROP_SWITCH_VALID);
                         ctxt.info.switch_id =
-                                cpu_to_le16(I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB);
+                           cpu_to_le16(I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB);
                 }
                 i40e_vsi_setup_queue_map(vsi, &ctxt, enabled_tc, true);
                 break;
@@ -8746,6 +8756,14 @@ struct i40e_vsi *i40e_vsi_setup(struct i40e_pf *pf, u8 type,
                                          __func__);
                                 return NULL;
                         }
+                        /* We come up by default in VEPA mode if SRIOV is not
+                         * already enabled, in which case we can't force VEPA
+                         * mode.
+                         */
+                        if (!(pf->flags & I40E_FLAG_VEB_MODE_ENABLED)) {
+                                veb->bridge_mode = BRIDGE_MODE_VEPA;
+                                pf->flags &= ~I40E_FLAG_VEB_MODE_ENABLED;
+                        }
                         i40e_config_bridge_mode(veb);
                 }
                 for (i = 0; i < I40E_MAX_VEB && !veb; i++) {
@@ -9856,6 +9874,15 @@ static int i40e_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 goto err_switch_setup;
         }
 
+#ifdef CONFIG_PCI_IOV
+        /* prep for VF support */
+        if ((pf->flags & I40E_FLAG_SRIOV_ENABLED) &&
+            (pf->flags & I40E_FLAG_MSIX_ENABLED) &&
+            !test_bit(__I40E_BAD_EEPROM, &pf->state)) {
+                if (pci_num_vf(pdev))
+                        pf->flags |= I40E_FLAG_VEB_MODE_ENABLED;
+        }
+#endif
         err = i40e_setup_pf_switch(pf, false);
         if (err) {
                 dev_info(&pdev->dev, "setup_pf_switch failed: %d\n", err);
diff --git a/drivers/net/ethernet/intel/i40e/i40e_txrx.c b/drivers/net/ethernet/intel/i40e/i40e_txrx.c
index 4bd3a80aba82..9d95042d5a0f 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_txrx.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_txrx.c
@@ -2410,14 +2410,12 @@ static int i40e_maybe_stop_tx(struct i40e_ring *tx_ring, int size)
  * i40e_chk_linearize - Check if there are more than 8 fragments per packet
  * @skb:      send buffer
  * @tx_flags: collected send information
- * @hdr_len:  size of the packet header
  *
  * Note: Our HW can't scatter-gather more than 8 fragments to build
  * a packet on the wire and so we need to figure out the cases where we
  * need to linearize the skb.
  **/
-static bool i40e_chk_linearize(struct sk_buff *skb, u32 tx_flags,
-                               const u8 hdr_len)
+static bool i40e_chk_linearize(struct sk_buff *skb, u32 tx_flags)
 {
         struct skb_frag_struct *frag;
         bool linearize = false;
@@ -2429,7 +2427,7 @@ static bool i40e_chk_linearize(struct sk_buff *skb, u32 tx_flags,
         gso_segs = skb_shinfo(skb)->gso_segs;
 
         if (tx_flags & (I40E_TX_FLAGS_TSO | I40E_TX_FLAGS_FSO)) {
-                u16 j = 1;
+                u16 j = 0;
 
                 if (num_frags < (I40E_MAX_BUFFER_TXD))
                         goto linearize_chk_done;
@@ -2440,21 +2438,18 @@ static bool i40e_chk_linearize(struct sk_buff *skb, u32 tx_flags,
                         goto linearize_chk_done;
                 }
                 frag = &skb_shinfo(skb)->frags[0];
-                size = hdr_len;
                 /* we might still have more fragments per segment */
                 do {
                         size += skb_frag_size(frag);
                         frag++; j++;
+                        if ((size >= skb_shinfo(skb)->gso_size) &&
+                            (j < I40E_MAX_BUFFER_TXD)) {
+                                size = (size % skb_shinfo(skb)->gso_size);
+                                j = (size) ? 1 : 0;
+                        }
                         if (j == I40E_MAX_BUFFER_TXD) {
-                                if (size < skb_shinfo(skb)->gso_size) {
-                                        linearize = true;
-                                        break;
-                                }
-                                j = 1;
-                                size -= skb_shinfo(skb)->gso_size;
-                                if (size)
-                                        j++;
-                                size += hdr_len;
+                                linearize = true;
+                                break;
                         }
                         num_frags--;
                 } while (num_frags);
@@ -2724,7 +2719,7 @@ static netdev_tx_t i40e_xmit_frame_ring(struct sk_buff *skb,
         if (tsyn)
                 tx_flags |= I40E_TX_FLAGS_TSYN;
 
-        if (i40e_chk_linearize(skb, tx_flags, hdr_len))
+        if (i40e_chk_linearize(skb, tx_flags))
                 if (skb_linearize(skb))
                         goto out_drop;
 
diff --git a/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c b/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c
index 78d1c4ff565e..4e9376da0518 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c
@@ -1018,11 +1018,19 @@ int i40e_pci_sriov_configure(struct pci_dev *pdev, int num_vfs)
 {
         struct i40e_pf *pf = pci_get_drvdata(pdev);
 
-        if (num_vfs)
+        if (num_vfs) {
+                if (!(pf->flags & I40E_FLAG_VEB_MODE_ENABLED)) {
+                        pf->flags |= I40E_FLAG_VEB_MODE_ENABLED;
+                        i40e_do_reset_safe(pf,
+                                           BIT_ULL(__I40E_PF_RESET_REQUESTED));
+                }
                 return i40e_pci_sriov_enable(pdev, num_vfs);
+        }
 
         if (!pci_vfs_assigned(pf->pdev)) {
                 i40e_free_vfs(pf);
+                pf->flags &= ~I40E_FLAG_VEB_MODE_ENABLED;
+                i40e_do_reset_safe(pf, BIT_ULL(__I40E_PF_RESET_REQUESTED));
         } else {
                 dev_warn(&pdev->dev, "Unable to free VFs because some are assigned to VMs.\n");
                 return -EINVAL;
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_txrx.c b/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
index b077e02a0cc7..458fbb421090 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
+++ b/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
@@ -1619,14 +1619,12 @@ static void i40e_create_tx_ctx(struct i40e_ring *tx_ring,
  * i40e_chk_linearize - Check if there are more than 8 fragments per packet
  * @skb:      send buffer
  * @tx_flags: collected send information
- * @hdr_len:  size of the packet header
  *
  * Note: Our HW can't scatter-gather more than 8 fragments to build
  * a packet on the wire and so we need to figure out the cases where we
  * need to linearize the skb.
  **/
-static bool i40e_chk_linearize(struct sk_buff *skb, u32 tx_flags,
-                               const u8 hdr_len)
+static bool i40e_chk_linearize(struct sk_buff *skb, u32 tx_flags)
 {
         struct skb_frag_struct *frag;
         bool linearize = false;
@@ -1638,7 +1636,7 @@ static bool i40e_chk_linearize(struct sk_buff *skb, u32 tx_flags,
         gso_segs = skb_shinfo(skb)->gso_segs;
 
         if (tx_flags & (I40E_TX_FLAGS_TSO | I40E_TX_FLAGS_FSO)) {
-                u16 j = 1;
+                u16 j = 0;
 
                 if (num_frags < (I40E_MAX_BUFFER_TXD))
                         goto linearize_chk_done;
@@ -1649,21 +1647,18 @@ static bool i40e_chk_linearize(struct sk_buff *skb, u32 tx_flags,
                         goto linearize_chk_done;
                 }
                 frag = &skb_shinfo(skb)->frags[0];
-                size = hdr_len;
                 /* we might still have more fragments per segment */
                 do {
                         size += skb_frag_size(frag);
                         frag++; j++;
+                        if ((size >= skb_shinfo(skb)->gso_size) &&
+                            (j < I40E_MAX_BUFFER_TXD)) {
+                                size = (size % skb_shinfo(skb)->gso_size);
+                                j = (size) ? 1 : 0;
+                        }
                         if (j == I40E_MAX_BUFFER_TXD) {
-                                if (size < skb_shinfo(skb)->gso_size) {
-                                        linearize = true;
-                                        break;
-                                }
-                                j = 1;
-                                size -= skb_shinfo(skb)->gso_size;
-                                if (size)
-                                        j++;
-                                size += hdr_len;
+                                linearize = true;
+                                break;
                         }
                         num_frags--;
                 } while (num_frags);
@@ -1950,7 +1945,7 @@ static netdev_tx_t i40e_xmit_frame_ring(struct sk_buff *skb,
         else if (tso)
                 tx_flags |= I40E_TX_FLAGS_TSO;
 
-        if (i40e_chk_linearize(skb, tx_flags, hdr_len))
+        if (i40e_chk_linearize(skb, tx_flags))
                 if (skb_linearize(skb))
                         goto out_drop;
 
diff --git a/drivers/net/ethernet/intel/igb/igb_ptp.c b/drivers/net/ethernet/intel/igb/igb_ptp.c
index e3b9b63ad010..c3a9392cbc19 100644
--- a/drivers/net/ethernet/intel/igb/igb_ptp.c
+++ b/drivers/net/ethernet/intel/igb/igb_ptp.c
@@ -538,8 +538,8 @@ static int igb_ptp_feature_enable_i210(struct ptp_clock_info *ptp,
                         igb->perout[i].start.tv_nsec = rq->perout.start.nsec;
                         igb->perout[i].period.tv_sec = ts.tv_sec;
                         igb->perout[i].period.tv_nsec = ts.tv_nsec;
-                        wr32(trgttiml, rq->perout.start.sec);
-                        wr32(trgttimh, rq->perout.start.nsec);
+                        wr32(trgttimh, rq->perout.start.sec);
+                        wr32(trgttiml, rq->perout.start.nsec);
                         tsauxc |= tsauxc_mask;
                         tsim |= tsim_mask;
                 } else {
diff --git a/drivers/net/ethernet/sfc/rx.c b/drivers/net/ethernet/sfc/rx.c
index c0ad95d2f63d..809ea4610a77 100644
--- a/drivers/net/ethernet/sfc/rx.c
+++ b/drivers/net/ethernet/sfc/rx.c
@@ -224,12 +224,17 @@ static void efx_unmap_rx_buffer(struct efx_nic *efx,
         }
 }
 
-static void efx_free_rx_buffer(struct efx_rx_buffer *rx_buf)
+static void efx_free_rx_buffers(struct efx_rx_queue *rx_queue,
+                                struct efx_rx_buffer *rx_buf,
+                                unsigned int num_bufs)
 {
-        if (rx_buf->page) {
-                put_page(rx_buf->page);
-                rx_buf->page = NULL;
-        }
+        do {
+                if (rx_buf->page) {
+                        put_page(rx_buf->page);
+                        rx_buf->page = NULL;
+                }
+                rx_buf = efx_rx_buf_next(rx_queue, rx_buf);
+        } while (--num_bufs);
 }
 
 /* Attempt to recycle the page if there is an RX recycle ring; the page can
@@ -278,7 +283,7 @@ static void efx_fini_rx_buffer(struct efx_rx_queue *rx_queue,
         /* If this is the last buffer in a page, unmap and free it. */
         if (rx_buf->flags & EFX_RX_BUF_LAST_IN_PAGE) {
                 efx_unmap_rx_buffer(rx_queue->efx, rx_buf);
-                efx_free_rx_buffer(rx_buf);
+                efx_free_rx_buffers(rx_queue, rx_buf, 1);
         }
         rx_buf->page = NULL;
 }
@@ -304,10 +309,7 @@ static void efx_discard_rx_packet(struct efx_channel *channel,
 
         efx_recycle_rx_pages(channel, rx_buf, n_frags);
 
-        do {
-                efx_free_rx_buffer(rx_buf);
-                rx_buf = efx_rx_buf_next(rx_queue, rx_buf);
-        } while (--n_frags);
+        efx_free_rx_buffers(rx_queue, rx_buf, n_frags);
 }
 
 /**
@@ -431,11 +433,10 @@ efx_rx_packet_gro(struct efx_channel *channel, struct efx_rx_buffer *rx_buf,
 
         skb = napi_get_frags(napi);
         if (unlikely(!skb)) {
-                while (n_frags--) {
-                        put_page(rx_buf->page);
-                        rx_buf->page = NULL;
-                        rx_buf = efx_rx_buf_next(&channel->rx_queue, rx_buf);
-                }
+                struct efx_rx_queue *rx_queue;
+
+                rx_queue = efx_channel_get_rx_queue(channel);
+                efx_free_rx_buffers(rx_queue, rx_buf, n_frags);
                 return;
         }
 
@@ -622,7 +623,10 @@ static void efx_rx_deliver(struct efx_channel *channel, u8 *eh,
 
         skb = efx_rx_mk_skb(channel, rx_buf, n_frags, eh, hdr_len);
         if (unlikely(skb == NULL)) {
-                efx_free_rx_buffer(rx_buf);
+                struct efx_rx_queue *rx_queue;
+
+                rx_queue = efx_channel_get_rx_queue(channel);
+                efx_free_rx_buffers(rx_queue, rx_buf, n_frags);
                 return;
         }
         skb_record_rx_queue(skb, channel->rx_queue.core_index);
@@ -661,8 +665,12 @@ void __efx_rx_packet(struct efx_channel *channel)
          * loopback layer, and free the rx_buf here
          */
         if (unlikely(efx->loopback_selftest)) {
+                struct efx_rx_queue *rx_queue;
+
                 efx_loopback_rx_packet(efx, eh, rx_buf->len);
-                efx_free_rx_buffer(rx_buf);
+                rx_queue = efx_channel_get_rx_queue(channel);
+                efx_free_rx_buffers(rx_queue, rx_buf,
+                                    channel->rx_pkt_n_frags);
                 goto out;
         }
 
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/msgbuf.c b/drivers/net/wireless/brcm80211/brcmfmac/msgbuf.c
index 4ec9811f49c8..65efb1468988 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/msgbuf.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/msgbuf.c
@@ -511,11 +511,9 @@ static int brcmf_msgbuf_query_dcmd(struct brcmf_pub *drvr, int ifidx,
                                      msgbuf->rx_pktids,
                                      msgbuf->ioctl_resp_pktid);
         if (msgbuf->ioctl_resp_ret_len != 0) {
-                if (!skb) {
-                        brcmf_err("Invalid packet id idx recv'd %d\n",
-                                  msgbuf->ioctl_resp_pktid);
+                if (!skb)
                         return -EBADF;
-                }
+
                 memcpy(buf, skb->data, (len < msgbuf->ioctl_resp_ret_len) ?
                                        len : msgbuf->ioctl_resp_ret_len);
         }
@@ -874,10 +872,8 @@ brcmf_msgbuf_process_txstatus(struct brcmf_msgbuf *msgbuf, void *buf)
         flowid -= BRCMF_NROF_H2D_COMMON_MSGRINGS;
         skb = brcmf_msgbuf_get_pktid(msgbuf->drvr->bus_if->dev,
                                      msgbuf->tx_pktids, idx);
-        if (!skb) {
-                brcmf_err("Invalid packet id idx recv'd %d\n", idx);
+        if (!skb)
                 return;
-        }
 
         set_bit(flowid, msgbuf->txstatus_done_map);
         commonring = msgbuf->flowrings[flowid];
@@ -1156,6 +1152,8 @@ brcmf_msgbuf_process_rx_complete(struct brcmf_msgbuf *msgbuf, void *buf)
 
         skb = brcmf_msgbuf_get_pktid(msgbuf->drvr->bus_if->dev,
                                      msgbuf->rx_pktids, idx);
+        if (!skb)
+                return;
 
         if (data_offset)
                 skb_pull(skb, data_offset);
diff --git a/drivers/net/wireless/iwlwifi/iwl-nvm-parse.c b/drivers/net/wireless/iwlwifi/iwl-nvm-parse.c
index 75e96db6626b..8e604a3931ca 100644
--- a/drivers/net/wireless/iwlwifi/iwl-nvm-parse.c
+++ b/drivers/net/wireless/iwlwifi/iwl-nvm-parse.c
@@ -471,7 +471,7 @@ static int iwl_get_radio_cfg(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
                 return le16_to_cpup(nvm_sw + RADIO_CFG);
 
-        return le32_to_cpup((__le32 *)(nvm_sw + RADIO_CFG_FAMILY_8000));
+        return le32_to_cpup((__le32 *)(phy_sku + RADIO_CFG_FAMILY_8000));
 
 }
 
diff --git a/drivers/net/wireless/iwlwifi/pcie/internal.h b/drivers/net/wireless/iwlwifi/pcie/internal.h
index 01996c9d98a7..376b84e54ad7 100644
--- a/drivers/net/wireless/iwlwifi/pcie/internal.h
+++ b/drivers/net/wireless/iwlwifi/pcie/internal.h
@@ -1,7 +1,7 @@
 /******************************************************************************
  *
- * Copyright(c) 2003 - 2014 Intel Corporation. All rights reserved.
- * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
+ * Copyright(c) 2003 - 2015 Intel Corporation. All rights reserved.
+ * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  *
  * Portions of this file are derived from the ipw3945 project, as well
  * as portions of the ieee80211 subsystem header files.
@@ -320,7 +320,7 @@ struct iwl_trans_pcie {
 
         /*protect hw register */
         spinlock_t reg_lock;
-        bool cmd_in_flight;
+        bool cmd_hold_nic_awake;
         bool ref_cmd_in_flight;
 
         /* protect ref counter */
diff --git a/drivers/net/wireless/iwlwifi/pcie/trans.c b/drivers/net/wireless/iwlwifi/pcie/trans.c
index d6f6515fe663..dc179094e6a0 100644
--- a/drivers/net/wireless/iwlwifi/pcie/trans.c
+++ b/drivers/net/wireless/iwlwifi/pcie/trans.c
@@ -1372,7 +1372,7 @@ static bool iwl_trans_pcie_grab_nic_access(struct iwl_trans *trans, bool silent,
 
         spin_lock_irqsave(&trans_pcie->reg_lock, *flags);
 
-        if (trans_pcie->cmd_in_flight)
+        if (trans_pcie->cmd_hold_nic_awake)
                 goto out;
 
         /* this bit wakes up the NIC */
@@ -1438,7 +1438,7 @@ static void iwl_trans_pcie_release_nic_access(struct iwl_trans *trans,
          */
         __acquire(&trans_pcie->reg_lock);
 
-        if (trans_pcie->cmd_in_flight)
+        if (trans_pcie->cmd_hold_nic_awake)
                 goto out;
 
         __iwl_trans_pcie_clear_bit(trans, CSR_GP_CNTRL,
diff --git a/drivers/net/wireless/iwlwifi/pcie/tx.c b/drivers/net/wireless/iwlwifi/pcie/tx.c
index 06952aadfd7b..5ef8044c2ea3 100644
--- a/drivers/net/wireless/iwlwifi/pcie/tx.c
+++ b/drivers/net/wireless/iwlwifi/pcie/tx.c
@@ -1039,18 +1039,14 @@ static int iwl_pcie_set_cmd_in_flight(struct iwl_trans *trans,
                 iwl_trans_pcie_ref(trans);
         }
 
-        if (trans_pcie->cmd_in_flight)
-                return 0;
-
-        trans_pcie->cmd_in_flight = true;
-
         /*
          * wake up the NIC to make sure that the firmware will see the host
          * command - we will let the NIC sleep once all the host commands
          * returned. This needs to be done only on NICs that have
          * apmg_wake_up_wa set.
          */
-        if (trans->cfg->base_params->apmg_wake_up_wa) {
+        if (trans->cfg->base_params->apmg_wake_up_wa &&
+            !trans_pcie->cmd_hold_nic_awake) {
                 __iwl_trans_pcie_set_bit(trans, CSR_GP_CNTRL,
                                          CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
                 if (trans->cfg->device_family == IWL_DEVICE_FAMILY_8000)
@@ -1064,10 +1060,10 @@ static int iwl_pcie_set_cmd_in_flight(struct iwl_trans *trans,
                 if (ret < 0) {
                         __iwl_trans_pcie_clear_bit(trans, CSR_GP_CNTRL,
                                         CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
-                        trans_pcie->cmd_in_flight = false;
                         IWL_ERR(trans, "Failed to wake NIC for hcmd\n");
                         return -EIO;
                 }
+                trans_pcie->cmd_hold_nic_awake = true;
         }
 
         return 0;
@@ -1085,15 +1081,14 @@ static int iwl_pcie_clear_cmd_in_flight(struct iwl_trans *trans)
                 iwl_trans_pcie_unref(trans);
         }
 
-        if (WARN_ON(!trans_pcie->cmd_in_flight))
-                return 0;
-
-        trans_pcie->cmd_in_flight = false;
+        if (trans->cfg->base_params->apmg_wake_up_wa) {
+                if (WARN_ON(!trans_pcie->cmd_hold_nic_awake))
+                        return 0;
 
-        if (trans->cfg->base_params->apmg_wake_up_wa)
+                trans_pcie->cmd_hold_nic_awake = false;
                 __iwl_trans_pcie_clear_bit(trans, CSR_GP_CNTRL,
-                                        CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
-
+                                           CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
+        }
         return 0;
 }
 
diff --git a/drivers/net/xen-netback/netback.c b/drivers/net/xen-netback/netback.c
index 4de46aa61d95..0d2594395ffb 100644
--- a/drivers/net/xen-netback/netback.c
+++ b/drivers/net/xen-netback/netback.c
@@ -1250,7 +1250,7 @@ static void xenvif_tx_build_gops(struct xenvif_queue *queue,
                         netdev_err(queue->vif->dev,
                                    "txreq.offset: %x, size: %u, end: %lu\n",
                                    txreq.offset, txreq.size,
-                                   (txreq.offset&~PAGE_MASK) + txreq.size);
+                                   (unsigned long)(txreq.offset&~PAGE_MASK) + txreq.size);
                         xenvif_fatal_tx_err(queue->vif);
                         break;
                 }
diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c
index fee02414529e..968787abf78d 100644
--- a/drivers/net/xen-netback/xenbus.c
+++ b/drivers/net/xen-netback/xenbus.c
@@ -34,6 +34,8 @@ struct backend_info {
         enum xenbus_state frontend_state;
         struct xenbus_watch hotplug_status_watch;
         u8 have_hotplug_status_watch:1;
+
+        const char *hotplug_script;
 };
 
 static int connect_rings(struct backend_info *be, struct xenvif_queue *queue);
@@ -238,6 +240,7 @@ static int netback_remove(struct xenbus_device *dev)
                 xenvif_free(be->vif);
                 be->vif = NULL;
         }
+        kfree(be->hotplug_script);
         kfree(be);
         dev_set_drvdata(&dev->dev, NULL);
         return 0;
@@ -255,6 +258,7 @@ static int netback_probe(struct xenbus_device *dev,
         struct xenbus_transaction xbt;
         int err;
         int sg;
+        const char *script;
         struct backend_info *be = kzalloc(sizeof(struct backend_info),
                                           GFP_KERNEL);
         if (!be) {
@@ -347,6 +351,15 @@ static int netback_probe(struct xenbus_device *dev,
         if (err)
                 pr_debug("Error writing multi-queue-max-queues\n");
 
+        script = xenbus_read(XBT_NIL, dev->nodename, "script", NULL);
+        if (IS_ERR(script)) {
+                err = PTR_ERR(script);
+                xenbus_dev_fatal(dev, err, "reading script");
+                goto fail;
+        }
+
+        be->hotplug_script = script;
+
         err = xenbus_switch_state(dev, XenbusStateInitWait);
         if (err)
                 goto fail;
@@ -379,22 +392,14 @@ static int netback_uevent(struct xenbus_device *xdev,
                           struct kobj_uevent_env *env)
 {
         struct backend_info *be = dev_get_drvdata(&xdev->dev);
-        char *val;
 
-        val = xenbus_read(XBT_NIL, xdev->nodename, "script", NULL);
-        if (IS_ERR(val)) {
-                int err = PTR_ERR(val);
-                xenbus_dev_fatal(xdev, err, "reading script");
-                return err;
-        } else {
-                if (add_uevent_var(env, "script=%s", val)) {
-                        kfree(val);
-                        return -ENOMEM;
-                }
-                kfree(val);
-        }
+        if (!be)
+                return 0;
+
+        if (add_uevent_var(env, "script=%s", be->hotplug_script))
+                return -ENOMEM;
 
-        if (!be || !be->vif)
+        if (!be->vif)
                 return 0;
 
         return add_uevent_var(env, "vif=%s", be->vif->dev->name);