104 files changed, 7238 insertions, 3876 deletions

diff --git a/drivers/net/ethernet/adi/Kconfig b/drivers/net/ethernet/adi/Kconfig
index 49a30d37ae4a..e49c0eff040b 100644
--- a/drivers/net/ethernet/adi/Kconfig
+++ b/drivers/net/ethernet/adi/Kconfig
@@ -61,7 +61,7 @@ config BFIN_RX_DESC_NUM
 
 config BFIN_MAC_USE_HWSTAMP
         bool "Use IEEE 1588 hwstamp"
-        depends on BFIN_MAC && BF518
+        select PTP_1588_CLOCK
         default y
         ---help---
           To support the IEEE 1588 Precision Time Protocol (PTP), select y here
diff --git a/drivers/net/ethernet/adi/bfin_mac.c b/drivers/net/ethernet/adi/bfin_mac.c
index f816426e1085..f1c458dc039a 100644
--- a/drivers/net/ethernet/adi/bfin_mac.c
+++ b/drivers/net/ethernet/adi/bfin_mac.c
@@ -548,14 +548,17 @@ static int bfin_mac_ethtool_setwol(struct net_device *dev,
         return 0;
 }
 
+#ifdef CONFIG_BFIN_MAC_USE_HWSTAMP
 static int bfin_mac_ethtool_get_ts_info(struct net_device *dev,
         struct ethtool_ts_info *info)
 {
+        struct bfin_mac_local *lp = netdev_priv(dev);
+
         info->so_timestamping =
                 SOF_TIMESTAMPING_TX_HARDWARE |
                 SOF_TIMESTAMPING_RX_HARDWARE |
-                SOF_TIMESTAMPING_SYS_HARDWARE;
-        info->phc_index = -1;
+                SOF_TIMESTAMPING_RAW_HARDWARE;
+        info->phc_index = lp->phc_index;
         info->tx_types =
                 (1 << HWTSTAMP_TX_OFF) |
                 (1 << HWTSTAMP_TX_ON);
@@ -566,6 +569,7 @@ static int bfin_mac_ethtool_get_ts_info(struct net_device *dev,
                 (1 << HWTSTAMP_FILTER_PTP_V2_L4_EVENT);
         return 0;
 }
+#endif
 
 static const struct ethtool_ops bfin_mac_ethtool_ops = {
         .get_settings = bfin_mac_ethtool_getsettings,
@@ -574,7 +578,9 @@ static const struct ethtool_ops bfin_mac_ethtool_ops = {
         .get_drvinfo = bfin_mac_ethtool_getdrvinfo,
         .get_wol = bfin_mac_ethtool_getwol,
         .set_wol = bfin_mac_ethtool_setwol,
+#ifdef CONFIG_BFIN_MAC_USE_HWSTAMP
         .get_ts_info = bfin_mac_ethtool_get_ts_info,
+#endif
 };
 
 /**************************************************************************/
@@ -649,6 +655,20 @@ static int bfin_mac_set_mac_address(struct net_device *dev, void *p)
 #ifdef CONFIG_BFIN_MAC_USE_HWSTAMP
 #define bfin_mac_hwtstamp_is_none(cfg) ((cfg) == HWTSTAMP_FILTER_NONE)
 
+static u32 bfin_select_phc_clock(u32 input_clk, unsigned int *shift_result)
+{
+        u32 ipn = 1000000000UL / input_clk;
+        u32 ppn = 1;
+        unsigned int shift = 0;
+
+        while (ppn <= ipn) {
+                ppn <<= 1;
+                shift++;
+        }
+        *shift_result = shift;
+        return 1000000000UL / ppn;
+}
+
 static int bfin_mac_hwtstamp_ioctl(struct net_device *netdev,
                 struct ifreq *ifr, int cmd)
 {
@@ -798,19 +818,7 @@ static int bfin_mac_hwtstamp_ioctl(struct net_device *netdev,
                 bfin_read_EMAC_PTP_TXSNAPLO();
                 bfin_read_EMAC_PTP_TXSNAPHI();
 
-                /*
-                 * Set registers so that rollover occurs soon to test this.
-                 */
-                bfin_write_EMAC_PTP_TIMELO(0x00000000);
-                bfin_write_EMAC_PTP_TIMEHI(0xFF800000);
-
                 SSYNC();
-
-                lp->compare.last_update = 0;
-                timecounter_init(&lp->clock,
-                                &lp->cycles,
-                                ktime_to_ns(ktime_get_real()));
-                timecompare_update(&lp->compare, 0);
         }
 
         lp->stamp_cfg = config;
@@ -818,15 +826,6 @@ static int bfin_mac_hwtstamp_ioctl(struct net_device *netdev,
                 -EFAULT : 0;
 }
 
-static void bfin_dump_hwtamp(char *s, ktime_t *hw, ktime_t *ts, struct timecompare *cmp)
-{
-        ktime_t sys = ktime_get_real();
-
-        pr_debug("%s %s hardware:%d,%d transform system:%d,%d system:%d,%d, cmp:%lld, %lld\n",
-                        __func__, s, hw->tv.sec, hw->tv.nsec, ts->tv.sec, ts->tv.nsec, sys.tv.sec,
-                        sys.tv.nsec, cmp->offset, cmp->skew);
-}
-
 static void bfin_tx_hwtstamp(struct net_device *netdev, struct sk_buff *skb)
 {
         struct bfin_mac_local *lp = netdev_priv(netdev);
@@ -857,15 +856,9 @@ static void bfin_tx_hwtstamp(struct net_device *netdev, struct sk_buff *skb)
                         regval = bfin_read_EMAC_PTP_TXSNAPLO();
                         regval |= (u64)bfin_read_EMAC_PTP_TXSNAPHI() << 32;
                         memset(&shhwtstamps, 0, sizeof(shhwtstamps));
-                        ns = timecounter_cyc2time(&lp->clock,
-                                        regval);
-                        timecompare_update(&lp->compare, ns);
+                        ns = regval << lp->shift;
                         shhwtstamps.hwtstamp = ns_to_ktime(ns);
-                        shhwtstamps.syststamp =
-                                timecompare_transform(&lp->compare, ns);
                         skb_tstamp_tx(skb, &shhwtstamps);
-
-                        bfin_dump_hwtamp("TX", &shhwtstamps.hwtstamp, &shhwtstamps.syststamp, &lp->compare);
                 }
         }
 }
@@ -888,55 +881,184 @@ static void bfin_rx_hwtstamp(struct net_device *netdev, struct sk_buff *skb)
 
         regval = bfin_read_EMAC_PTP_RXSNAPLO();
         regval |= (u64)bfin_read_EMAC_PTP_RXSNAPHI() << 32;
-        ns = timecounter_cyc2time(&lp->clock, regval);
-        timecompare_update(&lp->compare, ns);
+        ns = regval << lp->shift;
         memset(shhwtstamps, 0, sizeof(*shhwtstamps));
         shhwtstamps->hwtstamp = ns_to_ktime(ns);
-        shhwtstamps->syststamp = timecompare_transform(&lp->compare, ns);
+}
+
+static void bfin_mac_hwtstamp_init(struct net_device *netdev)
+{
+        struct bfin_mac_local *lp = netdev_priv(netdev);
+        u64 addend, ppb;
+        u32 input_clk, phc_clk;
+
+        /* Initialize hardware timer */
+        input_clk = get_sclk();
+        phc_clk = bfin_select_phc_clock(input_clk, &lp->shift);
+        addend = phc_clk * (1ULL << 32);
+        do_div(addend, input_clk);
+        bfin_write_EMAC_PTP_ADDEND((u32)addend);
+
+        lp->addend = addend;
+        ppb = 1000000000ULL * input_clk;
+        do_div(ppb, phc_clk);
+        lp->max_ppb = ppb - 1000000000ULL - 1ULL;
 
-        bfin_dump_hwtamp("RX", &shhwtstamps->hwtstamp, &shhwtstamps->syststamp, &lp->compare);
+        /* Initialize hwstamp config */
+        lp->stamp_cfg.rx_filter = HWTSTAMP_FILTER_NONE;
+        lp->stamp_cfg.tx_type = HWTSTAMP_TX_OFF;
 }
 
-/*
- * bfin_read_clock - read raw cycle counter (to be used by time counter)
- */
-static cycle_t bfin_read_clock(const struct cyclecounter *tc)
+static u64 bfin_ptp_time_read(struct bfin_mac_local *lp)
 {
-        u64 stamp;
+        u64 ns;
+        u32 lo, hi;
+
+        lo = bfin_read_EMAC_PTP_TIMELO();
+        hi = bfin_read_EMAC_PTP_TIMEHI();
 
-        stamp =  bfin_read_EMAC_PTP_TIMELO();
-        stamp |= (u64)bfin_read_EMAC_PTP_TIMEHI() << 32ULL;
+        ns = ((u64) hi) << 32;
+        ns |= lo;
+        ns <<= lp->shift;
 
-        return stamp;
+        return ns;
 }
 
-#define PTP_CLK 25000000
+static void bfin_ptp_time_write(struct bfin_mac_local *lp, u64 ns)
+{
+        u32 hi, lo;
 
-static void bfin_mac_hwtstamp_init(struct net_device *netdev)
+        ns >>= lp->shift;
+        hi = ns >> 32;
+        lo = ns & 0xffffffff;
+
+        bfin_write_EMAC_PTP_TIMELO(lo);
+        bfin_write_EMAC_PTP_TIMEHI(hi);
+}
+
+/* PTP Hardware Clock operations */
+
+static int bfin_ptp_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
+{
+        u64 adj;
+        u32 diff, addend;
+        int neg_adj = 0;
+        struct bfin_mac_local *lp =
+                container_of(ptp, struct bfin_mac_local, caps);
+
+        if (ppb < 0) {
+                neg_adj = 1;
+                ppb = -ppb;
+        }
+        addend = lp->addend;
+        adj = addend;
+        adj *= ppb;
+        diff = div_u64(adj, 1000000000ULL);
+
+        addend = neg_adj ? addend - diff : addend + diff;
+
+        bfin_write_EMAC_PTP_ADDEND(addend);
+
+        return 0;
+}
+
+static int bfin_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
+{
+        s64 now;
+        unsigned long flags;
+        struct bfin_mac_local *lp =
+                container_of(ptp, struct bfin_mac_local, caps);
+
+        spin_lock_irqsave(&lp->phc_lock, flags);
+
+        now = bfin_ptp_time_read(lp);
+        now += delta;
+        bfin_ptp_time_write(lp, now);
+
+        spin_unlock_irqrestore(&lp->phc_lock, flags);
+
+        return 0;
+}
+
+static int bfin_ptp_gettime(struct ptp_clock_info *ptp, struct timespec *ts)
+{
+        u64 ns;
+        u32 remainder;
+        unsigned long flags;
+        struct bfin_mac_local *lp =
+                container_of(ptp, struct bfin_mac_local, caps);
+
+        spin_lock_irqsave(&lp->phc_lock, flags);
+
+        ns = bfin_ptp_time_read(lp);
+
+        spin_unlock_irqrestore(&lp->phc_lock, flags);
+
+        ts->tv_sec = div_u64_rem(ns, 1000000000, &remainder);
+        ts->tv_nsec = remainder;
+        return 0;
+}
+
+static int bfin_ptp_settime(struct ptp_clock_info *ptp,
+                           const struct timespec *ts)
+{
+        u64 ns;
+        unsigned long flags;
+        struct bfin_mac_local *lp =
+                container_of(ptp, struct bfin_mac_local, caps);
+
+        ns = ts->tv_sec * 1000000000ULL;
+        ns += ts->tv_nsec;
+
+        spin_lock_irqsave(&lp->phc_lock, flags);
+
+        bfin_ptp_time_write(lp, ns);
+
+        spin_unlock_irqrestore(&lp->phc_lock, flags);
+
+        return 0;
+}
+
+static int bfin_ptp_enable(struct ptp_clock_info *ptp,
+                          struct ptp_clock_request *rq, int on)
+{
+        return -EOPNOTSUPP;
+}
+
+static struct ptp_clock_info bfin_ptp_caps = {
+        .owner          = THIS_MODULE,
+        .name           = "BF518 clock",
+        .max_adj        = 0,
+        .n_alarm        = 0,
+        .n_ext_ts       = 0,
+        .n_per_out      = 0,
+        .pps            = 0,
+        .adjfreq        = bfin_ptp_adjfreq,
+        .adjtime        = bfin_ptp_adjtime,
+        .gettime        = bfin_ptp_gettime,
+        .settime        = bfin_ptp_settime,
+        .enable         = bfin_ptp_enable,
+};
+
+static int bfin_phc_init(struct net_device *netdev, struct device *dev)
 {
         struct bfin_mac_local *lp = netdev_priv(netdev);
-        u64 append;
 
-        /* Initialize hardware timer */
-        append = PTP_CLK * (1ULL << 32);
-        do_div(append, get_sclk());
-        bfin_write_EMAC_PTP_ADDEND((u32)append);
-
-        memset(&lp->cycles, 0, sizeof(lp->cycles));
-        lp->cycles.read = bfin_read_clock;
-        lp->cycles.mask = CLOCKSOURCE_MASK(64);
-        lp->cycles.mult = 1000000000 / PTP_CLK;
-        lp->cycles.shift = 0;
-
-        /* Synchronize our NIC clock against system wall clock */
-        memset(&lp->compare, 0, sizeof(lp->compare));
-        lp->compare.source = &lp->clock;
-        lp->compare.target = ktime_get_real;
-        lp->compare.num_samples = 10;
+        lp->caps = bfin_ptp_caps;
+        lp->caps.max_adj = lp->max_ppb;
+        lp->clock = ptp_clock_register(&lp->caps, dev);
+        if (IS_ERR(lp->clock))
+                return PTR_ERR(lp->clock);
 
-        /* Initialize hwstamp config */
-        lp->stamp_cfg.rx_filter = HWTSTAMP_FILTER_NONE;
-        lp->stamp_cfg.tx_type = HWTSTAMP_TX_OFF;
+        lp->phc_index = ptp_clock_index(lp->clock);
+        spin_lock_init(&lp->phc_lock);
+
+        return 0;
+}
+
+static void bfin_phc_release(struct bfin_mac_local *lp)
+{
+        ptp_clock_unregister(lp->clock);
 }
 
 #else
@@ -945,6 +1067,8 @@ static void bfin_mac_hwtstamp_init(struct net_device *netdev)
 # define bfin_mac_hwtstamp_ioctl(dev, ifr, cmd) (-EOPNOTSUPP)
 # define bfin_rx_hwtstamp(dev, skb)
 # define bfin_tx_hwtstamp(dev, skb)
+# define bfin_phc_init(netdev, dev) 0
+# define bfin_phc_release(lp)
 #endif
 
 static inline void _tx_reclaim_skb(void)
@@ -1579,12 +1703,17 @@ static int __devinit bfin_mac_probe(struct platform_device *pdev)
         }
 
         bfin_mac_hwtstamp_init(ndev);
+        if (bfin_phc_init(ndev, &pdev->dev)) {
+                dev_err(&pdev->dev, "Cannot register PHC device!\n");
+                goto out_err_phc;
+        }
 
         /* now, print out the card info, in a short format.. */
         netdev_info(ndev, "%s, Version %s\n", DRV_DESC, DRV_VERSION);
 
         return 0;
 
+out_err_phc:
 out_err_reg_ndev:
         free_irq(IRQ_MAC_RX, ndev);
 out_err_request_irq:
@@ -1603,6 +1732,8 @@ static int __devexit bfin_mac_remove(struct platform_device *pdev)
         struct net_device *ndev = platform_get_drvdata(pdev);
         struct bfin_mac_local *lp = netdev_priv(ndev);
 
+        bfin_phc_release(lp);
+
         platform_set_drvdata(pdev, NULL);
 
         lp->mii_bus->priv = NULL;
diff --git a/drivers/net/ethernet/adi/bfin_mac.h b/drivers/net/ethernet/adi/bfin_mac.h
index 960905c08223..7a07ee07906b 100644
--- a/drivers/net/ethernet/adi/bfin_mac.h
+++ b/drivers/net/ethernet/adi/bfin_mac.h
@@ -11,8 +11,7 @@
 #define _BFIN_MAC_H_
 
 #include <linux/net_tstamp.h>
-#include <linux/clocksource.h>
-#include <linux/timecompare.h>
+#include <linux/ptp_clock_kernel.h>
 #include <linux/timer.h>
 #include <linux/etherdevice.h>
 #include <linux/bfin_mac.h>
@@ -94,10 +93,14 @@ struct bfin_mac_local {
         struct mii_bus *mii_bus;
 
 #if defined(CONFIG_BFIN_MAC_USE_HWSTAMP)
-        struct cyclecounter cycles;
-        struct timecounter clock;
-        struct timecompare compare;
+        u32 addend;
+        unsigned int shift;
+        s32 max_ppb;
         struct hwtstamp_config stamp_cfg;
+        struct ptp_clock_info caps;
+        struct ptp_clock *clock;
+        int phc_index;
+        spinlock_t phc_lock; /* protects time lo/hi registers */
 #endif
 };
 
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
index 72897c47b8c8..de121ccd675e 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
@@ -34,18 +34,10 @@
 
 #include "bnx2x_hsi.h"
 
-#if defined(CONFIG_CNIC) || defined(CONFIG_CNIC_MODULE)
-#define BCM_CNIC 1
 #include "../cnic_if.h"
-#endif
 
-#ifdef BCM_CNIC
-#define BNX2X_MIN_MSIX_VEC_CNT 3
-#define BNX2X_MSIX_VEC_FP_START 2
-#else
-#define BNX2X_MIN_MSIX_VEC_CNT 2
-#define BNX2X_MSIX_VEC_FP_START 1
-#endif
+
+#define BNX2X_MIN_MSIX_VEC_CNT(bp)              ((bp)->min_msix_vec_cnt)
 
 #include <linux/mdio.h>
 
@@ -256,15 +248,10 @@ enum {
         /* FCoE L2 */
 #define BNX2X_FCOE_ETH_CID(bp)          (BNX2X_CNIC_START_ETH_CID(bp) + 1)
 
-/** Additional rings budgeting */
-#ifdef BCM_CNIC
-#define CNIC_PRESENT                    1
-#define FCOE_PRESENT                    1
-#else
-#define CNIC_PRESENT                    0
-#define FCOE_PRESENT                    0
-#endif /* BCM_CNIC */
-#define NON_ETH_CONTEXT_USE     (FCOE_PRESENT)
+#define CNIC_SUPPORT(bp)                ((bp)->cnic_support)
+#define CNIC_ENABLED(bp)                ((bp)->cnic_enabled)
+#define CNIC_LOADED(bp)                 ((bp)->cnic_loaded)
+#define FCOE_INIT(bp)                   ((bp)->fcoe_init)
 
 #define AEU_IN_ATTN_BITS_PXPPCICLOCKCLIENT_PARITY_ERROR \
         AEU_INPUTS_ATTN_BITS_PXPPCICLOCKCLIENT_PARITY_ERROR
@@ -297,9 +284,7 @@ enum {
         OOO_TXQ_IDX_OFFSET,
 };
 #define MAX_ETH_TXQ_IDX(bp)     (BNX2X_NUM_NON_CNIC_QUEUES(bp) * (bp)->max_cos)
-#ifdef BCM_CNIC
 #define FCOE_TXQ_IDX(bp)        (MAX_ETH_TXQ_IDX(bp) + FCOE_TXQ_IDX_OFFSET)
-#endif
 
 /* fast path */
 /*
@@ -585,15 +570,9 @@ struct bnx2x_fastpath {
                                                 ->var)
 
 
-#define IS_ETH_FP(fp)                   (fp->index < \
-                                         BNX2X_NUM_ETH_QUEUES(fp->bp))
-#ifdef BCM_CNIC
-#define IS_FCOE_FP(fp)                  (fp->index == FCOE_IDX(fp->bp))
-#define IS_FCOE_IDX(idx)                ((idx) == FCOE_IDX(bp))
-#else
-#define IS_FCOE_FP(fp)          false
-#define IS_FCOE_IDX(idx)        false
-#endif
+#define IS_ETH_FP(fp)           ((fp)->index < BNX2X_NUM_ETH_QUEUES((fp)->bp))
+#define IS_FCOE_FP(fp)          ((fp)->index == FCOE_IDX((fp)->bp))
+#define IS_FCOE_IDX(idx)        ((idx) == FCOE_IDX(bp))
 
 
 /* MC hsi */
@@ -886,6 +865,18 @@ struct bnx2x_common {
                                          (CHIP_REV(bp) == CHIP_REV_Bx))
 #define CHIP_IS_E3A0(bp)                (CHIP_IS_E3(bp) && \
                                          (CHIP_REV(bp) == CHIP_REV_Ax))
+/* This define is used in two main places:
+ * 1. In the early stages of nic_load, to know if to configrue Parser / Searcher
+ * to nic-only mode or to offload mode. Offload mode is configured if either the
+ * chip is E1x (where MIC_MODE register is not applicable), or if cnic already
+ * registered for this port (which means that the user wants storage services).
+ * 2. During cnic-related load, to know if offload mode is already configured in
+ * the HW or needs to be configrued.
+ * Since the transition from nic-mode to offload-mode in HW causes traffic
+ * coruption, nic-mode is configured only in ports on which storage services
+ * where never requested.
+ */
+#define CONFIGURE_NIC_MODE(bp)          (!CHIP_IS_E1x(bp) && !CNIC_ENABLED(bp))
 
         int                     flash_size;
 #define BNX2X_NVRAM_1MB_SIZE                    0x20000 /* 1M bit in bytes */
@@ -1003,18 +994,15 @@ union cdu_context {
 #define CDU_ILT_PAGE_SZ         (8192 << CDU_ILT_PAGE_SZ_HW) /* 32K */
 #define ILT_PAGE_CIDS           (CDU_ILT_PAGE_SZ / sizeof(union cdu_context))
 
-#ifdef BCM_CNIC
 #define CNIC_ISCSI_CID_MAX      256
 #define CNIC_FCOE_CID_MAX       2048
 #define CNIC_CID_MAX            (CNIC_ISCSI_CID_MAX + CNIC_FCOE_CID_MAX)
 #define CNIC_ILT_LINES          DIV_ROUND_UP(CNIC_CID_MAX, ILT_PAGE_CIDS)
-#endif
 
 #define QM_ILT_PAGE_SZ_HW       0
 #define QM_ILT_PAGE_SZ          (4096 << QM_ILT_PAGE_SZ_HW) /* 4K */
 #define QM_CID_ROUND            1024
 
-#ifdef BCM_CNIC
 /* TM (timers) host DB constants */
 #define TM_ILT_PAGE_SZ_HW       0
 #define TM_ILT_PAGE_SZ          (4096 << TM_ILT_PAGE_SZ_HW) /* 4K */
@@ -1032,8 +1020,6 @@ union cdu_context {
 #define SRC_T2_SZ               SRC_ILT_SZ
 #define SRC_ILT_LINES           DIV_ROUND_UP(SRC_ILT_SZ, SRC_ILT_PAGE_SZ)
 
-#endif
-
 #define MAX_DMAE_C              8
 
 /* DMA memory not used in fastpath */
@@ -1227,7 +1213,6 @@ struct bnx2x {
         struct bnx2x_sp_objs    *sp_objs;
         struct bnx2x_fp_stats   *fp_stats;
         struct bnx2x_fp_txdata  *bnx2x_txq;
-        int                     bnx2x_txq_size;
         void __iomem            *regview;
         void __iomem            *doorbells;
         u16                     db_size;
@@ -1350,6 +1335,15 @@ struct bnx2x {
 #define NO_ISCSI_OOO(bp)        ((bp)->flags & NO_ISCSI_OOO_FLAG)
 #define NO_FCOE(bp)             ((bp)->flags & NO_FCOE_FLAG)
 
+        u8                      cnic_support;
+        bool                    cnic_enabled;
+        bool                    cnic_loaded;
+
+        /* Flag that indicates that we can start looking for FCoE L2 queue
+         * completions in the default status block.
+         */
+        bool                    fcoe_init;
+
         int                     pm_cap;
         int                     mrrs;
 
@@ -1420,6 +1414,8 @@ struct bnx2x {
 #define BNX2X_MAX_COS                   3
 #define BNX2X_MAX_TX_COS                2
         int                     num_queues;
+        uint                    num_ethernet_queues;
+        uint                    num_cnic_queues;
         int                     num_napi_queues;
         int                     disable_tpa;
 
@@ -1433,6 +1429,7 @@ struct bnx2x {
         u8                      igu_dsb_id;
         u8                      igu_base_sb;
         u8                      igu_sb_cnt;
+        u8                      min_msix_vec_cnt;
 
         dma_addr_t              def_status_blk_mapping;
 
@@ -1478,16 +1475,16 @@ struct bnx2x {
  * Maximum supported number of RSS queues: number of IGU SBs minus one that goes
  * to CNIC.
  */
-#define BNX2X_MAX_RSS_COUNT(bp) ((bp)->igu_sb_cnt - CNIC_PRESENT)
+#define BNX2X_MAX_RSS_COUNT(bp) ((bp)->igu_sb_cnt - CNIC_SUPPORT(bp))
 
 /*
  * Maximum CID count that might be required by the bnx2x:
  * Max RSS * Max_Tx_Multi_Cos + FCoE + iSCSI
  */
 #define BNX2X_L2_CID_COUNT(bp)  (BNX2X_NUM_ETH_QUEUES(bp) * BNX2X_MULTI_TX_COS \
-                                + NON_ETH_CONTEXT_USE + CNIC_PRESENT)
+                                + 2 * CNIC_SUPPORT(bp))
 #define BNX2X_L2_MAX_CID(bp)    (BNX2X_MAX_RSS_COUNT(bp) * BNX2X_MULTI_TX_COS \
-                                + NON_ETH_CONTEXT_USE + CNIC_PRESENT)
+                                + 2 * CNIC_SUPPORT(bp))
 #define L2_ILT_LINES(bp)        (DIV_ROUND_UP(BNX2X_L2_CID_COUNT(bp),\
                                         ILT_PAGE_CIDS))
 
@@ -1495,9 +1492,6 @@ struct bnx2x {
 
         int                     dropless_fc;
 
-#ifdef BCM_CNIC
-        u32                     cnic_flags;
-#define BNX2X_CNIC_FLAG_MAC_SET         1
         void                    *t2;
         dma_addr_t              t2_mapping;
         struct cnic_ops __rcu   *cnic_ops;
@@ -1518,7 +1512,6 @@ struct bnx2x {
 
         /* Start index of the "special" (CNIC related) L2 cleints */
         u8                              cnic_base_cl_id;
-#endif
 
         int                     dmae_ready;
         /* used to synchronize dmae accesses */
@@ -1647,9 +1640,9 @@ struct bnx2x {
 /* Tx queues may be less or equal to Rx queues */
 extern int num_queues;
 #define BNX2X_NUM_QUEUES(bp)    (bp->num_queues)
-#define BNX2X_NUM_ETH_QUEUES(bp) (BNX2X_NUM_QUEUES(bp) - NON_ETH_CONTEXT_USE)
+#define BNX2X_NUM_ETH_QUEUES(bp) ((bp)->num_ethernet_queues)
 #define BNX2X_NUM_NON_CNIC_QUEUES(bp)   (BNX2X_NUM_QUEUES(bp) - \
-                                         NON_ETH_CONTEXT_USE)
+                                         (bp)->num_cnic_queues)
 #define BNX2X_NUM_RX_QUEUES(bp) BNX2X_NUM_QUEUES(bp)
 
 #define is_multi(bp)            (BNX2X_NUM_QUEUES(bp) > 1)
@@ -1689,6 +1682,13 @@ struct bnx2x_func_init_params {
         u16             spq_prod;       /* valid iff FUNC_FLG_SPQ */
 };
 
+#define for_each_cnic_queue(bp, var) \
+        for ((var) = BNX2X_NUM_ETH_QUEUES(bp); (var) < BNX2X_NUM_QUEUES(bp); \
+             (var)++) \
+                if (skip_queue(bp, var))        \
+                        continue;               \
+                else
+
 #define for_each_eth_queue(bp, var) \
         for ((var) = 0; (var) < BNX2X_NUM_ETH_QUEUES(bp); (var)++)
 
@@ -1702,6 +1702,22 @@ struct bnx2x_func_init_params {
                 else
 
 /* Skip forwarding FP */
+#define for_each_valid_rx_queue(bp, var)                        \
+        for ((var) = 0;                                         \
+             (var) < (CNIC_LOADED(bp) ? BNX2X_NUM_QUEUES(bp) :  \
+                      BNX2X_NUM_ETH_QUEUES(bp));                \
+             (var)++)                                           \
+                if (skip_rx_queue(bp, var))                     \
+                        continue;                               \
+                else
+
+#define for_each_rx_queue_cnic(bp, var) \
+        for ((var) = BNX2X_NUM_ETH_QUEUES(bp); (var) < BNX2X_NUM_QUEUES(bp); \
+             (var)++) \
+                if (skip_rx_queue(bp, var))     \
+                        continue;               \
+                else
+
 #define for_each_rx_queue(bp, var) \
         for ((var) = 0; (var) < BNX2X_NUM_QUEUES(bp); (var)++) \
                 if (skip_rx_queue(bp, var))     \
@@ -1709,6 +1725,22 @@ struct bnx2x_func_init_params {
                 else
 
 /* Skip OOO FP */
+#define for_each_valid_tx_queue(bp, var)                        \
+        for ((var) = 0;                                         \
+             (var) < (CNIC_LOADED(bp) ? BNX2X_NUM_QUEUES(bp) :  \
+                      BNX2X_NUM_ETH_QUEUES(bp));                \
+             (var)++)                                           \
+                if (skip_tx_queue(bp, var))                     \
+                        continue;                               \
+                else
+
+#define for_each_tx_queue_cnic(bp, var) \
+        for ((var) = BNX2X_NUM_ETH_QUEUES(bp); (var) < BNX2X_NUM_QUEUES(bp); \
+             (var)++) \
+                if (skip_tx_queue(bp, var))     \
+                        continue;               \
+                else
+
 #define for_each_tx_queue(bp, var) \
         for ((var) = 0; (var) < BNX2X_NUM_QUEUES(bp); (var)++) \
                 if (skip_tx_queue(bp, var))     \
@@ -2179,7 +2211,6 @@ void bnx2x_notify_link_changed(struct bnx2x *bp);
 #define BNX2X_MF_SD_PROTOCOL(bp) \
         ((bp)->mf_config[BP_VN(bp)] & FUNC_MF_CFG_PROTOCOL_MASK)
 
-#ifdef BCM_CNIC
 #define BNX2X_IS_MF_SD_PROTOCOL_ISCSI(bp) \
         (BNX2X_MF_SD_PROTOCOL(bp) == FUNC_MF_CFG_PROTOCOL_ISCSI)
 
@@ -2196,9 +2227,12 @@ void bnx2x_notify_link_changed(struct bnx2x *bp);
 #define IS_MF_STORAGE_SD(bp) (IS_MF_SD(bp) && \
                                 (BNX2X_IS_MF_SD_PROTOCOL_ISCSI(bp) || \
                                  BNX2X_IS_MF_SD_PROTOCOL_FCOE(bp)))
-#else
-#define IS_MF_FCOE_AFEX(bp)     false
-#endif
 
+enum {
+        SWITCH_UPDATE,
+        AFEX_UPDATE,
+};
+
+#define NUM_MACS        8
 
 #endif /* bnx2x.h */
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
index 4833b6a9031c..54d522da1aa7 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
@@ -1152,6 +1152,25 @@ static void bnx2x_free_tpa_pool(struct bnx2x *bp,
         }
 }
 
+void bnx2x_init_rx_rings_cnic(struct bnx2x *bp)
+{
+        int j;
+
+        for_each_rx_queue_cnic(bp, j) {
+                struct bnx2x_fastpath *fp = &bp->fp[j];
+
+                fp->rx_bd_cons = 0;
+
+                /* Activate BD ring */
+                /* Warning!
+                 * this will generate an interrupt (to the TSTORM)
+                 * must only be done after chip is initialized
+                 */
+                bnx2x_update_rx_prod(bp, fp, fp->rx_bd_prod, fp->rx_comp_prod,
+                                     fp->rx_sge_prod);
+        }
+}
+
 void bnx2x_init_rx_rings(struct bnx2x *bp)
 {
         int func = BP_FUNC(bp);
@@ -1159,7 +1178,7 @@ void bnx2x_init_rx_rings(struct bnx2x *bp)
         int i, j;
 
         /* Allocate TPA resources */
-        for_each_rx_queue(bp, j) {
+        for_each_eth_queue(bp, j) {
                 struct bnx2x_fastpath *fp = &bp->fp[j];
 
                 DP(NETIF_MSG_IFUP,
@@ -1217,7 +1236,7 @@ void bnx2x_init_rx_rings(struct bnx2x *bp)
                 }
         }
 
-        for_each_rx_queue(bp, j) {
+        for_each_eth_queue(bp, j) {
                 struct bnx2x_fastpath *fp = &bp->fp[j];
 
                 fp->rx_bd_cons = 0;
@@ -1244,29 +1263,45 @@ void bnx2x_init_rx_rings(struct bnx2x *bp)
         }
 }
 
-static void bnx2x_free_tx_skbs(struct bnx2x *bp)
+static void bnx2x_free_tx_skbs_queue(struct bnx2x_fastpath *fp)
 {
-        int i;
         u8 cos;
+        struct bnx2x *bp = fp->bp;
 
-        for_each_tx_queue(bp, i) {
-                struct bnx2x_fastpath *fp = &bp->fp[i];
-                for_each_cos_in_tx_queue(fp, cos) {
-                        struct bnx2x_fp_txdata *txdata = fp->txdata_ptr[cos];
-                        unsigned pkts_compl = 0, bytes_compl = 0;
+        for_each_cos_in_tx_queue(fp, cos) {
+                struct bnx2x_fp_txdata *txdata = fp->txdata_ptr[cos];
+                unsigned pkts_compl = 0, bytes_compl = 0;
 
-                        u16 sw_prod = txdata->tx_pkt_prod;
-                        u16 sw_cons = txdata->tx_pkt_cons;
+                u16 sw_prod = txdata->tx_pkt_prod;
+                u16 sw_cons = txdata->tx_pkt_cons;
 
-                        while (sw_cons != sw_prod) {
-                                bnx2x_free_tx_pkt(bp, txdata, TX_BD(sw_cons),
-                                    &pkts_compl, &bytes_compl);
-                                sw_cons++;
-                        }
-                        netdev_tx_reset_queue(
-                                netdev_get_tx_queue(bp->dev,
-                                                    txdata->txq_index));
+                while (sw_cons != sw_prod) {
+                        bnx2x_free_tx_pkt(bp, txdata, TX_BD(sw_cons),
+                                          &pkts_compl, &bytes_compl);
+                        sw_cons++;
                 }
+
+                netdev_tx_reset_queue(
+                        netdev_get_tx_queue(bp->dev,
+                                            txdata->txq_index));
+        }
+}
+
+static void bnx2x_free_tx_skbs_cnic(struct bnx2x *bp)
+{
+        int i;
+
+        for_each_tx_queue_cnic(bp, i) {
+                bnx2x_free_tx_skbs_queue(&bp->fp[i]);
+        }
+}
+
+static void bnx2x_free_tx_skbs(struct bnx2x *bp)
+{
+        int i;
+
+        for_each_eth_queue(bp, i) {
+                bnx2x_free_tx_skbs_queue(&bp->fp[i]);
         }
 }
 
@@ -1294,11 +1329,20 @@ static void bnx2x_free_rx_bds(struct bnx2x_fastpath *fp)
         }
 }
 
+static void bnx2x_free_rx_skbs_cnic(struct bnx2x *bp)
+{
+        int j;
+
+        for_each_rx_queue_cnic(bp, j) {
+                bnx2x_free_rx_bds(&bp->fp[j]);
+        }
+}
+
 static void bnx2x_free_rx_skbs(struct bnx2x *bp)
 {
         int j;
 
-        for_each_rx_queue(bp, j) {
+        for_each_eth_queue(bp, j) {
                 struct bnx2x_fastpath *fp = &bp->fp[j];
 
                 bnx2x_free_rx_bds(fp);
@@ -1308,6 +1352,12 @@ static void bnx2x_free_rx_skbs(struct bnx2x *bp)
         }
 }
 
+void bnx2x_free_skbs_cnic(struct bnx2x *bp)
+{
+        bnx2x_free_tx_skbs_cnic(bp);
+        bnx2x_free_rx_skbs_cnic(bp);
+}
+
 void bnx2x_free_skbs(struct bnx2x *bp)
 {
         bnx2x_free_tx_skbs(bp);
@@ -1347,11 +1397,12 @@ static void bnx2x_free_msix_irqs(struct bnx2x *bp, int nvecs)
         DP(NETIF_MSG_IFDOWN, "released sp irq (%d)\n",
            bp->msix_table[offset].vector);
         offset++;
-#ifdef BCM_CNIC
-        if (nvecs == offset)
-                return;
-        offset++;
-#endif
+
+        if (CNIC_SUPPORT(bp)) {
+                if (nvecs == offset)
+                        return;
+                offset++;
+        }
 
         for_each_eth_queue(bp, i) {
                 if (nvecs == offset)
@@ -1368,7 +1419,7 @@ void bnx2x_free_irq(struct bnx2x *bp)
         if (bp->flags & USING_MSIX_FLAG &&
             !(bp->flags & USING_SINGLE_MSIX_FLAG))
                 bnx2x_free_msix_irqs(bp, BNX2X_NUM_ETH_QUEUES(bp) +
-                                     CNIC_PRESENT + 1);
+                                     CNIC_SUPPORT(bp) + 1);
         else
                 free_irq(bp->dev->irq, bp->dev);
 }
@@ -1382,12 +1433,14 @@ int bnx2x_enable_msix(struct bnx2x *bp)
            bp->msix_table[0].entry);
         msix_vec++;
 
-#ifdef BCM_CNIC
-        bp->msix_table[msix_vec].entry = msix_vec;
-        BNX2X_DEV_INFO("msix_table[%d].entry = %d (CNIC)\n",
-           bp->msix_table[msix_vec].entry, bp->msix_table[msix_vec].entry);
-        msix_vec++;
-#endif
+        /* Cnic requires an msix vector for itself */
+        if (CNIC_SUPPORT(bp)) {
+                bp->msix_table[msix_vec].entry = msix_vec;
+                BNX2X_DEV_INFO("msix_table[%d].entry = %d (CNIC)\n",
+                               msix_vec, bp->msix_table[msix_vec].entry);
+                msix_vec++;
+        }
+
         /* We need separate vectors for ETH queues only (not FCoE) */
         for_each_eth_queue(bp, i) {
                 bp->msix_table[msix_vec].entry = msix_vec;
@@ -1396,7 +1449,7 @@ int bnx2x_enable_msix(struct bnx2x *bp)
                 msix_vec++;
         }
 
-        req_cnt = BNX2X_NUM_ETH_QUEUES(bp) + CNIC_PRESENT + 1;
+        req_cnt = BNX2X_NUM_ETH_QUEUES(bp) + CNIC_SUPPORT(bp) + 1;
 
         rc = pci_enable_msix(bp->pdev, &bp->msix_table[0], req_cnt);
 
@@ -1404,7 +1457,7 @@ int bnx2x_enable_msix(struct bnx2x *bp)
          * reconfigure number of tx/rx queues according to available
          * MSI-X vectors
          */
-        if (rc >= BNX2X_MIN_MSIX_VEC_CNT) {
+        if (rc >= BNX2X_MIN_MSIX_VEC_CNT(bp)) {
                 /* how less vectors we will have? */
                 int diff = req_cnt - rc;
 
@@ -1419,7 +1472,8 @@ int bnx2x_enable_msix(struct bnx2x *bp)
                 /*
                  * decrease number of queues by number of unallocated entries
                  */
-                bp->num_queues -= diff;
+                bp->num_ethernet_queues -= diff;
+                bp->num_queues = bp->num_ethernet_queues + bp->num_cnic_queues;
 
                 BNX2X_DEV_INFO("New queue configuration set: %d\n",
                                bp->num_queues);
@@ -1435,6 +1489,9 @@ int bnx2x_enable_msix(struct bnx2x *bp)
                 BNX2X_DEV_INFO("Using single MSI-X vector\n");
                 bp->flags |= USING_SINGLE_MSIX_FLAG;
 
+                BNX2X_DEV_INFO("set number of queues to 1\n");
+                bp->num_ethernet_queues = 1;
+                bp->num_queues = bp->num_ethernet_queues + bp->num_cnic_queues;
         } else if (rc < 0) {
                 BNX2X_DEV_INFO("MSI-X is not attainable  rc %d\n", rc);
                 goto no_msix;
@@ -1464,9 +1521,9 @@ static int bnx2x_req_msix_irqs(struct bnx2x *bp)
                 return -EBUSY;
         }
 
-#ifdef BCM_CNIC
-        offset++;
-#endif
+        if (CNIC_SUPPORT(bp))
+                offset++;
+
         for_each_eth_queue(bp, i) {
                 struct bnx2x_fastpath *fp = &bp->fp[i];
                 snprintf(fp->name, sizeof(fp->name), "%s-fp-%d",
@@ -1485,7 +1542,7 @@ static int bnx2x_req_msix_irqs(struct bnx2x *bp)
         }
 
         i = BNX2X_NUM_ETH_QUEUES(bp);
-        offset = 1 + CNIC_PRESENT;
+        offset = 1 + CNIC_SUPPORT(bp);
         netdev_info(bp->dev, "using MSI-X  IRQs: sp %d  fp[%d] %d ... fp[%d] %d\n",
                bp->msix_table[0].vector,
                0, bp->msix_table[offset].vector,
@@ -1556,19 +1613,35 @@ static int bnx2x_setup_irqs(struct bnx2x *bp)
         return 0;
 }
 
+static void bnx2x_napi_enable_cnic(struct bnx2x *bp)
+{
+        int i;
+
+        for_each_rx_queue_cnic(bp, i)
+                napi_enable(&bnx2x_fp(bp, i, napi));
+}
+
 static void bnx2x_napi_enable(struct bnx2x *bp)
 {
         int i;
 
-        for_each_rx_queue(bp, i)
+        for_each_eth_queue(bp, i)
                 napi_enable(&bnx2x_fp(bp, i, napi));
 }
 
+static void bnx2x_napi_disable_cnic(struct bnx2x *bp)
+{
+        int i;
+
+        for_each_rx_queue_cnic(bp, i)
+                napi_disable(&bnx2x_fp(bp, i, napi));
+}
+
 static void bnx2x_napi_disable(struct bnx2x *bp)
 {
         int i;
 
-        for_each_rx_queue(bp, i)
+        for_each_eth_queue(bp, i)
                 napi_disable(&bnx2x_fp(bp, i, napi));
 }
 
@@ -1576,6 +1649,8 @@ void bnx2x_netif_start(struct bnx2x *bp)
 {
         if (netif_running(bp->dev)) {
                 bnx2x_napi_enable(bp);
+                if (CNIC_LOADED(bp))
+                        bnx2x_napi_enable_cnic(bp);
                 bnx2x_int_enable(bp);
                 if (bp->state == BNX2X_STATE_OPEN)
                         netif_tx_wake_all_queues(bp->dev);
@@ -1586,14 +1661,15 @@ void bnx2x_netif_stop(struct bnx2x *bp, int disable_hw)
 {
         bnx2x_int_disable_sync(bp, disable_hw);
         bnx2x_napi_disable(bp);
+        if (CNIC_LOADED(bp))
+                bnx2x_napi_disable_cnic(bp);
 }
 
 u16 bnx2x_select_queue(struct net_device *dev, struct sk_buff *skb)
 {
         struct bnx2x *bp = netdev_priv(dev);
 
-#ifdef BCM_CNIC
-        if (!NO_FCOE(bp)) {
+        if (CNIC_LOADED(bp) && !NO_FCOE(bp)) {
                 struct ethhdr *hdr = (struct ethhdr *)skb->data;
                 u16 ether_type = ntohs(hdr->h_proto);
 
@@ -1609,7 +1685,7 @@ u16 bnx2x_select_queue(struct net_device *dev, struct sk_buff *skb)
                 if ((ether_type == ETH_P_FCOE) || (ether_type == ETH_P_FIP))
                         return bnx2x_fcoe_tx(bp, txq_index);
         }
-#endif
+
         /* select a non-FCoE queue */
         return __skb_tx_hash(dev, skb, BNX2X_NUM_ETH_QUEUES(bp));
 }
@@ -1618,15 +1694,15 @@ u16 bnx2x_select_queue(struct net_device *dev, struct sk_buff *skb)
 void bnx2x_set_num_queues(struct bnx2x *bp)
 {
         /* RSS queues */
-        bp->num_queues = bnx2x_calc_num_queues(bp);
+        bp->num_ethernet_queues = bnx2x_calc_num_queues(bp);
 
-#ifdef BCM_CNIC
         /* override in STORAGE SD modes */
         if (IS_MF_STORAGE_SD(bp) || IS_MF_FCOE_AFEX(bp))
-                bp->num_queues = 1;
-#endif
+                bp->num_ethernet_queues = 1;
+
         /* Add special queues */
-        bp->num_queues += NON_ETH_CONTEXT_USE;
+        bp->num_cnic_queues = CNIC_SUPPORT(bp); /* For FCOE */
+        bp->num_queues = bp->num_ethernet_queues + bp->num_cnic_queues;
 
         BNX2X_DEV_INFO("set number of queues to %d\n", bp->num_queues);
 }
@@ -1653,20 +1729,18 @@ void bnx2x_set_num_queues(struct bnx2x *bp)
  * bnx2x_setup_tc() takes care of the proper TC mappings so that __skb_tx_hash()
  * will return a proper Tx index if TC is enabled (netdev->num_tc > 0).
  */
-static int bnx2x_set_real_num_queues(struct bnx2x *bp)
+static int bnx2x_set_real_num_queues(struct bnx2x *bp, int include_cnic)
 {
         int rc, tx, rx;
 
         tx = BNX2X_NUM_ETH_QUEUES(bp) * bp->max_cos;
-        rx = BNX2X_NUM_QUEUES(bp) - NON_ETH_CONTEXT_USE;
+        rx = BNX2X_NUM_ETH_QUEUES(bp);
 
 /* account for fcoe queue */
-#ifdef BCM_CNIC
-        if (!NO_FCOE(bp)) {
-                rx += FCOE_PRESENT;
-                tx += FCOE_PRESENT;
+        if (include_cnic && !NO_FCOE(bp)) {
+                rx++;
+                tx++;
         }
-#endif
 
         rc = netif_set_real_num_tx_queues(bp->dev, tx);
         if (rc) {
@@ -1859,14 +1933,26 @@ static void bnx2x_squeeze_objects(struct bnx2x *bp)
                 (bp)->state = BNX2X_STATE_ERROR; \
                 goto label; \
         } while (0)
-#else
+
+#define LOAD_ERROR_EXIT_CNIC(bp, label) \
+        do { \
+                bp->cnic_loaded = false; \
+                goto label; \
+        } while (0)
+#else /*BNX2X_STOP_ON_ERROR*/
 #define LOAD_ERROR_EXIT(bp, label) \
         do { \
                 (bp)->state = BNX2X_STATE_ERROR; \
                 (bp)->panic = 1; \
                 return -EBUSY; \
         } while (0)
-#endif
+#define LOAD_ERROR_EXIT_CNIC(bp, label) \
+        do { \
+                bp->cnic_loaded = false; \
+                (bp)->panic = 1; \
+                return -EBUSY; \
+        } while (0)
+#endif /*BNX2X_STOP_ON_ERROR*/
 
 bool bnx2x_test_firmware_version(struct bnx2x *bp, bool is_err)
 {
@@ -1959,10 +2045,8 @@ static void bnx2x_bz_fp(struct bnx2x *bp, int index)
                 fp->max_cos = 1;
 
         /* Init txdata pointers */
-#ifdef BCM_CNIC
         if (IS_FCOE_FP(fp))
                 fp->txdata_ptr[0] = &bp->bnx2x_txq[FCOE_TXQ_IDX(bp)];
-#endif
         if (IS_ETH_FP(fp))
                 for_each_cos_in_tx_queue(fp, cos)
                         fp->txdata_ptr[cos] = &bp->bnx2x_txq[cos *
@@ -1980,11 +2064,95 @@ static void bnx2x_bz_fp(struct bnx2x *bp, int index)
         else if (bp->flags & GRO_ENABLE_FLAG)
                 fp->mode = TPA_MODE_GRO;
 
-#ifdef BCM_CNIC
         /* We don't want TPA on an FCoE L2 ring */
         if (IS_FCOE_FP(fp))
                 fp->disable_tpa = 1;
-#endif
+}
+
+int bnx2x_load_cnic(struct bnx2x *bp)
+{
+        int i, rc, port = BP_PORT(bp);
+
+        DP(NETIF_MSG_IFUP, "Starting CNIC-related load\n");
+
+        mutex_init(&bp->cnic_mutex);
+
+        rc = bnx2x_alloc_mem_cnic(bp);
+        if (rc) {
+                BNX2X_ERR("Unable to allocate bp memory for cnic\n");
+                LOAD_ERROR_EXIT_CNIC(bp, load_error_cnic0);
+        }
+
+        rc = bnx2x_alloc_fp_mem_cnic(bp);
+        if (rc) {
+                BNX2X_ERR("Unable to allocate memory for cnic fps\n");
+                LOAD_ERROR_EXIT_CNIC(bp, load_error_cnic0);
+        }
+
+        /* Update the number of queues with the cnic queues */
+        rc = bnx2x_set_real_num_queues(bp, 1);
+        if (rc) {
+                BNX2X_ERR("Unable to set real_num_queues including cnic\n");
+                LOAD_ERROR_EXIT_CNIC(bp, load_error_cnic0);
+        }
+
+        /* Add all CNIC NAPI objects */
+        bnx2x_add_all_napi_cnic(bp);
+        DP(NETIF_MSG_IFUP, "cnic napi added\n");
+        bnx2x_napi_enable_cnic(bp);
+
+        rc = bnx2x_init_hw_func_cnic(bp);
+        if (rc)
+                LOAD_ERROR_EXIT_CNIC(bp, load_error_cnic1);
+
+        bnx2x_nic_init_cnic(bp);
+
+        /* Enable Timer scan */
+        REG_WR(bp, TM_REG_EN_LINEAR0_TIMER + port*4, 1);
+
+        for_each_cnic_queue(bp, i) {
+                rc = bnx2x_setup_queue(bp, &bp->fp[i], 0);
+                if (rc) {
+                        BNX2X_ERR("Queue setup failed\n");
+                        LOAD_ERROR_EXIT(bp, load_error_cnic2);
+                }
+        }
+
+        /* Initialize Rx filter. */
+        netif_addr_lock_bh(bp->dev);
+        bnx2x_set_rx_mode(bp->dev);
+        netif_addr_unlock_bh(bp->dev);
+
+        /* re-read iscsi info */
+        bnx2x_get_iscsi_info(bp);
+        bnx2x_setup_cnic_irq_info(bp);
+        bnx2x_setup_cnic_info(bp);
+        bp->cnic_loaded = true;
+        if (bp->state == BNX2X_STATE_OPEN)
+                bnx2x_cnic_notify(bp, CNIC_CTL_START_CMD);
+
+
+        DP(NETIF_MSG_IFUP, "Ending successfully CNIC-related load\n");
+
+        return 0;
+
+#ifndef BNX2X_STOP_ON_ERROR
+load_error_cnic2:
+        /* Disable Timer scan */
+        REG_WR(bp, TM_REG_EN_LINEAR0_TIMER + port*4, 0);
+
+load_error_cnic1:
+        bnx2x_napi_disable_cnic(bp);
+        /* Update the number of queues without the cnic queues */
+        rc = bnx2x_set_real_num_queues(bp, 0);
+        if (rc)
+                BNX2X_ERR("Unable to set real_num_queues not including cnic\n");
+load_error_cnic0:
+        BNX2X_ERR("CNIC-related load failed\n");
+        bnx2x_free_fp_mem_cnic(bp);
+        bnx2x_free_mem_cnic(bp);
+        return rc;
+#endif /* ! BNX2X_STOP_ON_ERROR */
 }
 
 
@@ -1995,6 +2163,10 @@ int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
         u32 load_code;
         int i, rc;
 
+        DP(NETIF_MSG_IFUP, "Starting NIC load\n");
+        DP(NETIF_MSG_IFUP,
+           "CNIC is %s\n", CNIC_ENABLED(bp) ? "enabled" : "disabled");
+
 #ifdef BNX2X_STOP_ON_ERROR
         if (unlikely(bp->panic)) {
                 BNX2X_ERR("Can't load NIC when there is panic\n");
@@ -2022,9 +2194,11 @@ int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
         DP(NETIF_MSG_IFUP, "num queues: %d", bp->num_queues);
         for_each_queue(bp, i)
                 bnx2x_bz_fp(bp, i);
-        memset(bp->bnx2x_txq, 0, bp->bnx2x_txq_size *
-               sizeof(struct bnx2x_fp_txdata));
+        memset(bp->bnx2x_txq, 0, (BNX2X_MAX_RSS_COUNT(bp) * BNX2X_MULTI_TX_COS +
+                                  bp->num_cnic_queues) *
+                                  sizeof(struct bnx2x_fp_txdata));
 
+        bp->fcoe_init = false;
 
         /* Set the receive queues buffer size */
         bnx2x_set_rx_buf_size(bp);
@@ -2034,9 +2208,9 @@ int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
 
         /* As long as bnx2x_alloc_mem() may possibly update
          * bp->num_queues, bnx2x_set_real_num_queues() should always
-         * come after it.
+         * come after it. At this stage cnic queues are not counted.
          */
-        rc = bnx2x_set_real_num_queues(bp);
+        rc = bnx2x_set_real_num_queues(bp, 0);
         if (rc) {
                 BNX2X_ERR("Unable to set real_num_queues\n");
                 LOAD_ERROR_EXIT(bp, load_error0);
@@ -2050,6 +2224,7 @@ int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
 
         /* Add all NAPI objects */
         bnx2x_add_all_napi(bp);
+        DP(NETIF_MSG_IFUP, "napi added\n");
         bnx2x_napi_enable(bp);
 
         /* set pf load just before approaching the MCP */
@@ -2191,23 +2366,18 @@ int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                 LOAD_ERROR_EXIT(bp, load_error3);
         }
 
-#ifdef BCM_CNIC
-        /* Enable Timer scan */
-        REG_WR(bp, TM_REG_EN_LINEAR0_TIMER + port*4, 1);
-#endif
-
-        for_each_nondefault_queue(bp, i) {
+        for_each_nondefault_eth_queue(bp, i) {
                 rc = bnx2x_setup_queue(bp, &bp->fp[i], 0);
                 if (rc) {
                         BNX2X_ERR("Queue setup failed\n");
-                        LOAD_ERROR_EXIT(bp, load_error4);
+                        LOAD_ERROR_EXIT(bp, load_error3);
                 }
         }
 
         rc = bnx2x_init_rss_pf(bp);
         if (rc) {
                 BNX2X_ERR("PF RSS init failed\n");
-                LOAD_ERROR_EXIT(bp, load_error4);
+                LOAD_ERROR_EXIT(bp, load_error3);
         }
 
         /* Now when Clients are configured we are ready to work */
@@ -2217,7 +2387,7 @@ int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
         rc = bnx2x_set_eth_mac(bp, true);
         if (rc) {
                 BNX2X_ERR("Setting Ethernet MAC failed\n");
-                LOAD_ERROR_EXIT(bp, load_error4);
+                LOAD_ERROR_EXIT(bp, load_error3);
         }
 
         if (bp->pending_max) {
@@ -2264,14 +2434,8 @@ int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
         /* start the timer */
         mod_timer(&bp->timer, jiffies + bp->current_interval);
 
-#ifdef BCM_CNIC
-        /* re-read iscsi info */
-        bnx2x_get_iscsi_info(bp);
-        bnx2x_setup_cnic_irq_info(bp);
-        bnx2x_setup_cnic_info(bp);
-        if (bp->state == BNX2X_STATE_OPEN)
-                bnx2x_cnic_notify(bp, CNIC_CTL_START_CMD);
-#endif
+        if (CNIC_ENABLED(bp))
+                bnx2x_load_cnic(bp);
 
         /* mark driver is loaded in shmem2 */
         if (SHMEM2_HAS(bp, drv_capabilities_flag)) {
@@ -2293,14 +2457,11 @@ int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
         if (bp->port.pmf && (bp->state != BNX2X_STATE_DIAG))
                 bnx2x_dcbx_init(bp, false);
 
+        DP(NETIF_MSG_IFUP, "Ending successfully NIC load\n");
+
         return 0;
 
 #ifndef BNX2X_STOP_ON_ERROR
-load_error4:
-#ifdef BCM_CNIC
-        /* Disable Timer scan */
-        REG_WR(bp, TM_REG_EN_LINEAR0_TIMER + port*4, 0);
-#endif
 load_error3:
         bnx2x_int_disable_sync(bp, 1);
 
@@ -2338,6 +2499,8 @@ int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode, bool keep_link)
         int i;
         bool global = false;
 
+        DP(NETIF_MSG_IFUP, "Starting NIC unload\n");
+
         /* mark driver is unloaded in shmem2 */
         if (SHMEM2_HAS(bp, drv_capabilities_flag)) {
                 u32 val;
@@ -2373,14 +2536,13 @@ int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode, bool keep_link)
         bp->state = BNX2X_STATE_CLOSING_WAIT4_HALT;
         smp_mb();
 
+        if (CNIC_LOADED(bp))
+                bnx2x_cnic_notify(bp, CNIC_CTL_STOP_CMD);
+
         /* Stop Tx */
         bnx2x_tx_disable(bp);
         netdev_reset_tc(bp->dev);
 
-#ifdef BCM_CNIC
-        bnx2x_cnic_notify(bp, CNIC_CTL_STOP_CMD);
-#endif
-
         bp->rx_mode = BNX2X_RX_MODE_NONE;
 
         del_timer_sync(&bp->timer);
@@ -2414,7 +2576,8 @@ int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode, bool keep_link)
                 bnx2x_netif_stop(bp, 1);
                 /* Delete all NAPI objects */
                 bnx2x_del_all_napi(bp);
-
+                if (CNIC_LOADED(bp))
+                        bnx2x_del_all_napi_cnic(bp);
                 /* Release IRQs */
                 bnx2x_free_irq(bp);
 
@@ -2435,12 +2598,19 @@ int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode, bool keep_link)
 
         /* Free SKBs, SGEs, TPA pool and driver internals */
         bnx2x_free_skbs(bp);
+        if (CNIC_LOADED(bp))
+                bnx2x_free_skbs_cnic(bp);
         for_each_rx_queue(bp, i)
                 bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
 
+        if (CNIC_LOADED(bp)) {
+                bnx2x_free_fp_mem_cnic(bp);
+                bnx2x_free_mem_cnic(bp);
+        }
         bnx2x_free_mem(bp);
 
         bp->state = BNX2X_STATE_CLOSED;
+        bp->cnic_loaded = false;
 
         /* Check if there are pending parity attentions. If there are - set
          * RECOVERY_IN_PROGRESS.
@@ -2460,6 +2630,8 @@ int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode, bool keep_link)
         if (!bnx2x_clear_pf_load(bp) && bnx2x_reset_is_done(bp, BP_PATH(bp)))
                 bnx2x_disable_close_the_gate(bp);
 
+        DP(NETIF_MSG_IFUP, "Ending NIC unload\n");
+
         return 0;
 }
 
@@ -2550,7 +2722,7 @@ int bnx2x_poll(struct napi_struct *napi, int budget)
 
                 /* Fall out from the NAPI loop if needed */
                 if (!(bnx2x_has_rx_work(fp) || bnx2x_has_tx_work(fp))) {
-#ifdef BCM_CNIC
+
                         /* No need to update SB for FCoE L2 ring as long as
                          * it's connected to the default SB and the SB
                          * has been updated when NAPI was scheduled.
@@ -2559,8 +2731,6 @@ int bnx2x_poll(struct napi_struct *napi, int budget)
                                 napi_complete(napi);
                                 break;
                         }
-#endif
-
                         bnx2x_update_fpsb_idx(fp);
                         /* bnx2x_has_rx_work() reads the status block,
                          * thus we need to ensure that status block indices
@@ -2940,7 +3110,7 @@ netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
         txq_index = skb_get_queue_mapping(skb);
         txq = netdev_get_tx_queue(dev, txq_index);
 
-        BUG_ON(txq_index >= MAX_ETH_TXQ_IDX(bp) + FCOE_PRESENT);
+        BUG_ON(txq_index >= MAX_ETH_TXQ_IDX(bp) + (CNIC_LOADED(bp) ? 1 : 0));
 
         txdata = &bp->bnx2x_txq[txq_index];
 
@@ -3339,13 +3509,11 @@ int bnx2x_change_mac_addr(struct net_device *dev, void *p)
                 return -EINVAL;
         }
 
-#ifdef BCM_CNIC
         if ((IS_MF_STORAGE_SD(bp) || IS_MF_FCOE_AFEX(bp)) &&
             !is_zero_ether_addr(addr->sa_data)) {
                 BNX2X_ERR("Can't configure non-zero address on iSCSI or FCoE functions in MF-SD mode\n");
                 return -EINVAL;
         }
-#endif
 
         if (netif_running(dev))  {
                 rc = bnx2x_set_eth_mac(bp, false);
@@ -3369,13 +3537,11 @@ static void bnx2x_free_fp_mem_at(struct bnx2x *bp, int fp_index)
         u8 cos;
 
         /* Common */
-#ifdef BCM_CNIC
+
         if (IS_FCOE_IDX(fp_index)) {
                 memset(sb, 0, sizeof(union host_hc_status_block));
                 fp->status_blk_mapping = 0;
-
         } else {
-#endif
                 /* status blocks */
                 if (!CHIP_IS_E1x(bp))
                         BNX2X_PCI_FREE(sb->e2_sb,
@@ -3387,9 +3553,8 @@ static void bnx2x_free_fp_mem_at(struct bnx2x *bp, int fp_index)
                                        bnx2x_fp(bp, fp_index,
                                                 status_blk_mapping),
                                        sizeof(struct host_hc_status_block_e1x));
-#ifdef BCM_CNIC
         }
-#endif
+
         /* Rx */
         if (!skip_rx_queue(bp, fp_index)) {
                 bnx2x_free_rx_bds(fp);
@@ -3431,10 +3596,17 @@ static void bnx2x_free_fp_mem_at(struct bnx2x *bp, int fp_index)
         /* end of fastpath */
 }
 
+void bnx2x_free_fp_mem_cnic(struct bnx2x *bp)
+{
+        int i;
+        for_each_cnic_queue(bp, i)
+                bnx2x_free_fp_mem_at(bp, i);
+}
+
 void bnx2x_free_fp_mem(struct bnx2x *bp)
 {
         int i;
-        for_each_queue(bp, i)
+        for_each_eth_queue(bp, i)
                 bnx2x_free_fp_mem_at(bp, i);
 }
 
@@ -3519,14 +3691,11 @@ static int bnx2x_alloc_fp_mem_at(struct bnx2x *bp, int index)
         u8 cos;
         int rx_ring_size = 0;
 
-#ifdef BCM_CNIC
         if (!bp->rx_ring_size &&
             (IS_MF_STORAGE_SD(bp) || IS_MF_FCOE_AFEX(bp))) {
                 rx_ring_size = MIN_RX_SIZE_NONTPA;
                 bp->rx_ring_size = rx_ring_size;
-        } else
-#endif
-        if (!bp->rx_ring_size) {
+        } else if (!bp->rx_ring_size) {
                 rx_ring_size = MAX_RX_AVAIL/BNX2X_NUM_RX_QUEUES(bp);
 
                 if (CHIP_IS_E3(bp)) {
@@ -3550,9 +3719,8 @@ static int bnx2x_alloc_fp_mem_at(struct bnx2x *bp, int index)
 
         /* Common */
         sb = &bnx2x_fp(bp, index, status_blk);
-#ifdef BCM_CNIC
+
         if (!IS_FCOE_IDX(index)) {
-#endif
                 /* status blocks */
                 if (!CHIP_IS_E1x(bp))
                         BNX2X_PCI_ALLOC(sb->e2_sb,
@@ -3562,9 +3730,7 @@ static int bnx2x_alloc_fp_mem_at(struct bnx2x *bp, int index)
                         BNX2X_PCI_ALLOC(sb->e1x_sb,
                                 &bnx2x_fp(bp, index, status_blk_mapping),
                             sizeof(struct host_hc_status_block_e1x));
-#ifdef BCM_CNIC
         }
-#endif
 
         /* FCoE Queue uses Default SB and doesn't ACK the SB, thus no need to
          * set shortcuts for it.
@@ -3641,31 +3807,31 @@ alloc_mem_err:
         return 0;
 }
 
+int bnx2x_alloc_fp_mem_cnic(struct bnx2x *bp)
+{
+        if (!NO_FCOE(bp))
+                /* FCoE */
+                if (bnx2x_alloc_fp_mem_at(bp, FCOE_IDX(bp)))
+                        /* we will fail load process instead of mark
+                         * NO_FCOE_FLAG
+                         */
+                        return -ENOMEM;
+
+        return 0;
+}
+
 int bnx2x_alloc_fp_mem(struct bnx2x *bp)
 {
         int i;
 
-        /**
-         * 1. Allocate FP for leading - fatal if error
-         * 2. {CNIC} Allocate FCoE FP - fatal if error
-         * 3. {CNIC} Allocate OOO + FWD - disable OOO if error
-         * 4. Allocate RSS - fix number of queues if error
+        /* 1. Allocate FP for leading - fatal if error
+         * 2. Allocate RSS - fix number of queues if error
          */
 
         /* leading */
         if (bnx2x_alloc_fp_mem_at(bp, 0))
                 return -ENOMEM;
 
-#ifdef BCM_CNIC
-        if (!NO_FCOE(bp))
-                /* FCoE */
-                if (bnx2x_alloc_fp_mem_at(bp, FCOE_IDX(bp)))
-                        /* we will fail load process instead of mark
-                         * NO_FCOE_FLAG
-                         */
-                        return -ENOMEM;
-#endif
-
         /* RSS */
         for_each_nondefault_eth_queue(bp, i)
                 if (bnx2x_alloc_fp_mem_at(bp, i))
@@ -3676,17 +3842,17 @@ int bnx2x_alloc_fp_mem(struct bnx2x *bp)
                 int delta = BNX2X_NUM_ETH_QUEUES(bp) - i;
 
                 WARN_ON(delta < 0);
-#ifdef BCM_CNIC
-                /**
-                 * move non eth FPs next to last eth FP
-                 * must be done in that order
-                 * FCOE_IDX < FWD_IDX < OOO_IDX
-                 */
+                if (CNIC_SUPPORT(bp))
+                        /* move non eth FPs next to last eth FP
+                         * must be done in that order
+                         * FCOE_IDX < FWD_IDX < OOO_IDX
+                         */
 
-                /* move FCoE fp even NO_FCOE_FLAG is on */
-                bnx2x_move_fp(bp, FCOE_IDX(bp), FCOE_IDX(bp) - delta);
-#endif
-                bp->num_queues -= delta;
+                        /* move FCoE fp even NO_FCOE_FLAG is on */
+                        bnx2x_move_fp(bp, FCOE_IDX(bp), FCOE_IDX(bp) - delta);
+                bp->num_ethernet_queues -= delta;
+                bp->num_queues = bp->num_ethernet_queues +
+                                 bp->num_cnic_queues;
                 BNX2X_ERR("Adjusted num of queues from %d to %d\n",
                           bp->num_queues + delta, bp->num_queues);
         }
@@ -3711,7 +3877,7 @@ int __devinit bnx2x_alloc_mem_bp(struct bnx2x *bp)
         struct msix_entry *tbl;
         struct bnx2x_ilt *ilt;
         int msix_table_size = 0;
-        int fp_array_size;
+        int fp_array_size, txq_array_size;
         int i;
 
         /*
@@ -3721,7 +3887,7 @@ int __devinit bnx2x_alloc_mem_bp(struct bnx2x *bp)
         msix_table_size = bp->igu_sb_cnt + 1;
 
         /* fp array: RSS plus CNIC related L2 queues */
-        fp_array_size = BNX2X_MAX_RSS_COUNT(bp) + NON_ETH_CONTEXT_USE;
+        fp_array_size = BNX2X_MAX_RSS_COUNT(bp) + CNIC_SUPPORT(bp);
         BNX2X_DEV_INFO("fp_array_size %d", fp_array_size);
 
         fp = kcalloc(fp_array_size, sizeof(*fp), GFP_KERNEL);
@@ -3750,12 +3916,12 @@ int __devinit bnx2x_alloc_mem_bp(struct bnx2x *bp)
                 goto alloc_err;
 
         /* Allocate memory for the transmission queues array */
-        bp->bnx2x_txq_size = BNX2X_MAX_RSS_COUNT(bp) * BNX2X_MULTI_TX_COS;
-#ifdef BCM_CNIC
-        bp->bnx2x_txq_size++;
-#endif
-        bp->bnx2x_txq = kcalloc(bp->bnx2x_txq_size,
-                                sizeof(struct bnx2x_fp_txdata), GFP_KERNEL);
+        txq_array_size =
+                BNX2X_MAX_RSS_COUNT(bp) * BNX2X_MULTI_TX_COS + CNIC_SUPPORT(bp);
+        BNX2X_DEV_INFO("txq_array_size %d", txq_array_size);
+
+        bp->bnx2x_txq = kcalloc(txq_array_size, sizeof(struct bnx2x_fp_txdata),
+                                GFP_KERNEL);
         if (!bp->bnx2x_txq)
                 goto alloc_err;
 
@@ -3838,7 +4004,7 @@ int bnx2x_get_link_cfg_idx(struct bnx2x *bp)
         return LINK_CONFIG_IDX(sel_phy_idx);
 }
 
-#if defined(NETDEV_FCOE_WWNN) && defined(BCM_CNIC)
+#ifdef NETDEV_FCOE_WWNN
 int bnx2x_fcoe_get_wwn(struct net_device *dev, u64 *wwn, int type)
 {
         struct bnx2x *bp = netdev_priv(dev);
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h
index 9c5ea6c5b4c7..ad280740b134 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h
@@ -238,7 +238,6 @@ irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance);
  * @dev_instance:       private instance
  */
 irqreturn_t bnx2x_interrupt(int irq, void *dev_instance);
-#ifdef BCM_CNIC
 
 /**
  * bnx2x_cnic_notify - send command to cnic driver
@@ -262,8 +261,6 @@ void bnx2x_setup_cnic_irq_info(struct bnx2x *bp);
  */
 void bnx2x_setup_cnic_info(struct bnx2x *bp);
 
-#endif
-
 /**
  * bnx2x_int_enable - enable HW interrupts.
  *
@@ -283,7 +280,7 @@ void bnx2x_int_enable(struct bnx2x *bp);
 void bnx2x_int_disable_sync(struct bnx2x *bp, int disable_hw);
 
 /**
- * bnx2x_nic_init - init driver internals.
+ * bnx2x_nic_init_cnic - init driver internals for cnic.
  *
  * @bp:         driver handle
  * @load_code:  COMMON, PORT or FUNCTION
@@ -293,9 +290,26 @@ void bnx2x_int_disable_sync(struct bnx2x *bp, int disable_hw);
  *  - status blocks
  *  - etc.
  */
-void bnx2x_nic_init(struct bnx2x *bp, u32 load_code);
+void bnx2x_nic_init_cnic(struct bnx2x *bp);
 
 /**
+ * bnx2x_nic_init - init driver internals.
+ *
+ * @bp:         driver handle
+ *
+ * Initializes:
+ *  - rings
+ *  - status blocks
+ *  - etc.
+ */
+void bnx2x_nic_init(struct bnx2x *bp, u32 load_code);
+/**
+ * bnx2x_alloc_mem_cnic - allocate driver's memory for cnic.
+ *
+ * @bp:         driver handle
+ */
+int bnx2x_alloc_mem_cnic(struct bnx2x *bp);
+/**
  * bnx2x_alloc_mem - allocate driver's memory.
  *
  * @bp:         driver handle
@@ -303,6 +317,12 @@ void bnx2x_nic_init(struct bnx2x *bp, u32 load_code);
 int bnx2x_alloc_mem(struct bnx2x *bp);
 
 /**
+ * bnx2x_free_mem_cnic - release driver's memory for cnic.
+ *
+ * @bp:         driver handle
+ */
+void bnx2x_free_mem_cnic(struct bnx2x *bp);
+/**
  * bnx2x_free_mem - release driver's memory.
  *
  * @bp:         driver handle
@@ -407,6 +427,7 @@ bool bnx2x_reset_is_done(struct bnx2x *bp, int engine);
 void bnx2x_set_reset_in_progress(struct bnx2x *bp);
 void bnx2x_set_reset_global(struct bnx2x *bp);
 void bnx2x_disable_close_the_gate(struct bnx2x *bp);
+int bnx2x_init_hw_func_cnic(struct bnx2x *bp);
 
 /**
  * bnx2x_sp_event - handle ramrods completion.
@@ -424,6 +445,14 @@ void bnx2x_sp_event(struct bnx2x_fastpath *fp, union eth_rx_cqe *rr_cqe);
 void bnx2x_ilt_set_info(struct bnx2x *bp);
 
 /**
+ * bnx2x_ilt_set_cnic_info - prepare ILT configurations for SRC
+ * and TM.
+ *
+ * @bp:         driver handle
+ */
+void bnx2x_ilt_set_info_cnic(struct bnx2x *bp);
+
+/**
  * bnx2x_dcbx_init - initialize dcbx protocol.
  *
  * @bp:         driver handle
@@ -491,12 +520,17 @@ int bnx2x_resume(struct pci_dev *pdev);
 /* Release IRQ vectors */
 void bnx2x_free_irq(struct bnx2x *bp);
 
+void bnx2x_free_fp_mem_cnic(struct bnx2x *bp);
 void bnx2x_free_fp_mem(struct bnx2x *bp);
+int bnx2x_alloc_fp_mem_cnic(struct bnx2x *bp);
 int bnx2x_alloc_fp_mem(struct bnx2x *bp);
 void bnx2x_init_rx_rings(struct bnx2x *bp);
+void bnx2x_init_rx_rings_cnic(struct bnx2x *bp);
+void bnx2x_free_skbs_cnic(struct bnx2x *bp);
 void bnx2x_free_skbs(struct bnx2x *bp);
 void bnx2x_netif_stop(struct bnx2x *bp, int disable_hw);
 void bnx2x_netif_start(struct bnx2x *bp);
+int bnx2x_load_cnic(struct bnx2x *bp);
 
 /**
  * bnx2x_enable_msix - set msix configuration.
@@ -547,7 +581,7 @@ void bnx2x_free_mem_bp(struct bnx2x *bp);
  */
 int bnx2x_change_mtu(struct net_device *dev, int new_mtu);
 
-#if defined(NETDEV_FCOE_WWNN) && defined(BCM_CNIC)
+#ifdef NETDEV_FCOE_WWNN
 /**
  * bnx2x_fcoe_get_wwn - return the requested WWN value for this port
  *
@@ -793,23 +827,39 @@ static inline void bnx2x_free_rx_sge(struct bnx2x *bp,
         sge->addr_lo = 0;
 }
 
-static inline void bnx2x_add_all_napi(struct bnx2x *bp)
+static inline void bnx2x_add_all_napi_cnic(struct bnx2x *bp)
 {
         int i;
 
-        bp->num_napi_queues = bp->num_queues;
+        /* Add NAPI objects */
+        for_each_rx_queue_cnic(bp, i)
+                netif_napi_add(bp->dev, &bnx2x_fp(bp, i, napi),
+                               bnx2x_poll, BNX2X_NAPI_WEIGHT);
+}
+
+static inline void bnx2x_add_all_napi(struct bnx2x *bp)
+{
+        int i;
 
         /* Add NAPI objects */
-        for_each_rx_queue(bp, i)
+        for_each_eth_queue(bp, i)
                 netif_napi_add(bp->dev, &bnx2x_fp(bp, i, napi),
                                bnx2x_poll, BNX2X_NAPI_WEIGHT);
 }
 
+static inline void bnx2x_del_all_napi_cnic(struct bnx2x *bp)
+{
+        int i;
+
+        for_each_rx_queue_cnic(bp, i)
+                netif_napi_del(&bnx2x_fp(bp, i, napi));
+}
+
 static inline void bnx2x_del_all_napi(struct bnx2x *bp)
 {
         int i;
 
-        for_each_rx_queue(bp, i)
+        for_each_eth_queue(bp, i)
                 netif_napi_del(&bnx2x_fp(bp, i, napi));
 }
 
@@ -979,11 +1029,9 @@ static inline u8 bnx2x_stats_id(struct bnx2x_fastpath *fp)
 {
         struct bnx2x *bp = fp->bp;
         if (!CHIP_IS_E1x(bp)) {
-#ifdef BCM_CNIC
                 /* there are special statistics counters for FCoE 136..140 */
                 if (IS_FCOE_FP(fp))
                         return bp->cnic_base_cl_id + (bp->pf_num >> 1);
-#endif
                 return fp->cl_id;
         }
         return fp->cl_id + BP_PORT(bp) * FP_SB_MAX_E1x;
@@ -1102,7 +1150,6 @@ static inline void bnx2x_init_txdata(struct bnx2x *bp,
            txdata->cid, txdata->txq_index);
 }
 
-#ifdef BCM_CNIC
 static inline u8 bnx2x_cnic_eth_cl_id(struct bnx2x *bp, u8 cl_idx)
 {
         return bp->cnic_base_cl_id + cl_idx +
@@ -1162,7 +1209,6 @@ static inline void bnx2x_init_fcoe_fp(struct bnx2x *bp)
            fp->index, bp, fp->status_blk.e2_sb, fp->cl_id, fp->fw_sb_id,
            fp->igu_sb_id);
 }
-#endif
 
 static inline int bnx2x_clean_tx_queue(struct bnx2x *bp,
                                        struct bnx2x_fp_txdata *txdata)
@@ -1280,7 +1326,7 @@ static inline bool bnx2x_mtu_allows_gro(int mtu)
          */
         return mtu <= SGE_PAGE_SIZE && (U_ETH_SGL_SIZE * fpp) <= MAX_SKB_FRAGS;
 }
-#ifdef BCM_CNIC
+
 /**
  * bnx2x_get_iscsi_info - update iSCSI params according to licensing info.
  *
@@ -1288,7 +1334,6 @@ static inline bool bnx2x_mtu_allows_gro(int mtu)
  *
  */
 void bnx2x_get_iscsi_info(struct bnx2x *bp);
-#endif
 
 /**
  * bnx2x_link_sync_notify - send notification to other functions.
@@ -1340,13 +1385,11 @@ static inline void bnx2x_update_drv_flags(struct bnx2x *bp, u32 flags, u32 set)
 
 static inline bool bnx2x_is_valid_ether_addr(struct bnx2x *bp, u8 *addr)
 {
-        if (is_valid_ether_addr(addr))
+        if (is_valid_ether_addr(addr) ||
+            (is_zero_ether_addr(addr) &&
+             (IS_MF_STORAGE_SD(bp) || IS_MF_FCOE_AFEX(bp))))
                 return true;
-#ifdef BCM_CNIC
-        if (is_zero_ether_addr(addr) &&
-            (IS_MF_STORAGE_SD(bp) || IS_MF_FCOE_AFEX(bp)))
-                return true;
-#endif
+
         return false;
 }
 
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_dcb.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_dcb.c
index 2245c3895409..cba4a16ab86a 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_dcb.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_dcb.c
@@ -1908,10 +1908,10 @@ static void bnx2x_dcbnl_get_perm_hw_addr(struct net_device *netdev,
         /* first the HW mac address */
         memcpy(perm_addr, netdev->dev_addr, netdev->addr_len);
 
-#ifdef BCM_CNIC
-        /* second SAN address */
-        memcpy(perm_addr+netdev->addr_len, bp->fip_mac, netdev->addr_len);
-#endif
+        if (CNIC_LOADED(bp))
+                /* second SAN address */
+                memcpy(perm_addr+netdev->addr_len, bp->fip_mac,
+                       netdev->addr_len);
 }
 
 static void bnx2x_dcbnl_set_pg_tccfg_tx(struct net_device *netdev, int prio,
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c
index 6e5bdd1a31d9..c40c0253e105 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c
@@ -2901,7 +2901,9 @@ static void bnx2x_get_channels(struct net_device *dev,
 static void bnx2x_change_num_queues(struct bnx2x *bp, int num_rss)
 {
         bnx2x_disable_msi(bp);
-        BNX2X_NUM_QUEUES(bp) = num_rss + NON_ETH_CONTEXT_USE;
+        bp->num_ethernet_queues = num_rss;
+        bp->num_queues = bp->num_ethernet_queues + bp->num_cnic_queues;
+        BNX2X_DEV_INFO("set number of queues to %d\n", bp->num_queues);
         bnx2x_set_int_mode(bp);
 }
 
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_hsi.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_hsi.h
index 18704929e642..7eaa74b78a5b 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_hsi.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_hsi.h
@@ -4845,9 +4845,17 @@ struct vif_list_event_data {
         __le32 reserved2;
 };
 
-/*
- * union for all event ring message types
- */
+/* function update event data */
+struct function_update_event_data {
+        u8 echo;
+        u8 reserved;
+        __le16 reserved0;
+        __le32 reserved1;
+        __le32 reserved2;
+};
+
+
+/* union for all event ring message types */
 union event_data {
         struct vf_pf_event_data vf_pf_event;
         struct eth_event_data eth_event;
@@ -4855,6 +4863,7 @@ union event_data {
         struct vf_flr_event_data vf_flr_event;
         struct malicious_vf_event_data malicious_vf_event;
         struct vif_list_event_data vif_list_event;
+        struct function_update_event_data function_update_event;
 };
 
 
@@ -4984,8 +4993,10 @@ struct function_update_data {
         u8 allowed_priorities;
         u8 network_cos_mode;
         u8 lb_mode_en;
-        u8 reserved0;
-        __le32 reserved1;
+        u8 tx_switch_suspend_change_flg;
+        u8 tx_switch_suspend;
+        u8 echo;
+        __le16 reserved1;
 };
 
 
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_init_ops.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_init_ops.h
index fe66d902dc62..d755acfe7a40 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_init_ops.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_init_ops.h
@@ -648,15 +648,25 @@ static int bnx2x_ilt_client_mem_op(struct bnx2x *bp, int cli_num,
         return rc;
 }
 
+static int bnx2x_ilt_mem_op_cnic(struct bnx2x *bp, u8 memop)
+{
+        int rc = 0;
+
+        if (CONFIGURE_NIC_MODE(bp))
+                rc = bnx2x_ilt_client_mem_op(bp, ILT_CLIENT_SRC, memop);
+        if (!rc)
+                rc = bnx2x_ilt_client_mem_op(bp, ILT_CLIENT_TM, memop);
+
+        return rc;
+}
+
 static int bnx2x_ilt_mem_op(struct bnx2x *bp, u8 memop)
 {
         int rc = bnx2x_ilt_client_mem_op(bp, ILT_CLIENT_CDU, memop);
         if (!rc)
                 rc = bnx2x_ilt_client_mem_op(bp, ILT_CLIENT_QM, memop);
-        if (!rc)
+        if (!rc && CNIC_SUPPORT(bp) && !CONFIGURE_NIC_MODE(bp))
                 rc = bnx2x_ilt_client_mem_op(bp, ILT_CLIENT_SRC, memop);
-        if (!rc)
-                rc = bnx2x_ilt_client_mem_op(bp, ILT_CLIENT_TM, memop);
 
         return rc;
 }
@@ -781,12 +791,19 @@ static void bnx2x_ilt_client_id_init_op(struct bnx2x *bp,
         bnx2x_ilt_client_init_op(bp, ilt_cli, initop);
 }
 
+static void bnx2x_ilt_init_op_cnic(struct bnx2x *bp, u8 initop)
+{
+        if (CONFIGURE_NIC_MODE(bp))
+                bnx2x_ilt_client_id_init_op(bp, ILT_CLIENT_SRC, initop);
+        bnx2x_ilt_client_id_init_op(bp, ILT_CLIENT_TM, initop);
+}
+
 static void bnx2x_ilt_init_op(struct bnx2x *bp, u8 initop)
 {
         bnx2x_ilt_client_id_init_op(bp, ILT_CLIENT_CDU, initop);
         bnx2x_ilt_client_id_init_op(bp, ILT_CLIENT_QM, initop);
-        bnx2x_ilt_client_id_init_op(bp, ILT_CLIENT_SRC, initop);
-        bnx2x_ilt_client_id_init_op(bp, ILT_CLIENT_TM, initop);
+        if (CNIC_SUPPORT(bp) && !CONFIGURE_NIC_MODE(bp))
+                bnx2x_ilt_client_id_init_op(bp, ILT_CLIENT_SRC, initop);
 }
 
 static void bnx2x_ilt_init_client_psz(struct bnx2x *bp, int cli_num,
@@ -890,7 +907,6 @@ static void bnx2x_qm_init_ptr_table(struct bnx2x *bp, int qm_cid_count,
 /****************************************************************************
 * SRC initializations
 ****************************************************************************/
-#ifdef BCM_CNIC
 /* called during init func stage */
 static void bnx2x_src_init_t2(struct bnx2x *bp, struct src_ent *t2,
                               dma_addr_t t2_mapping, int src_cid_count)
@@ -915,5 +931,4 @@ static void bnx2x_src_init_t2(struct bnx2x *bp, struct src_ent *t2,
                     U64_HI((u64)t2_mapping +
                            (src_cid_count-1) * sizeof(struct src_ent)));
 }
-#endif
 #endif /* BNX2X_INIT_OPS_H */
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c
index f6cfdc6cf20f..cd002943fac8 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c
@@ -12066,7 +12066,7 @@ void bnx2x_init_xgxs_loopback(struct link_params *params,
         bnx2x_set_led(params, vars, LED_MODE_OPER, vars->line_speed);
 }
 
-static void bnx2x_set_rx_filter(struct link_params *params, u8 en)
+void bnx2x_set_rx_filter(struct link_params *params, u8 en)
 {
         struct bnx2x *bp = params->bp;
         u8 val = en * 0x1F;
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.h
index 9165b89a4b19..ba981ced628b 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.h
@@ -432,7 +432,8 @@ int bnx2x_phy_probe(struct link_params *params);
 u8 bnx2x_fan_failure_det_req(struct bnx2x *bp, u32 shmem_base,
                              u32 shmem2_base, u8 port);
 
-
+/* Open / close the gate between the NIG and the BRB */
+void bnx2x_set_rx_filter(struct link_params *params, u8 en);
 
 /* DCBX structs */
 
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
index bd1fd3d87c24..04b9f0ab183b 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
@@ -791,10 +791,9 @@ void bnx2x_panic_dump(struct bnx2x *bp)
 
                 /* host sb data */
 
-#ifdef BCM_CNIC
                 if (IS_FCOE_FP(fp))
                         continue;
-#endif
+
                 BNX2X_ERR("     run indexes (");
                 for (j = 0; j < HC_SB_MAX_SM; j++)
                         pr_cont("0x%x%s",
@@ -859,7 +858,7 @@ void bnx2x_panic_dump(struct bnx2x *bp)
 #ifdef BNX2X_STOP_ON_ERROR
         /* Rings */
         /* Rx */
-        for_each_rx_queue(bp, i) {
+        for_each_valid_rx_queue(bp, i) {
                 struct bnx2x_fastpath *fp = &bp->fp[i];
 
                 start = RX_BD(le16_to_cpu(*fp->rx_cons_sb) - 10);
@@ -893,7 +892,7 @@ void bnx2x_panic_dump(struct bnx2x *bp)
         }
 
         /* Tx */
-        for_each_tx_queue(bp, i) {
+        for_each_valid_tx_queue(bp, i) {
                 struct bnx2x_fastpath *fp = &bp->fp[i];
                 for_each_cos_in_tx_queue(fp, cos) {
                         struct bnx2x_fp_txdata *txdata = fp->txdata_ptr[cos];
@@ -1504,9 +1503,8 @@ void bnx2x_int_disable_sync(struct bnx2x *bp, int disable_hw)
         if (msix) {
                 synchronize_irq(bp->msix_table[0].vector);
                 offset = 1;
-#ifdef BCM_CNIC
-                offset++;
-#endif
+                if (CNIC_SUPPORT(bp))
+                        offset++;
                 for_each_eth_queue(bp, i)
                         synchronize_irq(bp->msix_table[offset++].vector);
         } else
@@ -1588,9 +1586,8 @@ static bool bnx2x_trylock_leader_lock(struct bnx2x *bp)
         return bnx2x_trylock_hw_lock(bp, bnx2x_get_leader_lock_resource(bp));
 }
 
-#ifdef BCM_CNIC
 static void bnx2x_cnic_cfc_comp(struct bnx2x *bp, int cid, u8 err);
-#endif
+
 
 void bnx2x_sp_event(struct bnx2x_fastpath *fp, union eth_rx_cqe *rr_cqe)
 {
@@ -1720,7 +1717,7 @@ irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
         for_each_eth_queue(bp, i) {
                 struct bnx2x_fastpath *fp = &bp->fp[i];
 
-                mask = 0x2 << (fp->index + CNIC_PRESENT);
+                mask = 0x2 << (fp->index + CNIC_SUPPORT(bp));
                 if (status & mask) {
                         /* Handle Rx or Tx according to SB id */
                         prefetch(fp->rx_cons_sb);
@@ -1732,22 +1729,23 @@ irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
                 }
         }
 
-#ifdef BCM_CNIC
-        mask = 0x2;
-        if (status & (mask | 0x1)) {
-                struct cnic_ops *c_ops = NULL;
+        if (CNIC_SUPPORT(bp)) {
+                mask = 0x2;
+                if (status & (mask | 0x1)) {
+                        struct cnic_ops *c_ops = NULL;
 
-                if (likely(bp->state == BNX2X_STATE_OPEN)) {
-                        rcu_read_lock();
-                        c_ops = rcu_dereference(bp->cnic_ops);
-                        if (c_ops)
-                                c_ops->cnic_handler(bp->cnic_data, NULL);
-                        rcu_read_unlock();
-                }
+                        if (likely(bp->state == BNX2X_STATE_OPEN)) {
+                                rcu_read_lock();
+                                c_ops = rcu_dereference(bp->cnic_ops);
+                                if (c_ops)
+                                        c_ops->cnic_handler(bp->cnic_data,
+                                                            NULL);
+                                rcu_read_unlock();
+                        }
 
-                status &= ~mask;
+                        status &= ~mask;
+                }
         }
-#endif
 
         if (unlikely(status & 0x1)) {
                 queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
@@ -3075,11 +3073,13 @@ static void bnx2x_drv_info_ether_stat(struct bnx2x *bp)
 
 static void bnx2x_drv_info_fcoe_stat(struct bnx2x *bp)
 {
-#ifdef BCM_CNIC
         struct bnx2x_dcbx_app_params *app = &bp->dcbx_port_params.app;
         struct fcoe_stats_info *fcoe_stat =
                 &bp->slowpath->drv_info_to_mcp.fcoe_stat;
 
+        if (!CNIC_LOADED(bp))
+                return;
+
         memcpy(fcoe_stat->mac_local + MAC_LEADING_ZERO_CNT,
                bp->fip_mac, ETH_ALEN);
 
@@ -3162,16 +3162,17 @@ static void bnx2x_drv_info_fcoe_stat(struct bnx2x *bp)
 
         /* ask L5 driver to add data to the struct */
         bnx2x_cnic_notify(bp, CNIC_CTL_FCOE_STATS_GET_CMD);
-#endif
 }
 
 static void bnx2x_drv_info_iscsi_stat(struct bnx2x *bp)
 {
-#ifdef BCM_CNIC
         struct bnx2x_dcbx_app_params *app = &bp->dcbx_port_params.app;
         struct iscsi_stats_info *iscsi_stat =
                 &bp->slowpath->drv_info_to_mcp.iscsi_stat;
 
+        if (!CNIC_LOADED(bp))
+                return;
+
         memcpy(iscsi_stat->mac_local + MAC_LEADING_ZERO_CNT,
                bp->cnic_eth_dev.iscsi_mac, ETH_ALEN);
 
@@ -3180,7 +3181,6 @@ static void bnx2x_drv_info_iscsi_stat(struct bnx2x *bp)
 
         /* ask L5 driver to add data to the struct */
         bnx2x_cnic_notify(bp, CNIC_CTL_ISCSI_STATS_GET_CMD);
-#endif
 }
 
 /* called due to MCP event (on pmf):
@@ -4572,7 +4572,6 @@ static void bnx2x_update_eq_prod(struct bnx2x *bp, u16 prod)
         mmiowb(); /* keep prod updates ordered */
 }
 
-#ifdef BCM_CNIC
 static int  bnx2x_cnic_handle_cfc_del(struct bnx2x *bp, u32 cid,
                                       union event_ring_elem *elem)
 {
@@ -4594,7 +4593,6 @@ static int  bnx2x_cnic_handle_cfc_del(struct bnx2x *bp, u32 cid,
         bnx2x_cnic_cfc_comp(bp, cid, err);
         return 0;
 }
-#endif
 
 static void bnx2x_handle_mcast_eqe(struct bnx2x *bp)
 {
@@ -4635,11 +4633,9 @@ static void bnx2x_handle_classification_eqe(struct bnx2x *bp,
         switch (elem->message.data.eth_event.echo >> BNX2X_SWCID_SHIFT) {
         case BNX2X_FILTER_MAC_PENDING:
                 DP(BNX2X_MSG_SP, "Got SETUP_MAC completions\n");
-#ifdef BCM_CNIC
-                if (cid == BNX2X_ISCSI_ETH_CID(bp))
+                if (CNIC_LOADED(bp) && (cid == BNX2X_ISCSI_ETH_CID(bp)))
                         vlan_mac_obj = &bp->iscsi_l2_mac_obj;
                 else
-#endif
                         vlan_mac_obj = &bp->sp_objs[cid].mac_obj;
 
                 break;
@@ -4665,9 +4661,7 @@ static void bnx2x_handle_classification_eqe(struct bnx2x *bp,
 
 }
 
-#ifdef BCM_CNIC
 static void bnx2x_set_iscsi_eth_rx_mode(struct bnx2x *bp, bool start);
-#endif
 
 static void bnx2x_handle_rx_mode_eqe(struct bnx2x *bp)
 {
@@ -4678,14 +4672,12 @@ static void bnx2x_handle_rx_mode_eqe(struct bnx2x *bp)
         /* Send rx_mode command again if was requested */
         if (test_and_clear_bit(BNX2X_FILTER_RX_MODE_SCHED, &bp->sp_state))
                 bnx2x_set_storm_rx_mode(bp);
-#ifdef BCM_CNIC
         else if (test_and_clear_bit(BNX2X_FILTER_ISCSI_ETH_START_SCHED,
                                     &bp->sp_state))
                 bnx2x_set_iscsi_eth_rx_mode(bp, true);
         else if (test_and_clear_bit(BNX2X_FILTER_ISCSI_ETH_STOP_SCHED,
                                     &bp->sp_state))
                 bnx2x_set_iscsi_eth_rx_mode(bp, false);
-#endif
 
         netif_addr_unlock_bh(bp->dev);
 }
@@ -4747,7 +4739,6 @@ static void bnx2x_after_function_update(struct bnx2x *bp)
                                   q);
         }
 
-#ifdef BCM_CNIC
         if (!NO_FCOE(bp)) {
                 fp = &bp->fp[FCOE_IDX(bp)];
                 queue_params.q_obj = &bnx2x_sp_obj(bp, fp).q_obj;
@@ -4770,22 +4761,16 @@ static void bnx2x_after_function_update(struct bnx2x *bp)
                 bnx2x_link_report(bp);
                 bnx2x_fw_command(bp, DRV_MSG_CODE_AFEX_VIFSET_ACK, 0);
         }
-#else
-        /* If no FCoE ring - ACK MCP now */
-        bnx2x_link_report(bp);
-        bnx2x_fw_command(bp, DRV_MSG_CODE_AFEX_VIFSET_ACK, 0);
-#endif /* BCM_CNIC */
 }
 
 static struct bnx2x_queue_sp_obj *bnx2x_cid_to_q_obj(
         struct bnx2x *bp, u32 cid)
 {
         DP(BNX2X_MSG_SP, "retrieving fp from cid %d\n", cid);
-#ifdef BCM_CNIC
-        if (cid == BNX2X_FCOE_ETH_CID(bp))
+
+        if (CNIC_LOADED(bp) && (cid == BNX2X_FCOE_ETH_CID(bp)))
                 return &bnx2x_fcoe_sp_obj(bp, q_obj);
         else
-#endif
                 return &bp->sp_objs[CID_TO_FP(cid, bp)].q_obj;
 }
 
@@ -4793,6 +4778,7 @@ static void bnx2x_eq_int(struct bnx2x *bp)
 {
         u16 hw_cons, sw_cons, sw_prod;
         union event_ring_elem *elem;
+        u8 echo;
         u32 cid;
         u8 opcode;
         int spqe_cnt = 0;
@@ -4847,10 +4833,11 @@ static void bnx2x_eq_int(struct bnx2x *bp)
                          */
                         DP(BNX2X_MSG_SP,
                            "got delete ramrod for MULTI[%d]\n", cid);
-#ifdef BCM_CNIC
-                        if (!bnx2x_cnic_handle_cfc_del(bp, cid, elem))
+
+                        if (CNIC_LOADED(bp) &&
+                            !bnx2x_cnic_handle_cfc_del(bp, cid, elem))
                                 goto next_spqe;
-#endif
+
                         q_obj = bnx2x_cid_to_q_obj(bp, cid);
 
                         if (q_obj->complete_cmd(bp, q_obj, BNX2X_Q_CMD_CFC_DEL))
@@ -4875,21 +4862,34 @@ static void bnx2x_eq_int(struct bnx2x *bp)
                                 break;
                         bnx2x_dcbx_set_params(bp, BNX2X_DCBX_STATE_TX_RELEASED);
                         goto next_spqe;
+
                 case EVENT_RING_OPCODE_FUNCTION_UPDATE:
-                        DP(BNX2X_MSG_SP | BNX2X_MSG_MCP,
-                           "AFEX: ramrod completed FUNCTION_UPDATE\n");
-                        f_obj->complete_cmd(bp, f_obj, BNX2X_F_CMD_AFEX_UPDATE);
+                        echo = elem->message.data.function_update_event.echo;
+                        if (echo == SWITCH_UPDATE) {
+                                DP(BNX2X_MSG_SP | NETIF_MSG_IFUP,
+                                   "got FUNC_SWITCH_UPDATE ramrod\n");
+                                if (f_obj->complete_cmd(
+                                        bp, f_obj, BNX2X_F_CMD_SWITCH_UPDATE))
+                                        break;
 
-                        /* We will perform the Queues update from sp_rtnl task
-                         * as all Queue SP operations should run under
-                         * rtnl_lock.
-                         */
-                        smp_mb__before_clear_bit();
-                        set_bit(BNX2X_SP_RTNL_AFEX_F_UPDATE,
-                                &bp->sp_rtnl_state);
-                        smp_mb__after_clear_bit();
+                        } else {
+                                DP(BNX2X_MSG_SP | BNX2X_MSG_MCP,
+                                   "AFEX: ramrod completed FUNCTION_UPDATE\n");
+                                f_obj->complete_cmd(bp, f_obj,
+                                                    BNX2X_F_CMD_AFEX_UPDATE);
+
+                                /* We will perform the Queues update from
+                                 * sp_rtnl task as all Queue SP operations
+                                 * should run under rtnl_lock.
+                                 */
+                                smp_mb__before_clear_bit();
+                                set_bit(BNX2X_SP_RTNL_AFEX_F_UPDATE,
+                                        &bp->sp_rtnl_state);
+                                smp_mb__after_clear_bit();
+
+                                schedule_delayed_work(&bp->sp_rtnl_task, 0);
+                        }
 
-                        schedule_delayed_work(&bp->sp_rtnl_task, 0);
                         goto next_spqe;
 
                 case EVENT_RING_OPCODE_AFEX_VIF_LISTS:
@@ -4999,11 +4999,10 @@ static void bnx2x_sp_task(struct work_struct *work)
 
         /* SP events: STAT_QUERY and others */
         if (status & BNX2X_DEF_SB_IDX) {
-#ifdef BCM_CNIC
                 struct bnx2x_fastpath *fp = bnx2x_fcoe_fp(bp);
 
-                if ((!NO_FCOE(bp)) &&
-                        (bnx2x_has_rx_work(fp) || bnx2x_has_tx_work(fp))) {
+                if (FCOE_INIT(bp) &&
+                    (bnx2x_has_rx_work(fp) || bnx2x_has_tx_work(fp))) {
                         /*
                          * Prevent local bottom-halves from running as
                          * we are going to change the local NAPI list.
@@ -5012,7 +5011,7 @@ static void bnx2x_sp_task(struct work_struct *work)
                         napi_schedule(&bnx2x_fcoe(bp, napi));
                         local_bh_enable();
                 }
-#endif
+
                 /* Handle EQ completions */
                 bnx2x_eq_int(bp);
 
@@ -5050,8 +5049,7 @@ irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance)
                 return IRQ_HANDLED;
 #endif
 
-#ifdef BCM_CNIC
-        {
+        if (CNIC_LOADED(bp)) {
                 struct cnic_ops *c_ops;
 
                 rcu_read_lock();
@@ -5060,7 +5058,7 @@ irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance)
                         c_ops->cnic_handler(bp->cnic_data, NULL);
                 rcu_read_unlock();
         }
-#endif
+
         queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
 
         return IRQ_HANDLED;
@@ -5498,12 +5496,10 @@ void bnx2x_set_storm_rx_mode(struct bnx2x *bp)
         unsigned long rx_mode_flags = 0, ramrod_flags = 0;
         unsigned long rx_accept_flags = 0, tx_accept_flags = 0;
 
-#ifdef BCM_CNIC
         if (!NO_FCOE(bp))
 
                 /* Configure rx_mode of FCoE Queue */
                 __set_bit(BNX2X_RX_MODE_FCOE_ETH, &rx_mode_flags);
-#endif
 
         switch (bp->rx_mode) {
         case BNX2X_RX_MODE_NONE:
@@ -5624,12 +5620,12 @@ static void bnx2x_init_internal(struct bnx2x *bp, u32 load_code)
 
 static inline u8 bnx2x_fp_igu_sb_id(struct bnx2x_fastpath *fp)
 {
-        return fp->bp->igu_base_sb + fp->index + CNIC_PRESENT;
+        return fp->bp->igu_base_sb + fp->index + CNIC_SUPPORT(fp->bp);
 }
 
 static inline u8 bnx2x_fp_fw_sb_id(struct bnx2x_fastpath *fp)
 {
-        return fp->bp->base_fw_ndsb + fp->index + CNIC_PRESENT;
+        return fp->bp->base_fw_ndsb + fp->index + CNIC_SUPPORT(fp->bp);
 }
 
 static u8 bnx2x_fp_cl_id(struct bnx2x_fastpath *fp)
@@ -5720,23 +5716,25 @@ static void bnx2x_init_tx_ring_one(struct bnx2x_fp_txdata *txdata)
         txdata->tx_pkt = 0;
 }
 
+static void bnx2x_init_tx_rings_cnic(struct bnx2x *bp)
+{
+        int i;
+
+        for_each_tx_queue_cnic(bp, i)
+                bnx2x_init_tx_ring_one(bp->fp[i].txdata_ptr[0]);
+}
 static void bnx2x_init_tx_rings(struct bnx2x *bp)
 {
         int i;
         u8 cos;
 
-        for_each_tx_queue(bp, i)
+        for_each_eth_queue(bp, i)
                 for_each_cos_in_tx_queue(&bp->fp[i], cos)
                         bnx2x_init_tx_ring_one(bp->fp[i].txdata_ptr[cos]);
 }
 
-void bnx2x_nic_init(struct bnx2x *bp, u32 load_code)
+void bnx2x_nic_init_cnic(struct bnx2x *bp)
 {
-        int i;
-
-        for_each_eth_queue(bp, i)
-                bnx2x_init_eth_fp(bp, i);
-#ifdef BCM_CNIC
         if (!NO_FCOE(bp))
                 bnx2x_init_fcoe_fp(bp);
 
@@ -5744,8 +5742,22 @@ void bnx2x_nic_init(struct bnx2x *bp, u32 load_code)
                       BNX2X_VF_ID_INVALID, false,
                       bnx2x_cnic_fw_sb_id(bp), bnx2x_cnic_igu_sb_id(bp));
 
-#endif
+        /* ensure status block indices were read */
+        rmb();
+        bnx2x_init_rx_rings_cnic(bp);
+        bnx2x_init_tx_rings_cnic(bp);
+
+        /* flush all */
+        mb();
+        mmiowb();
+}
 
+void bnx2x_nic_init(struct bnx2x *bp, u32 load_code)
+{
+        int i;
+
+        for_each_eth_queue(bp, i)
+                bnx2x_init_eth_fp(bp, i);
         /* Initialize MOD_ABS interrupts */
         bnx2x_init_mod_abs_int(bp, &bp->link_vars, bp->common.chip_id,
                                bp->common.shmem_base, bp->common.shmem2_base,
@@ -6031,10 +6043,9 @@ static int bnx2x_int_mem_test(struct bnx2x *bp)
         msleep(50);
         bnx2x_init_block(bp, BLOCK_BRB1, PHASE_COMMON);
         bnx2x_init_block(bp, BLOCK_PRS, PHASE_COMMON);
-#ifndef BCM_CNIC
-        /* set NIC mode */
-        REG_WR(bp, PRS_REG_NIC_MODE, 1);
-#endif
+        if (!CNIC_SUPPORT(bp))
+                /* set NIC mode */
+                REG_WR(bp, PRS_REG_NIC_MODE, 1);
 
         /* Enable inputs of parser neighbor blocks */
         REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x7fffffff);
@@ -6522,9 +6533,8 @@ static int bnx2x_init_hw_common(struct bnx2x *bp)
         REG_WR(bp, QM_REG_SOFT_RESET, 1);
         REG_WR(bp, QM_REG_SOFT_RESET, 0);
 
-#ifdef BCM_CNIC
-        bnx2x_init_block(bp, BLOCK_TM, PHASE_COMMON);
-#endif
+        if (CNIC_SUPPORT(bp))
+                bnx2x_init_block(bp, BLOCK_TM, PHASE_COMMON);
 
         bnx2x_init_block(bp, BLOCK_DORQ, PHASE_COMMON);
         REG_WR(bp, DORQ_REG_DPM_CID_OFST, BNX2X_DB_SHIFT);
@@ -6611,18 +6621,18 @@ static int bnx2x_init_hw_common(struct bnx2x *bp)
 
         bnx2x_init_block(bp, BLOCK_SRC, PHASE_COMMON);
 
-#ifdef BCM_CNIC
-        REG_WR(bp, SRC_REG_KEYSEARCH_0, 0x63285672);
-        REG_WR(bp, SRC_REG_KEYSEARCH_1, 0x24b8f2cc);
-        REG_WR(bp, SRC_REG_KEYSEARCH_2, 0x223aef9b);
-        REG_WR(bp, SRC_REG_KEYSEARCH_3, 0x26001e3a);
-        REG_WR(bp, SRC_REG_KEYSEARCH_4, 0x7ae91116);
-        REG_WR(bp, SRC_REG_KEYSEARCH_5, 0x5ce5230b);
-        REG_WR(bp, SRC_REG_KEYSEARCH_6, 0x298d8adf);
-        REG_WR(bp, SRC_REG_KEYSEARCH_7, 0x6eb0ff09);
-        REG_WR(bp, SRC_REG_KEYSEARCH_8, 0x1830f82f);
-        REG_WR(bp, SRC_REG_KEYSEARCH_9, 0x01e46be7);
-#endif
+        if (CNIC_SUPPORT(bp)) {
+                REG_WR(bp, SRC_REG_KEYSEARCH_0, 0x63285672);
+                REG_WR(bp, SRC_REG_KEYSEARCH_1, 0x24b8f2cc);
+                REG_WR(bp, SRC_REG_KEYSEARCH_2, 0x223aef9b);
+                REG_WR(bp, SRC_REG_KEYSEARCH_3, 0x26001e3a);
+                REG_WR(bp, SRC_REG_KEYSEARCH_4, 0x7ae91116);
+                REG_WR(bp, SRC_REG_KEYSEARCH_5, 0x5ce5230b);
+                REG_WR(bp, SRC_REG_KEYSEARCH_6, 0x298d8adf);
+                REG_WR(bp, SRC_REG_KEYSEARCH_7, 0x6eb0ff09);
+                REG_WR(bp, SRC_REG_KEYSEARCH_8, 0x1830f82f);
+                REG_WR(bp, SRC_REG_KEYSEARCH_9, 0x01e46be7);
+        }
         REG_WR(bp, SRC_REG_SOFT_RST, 0);
 
         if (sizeof(union cdu_context) != 1024)
@@ -6786,11 +6796,11 @@ static int bnx2x_init_hw_port(struct bnx2x *bp)
         /* QM cid (connection) count */
         bnx2x_qm_init_cid_count(bp, bp->qm_cid_count, INITOP_SET);
 
-#ifdef BCM_CNIC
-        bnx2x_init_block(bp, BLOCK_TM, init_phase);
-        REG_WR(bp, TM_REG_LIN0_SCAN_TIME + port*4, 20);
-        REG_WR(bp, TM_REG_LIN0_MAX_ACTIVE_CID + port*4, 31);
-#endif
+        if (CNIC_SUPPORT(bp)) {
+                bnx2x_init_block(bp, BLOCK_TM, init_phase);
+                REG_WR(bp, TM_REG_LIN0_SCAN_TIME + port*4, 20);
+                REG_WR(bp, TM_REG_LIN0_MAX_ACTIVE_CID + port*4, 31);
+        }
 
         bnx2x_init_block(bp, BLOCK_DORQ, init_phase);
 
@@ -6877,9 +6887,9 @@ static int bnx2x_init_hw_port(struct bnx2x *bp)
                 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 0);
         }
 
-#ifdef BCM_CNIC
-        bnx2x_init_block(bp, BLOCK_SRC, init_phase);
-#endif
+        if (CNIC_SUPPORT(bp))
+                bnx2x_init_block(bp, BLOCK_SRC, init_phase);
+
         bnx2x_init_block(bp, BLOCK_CDU, init_phase);
         bnx2x_init_block(bp, BLOCK_CFC, init_phase);
 
@@ -7040,6 +7050,130 @@ static void bnx2x_clear_func_ilt(struct bnx2x *bp, u32 func)
                 bnx2x_ilt_wr(bp, i, 0);
 }
 
+
+void bnx2x_init_searcher(struct bnx2x *bp)
+{
+        int port = BP_PORT(bp);
+        bnx2x_src_init_t2(bp, bp->t2, bp->t2_mapping, SRC_CONN_NUM);
+        /* T1 hash bits value determines the T1 number of entries */
+        REG_WR(bp, SRC_REG_NUMBER_HASH_BITS0 + port*4, SRC_HASH_BITS);
+}
+
+static inline int bnx2x_func_switch_update(struct bnx2x *bp, int suspend)
+{
+        int rc;
+        struct bnx2x_func_state_params func_params = {NULL};
+        struct bnx2x_func_switch_update_params *switch_update_params =
+                &func_params.params.switch_update;
+
+        /* Prepare parameters for function state transitions */
+        __set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
+        __set_bit(RAMROD_RETRY, &func_params.ramrod_flags);
+
+        func_params.f_obj = &bp->func_obj;
+        func_params.cmd = BNX2X_F_CMD_SWITCH_UPDATE;
+
+        /* Function parameters */
+        switch_update_params->suspend = suspend;
+
+        rc = bnx2x_func_state_change(bp, &func_params);
+
+        return rc;
+}
+
+int bnx2x_reset_nic_mode(struct bnx2x *bp)
+{
+        int rc, i, port = BP_PORT(bp);
+        int vlan_en = 0, mac_en[NUM_MACS];
+
+
+        /* Close input from network */
+        if (bp->mf_mode == SINGLE_FUNCTION) {
+                bnx2x_set_rx_filter(&bp->link_params, 0);
+        } else {
+                vlan_en = REG_RD(bp, port ? NIG_REG_LLH1_FUNC_EN :
+                                   NIG_REG_LLH0_FUNC_EN);
+                REG_WR(bp, port ? NIG_REG_LLH1_FUNC_EN :
+                          NIG_REG_LLH0_FUNC_EN, 0);
+                for (i = 0; i < NUM_MACS; i++) {
+                        mac_en[i] = REG_RD(bp, port ?
+                                             (NIG_REG_LLH1_FUNC_MEM_ENABLE +
+                                              4 * i) :
+                                             (NIG_REG_LLH0_FUNC_MEM_ENABLE +
+                                              4 * i));
+                        REG_WR(bp, port ? (NIG_REG_LLH1_FUNC_MEM_ENABLE +
+                                              4 * i) :
+                                  (NIG_REG_LLH0_FUNC_MEM_ENABLE + 4 * i), 0);
+                }
+        }
+
+        /* Close BMC to host */
+        REG_WR(bp, port ? NIG_REG_P0_TX_MNG_HOST_ENABLE :
+               NIG_REG_P1_TX_MNG_HOST_ENABLE, 0);
+
+        /* Suspend Tx switching to the PF. Completion of this ramrod
+         * further guarantees that all the packets of that PF / child
+         * VFs in BRB were processed by the Parser, so it is safe to
+         * change the NIC_MODE register.
+         */
+        rc = bnx2x_func_switch_update(bp, 1);
+        if (rc) {
+                BNX2X_ERR("Can't suspend tx-switching!\n");
+                return rc;
+        }
+
+        /* Change NIC_MODE register */
+        REG_WR(bp, PRS_REG_NIC_MODE, 0);
+
+        /* Open input from network */
+        if (bp->mf_mode == SINGLE_FUNCTION) {
+                bnx2x_set_rx_filter(&bp->link_params, 1);
+        } else {
+                REG_WR(bp, port ? NIG_REG_LLH1_FUNC_EN :
+                          NIG_REG_LLH0_FUNC_EN, vlan_en);
+                for (i = 0; i < NUM_MACS; i++) {
+                        REG_WR(bp, port ? (NIG_REG_LLH1_FUNC_MEM_ENABLE +
+                                              4 * i) :
+                                  (NIG_REG_LLH0_FUNC_MEM_ENABLE + 4 * i),
+                                  mac_en[i]);
+                }
+        }
+
+        /* Enable BMC to host */
+        REG_WR(bp, port ? NIG_REG_P0_TX_MNG_HOST_ENABLE :
+               NIG_REG_P1_TX_MNG_HOST_ENABLE, 1);
+
+        /* Resume Tx switching to the PF */
+        rc = bnx2x_func_switch_update(bp, 0);
+        if (rc) {
+                BNX2X_ERR("Can't resume tx-switching!\n");
+                return rc;
+        }
+
+        DP(NETIF_MSG_IFUP, "NIC MODE disabled\n");
+        return 0;
+}
+
+int bnx2x_init_hw_func_cnic(struct bnx2x *bp)
+{
+        int rc;
+
+        bnx2x_ilt_init_op_cnic(bp, INITOP_SET);
+
+        if (CONFIGURE_NIC_MODE(bp)) {
+                /* Configrue searcher as part of function hw init */
+                bnx2x_init_searcher(bp);
+
+                /* Reset NIC mode */
+                rc = bnx2x_reset_nic_mode(bp);
+                if (rc)
+                        BNX2X_ERR("Can't change NIC mode!\n");
+                return rc;
+        }
+
+        return 0;
+}
+
 static int bnx2x_init_hw_func(struct bnx2x *bp)
 {
         int port = BP_PORT(bp);
@@ -7082,17 +7216,16 @@ static int bnx2x_init_hw_func(struct bnx2x *bp)
         }
         bnx2x_ilt_init_op(bp, INITOP_SET);
 
-#ifdef BCM_CNIC
-        bnx2x_src_init_t2(bp, bp->t2, bp->t2_mapping, SRC_CONN_NUM);
-
-        /* T1 hash bits value determines the T1 number of entries */
-        REG_WR(bp, SRC_REG_NUMBER_HASH_BITS0 + port*4, SRC_HASH_BITS);
-#endif
+        if (!CONFIGURE_NIC_MODE(bp)) {
+                bnx2x_init_searcher(bp);
+                REG_WR(bp, PRS_REG_NIC_MODE, 0);
+                DP(NETIF_MSG_IFUP, "NIC MODE disabled\n");
+        } else {
+                /* Set NIC mode */
+                REG_WR(bp, PRS_REG_NIC_MODE, 1);
+                DP(NETIF_MSG_IFUP, "NIC MODE configrued\n");
 
-#ifndef BCM_CNIC
-        /* set NIC mode */
-        REG_WR(bp, PRS_REG_NIC_MODE, 1);
-#endif  /* BCM_CNIC */
+        }
 
         if (!CHIP_IS_E1x(bp)) {
                 u32 pf_conf = IGU_PF_CONF_FUNC_EN;
@@ -7343,6 +7476,20 @@ static int bnx2x_init_hw_func(struct bnx2x *bp)
 }
 
 
+void bnx2x_free_mem_cnic(struct bnx2x *bp)
+{
+        bnx2x_ilt_mem_op_cnic(bp, ILT_MEMOP_FREE);
+
+        if (!CHIP_IS_E1x(bp))
+                BNX2X_PCI_FREE(bp->cnic_sb.e2_sb, bp->cnic_sb_mapping,
+                               sizeof(struct host_hc_status_block_e2));
+        else
+                BNX2X_PCI_FREE(bp->cnic_sb.e1x_sb, bp->cnic_sb_mapping,
+                               sizeof(struct host_hc_status_block_e1x));
+
+        BNX2X_PCI_FREE(bp->t2, bp->t2_mapping, SRC_T2_SZ);
+}
+
 void bnx2x_free_mem(struct bnx2x *bp)
 {
         int i;
@@ -7367,17 +7514,6 @@ void bnx2x_free_mem(struct bnx2x *bp)
 
         BNX2X_FREE(bp->ilt->lines);
 
-#ifdef BCM_CNIC
-        if (!CHIP_IS_E1x(bp))
-                BNX2X_PCI_FREE(bp->cnic_sb.e2_sb, bp->cnic_sb_mapping,
-                               sizeof(struct host_hc_status_block_e2));
-        else
-                BNX2X_PCI_FREE(bp->cnic_sb.e1x_sb, bp->cnic_sb_mapping,
-                               sizeof(struct host_hc_status_block_e1x));
-
-        BNX2X_PCI_FREE(bp->t2, bp->t2_mapping, SRC_T2_SZ);
-#endif
-
         BNX2X_PCI_FREE(bp->spq, bp->spq_mapping, BCM_PAGE_SIZE);
 
         BNX2X_PCI_FREE(bp->eq_ring, bp->eq_mapping,
@@ -7445,24 +7581,44 @@ alloc_mem_err:
         return -ENOMEM;
 }
 
-
-int bnx2x_alloc_mem(struct bnx2x *bp)
+int bnx2x_alloc_mem_cnic(struct bnx2x *bp)
 {
-        int i, allocated, context_size;
-
-#ifdef BCM_CNIC
         if (!CHIP_IS_E1x(bp))
                 /* size = the status block + ramrod buffers */
                 BNX2X_PCI_ALLOC(bp->cnic_sb.e2_sb, &bp->cnic_sb_mapping,
                                 sizeof(struct host_hc_status_block_e2));
         else
-                BNX2X_PCI_ALLOC(bp->cnic_sb.e1x_sb, &bp->cnic_sb_mapping,
-                                sizeof(struct host_hc_status_block_e1x));
+                BNX2X_PCI_ALLOC(bp->cnic_sb.e1x_sb,
+                                &bp->cnic_sb_mapping,
+                                sizeof(struct
+                                       host_hc_status_block_e1x));
 
-        /* allocate searcher T2 table */
-        BNX2X_PCI_ALLOC(bp->t2, &bp->t2_mapping, SRC_T2_SZ);
-#endif
+        if (CONFIGURE_NIC_MODE(bp))
+                /* allocate searcher T2 table, as it wan't allocated before */
+                BNX2X_PCI_ALLOC(bp->t2, &bp->t2_mapping, SRC_T2_SZ);
+
+        /* write address to which L5 should insert its values */
+        bp->cnic_eth_dev.addr_drv_info_to_mcp =
+                &bp->slowpath->drv_info_to_mcp;
+
+        if (bnx2x_ilt_mem_op_cnic(bp, ILT_MEMOP_ALLOC))
+                goto alloc_mem_err;
+
+        return 0;
+
+alloc_mem_err:
+        bnx2x_free_mem_cnic(bp);
+        BNX2X_ERR("Can't allocate memory\n");
+        return -ENOMEM;
+}
+
+int bnx2x_alloc_mem(struct bnx2x *bp)
+{
+        int i, allocated, context_size;
 
+        if (!CONFIGURE_NIC_MODE(bp))
+                /* allocate searcher T2 table */
+                BNX2X_PCI_ALLOC(bp->t2, &bp->t2_mapping, SRC_T2_SZ);
 
         BNX2X_PCI_ALLOC(bp->def_status_blk, &bp->def_status_blk_mapping,
                         sizeof(struct host_sp_status_block));
@@ -7470,11 +7626,6 @@ int bnx2x_alloc_mem(struct bnx2x *bp)
         BNX2X_PCI_ALLOC(bp->slowpath, &bp->slowpath_mapping,
                         sizeof(struct bnx2x_slowpath));
 
-#ifdef BCM_CNIC
-        /* write address to which L5 should insert its values */
-        bp->cnic_eth_dev.addr_drv_info_to_mcp = &bp->slowpath->drv_info_to_mcp;
-#endif
-
         /* Allocated memory for FW statistics  */
         if (bnx2x_alloc_fw_stats_mem(bp))
                 goto alloc_mem_err;
@@ -7596,14 +7747,12 @@ int bnx2x_set_eth_mac(struct bnx2x *bp, bool set)
 {
         unsigned long ramrod_flags = 0;
 
-#ifdef BCM_CNIC
         if (is_zero_ether_addr(bp->dev->dev_addr) &&
             (IS_MF_STORAGE_SD(bp) || IS_MF_FCOE_AFEX(bp))) {
                 DP(NETIF_MSG_IFUP | NETIF_MSG_IFDOWN,
                    "Ignoring Zero MAC for STORAGE SD mode\n");
                 return 0;
         }
-#endif
 
         DP(NETIF_MSG_IFUP, "Adding Eth MAC\n");
 
@@ -7632,7 +7781,8 @@ void bnx2x_set_int_mode(struct bnx2x *bp)
                 bnx2x_enable_msi(bp);
                 /* falling through... */
         case INT_MODE_INTx:
-                bp->num_queues = 1 + NON_ETH_CONTEXT_USE;
+                bp->num_ethernet_queues = 1;
+                bp->num_queues = bp->num_ethernet_queues + bp->num_cnic_queues;
                 BNX2X_DEV_INFO("set number of queues to 1\n");
                 break;
         default:
@@ -7644,9 +7794,10 @@ void bnx2x_set_int_mode(struct bnx2x *bp)
                     bp->flags & USING_SINGLE_MSIX_FLAG) {
                         /* failed to enable multiple MSI-X */
                         BNX2X_DEV_INFO("Failed to enable multiple MSI-X (%d), set number of queues to %d\n",
-                                       bp->num_queues, 1 + NON_ETH_CONTEXT_USE);
+                                       bp->num_queues,
+                                       1 + bp->num_cnic_queues);
 
-                        bp->num_queues = 1 + NON_ETH_CONTEXT_USE;
+                        bp->num_queues = 1 + bp->num_cnic_queues;
 
                         /* Try to enable MSI */
                         if (!(bp->flags & USING_SINGLE_MSIX_FLAG) &&
@@ -7679,9 +7830,9 @@ void bnx2x_ilt_set_info(struct bnx2x *bp)
         ilt_client->flags = ILT_CLIENT_SKIP_MEM;
         ilt_client->start = line;
         line += bnx2x_cid_ilt_lines(bp);
-#ifdef BCM_CNIC
-        line += CNIC_ILT_LINES;
-#endif
+
+        if (CNIC_SUPPORT(bp))
+                line += CNIC_ILT_LINES;
         ilt_client->end = line - 1;
 
         DP(NETIF_MSG_IFUP, "ilt client[CDU]: start %d, end %d, psz 0x%x, flags 0x%x, hw psz %d\n",
@@ -7714,49 +7865,43 @@ void bnx2x_ilt_set_info(struct bnx2x *bp)
                    ilog2(ilt_client->page_size >> 12));
 
         }
-        /* SRC */
-        ilt_client = &ilt->clients[ILT_CLIENT_SRC];
-#ifdef BCM_CNIC
-        ilt_client->client_num = ILT_CLIENT_SRC;
-        ilt_client->page_size = SRC_ILT_PAGE_SZ;
-        ilt_client->flags = 0;
-        ilt_client->start = line;
-        line += SRC_ILT_LINES;
-        ilt_client->end = line - 1;
 
-        DP(NETIF_MSG_IFUP,
-           "ilt client[SRC]: start %d, end %d, psz 0x%x, flags 0x%x, hw psz %d\n",
-           ilt_client->start,
-           ilt_client->end,
-           ilt_client->page_size,
-           ilt_client->flags,
-           ilog2(ilt_client->page_size >> 12));
+        if (CNIC_SUPPORT(bp)) {
+                /* SRC */
+                ilt_client = &ilt->clients[ILT_CLIENT_SRC];
+                ilt_client->client_num = ILT_CLIENT_SRC;
+                ilt_client->page_size = SRC_ILT_PAGE_SZ;
+                ilt_client->flags = 0;
+                ilt_client->start = line;
+                line += SRC_ILT_LINES;
+                ilt_client->end = line - 1;
 
-#else
-        ilt_client->flags = (ILT_CLIENT_SKIP_INIT | ILT_CLIENT_SKIP_MEM);
-#endif
+                DP(NETIF_MSG_IFUP,
+                   "ilt client[SRC]: start %d, end %d, psz 0x%x, flags 0x%x, hw psz %d\n",
+                   ilt_client->start,
+                   ilt_client->end,
+                   ilt_client->page_size,
+                   ilt_client->flags,
+                   ilog2(ilt_client->page_size >> 12));
 
-        /* TM */
-        ilt_client = &ilt->clients[ILT_CLIENT_TM];
-#ifdef BCM_CNIC
-        ilt_client->client_num = ILT_CLIENT_TM;
-        ilt_client->page_size = TM_ILT_PAGE_SZ;
-        ilt_client->flags = 0;
-        ilt_client->start = line;
-        line += TM_ILT_LINES;
-        ilt_client->end = line - 1;
+                /* TM */
+                ilt_client = &ilt->clients[ILT_CLIENT_TM];
+                ilt_client->client_num = ILT_CLIENT_TM;
+                ilt_client->page_size = TM_ILT_PAGE_SZ;
+                ilt_client->flags = 0;
+                ilt_client->start = line;
+                line += TM_ILT_LINES;
+                ilt_client->end = line - 1;
 
-        DP(NETIF_MSG_IFUP,
-           "ilt client[TM]: start %d, end %d, psz 0x%x, flags 0x%x, hw psz %d\n",
-           ilt_client->start,
-           ilt_client->end,
-           ilt_client->page_size,
-           ilt_client->flags,
-           ilog2(ilt_client->page_size >> 12));
+                DP(NETIF_MSG_IFUP,
+                   "ilt client[TM]: start %d, end %d, psz 0x%x, flags 0x%x, hw psz %d\n",
+                   ilt_client->start,
+                   ilt_client->end,
+                   ilt_client->page_size,
+                   ilt_client->flags,
+                   ilog2(ilt_client->page_size >> 12));
+        }
 
-#else
-        ilt_client->flags = (ILT_CLIENT_SKIP_INIT | ILT_CLIENT_SKIP_MEM);
-#endif
         BUG_ON(line > ILT_MAX_LINES);
 }
 
@@ -7924,6 +8069,9 @@ int bnx2x_setup_queue(struct bnx2x *bp, struct bnx2x_fastpath *fp,
         /* Set the command */
         q_params.cmd = BNX2X_Q_CMD_SETUP;
 
+        if (IS_FCOE_FP(fp))
+                bp->fcoe_init = true;
+
         /* Change the state to SETUP */
         rc = bnx2x_queue_state_change(bp, &q_params);
         if (rc) {
@@ -8037,12 +8185,12 @@ static void bnx2x_reset_func(struct bnx2x *bp)
                            SB_DISABLED);
         }
 
-#ifdef BCM_CNIC
-        /* CNIC SB */
-        REG_WR8(bp, BAR_CSTRORM_INTMEM +
-                CSTORM_STATUS_BLOCK_DATA_STATE_OFFSET(bnx2x_cnic_fw_sb_id(bp)),
-                SB_DISABLED);
-#endif
+        if (CNIC_LOADED(bp))
+                /* CNIC SB */
+                REG_WR8(bp, BAR_CSTRORM_INTMEM +
+                        CSTORM_STATUS_BLOCK_DATA_STATE_OFFSET
+                        (bnx2x_cnic_fw_sb_id(bp)), SB_DISABLED);
+
         /* SP SB */
         REG_WR8(bp, BAR_CSTRORM_INTMEM +
                    CSTORM_SP_STATUS_BLOCK_DATA_STATE_OFFSET(func),
@@ -8061,19 +8209,19 @@ static void bnx2x_reset_func(struct bnx2x *bp)
                 REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, 0);
         }
 
-#ifdef BCM_CNIC
-        /* Disable Timer scan */
-        REG_WR(bp, TM_REG_EN_LINEAR0_TIMER + port*4, 0);
-        /*
-         * Wait for at least 10ms and up to 2 second for the timers scan to
-         * complete
-         */
-        for (i = 0; i < 200; i++) {
-                msleep(10);
-                if (!REG_RD(bp, TM_REG_LIN0_SCAN_ON + port*4))
-                        break;
+        if (CNIC_LOADED(bp)) {
+                /* Disable Timer scan */
+                REG_WR(bp, TM_REG_EN_LINEAR0_TIMER + port*4, 0);
+                /*
+                 * Wait for at least 10ms and up to 2 second for the timers
+                 * scan to complete
+                 */
+                for (i = 0; i < 200; i++) {
+                        msleep(10);
+                        if (!REG_RD(bp, TM_REG_LIN0_SCAN_ON + port*4))
+                                break;
+                }
         }
-#endif
         /* Clear ILT */
         bnx2x_clear_func_ilt(bp, func);
 
@@ -8409,13 +8557,24 @@ void bnx2x_chip_cleanup(struct bnx2x *bp, int unload_mode, bool keep_link)
         /* Close multi and leading connections
          * Completions for ramrods are collected in a synchronous way
          */
-        for_each_queue(bp, i)
+        for_each_eth_queue(bp, i)
                 if (bnx2x_stop_queue(bp, i))
 #ifdef BNX2X_STOP_ON_ERROR
                         return;
 #else
                         goto unload_error;
 #endif
+
+        if (CNIC_LOADED(bp)) {
+                for_each_cnic_queue(bp, i)
+                        if (bnx2x_stop_queue(bp, i))
+#ifdef BNX2X_STOP_ON_ERROR
+                                return;
+#else
+                                goto unload_error;
+#endif
+        }
+
         /* If SP settings didn't get completed so far - something
          * very wrong has happen.
          */
@@ -8437,6 +8596,8 @@ unload_error:
         bnx2x_netif_stop(bp, 1);
         /* Delete all NAPI objects */
         bnx2x_del_all_napi(bp);
+        if (CNIC_LOADED(bp))
+                bnx2x_del_all_napi_cnic(bp);
 
         /* Release IRQs */
         bnx2x_free_irq(bp);
@@ -10224,12 +10385,15 @@ static void __devinit bnx2x_get_port_hwinfo(struct bnx2x *bp)
 void bnx2x_get_iscsi_info(struct bnx2x *bp)
 {
         u32 no_flags = NO_ISCSI_FLAG;
-#ifdef BCM_CNIC
         int port = BP_PORT(bp);
-
         u32 max_iscsi_conn = FW_ENCODE_32BIT_PATTERN ^ SHMEM_RD(bp,
                                 drv_lic_key[port].max_iscsi_conn);
 
+        if (!CNIC_SUPPORT(bp)) {
+                bp->flags |= no_flags;
+                return;
+        }
+
         /* Get the number of maximum allowed iSCSI connections */
         bp->cnic_eth_dev.max_iscsi_conn =
                 (max_iscsi_conn & BNX2X_MAX_ISCSI_INIT_CONN_MASK) >>
@@ -10244,12 +10408,9 @@ void bnx2x_get_iscsi_info(struct bnx2x *bp)
          */
         if (!bp->cnic_eth_dev.max_iscsi_conn)
                 bp->flags |= no_flags;
-#else
-        bp->flags |= no_flags;
-#endif
+
 }
 
-#ifdef BCM_CNIC
 static void __devinit bnx2x_get_ext_wwn_info(struct bnx2x *bp, int func)
 {
         /* Port info */
@@ -10264,16 +10425,18 @@ static void __devinit bnx2x_get_ext_wwn_info(struct bnx2x *bp, int func)
         bp->cnic_eth_dev.fcoe_wwn_node_name_lo =
                 MF_CFG_RD(bp, func_ext_config[func].fcoe_wwn_node_name_lower);
 }
-#endif
 static void __devinit bnx2x_get_fcoe_info(struct bnx2x *bp)
 {
-#ifdef BCM_CNIC
         int port = BP_PORT(bp);
         int func = BP_ABS_FUNC(bp);
-
         u32 max_fcoe_conn = FW_ENCODE_32BIT_PATTERN ^ SHMEM_RD(bp,
                                 drv_lic_key[port].max_fcoe_conn);
 
+        if (!CNIC_SUPPORT(bp)) {
+                bp->flags |= NO_FCOE_FLAG;
+                return;
+        }
+
         /* Get the number of maximum allowed FCoE connections */
         bp->cnic_eth_dev.max_fcoe_conn =
                 (max_fcoe_conn & BNX2X_MAX_FCOE_INIT_CONN_MASK) >>
@@ -10319,9 +10482,6 @@ static void __devinit bnx2x_get_fcoe_info(struct bnx2x *bp)
          */
         if (!bp->cnic_eth_dev.max_fcoe_conn)
                 bp->flags |= NO_FCOE_FLAG;
-#else
-        bp->flags |= NO_FCOE_FLAG;
-#endif
 }
 
 static void __devinit bnx2x_get_cnic_info(struct bnx2x *bp)
@@ -10335,132 +10495,133 @@ static void __devinit bnx2x_get_cnic_info(struct bnx2x *bp)
         bnx2x_get_fcoe_info(bp);
 }
 
-static void __devinit bnx2x_get_mac_hwinfo(struct bnx2x *bp)
+static void __devinit bnx2x_get_cnic_mac_hwinfo(struct bnx2x *bp)
 {
         u32 val, val2;
         int func = BP_ABS_FUNC(bp);
         int port = BP_PORT(bp);
-#ifdef BCM_CNIC
         u8 *iscsi_mac = bp->cnic_eth_dev.iscsi_mac;
         u8 *fip_mac = bp->fip_mac;
-#endif
 
-        /* Zero primary MAC configuration */
-        memset(bp->dev->dev_addr, 0, ETH_ALEN);
-
-        if (BP_NOMCP(bp)) {
-                BNX2X_ERROR("warning: random MAC workaround active\n");
-                eth_hw_addr_random(bp->dev);
-        } else if (IS_MF(bp)) {
-                val2 = MF_CFG_RD(bp, func_mf_config[func].mac_upper);
-                val = MF_CFG_RD(bp, func_mf_config[func].mac_lower);
-                if ((val2 != FUNC_MF_CFG_UPPERMAC_DEFAULT) &&
-                    (val != FUNC_MF_CFG_LOWERMAC_DEFAULT))
-                        bnx2x_set_mac_buf(bp->dev->dev_addr, val, val2);
-
-#ifdef BCM_CNIC
-                /*
-                 * iSCSI and FCoE NPAR MACs: if there is no either iSCSI or
+        if (IS_MF(bp)) {
+                /* iSCSI and FCoE NPAR MACs: if there is no either iSCSI or
                  * FCoE MAC then the appropriate feature should be disabled.
-                 *
-                 * In non SD mode features configuration comes from
-                 * struct func_ext_config.
+                 * In non SD mode features configuration comes from struct
+                 * func_ext_config.
                  */
-                if (!IS_MF_SD(bp)) {
+                if (!IS_MF_SD(bp) && !CHIP_IS_E1x(bp)) {
                         u32 cfg = MF_CFG_RD(bp, func_ext_config[func].func_cfg);
                         if (cfg & MACP_FUNC_CFG_FLAGS_ISCSI_OFFLOAD) {
                                 val2 = MF_CFG_RD(bp, func_ext_config[func].
-                                                     iscsi_mac_addr_upper);
+                                                 iscsi_mac_addr_upper);
                                 val = MF_CFG_RD(bp, func_ext_config[func].
-                                                    iscsi_mac_addr_lower);
+                                                iscsi_mac_addr_lower);
                                 bnx2x_set_mac_buf(iscsi_mac, val, val2);
-                                BNX2X_DEV_INFO("Read iSCSI MAC: %pM\n",
-                                               iscsi_mac);
-                        } else
+                                BNX2X_DEV_INFO
+                                        ("Read iSCSI MAC: %pM\n", iscsi_mac);
+                        } else {
                                 bp->flags |= NO_ISCSI_OOO_FLAG | NO_ISCSI_FLAG;
+                        }
 
                         if (cfg & MACP_FUNC_CFG_FLAGS_FCOE_OFFLOAD) {
                                 val2 = MF_CFG_RD(bp, func_ext_config[func].
-                                                     fcoe_mac_addr_upper);
+                                                 fcoe_mac_addr_upper);
                                 val = MF_CFG_RD(bp, func_ext_config[func].
-                                                    fcoe_mac_addr_lower);
+                                                fcoe_mac_addr_lower);
                                 bnx2x_set_mac_buf(fip_mac, val, val2);
-                                BNX2X_DEV_INFO("Read FCoE L2 MAC: %pM\n",
-                                               fip_mac);
-
-                        } else
+                                BNX2X_DEV_INFO
+                                        ("Read FCoE L2 MAC: %pM\n", fip_mac);
+                        } else {
                                 bp->flags |= NO_FCOE_FLAG;
+                        }
 
                         bp->mf_ext_config = cfg;
 
                 } else { /* SD MODE */
-                        if (IS_MF_STORAGE_SD(bp)) {
-                                if (BNX2X_IS_MF_SD_PROTOCOL_ISCSI(bp)) {
-                                        /* use primary mac as iscsi mac */
-                                        memcpy(iscsi_mac, bp->dev->dev_addr,
-                                               ETH_ALEN);
-
-                                        BNX2X_DEV_INFO("SD ISCSI MODE\n");
-                                        BNX2X_DEV_INFO("Read iSCSI MAC: %pM\n",
-                                                       iscsi_mac);
-                                } else { /* FCoE */
-                                        memcpy(fip_mac, bp->dev->dev_addr,
-                                               ETH_ALEN);
-                                        BNX2X_DEV_INFO("SD FCoE MODE\n");
-                                        BNX2X_DEV_INFO("Read FIP MAC: %pM\n",
-                                                       fip_mac);
-                                }
-                                /* Zero primary MAC configuration */
-                                memset(bp->dev->dev_addr, 0, ETH_ALEN);
+                        if (BNX2X_IS_MF_SD_PROTOCOL_ISCSI(bp)) {
+                                /* use primary mac as iscsi mac */
+                                memcpy(iscsi_mac, bp->dev->dev_addr, ETH_ALEN);
+
+                                BNX2X_DEV_INFO("SD ISCSI MODE\n");
+                                BNX2X_DEV_INFO
+                                        ("Read iSCSI MAC: %pM\n", iscsi_mac);
+                        } else if (BNX2X_IS_MF_SD_PROTOCOL_FCOE(bp)) {
+                                /* use primary mac as fip mac */
+                                memcpy(fip_mac, bp->dev->dev_addr, ETH_ALEN);
+                                BNX2X_DEV_INFO("SD FCoE MODE\n");
+                                BNX2X_DEV_INFO
+                                        ("Read FIP MAC: %pM\n", fip_mac);
                         }
                 }
 
+                if (IS_MF_STORAGE_SD(bp))
+                        /* Zero primary MAC configuration */
+                        memset(bp->dev->dev_addr, 0, ETH_ALEN);
+
                 if (IS_MF_FCOE_AFEX(bp))
                         /* use FIP MAC as primary MAC */
                         memcpy(bp->dev->dev_addr, fip_mac, ETH_ALEN);
 
-#endif
         } else {
-                /* in SF read MACs from port configuration */
-                val2 = SHMEM_RD(bp, dev_info.port_hw_config[port].mac_upper);
-                val = SHMEM_RD(bp, dev_info.port_hw_config[port].mac_lower);
-                bnx2x_set_mac_buf(bp->dev->dev_addr, val, val2);
-
-#ifdef BCM_CNIC
                 val2 = SHMEM_RD(bp, dev_info.port_hw_config[port].
-                                    iscsi_mac_upper);
+                                iscsi_mac_upper);
                 val = SHMEM_RD(bp, dev_info.port_hw_config[port].
-                                   iscsi_mac_lower);
+                               iscsi_mac_lower);
                 bnx2x_set_mac_buf(iscsi_mac, val, val2);
 
                 val2 = SHMEM_RD(bp, dev_info.port_hw_config[port].
-                                    fcoe_fip_mac_upper);
+                                fcoe_fip_mac_upper);
                 val = SHMEM_RD(bp, dev_info.port_hw_config[port].
-                                   fcoe_fip_mac_lower);
+                               fcoe_fip_mac_lower);
                 bnx2x_set_mac_buf(fip_mac, val, val2);
-#endif
         }
 
-        memcpy(bp->link_params.mac_addr, bp->dev->dev_addr, ETH_ALEN);
-        memcpy(bp->dev->perm_addr, bp->dev->dev_addr, ETH_ALEN);
-
-#ifdef BCM_CNIC
-        /* Disable iSCSI if MAC configuration is
-         * invalid.
-         */
+        /* Disable iSCSI OOO if MAC configuration is invalid. */
         if (!is_valid_ether_addr(iscsi_mac)) {
-                bp->flags |= NO_ISCSI_FLAG;
+                bp->flags |= NO_ISCSI_OOO_FLAG | NO_ISCSI_FLAG;
                 memset(iscsi_mac, 0, ETH_ALEN);
         }
 
-        /* Disable FCoE if MAC configuration is
-         * invalid.
-         */
+        /* Disable FCoE if MAC configuration is invalid. */
         if (!is_valid_ether_addr(fip_mac)) {
                 bp->flags |= NO_FCOE_FLAG;
                 memset(bp->fip_mac, 0, ETH_ALEN);
         }
-#endif
+}
+
+static void __devinit bnx2x_get_mac_hwinfo(struct bnx2x *bp)
+{
+        u32 val, val2;
+        int func = BP_ABS_FUNC(bp);
+        int port = BP_PORT(bp);
+
+        /* Zero primary MAC configuration */
+        memset(bp->dev->dev_addr, 0, ETH_ALEN);
+
+        if (BP_NOMCP(bp)) {
+                BNX2X_ERROR("warning: random MAC workaround active\n");
+                eth_hw_addr_random(bp->dev);
+        } else if (IS_MF(bp)) {
+                val2 = MF_CFG_RD(bp, func_mf_config[func].mac_upper);
+                val = MF_CFG_RD(bp, func_mf_config[func].mac_lower);
+                if ((val2 != FUNC_MF_CFG_UPPERMAC_DEFAULT) &&
+                    (val != FUNC_MF_CFG_LOWERMAC_DEFAULT))
+                        bnx2x_set_mac_buf(bp->dev->dev_addr, val, val2);
+
+                if (CNIC_SUPPORT(bp))
+                        bnx2x_get_cnic_mac_hwinfo(bp);
+        } else {
+                /* in SF read MACs from port configuration */
+                val2 = SHMEM_RD(bp, dev_info.port_hw_config[port].mac_upper);
+                val = SHMEM_RD(bp, dev_info.port_hw_config[port].mac_lower);
+                bnx2x_set_mac_buf(bp->dev->dev_addr, val, val2);
+
+                if (CNIC_SUPPORT(bp))
+                        bnx2x_get_cnic_mac_hwinfo(bp);
+        }
+
+        memcpy(bp->link_params.mac_addr, bp->dev->dev_addr, ETH_ALEN);
+        memcpy(bp->dev->perm_addr, bp->dev->dev_addr, ETH_ALEN);
 
         if (!bnx2x_is_valid_ether_addr(bp, bp->dev->dev_addr))
                 dev_err(&bp->pdev->dev,
@@ -10837,9 +10998,7 @@ static int __devinit bnx2x_init_bp(struct bnx2x *bp)
         mutex_init(&bp->port.phy_mutex);
         mutex_init(&bp->fw_mb_mutex);
         spin_lock_init(&bp->stats_lock);
-#ifdef BCM_CNIC
-        mutex_init(&bp->cnic_mutex);
-#endif
+
 
         INIT_DELAYED_WORK(&bp->sp_task, bnx2x_sp_task);
         INIT_DELAYED_WORK(&bp->sp_rtnl_task, bnx2x_sp_rtnl_task);
@@ -10877,10 +11036,7 @@ static int __devinit bnx2x_init_bp(struct bnx2x *bp)
                 dev_err(&bp->pdev->dev, "MCP disabled, must load devices in order!\n");
 
         bp->disable_tpa = disable_tpa;
-
-#ifdef BCM_CNIC
         bp->disable_tpa |= IS_MF_STORAGE_SD(bp) || IS_MF_FCOE_AFEX(bp);
-#endif
 
         /* Set TPA flags */
         if (bp->disable_tpa) {
@@ -10914,12 +11070,10 @@ static int __devinit bnx2x_init_bp(struct bnx2x *bp)
         bnx2x_dcbx_set_state(bp, true, BNX2X_DCBX_ENABLED_ON_NEG_ON);
         bnx2x_dcbx_init_params(bp);
 
-#ifdef BCM_CNIC
         if (CHIP_IS_E1x(bp))
                 bp->cnic_base_cl_id = FP_SB_MAX_E1x;
         else
                 bp->cnic_base_cl_id = FP_SB_MAX_E2;
-#endif
 
         /* multiple tx priority */
         if (CHIP_IS_E1x(bp))
@@ -10929,6 +11083,16 @@ static int __devinit bnx2x_init_bp(struct bnx2x *bp)
         if (CHIP_IS_E3B0(bp))
                 bp->max_cos = BNX2X_MULTI_TX_COS_E3B0;
 
+        /* We need at least one default status block for slow-path events,
+         * second status block for the L2 queue, and a third status block for
+         * CNIC if supproted.
+         */
+        if (CNIC_SUPPORT(bp))
+                bp->min_msix_vec_cnt = 3;
+        else
+                bp->min_msix_vec_cnt = 2;
+        BNX2X_DEV_INFO("bp->min_msix_vec_cnt %d", bp->min_msix_vec_cnt);
+
         return rc;
 }
 
@@ -11165,11 +11329,9 @@ void bnx2x_set_rx_mode(struct net_device *dev)
         }
 
         bp->rx_mode = rx_mode;
-#ifdef BCM_CNIC
         /* handle ISCSI SD mode */
         if (IS_MF_ISCSI_SD(bp))
                 bp->rx_mode = BNX2X_RX_MODE_NONE;
-#endif
 
         /* Schedule the rx_mode command */
         if (test_bit(BNX2X_FILTER_RX_MODE_PENDING, &bp->sp_state)) {
@@ -11281,7 +11443,7 @@ static const struct net_device_ops bnx2x_netdev_ops = {
 #endif
         .ndo_setup_tc           = bnx2x_setup_tc,
 
-#if defined(NETDEV_FCOE_WWNN) && defined(BCM_CNIC)
+#ifdef NETDEV_FCOE_WWNN
         .ndo_fcoe_get_wwn       = bnx2x_fcoe_get_wwn,
 #endif
 };
@@ -11747,9 +11909,8 @@ static int bnx2x_set_qm_cid_count(struct bnx2x *bp)
 {
         int cid_count = BNX2X_L2_MAX_CID(bp);
 
-#ifdef BCM_CNIC
-        cid_count += CNIC_CID_MAX;
-#endif
+        if (CNIC_SUPPORT(bp))
+                cid_count += CNIC_CID_MAX;
         return roundup(cid_count, QM_CID_ROUND);
 }
 
@@ -11759,7 +11920,8 @@ static int bnx2x_set_qm_cid_count(struct bnx2x *bp)
  * @dev:        pci device
  *
  */
-static int bnx2x_get_num_non_def_sbs(struct pci_dev *pdev)
+static int bnx2x_get_num_non_def_sbs(struct pci_dev *pdev,
+                                     int cnic_cnt)
 {
         int pos;
         u16 control;
@@ -11771,7 +11933,7 @@ static int bnx2x_get_num_non_def_sbs(struct pci_dev *pdev)
          * one fast path queue: one FP queue + SB for CNIC
          */
         if (!pos)
-                return 1 + CNIC_PRESENT;
+                return 1 + cnic_cnt;
 
         /*
          * The value in the PCI configuration space is the index of the last
@@ -11791,6 +11953,7 @@ static int __devinit bnx2x_init_one(struct pci_dev *pdev,
         int pcie_width, pcie_speed;
         int rc, max_non_def_sbs;
         int rx_count, tx_count, rss_count, doorbell_size;
+        int cnic_cnt;
         /*
          * An estimated maximum supported CoS number according to the chip
          * version.
@@ -11834,21 +11997,22 @@ static int __devinit bnx2x_init_one(struct pci_dev *pdev,
                 return -ENODEV;
         }
 
-        max_non_def_sbs = bnx2x_get_num_non_def_sbs(pdev);
+        cnic_cnt = 1;
+        max_non_def_sbs = bnx2x_get_num_non_def_sbs(pdev, cnic_cnt);
 
         WARN_ON(!max_non_def_sbs);
 
         /* Maximum number of RSS queues: one IGU SB goes to CNIC */
-        rss_count = max_non_def_sbs - CNIC_PRESENT;
+        rss_count = max_non_def_sbs - cnic_cnt;
 
         /* Maximum number of netdev Rx queues: RSS + FCoE L2 */
-        rx_count = rss_count + FCOE_PRESENT;
+        rx_count = rss_count + cnic_cnt;
 
         /*
          * Maximum number of netdev Tx queues:
          * Maximum TSS queues * Maximum supported number of CoS  + FCoE L2
          */
-        tx_count = rss_count * max_cos_est + FCOE_PRESENT;
+        tx_count = rss_count * max_cos_est + cnic_cnt;
 
         /* dev zeroed in init_etherdev */
         dev = alloc_etherdev_mqs(sizeof(*bp), tx_count, rx_count);
@@ -11859,6 +12023,8 @@ static int __devinit bnx2x_init_one(struct pci_dev *pdev,
 
         bp->igu_sb_cnt = max_non_def_sbs;
         bp->msg_enable = debug;
+        bp->cnic_support = cnic_cnt;
+
         pci_set_drvdata(pdev, dev);
 
         rc = bnx2x_init_dev(pdev, dev, ent->driver_data);
@@ -11867,6 +12033,7 @@ static int __devinit bnx2x_init_one(struct pci_dev *pdev,
                 return rc;
         }
 
+        BNX2X_DEV_INFO("Cnic support is %s\n", CNIC_SUPPORT(bp) ? "on" : "off");
         BNX2X_DEV_INFO("max_non_def_sbs %d\n", max_non_def_sbs);
 
         BNX2X_DEV_INFO("Allocated netdev with %d tx and %d rx queues\n",
@@ -11899,10 +12066,10 @@ static int __devinit bnx2x_init_one(struct pci_dev *pdev,
         /* calc qm_cid_count */
         bp->qm_cid_count = bnx2x_set_qm_cid_count(bp);
 
-#ifdef BCM_CNIC
-        /* disable FCOE L2 queue for E1x */
+        /* disable FCOE L2 queue for E1x*/
         if (CHIP_IS_E1x(bp))
                 bp->flags |= NO_FCOE_FLAG;
+
         /* disable FCOE for 57840 device, until FW supports it */
         switch (ent->driver_data) {
         case BCM57840_O:
@@ -11912,8 +12079,6 @@ static int __devinit bnx2x_init_one(struct pci_dev *pdev,
         case BCM57840_MF:
                 bp->flags |= NO_FCOE_FLAG;
         }
-#endif
-
 
         /* Set bp->num_queues for MSI-X mode*/
         bnx2x_set_num_queues(bp);
@@ -11929,14 +12094,13 @@ static int __devinit bnx2x_init_one(struct pci_dev *pdev,
                 goto init_one_exit;
         }
 
-#ifdef BCM_CNIC
+
         if (!NO_FCOE(bp)) {
                 /* Add storage MAC address */
                 rtnl_lock();
                 dev_addr_add(bp->dev, bp->fip_mac, NETDEV_HW_ADDR_T_SAN);
                 rtnl_unlock();
         }
-#endif
 
         bnx2x_get_pcie_width_speed(bp, &pcie_width, &pcie_speed);
 
@@ -11981,14 +12145,12 @@ static void __devexit bnx2x_remove_one(struct pci_dev *pdev)
         }
         bp = netdev_priv(dev);
 
-#ifdef BCM_CNIC
         /* Delete storage MAC address */
         if (!NO_FCOE(bp)) {
                 rtnl_lock();
                 dev_addr_del(bp->dev, bp->fip_mac, NETDEV_HW_ADDR_T_SAN);
                 rtnl_unlock();
         }
-#endif
 
 #ifdef BCM_DCBNL
         /* Delete app tlvs from dcbnl */
@@ -12036,15 +12198,17 @@ static int bnx2x_eeh_nic_unload(struct bnx2x *bp)
 
         bp->rx_mode = BNX2X_RX_MODE_NONE;
 
-#ifdef BCM_CNIC
-        bnx2x_cnic_notify(bp, CNIC_CTL_STOP_CMD);
-#endif
+        if (CNIC_LOADED(bp))
+                bnx2x_cnic_notify(bp, CNIC_CTL_STOP_CMD);
+
         /* Stop Tx */
         bnx2x_tx_disable(bp);
 
         bnx2x_netif_stop(bp, 0);
         /* Delete all NAPI objects */
         bnx2x_del_all_napi(bp);
+        if (CNIC_LOADED(bp))
+                bnx2x_del_all_napi_cnic(bp);
 
         del_timer_sync(&bp->timer);
 
@@ -12235,7 +12399,6 @@ void bnx2x_notify_link_changed(struct bnx2x *bp)
 module_init(bnx2x_init);
 module_exit(bnx2x_cleanup);
 
-#ifdef BCM_CNIC
 /**
  * bnx2x_set_iscsi_eth_mac_addr - set iSCSI MAC(s).
  *
@@ -12688,12 +12851,31 @@ static int bnx2x_register_cnic(struct net_device *dev, struct cnic_ops *ops,
 {
         struct bnx2x *bp = netdev_priv(dev);
         struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
+        int rc;
+
+        DP(NETIF_MSG_IFUP, "Register_cnic called\n");
 
         if (ops == NULL) {
                 BNX2X_ERR("NULL ops received\n");
                 return -EINVAL;
         }
 
+        if (!CNIC_SUPPORT(bp)) {
+                BNX2X_ERR("Can't register CNIC when not supported\n");
+                return -EOPNOTSUPP;
+        }
+
+        if (!CNIC_LOADED(bp)) {
+                rc = bnx2x_load_cnic(bp);
+                if (rc) {
+                        BNX2X_ERR("CNIC-related load failed\n");
+                        return rc;
+                }
+
+        }
+
+        bp->cnic_enabled = true;
+
         bp->cnic_kwq = kzalloc(PAGE_SIZE, GFP_KERNEL);
         if (!bp->cnic_kwq)
                 return -ENOMEM;
@@ -12785,5 +12967,4 @@ struct cnic_eth_dev *bnx2x_cnic_probe(struct net_device *dev)
 }
 EXPORT_SYMBOL(bnx2x_cnic_probe);
 
-#endif /* BCM_CNIC */
 
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_reg.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_reg.h
index 1b1999d34c71..7d93adb57f31 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_reg.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_reg.h
@@ -2107,6 +2107,7 @@
 #define NIG_REG_LLH1_ERROR_MASK                                  0x10090
 /* [RW 8] event id for llh1 */
 #define NIG_REG_LLH1_EVENT_ID                                    0x10088
+#define NIG_REG_LLH1_FUNC_EN                                     0x16104
 #define NIG_REG_LLH1_FUNC_MEM                                    0x161c0
 #define NIG_REG_LLH1_FUNC_MEM_ENABLE                             0x16160
 #define NIG_REG_LLH1_FUNC_MEM_SIZE                               16
@@ -2302,6 +2303,15 @@
  * set to 0x345678021. This is a new register (with 2_) added in E3 B0 to
  * accommodate the 9 input clients to ETS arbiter. */
 #define NIG_REG_P0_TX_ARB_PRIORITY_CLIENT2_MSB                   0x18684
+/* [RW 1] MCP-to-host path enable. Set this bit to enable the routing of MCP
+ * packets to BRB LB interface to forward the packet to the host. All
+ * packets from MCP are forwarded to the network when this bit is cleared -
+ * regardless of the configured destination in tx_mng_destination register.
+ * When MCP-to-host paths for both ports 0 and 1 are disabled - the arbiter
+ * for BRB LB interface is bypassed and PBF LB traffic is always selected to
+ * send to BRB LB.
+ */
+#define NIG_REG_P0_TX_MNG_HOST_ENABLE                            0x182f4
 #define NIG_REG_P1_HWPFC_ENABLE                                  0x181d0
 #define NIG_REG_P1_MAC_IN_EN                                     0x185c0
 /* [RW 1] Output enable for TX MAC interface */
@@ -2418,6 +2428,12 @@
 #define NIG_REG_P1_TX_ARB_PRIORITY_CLIENT2_MSB                   0x186e4
 /* [R 1] TX FIFO for transmitting data to MAC is empty. */
 #define NIG_REG_P1_TX_MACFIFO_EMPTY                              0x18594
+/* [RW 1] MCP-to-host path enable. Set this bit to enable the routing of MCP
+ * packets to BRB LB interface to forward the packet to the host. All
+ * packets from MCP are forwarded to the network when this bit is cleared -
+ * regardless of the configured destination in tx_mng_destination register.
+ */
+#define NIG_REG_P1_TX_MNG_HOST_ENABLE                            0x182f8
 /* [R 1] FIFO empty status of the MCP TX FIFO used for storing MCP packets
    forwarded to the host. */
 #define NIG_REG_P1_TX_MNG_HOST_FIFO_EMPTY                        0x182b8
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c
index 614981c02264..b8b4b749daab 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c
@@ -5350,12 +5350,24 @@ static int bnx2x_func_chk_transition(struct bnx2x *bp,
                 else if ((cmd == BNX2X_F_CMD_AFEX_VIFLISTS) &&
                          (!test_bit(BNX2X_F_CMD_STOP, &o->pending)))
                         next_state = BNX2X_F_STATE_STARTED;
+
+                /* Switch_update ramrod can be sent in either started or
+                 * tx_stopped state, and it doesn't change the state.
+                 */
+                else if ((cmd == BNX2X_F_CMD_SWITCH_UPDATE) &&
+                         (!test_bit(BNX2X_F_CMD_STOP, &o->pending)))
+                        next_state = BNX2X_F_STATE_STARTED;
+
                 else if (cmd == BNX2X_F_CMD_TX_STOP)
                         next_state = BNX2X_F_STATE_TX_STOPPED;
 
                 break;
         case BNX2X_F_STATE_TX_STOPPED:
-                if (cmd == BNX2X_F_CMD_TX_START)
+                if ((cmd == BNX2X_F_CMD_SWITCH_UPDATE) &&
+                    (!test_bit(BNX2X_F_CMD_STOP, &o->pending)))
+                        next_state = BNX2X_F_STATE_TX_STOPPED;
+
+                else if (cmd == BNX2X_F_CMD_TX_START)
                         next_state = BNX2X_F_STATE_STARTED;
 
                 break;
@@ -5637,6 +5649,28 @@ static inline int bnx2x_func_send_start(struct bnx2x *bp,
                              U64_LO(data_mapping), NONE_CONNECTION_TYPE);
 }
 
+static inline int bnx2x_func_send_switch_update(struct bnx2x *bp,
+                                        struct bnx2x_func_state_params *params)
+{
+        struct bnx2x_func_sp_obj *o = params->f_obj;
+        struct function_update_data *rdata =
+                (struct function_update_data *)o->rdata;
+        dma_addr_t data_mapping = o->rdata_mapping;
+        struct bnx2x_func_switch_update_params *switch_update_params =
+                &params->params.switch_update;
+
+        memset(rdata, 0, sizeof(*rdata));
+
+        /* Fill the ramrod data with provided parameters */
+        rdata->tx_switch_suspend_change_flg = 1;
+        rdata->tx_switch_suspend = switch_update_params->suspend;
+        rdata->echo = SWITCH_UPDATE;
+
+        return bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_FUNCTION_UPDATE, 0,
+                             U64_HI(data_mapping),
+                             U64_LO(data_mapping), NONE_CONNECTION_TYPE);
+}
+
 static inline int bnx2x_func_send_afex_update(struct bnx2x *bp,
                                          struct bnx2x_func_state_params *params)
 {
@@ -5657,6 +5691,7 @@ static inline int bnx2x_func_send_afex_update(struct bnx2x *bp,
                 cpu_to_le16(afex_update_params->afex_default_vlan);
         rdata->allowed_priorities_change_flg = 1;
         rdata->allowed_priorities = afex_update_params->allowed_priorities;
+        rdata->echo = AFEX_UPDATE;
 
         /*  No need for an explicit memory barrier here as long we would
          *  need to ensure the ordering of writing to the SPQ element
@@ -5773,6 +5808,8 @@ static int bnx2x_func_send_cmd(struct bnx2x *bp,
                 return bnx2x_func_send_tx_stop(bp, params);
         case BNX2X_F_CMD_TX_START:
                 return bnx2x_func_send_tx_start(bp, params);
+        case BNX2X_F_CMD_SWITCH_UPDATE:
+                return bnx2x_func_send_switch_update(bp, params);
         default:
                 BNX2X_ERR("Unknown command: %d\n", params->cmd);
                 return -EINVAL;
@@ -5818,16 +5855,30 @@ int bnx2x_func_state_change(struct bnx2x *bp,
                             struct bnx2x_func_state_params *params)
 {
         struct bnx2x_func_sp_obj *o = params->f_obj;
-        int rc;
+        int rc, cnt = 300;
         enum bnx2x_func_cmd cmd = params->cmd;
         unsigned long *pending = &o->pending;
 
         mutex_lock(&o->one_pending_mutex);
 
         /* Check that the requested transition is legal */
-        if (o->check_transition(bp, o, params)) {
+        rc = o->check_transition(bp, o, params);
+        if ((rc == -EBUSY) &&
+            (test_bit(RAMROD_RETRY, &params->ramrod_flags))) {
+                while ((rc == -EBUSY) && (--cnt > 0)) {
+                        mutex_unlock(&o->one_pending_mutex);
+                        msleep(10);
+                        mutex_lock(&o->one_pending_mutex);
+                        rc = o->check_transition(bp, o, params);
+                }
+                if (rc == -EBUSY) {
+                        mutex_unlock(&o->one_pending_mutex);
+                        BNX2X_ERR("timeout waiting for previous ramrod completion\n");
+                        return rc;
+                }
+        } else if (rc) {
                 mutex_unlock(&o->one_pending_mutex);
-                return -EINVAL;
+                return rc;
         }
 
         /* Set "pending" bit */
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.h
index acf2fe4ca608..adbd91b1bdfc 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.h
@@ -40,6 +40,12 @@ enum {
          * pending commands list.
          */
         RAMROD_CONT,
+        /* If there is another pending ramrod, wait until it finishes and
+         * re-try to submit this one. This flag can be set only in sleepable
+         * context, and should not be set from the context that completes the
+         * ramrods as deadlock will occur.
+         */
+        RAMROD_RETRY,
 };
 
 typedef enum {
@@ -1061,6 +1067,7 @@ enum bnx2x_func_cmd {
         BNX2X_F_CMD_AFEX_VIFLISTS,
         BNX2X_F_CMD_TX_STOP,
         BNX2X_F_CMD_TX_START,
+        BNX2X_F_CMD_SWITCH_UPDATE,
         BNX2X_F_CMD_MAX,
 };
 
@@ -1103,6 +1110,10 @@ struct bnx2x_func_start_params {
         u8 network_cos_mode;
 };
 
+struct bnx2x_func_switch_update_params {
+        u8 suspend;
+};
+
 struct bnx2x_func_afex_update_params {
         u16 vif_id;
         u16 afex_default_vlan;
@@ -1136,6 +1147,7 @@ struct bnx2x_func_state_params {
                 struct bnx2x_func_hw_init_params hw_init;
                 struct bnx2x_func_hw_reset_params hw_reset;
                 struct bnx2x_func_start_params start;
+                struct bnx2x_func_switch_update_params switch_update;
                 struct bnx2x_func_afex_update_params afex_update;
                 struct bnx2x_func_afex_viflists_params afex_viflists;
                 struct bnx2x_func_tx_start_params tx_start;
diff --git a/drivers/net/ethernet/broadcom/tg3.c b/drivers/net/ethernet/broadcom/tg3.c
index a8800ac10df9..038ce0215e3e 100644
--- a/drivers/net/ethernet/broadcom/tg3.c
+++ b/drivers/net/ethernet/broadcom/tg3.c
@@ -90,10 +90,10 @@ static inline void _tg3_flag_clear(enum TG3_FLAGS flag, unsigned long *bits)
 
 #define DRV_MODULE_NAME         "tg3"
 #define TG3_MAJ_NUM                     3
-#define TG3_MIN_NUM                     125
+#define TG3_MIN_NUM                     126
 #define DRV_MODULE_VERSION      \
         __stringify(TG3_MAJ_NUM) "." __stringify(TG3_MIN_NUM)
-#define DRV_MODULE_RELDATE      "September 26, 2012"
+#define DRV_MODULE_RELDATE      "November 05, 2012"
 
 #define RESET_KIND_SHUTDOWN     0
 #define RESET_KIND_INIT         1
@@ -291,6 +291,7 @@ static DEFINE_PCI_DEVICE_TABLE(tg3_pci_tbl) = {
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57790)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57788)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5717)},
+        {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5717_C)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5718)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57781)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57785)},
@@ -10429,10 +10430,8 @@ static void tg3_stop(struct tg3 *tp)
 {
         int i;
 
-        tg3_napi_disable(tp);
         tg3_reset_task_cancel(tp);
-
-        netif_tx_disable(tp->dev);
+        tg3_netif_stop(tp);
 
         tg3_timer_stop(tp);
 
@@ -14026,7 +14025,8 @@ out_not_found:
 
 out_no_vpd:
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717) {
-                if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_5717)
+                if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_5717 ||
+                    tp->pdev->device == TG3PCI_DEVICE_TIGON3_5717_C)
                         strcpy(tp->board_part_number, "BCM5717");
                 else if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_5718)
                         strcpy(tp->board_part_number, "BCM5718");
@@ -14397,6 +14397,7 @@ static void __devinit tg3_detect_asic_rev(struct tg3 *tp, u32 misc_ctrl_reg)
                 tg3_flag_set(tp, CPMU_PRESENT);
 
                 if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_5717 ||
+                    tp->pdev->device == TG3PCI_DEVICE_TIGON3_5717_C ||
                     tp->pdev->device == TG3PCI_DEVICE_TIGON3_5718 ||
                     tp->pdev->device == TG3PCI_DEVICE_TIGON3_5719 ||
                     tp->pdev->device == TG3PCI_DEVICE_TIGON3_5720)
@@ -14424,6 +14425,9 @@ static void __devinit tg3_detect_asic_rev(struct tg3 *tp, u32 misc_ctrl_reg)
         if (tp->pci_chip_rev_id == CHIPREV_ID_5752_A0_HW)
                 tp->pci_chip_rev_id = CHIPREV_ID_5752_A0;
 
+        if (tp->pci_chip_rev_id == CHIPREV_ID_5717_C0)
+                tp->pci_chip_rev_id = CHIPREV_ID_5720_A0;
+
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5720)
@@ -16013,6 +16017,7 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5761S ||
             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5761SE ||
             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5717 ||
+            tp->pdev->device == TG3PCI_DEVICE_TIGON3_5717_C ||
             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5718 ||
             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5719 ||
             tp->pdev->device == TG3PCI_DEVICE_TIGON3_5720) {
diff --git a/drivers/net/ethernet/broadcom/tg3.h b/drivers/net/ethernet/broadcom/tg3.h
index d9308c32102e..b3c2bf2c082f 100644
--- a/drivers/net/ethernet/broadcom/tg3.h
+++ b/drivers/net/ethernet/broadcom/tg3.h
@@ -50,6 +50,7 @@
 #define  TG3PCI_DEVICE_TIGON3_5785_G     0x1699 /* GPHY */
 #define  TG3PCI_DEVICE_TIGON3_5785_F     0x16a0 /* 10/100 only */
 #define  TG3PCI_DEVICE_TIGON3_5717       0x1655
+#define  TG3PCI_DEVICE_TIGON3_5717_C     0x1665
 #define  TG3PCI_DEVICE_TIGON3_5718       0x1656
 #define  TG3PCI_DEVICE_TIGON3_57781      0x16b1
 #define  TG3PCI_DEVICE_TIGON3_57785      0x16b5
@@ -149,6 +150,7 @@
 #define  CHIPREV_ID_57780_A0             0x57780000
 #define  CHIPREV_ID_57780_A1             0x57780001
 #define  CHIPREV_ID_5717_A0              0x05717000
+#define  CHIPREV_ID_5717_C0              0x05717200
 #define  CHIPREV_ID_57765_A0             0x57785000
 #define  CHIPREV_ID_5719_A0              0x05719000
 #define  CHIPREV_ID_5720_A0              0x05720000
diff --git a/drivers/net/ethernet/cadence/Kconfig b/drivers/net/ethernet/cadence/Kconfig
index db931916da08..ceb0de0cf62c 100644
--- a/drivers/net/ethernet/cadence/Kconfig
+++ b/drivers/net/ethernet/cadence/Kconfig
@@ -2,13 +2,10 @@
 # Atmel device configuration
 #
 
-config HAVE_NET_MACB
-        bool
-
 config NET_CADENCE
         bool "Cadence devices"
+        depends on HAS_IOMEM
         default y
-        depends on HAVE_NET_MACB || (ARM && ARCH_AT91RM9200)
         ---help---
           If you have a network (Ethernet) card belonging to this class, say Y.
           Make sure you know the name of your card. Read the Ethernet-HOWTO,
@@ -25,16 +22,14 @@ if NET_CADENCE
 
 config ARM_AT91_ETHER
         tristate "AT91RM9200 Ethernet support"
-        depends on ARM && ARCH_AT91RM9200
         select NET_CORE
-        select MII
+        select MACB
         ---help---
           If you wish to compile a kernel for the AT91RM9200 and enable
           ethernet support, then you should always answer Y to this.
 
 config MACB
         tristate "Cadence MACB/GEM support"
-        depends on HAVE_NET_MACB
         select PHYLIB
         ---help---
           The Cadence MACB ethernet interface is found on many Atmel AT32 and
diff --git a/drivers/net/ethernet/cadence/at91_ether.c b/drivers/net/ethernet/cadence/at91_ether.c
index 4e980a7886fb..e7a476cff6c5 100644
--- a/drivers/net/ethernet/cadence/at91_ether.c
+++ b/drivers/net/ethernet/cadence/at91_ether.c
@@ -6,11 +6,6 @@
  * Based on an earlier Atmel EMAC macrocell driver by Atmel and Lineo Inc.
  * Initial version by Rick Bronson 01/11/2003
  *
- * Intel LXT971A PHY support by Christopher Bahns & David Knickerbocker
- *   (Polaroid Corporation)
- *
- * Realtek RTL8201(B)L PHY support by Roman Avramenko <roman@imsystems.ru>
- *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version
@@ -20,7 +15,6 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <linux/mii.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
 #include <linux/skbuff.h>
@@ -31,956 +25,251 @@
 #include <linux/clk.h>
 #include <linux/gfp.h>
 #include <linux/phy.h>
+#include <linux/io.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_net.h>
+#include <linux/pinctrl/consumer.h>
 
-#include <asm/io.h>
-#include <asm/uaccess.h>
-#include <asm/mach-types.h>
-
-#include <mach/at91rm9200_emac.h>
-#include <asm/gpio.h>
-#include <mach/board.h>
-
-#include "at91_ether.h"
-
-#define DRV_NAME        "at91_ether"
-#define DRV_VERSION     "1.0"
-
-#define LINK_POLL_INTERVAL      (HZ)
-
-/* ..................................................................... */
-
-/*
- * Read from a EMAC register.
- */
-static inline unsigned long at91_emac_read(struct at91_private *lp, unsigned int reg)
-{
-        return __raw_readl(lp->emac_base + reg);
-}
-
-/*
- * Write to a EMAC register.
- */
-static inline void at91_emac_write(struct at91_private *lp, unsigned int reg, unsigned long value)
-{
-        __raw_writel(value, lp->emac_base + reg);
-}
-
-/* ........................... PHY INTERFACE ........................... */
-
-/*
- * Enable the MDIO bit in MAC control register
- * When not called from an interrupt-handler, access to the PHY must be
- *  protected by a spinlock.
- */
-static void enable_mdi(struct at91_private *lp)
-{
-        unsigned long ctl;
-
-        ctl = at91_emac_read(lp, AT91_EMAC_CTL);
-        at91_emac_write(lp, AT91_EMAC_CTL, ctl | AT91_EMAC_MPE);        /* enable management port */
-}
-
-/*
- * Disable the MDIO bit in the MAC control register
- */
-static void disable_mdi(struct at91_private *lp)
-{
-        unsigned long ctl;
-
-        ctl = at91_emac_read(lp, AT91_EMAC_CTL);
-        at91_emac_write(lp, AT91_EMAC_CTL, ctl & ~AT91_EMAC_MPE);       /* disable management port */
-}
-
-/*
- * Wait until the PHY operation is complete.
- */
-static inline void at91_phy_wait(struct at91_private *lp)
-{
-        unsigned long timeout = jiffies + 2;
-
-        while (!(at91_emac_read(lp, AT91_EMAC_SR) & AT91_EMAC_SR_IDLE)) {
-                if (time_after(jiffies, timeout)) {
-                        printk("at91_ether: MIO timeout\n");
-                        break;
-                }
-                cpu_relax();
-        }
-}
-
-/*
- * Write value to the a PHY register
- * Note: MDI interface is assumed to already have been enabled.
- */
-static void write_phy(struct at91_private *lp, unsigned char phy_addr, unsigned char address, unsigned int value)
-{
-        at91_emac_write(lp, AT91_EMAC_MAN, AT91_EMAC_MAN_802_3 | AT91_EMAC_RW_W
-                | ((phy_addr & 0x1f) << 23) | (address << 18) | (value & AT91_EMAC_DATA));
-
-        /* Wait until IDLE bit in Network Status register is cleared */
-        at91_phy_wait(lp);
-}
-
-/*
- * Read value stored in a PHY register.
- * Note: MDI interface is assumed to already have been enabled.
- */
-static void read_phy(struct at91_private *lp, unsigned char phy_addr, unsigned char address, unsigned int *value)
-{
-        at91_emac_write(lp, AT91_EMAC_MAN, AT91_EMAC_MAN_802_3 | AT91_EMAC_RW_R
-                | ((phy_addr & 0x1f) << 23) | (address << 18));
-
-        /* Wait until IDLE bit in Network Status register is cleared */
-        at91_phy_wait(lp);
-
-        *value = at91_emac_read(lp, AT91_EMAC_MAN) & AT91_EMAC_DATA;
-}
-
-/* ........................... PHY MANAGEMENT .......................... */
-
-/*
- * Access the PHY to determine the current link speed and mode, and update the
- * MAC accordingly.
- * If no link or auto-negotiation is busy, then no changes are made.
- */
-static void update_linkspeed(struct net_device *dev, int silent)
-{
-        struct at91_private *lp = netdev_priv(dev);
-        unsigned int bmsr, bmcr, lpa, mac_cfg;
-        unsigned int speed, duplex;
-
-        if (!mii_link_ok(&lp->mii)) {           /* no link */
-                netif_carrier_off(dev);
-                if (!silent)
-                        printk(KERN_INFO "%s: Link down.\n", dev->name);
-                return;
-        }
-
-        /* Link up, or auto-negotiation still in progress */
-        read_phy(lp, lp->phy_address, MII_BMSR, &bmsr);
-        read_phy(lp, lp->phy_address, MII_BMCR, &bmcr);
-        if (bmcr & BMCR_ANENABLE) {                             /* AutoNegotiation is enabled */
-                if (!(bmsr & BMSR_ANEGCOMPLETE))
-                        return;                 /* Do nothing - another interrupt generated when negotiation complete */
-
-                read_phy(lp, lp->phy_address, MII_LPA, &lpa);
-                if ((lpa & LPA_100FULL) || (lpa & LPA_100HALF)) speed = SPEED_100;
-                else speed = SPEED_10;
-                if ((lpa & LPA_100FULL) || (lpa & LPA_10FULL)) duplex = DUPLEX_FULL;
-                else duplex = DUPLEX_HALF;
-        } else {
-                speed = (bmcr & BMCR_SPEED100) ? SPEED_100 : SPEED_10;
-                duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF;
-        }
-
-        /* Update the MAC */
-        mac_cfg = at91_emac_read(lp, AT91_EMAC_CFG) & ~(AT91_EMAC_SPD | AT91_EMAC_FD);
-        if (speed == SPEED_100) {
-                if (duplex == DUPLEX_FULL)              /* 100 Full Duplex */
-                        mac_cfg |= AT91_EMAC_SPD | AT91_EMAC_FD;
-                else                                    /* 100 Half Duplex */
-                        mac_cfg |= AT91_EMAC_SPD;
-        } else {
-                if (duplex == DUPLEX_FULL)              /* 10 Full Duplex */
-                        mac_cfg |= AT91_EMAC_FD;
-                else {}                                 /* 10 Half Duplex */
-        }
-        at91_emac_write(lp, AT91_EMAC_CFG, mac_cfg);
-
-        if (!silent)
-                printk(KERN_INFO "%s: Link now %i-%s\n", dev->name, speed, (duplex == DUPLEX_FULL) ? "FullDuplex" : "HalfDuplex");
-        netif_carrier_on(dev);
-}
-
-/*
- * Handle interrupts from the PHY
- */
-static irqreturn_t at91ether_phy_interrupt(int irq, void *dev_id)
-{
-        struct net_device *dev = (struct net_device *) dev_id;
-        struct at91_private *lp = netdev_priv(dev);
-        unsigned int phy;
-
-        /*
-         * This hander is triggered on both edges, but the PHY chips expect
-         * level-triggering.  We therefore have to check if the PHY actually has
-         * an IRQ pending.
-         */
-        enable_mdi(lp);
-        if ((lp->phy_type == MII_DM9161_ID) || (lp->phy_type == MII_DM9161A_ID)) {
-                read_phy(lp, lp->phy_address, MII_DSINTR_REG, &phy);    /* ack interrupt in Davicom PHY */
-                if (!(phy & (1 << 0)))
-                        goto done;
-        }
-        else if (lp->phy_type == MII_LXT971A_ID) {
-                read_phy(lp, lp->phy_address, MII_ISINTS_REG, &phy);    /* ack interrupt in Intel PHY */
-                if (!(phy & (1 << 2)))
-                        goto done;
-        }
-        else if (lp->phy_type == MII_BCM5221_ID) {
-                read_phy(lp, lp->phy_address, MII_BCMINTR_REG, &phy);   /* ack interrupt in Broadcom PHY */
-                if (!(phy & (1 << 0)))
-                        goto done;
-        }
-        else if (lp->phy_type == MII_KS8721_ID) {
-                read_phy(lp, lp->phy_address, MII_TPISTATUS, &phy);             /* ack interrupt in Micrel PHY */
-                if (!(phy & ((1 << 2) | 1)))
-                        goto done;
-        }
-        else if (lp->phy_type == MII_T78Q21x3_ID) {                                     /* ack interrupt in Teridian PHY */
-                read_phy(lp, lp->phy_address, MII_T78Q21INT_REG, &phy);
-                if (!(phy & ((1 << 2) | 1)))
-                        goto done;
-        }
-        else if (lp->phy_type == MII_DP83848_ID) {
-                read_phy(lp, lp->phy_address, MII_DPPHYSTS_REG, &phy);  /* ack interrupt in DP83848 PHY */
-                if (!(phy & (1 << 7)))
-                        goto done;
-        }
-
-        update_linkspeed(dev, 0);
-
-done:
-        disable_mdi(lp);
-
-        return IRQ_HANDLED;
-}
-
-/*
- * Initialize and enable the PHY interrupt for link-state changes
- */
-static void enable_phyirq(struct net_device *dev)
-{
-        struct at91_private *lp = netdev_priv(dev);
-        unsigned int dsintr, irq_number;
-        int status;
-
-        if (!gpio_is_valid(lp->board_data.phy_irq_pin)) {
-                /*
-                 * PHY doesn't have an IRQ pin (RTL8201, DP83847, AC101L),
-                 * or board does not have it connected.
-                 */
-                mod_timer(&lp->check_timer, jiffies + LINK_POLL_INTERVAL);
-                return;
-        }
-
-        irq_number = gpio_to_irq(lp->board_data.phy_irq_pin);
-        status = request_irq(irq_number, at91ether_phy_interrupt, 0, dev->name, dev);
-        if (status) {
-                printk(KERN_ERR "at91_ether: PHY IRQ %d request failed - status %d!\n", irq_number, status);
-                return;
-        }
-
-        spin_lock_irq(&lp->lock);
-        enable_mdi(lp);
-
-        if ((lp->phy_type == MII_DM9161_ID) || (lp->phy_type == MII_DM9161A_ID)) {      /* for Davicom PHY */
-                read_phy(lp, lp->phy_address, MII_DSINTR_REG, &dsintr);
-                dsintr = dsintr & ~0xf00;               /* clear bits 8..11 */
-                write_phy(lp, lp->phy_address, MII_DSINTR_REG, dsintr);
-        }
-        else if (lp->phy_type == MII_LXT971A_ID) {      /* for Intel PHY */
-                read_phy(lp, lp->phy_address, MII_ISINTE_REG, &dsintr);
-                dsintr = dsintr | 0xf2;                 /* set bits 1, 4..7 */
-                write_phy(lp, lp->phy_address, MII_ISINTE_REG, dsintr);
-        }
-        else if (lp->phy_type == MII_BCM5221_ID) {      /* for Broadcom PHY */
-                dsintr = (1 << 15) | ( 1 << 14);
-                write_phy(lp, lp->phy_address, MII_BCMINTR_REG, dsintr);
-        }
-        else if (lp->phy_type == MII_KS8721_ID) {       /* for Micrel PHY */
-                dsintr = (1 << 10) | ( 1 << 8);
-                write_phy(lp, lp->phy_address, MII_TPISTATUS, dsintr);
-        }
-        else if (lp->phy_type == MII_T78Q21x3_ID) {     /* for Teridian PHY */
-                read_phy(lp, lp->phy_address, MII_T78Q21INT_REG, &dsintr);
-                dsintr = dsintr | 0x500;                /* set bits 8, 10 */
-                write_phy(lp, lp->phy_address, MII_T78Q21INT_REG, dsintr);
-        }
-        else if (lp->phy_type == MII_DP83848_ID) {      /* National Semiconductor DP83848 PHY */
-                read_phy(lp, lp->phy_address, MII_DPMISR_REG, &dsintr);
-                dsintr = dsintr | 0x3c;                 /* set bits 2..5 */
-                write_phy(lp, lp->phy_address, MII_DPMISR_REG, dsintr);
-                read_phy(lp, lp->phy_address, MII_DPMICR_REG, &dsintr);
-                dsintr = dsintr | 0x3;                  /* set bits 0,1 */
-                write_phy(lp, lp->phy_address, MII_DPMICR_REG, dsintr);
-        }
-
-        disable_mdi(lp);
-        spin_unlock_irq(&lp->lock);
-}
-
-/*
- * Disable the PHY interrupt
- */
-static void disable_phyirq(struct net_device *dev)
-{
-        struct at91_private *lp = netdev_priv(dev);
-        unsigned int dsintr;
-        unsigned int irq_number;
-
-        if (!gpio_is_valid(lp->board_data.phy_irq_pin)) {
-                del_timer_sync(&lp->check_timer);
-                return;
-        }
-
-        spin_lock_irq(&lp->lock);
-        enable_mdi(lp);
-
-        if ((lp->phy_type == MII_DM9161_ID) || (lp->phy_type == MII_DM9161A_ID)) {      /* for Davicom PHY */
-                read_phy(lp, lp->phy_address, MII_DSINTR_REG, &dsintr);
-                dsintr = dsintr | 0xf00;                        /* set bits 8..11 */
-                write_phy(lp, lp->phy_address, MII_DSINTR_REG, dsintr);
-        }
-        else if (lp->phy_type == MII_LXT971A_ID) {      /* for Intel PHY */
-                read_phy(lp, lp->phy_address, MII_ISINTE_REG, &dsintr);
-                dsintr = dsintr & ~0xf2;                        /* clear bits 1, 4..7 */
-                write_phy(lp, lp->phy_address, MII_ISINTE_REG, dsintr);
-        }
-        else if (lp->phy_type == MII_BCM5221_ID) {      /* for Broadcom PHY */
-                read_phy(lp, lp->phy_address, MII_BCMINTR_REG, &dsintr);
-                dsintr = ~(1 << 14);
-                write_phy(lp, lp->phy_address, MII_BCMINTR_REG, dsintr);
-        }
-        else if (lp->phy_type == MII_KS8721_ID) {       /* for Micrel PHY */
-                read_phy(lp, lp->phy_address, MII_TPISTATUS, &dsintr);
-                dsintr = ~((1 << 10) | (1 << 8));
-                write_phy(lp, lp->phy_address, MII_TPISTATUS, dsintr);
-        }
-        else if (lp->phy_type == MII_T78Q21x3_ID) {     /* for Teridian PHY */
-                read_phy(lp, lp->phy_address, MII_T78Q21INT_REG, &dsintr);
-                dsintr = dsintr & ~0x500;                       /* clear bits 8, 10 */
-                write_phy(lp, lp->phy_address, MII_T78Q21INT_REG, dsintr);
-        }
-        else if (lp->phy_type == MII_DP83848_ID) {      /* National Semiconductor DP83848 PHY */
-                read_phy(lp, lp->phy_address, MII_DPMICR_REG, &dsintr);
-                dsintr = dsintr & ~0x3;                         /* clear bits 0, 1 */
-                write_phy(lp, lp->phy_address, MII_DPMICR_REG, dsintr);
-                read_phy(lp, lp->phy_address, MII_DPMISR_REG, &dsintr);
-                dsintr = dsintr & ~0x3c;                        /* clear bits 2..5 */
-                write_phy(lp, lp->phy_address, MII_DPMISR_REG, dsintr);
-        }
-
-        disable_mdi(lp);
-        spin_unlock_irq(&lp->lock);
-
-        irq_number = gpio_to_irq(lp->board_data.phy_irq_pin);
-        free_irq(irq_number, dev);                      /* Free interrupt handler */
-}
-
-/*
- * Perform a software reset of the PHY.
- */
-#if 0
-static void reset_phy(struct net_device *dev)
-{
-        struct at91_private *lp = netdev_priv(dev);
-        unsigned int bmcr;
-
-        spin_lock_irq(&lp->lock);
-        enable_mdi(lp);
-
-        /* Perform PHY reset */
-        write_phy(lp, lp->phy_address, MII_BMCR, BMCR_RESET);
-
-        /* Wait until PHY reset is complete */
-        do {
-                read_phy(lp, lp->phy_address, MII_BMCR, &bmcr);
-        } while (!(bmcr & BMCR_RESET));
-
-        disable_mdi(lp);
-        spin_unlock_irq(&lp->lock);
-}
-#endif
-
-static void at91ether_check_link(unsigned long dev_id)
-{
-        struct net_device *dev = (struct net_device *) dev_id;
-        struct at91_private *lp = netdev_priv(dev);
-
-        enable_mdi(lp);
-        update_linkspeed(dev, 1);
-        disable_mdi(lp);
-
-        mod_timer(&lp->check_timer, jiffies + LINK_POLL_INTERVAL);
-}
-
-/*
- * Perform any PHY-specific initialization.
- */
-static void __init initialize_phy(struct at91_private *lp)
-{
-        unsigned int val;
-
-        spin_lock_irq(&lp->lock);
-        enable_mdi(lp);
-
-        if ((lp->phy_type == MII_DM9161_ID) || (lp->phy_type == MII_DM9161A_ID)) {
-                read_phy(lp, lp->phy_address, MII_DSCR_REG, &val);
-                if ((val & (1 << 10)) == 0)                     /* DSCR bit 10 is 0 -- fiber mode */
-                        lp->phy_media = PORT_FIBRE;
-        } else if (machine_is_csb337()) {
-                /* mix link activity status into LED2 link state */
-                write_phy(lp, lp->phy_address, MII_LEDCTRL_REG, 0x0d22);
-        } else if (machine_is_ecbat91())
-                write_phy(lp, lp->phy_address, MII_LEDCTRL_REG, 0x156A);
-
-        disable_mdi(lp);
-        spin_unlock_irq(&lp->lock);
-}
-
-/* ......................... ADDRESS MANAGEMENT ........................ */
-
-/*
- * NOTE: Your bootloader must always set the MAC address correctly before
- * booting into Linux.
- *
- * - It must always set the MAC address after reset, even if it doesn't
- *   happen to access the Ethernet while it's booting.  Some versions of
- *   U-Boot on the AT91RM9200-DK do not do this.
- *
- * - Likewise it must store the addresses in the correct byte order.
- *   MicroMonitor (uMon) on the CSB337 does this incorrectly (and
- *   continues to do so, for bug-compatibility).
- */
-
-static short __init unpack_mac_address(struct net_device *dev, unsigned int hi, unsigned int lo)
-{
-        char addr[6];
-
-        if (machine_is_csb337()) {
-                addr[5] = (lo & 0xff);                  /* The CSB337 bootloader stores the MAC the wrong-way around */
-                addr[4] = (lo & 0xff00) >> 8;
-                addr[3] = (lo & 0xff0000) >> 16;
-                addr[2] = (lo & 0xff000000) >> 24;
-                addr[1] = (hi & 0xff);
-                addr[0] = (hi & 0xff00) >> 8;
-        }
-        else {
-                addr[0] = (lo & 0xff);
-                addr[1] = (lo & 0xff00) >> 8;
-                addr[2] = (lo & 0xff0000) >> 16;
-                addr[3] = (lo & 0xff000000) >> 24;
-                addr[4] = (hi & 0xff);
-                addr[5] = (hi & 0xff00) >> 8;
-        }
-
-        if (is_valid_ether_addr(addr)) {
-                memcpy(dev->dev_addr, &addr, 6);
-                return 1;
-        }
-        return 0;
-}
-
-/*
- * Set the ethernet MAC address in dev->dev_addr
- */
-static void __init get_mac_address(struct net_device *dev)
-{
-        struct at91_private *lp = netdev_priv(dev);
-
-        /* Check Specific-Address 1 */
-        if (unpack_mac_address(dev, at91_emac_read(lp, AT91_EMAC_SA1H), at91_emac_read(lp, AT91_EMAC_SA1L)))
-                return;
-        /* Check Specific-Address 2 */
-        if (unpack_mac_address(dev, at91_emac_read(lp, AT91_EMAC_SA2H), at91_emac_read(lp, AT91_EMAC_SA2L)))
-                return;
-        /* Check Specific-Address 3 */
-        if (unpack_mac_address(dev, at91_emac_read(lp, AT91_EMAC_SA3H), at91_emac_read(lp, AT91_EMAC_SA3L)))
-                return;
-        /* Check Specific-Address 4 */
-        if (unpack_mac_address(dev, at91_emac_read(lp, AT91_EMAC_SA4H), at91_emac_read(lp, AT91_EMAC_SA4L)))
-                return;
-
-        printk(KERN_ERR "at91_ether: Your bootloader did not configure a MAC address.\n");
-}
-
-/*
- * Program the hardware MAC address from dev->dev_addr.
- */
-static void update_mac_address(struct net_device *dev)
-{
-        struct at91_private *lp = netdev_priv(dev);
-
-        at91_emac_write(lp, AT91_EMAC_SA1L, (dev->dev_addr[3] << 24) | (dev->dev_addr[2] << 16) | (dev->dev_addr[1] << 8) | (dev->dev_addr[0]));
-        at91_emac_write(lp, AT91_EMAC_SA1H, (dev->dev_addr[5] << 8) | (dev->dev_addr[4]));
-
-        at91_emac_write(lp, AT91_EMAC_SA2L, 0);
-        at91_emac_write(lp, AT91_EMAC_SA2H, 0);
-}
-
-/*
- * Store the new hardware address in dev->dev_addr, and update the MAC.
- */
-static int set_mac_address(struct net_device *dev, void* addr)
-{
-        struct sockaddr *address = addr;
-
-        if (!is_valid_ether_addr(address->sa_data))
-                return -EADDRNOTAVAIL;
-
-        memcpy(dev->dev_addr, address->sa_data, dev->addr_len);
-        update_mac_address(dev);
+#include "macb.h"
 
-        printk("%s: Setting MAC address to %pM\n", dev->name,
-               dev->dev_addr);
+/* 1518 rounded up */
+#define MAX_RBUFF_SZ    0x600
+/* max number of receive buffers */
+#define MAX_RX_DESCR    9
 
-        return 0;
-}
-
-static int inline hash_bit_value(int bitnr, __u8 *addr)
-{
-        if (addr[bitnr / 8] & (1 << (bitnr % 8)))
-                return 1;
-        return 0;
-}
-
-/*
- * The hash address register is 64 bits long and takes up two locations in the memory map.
- * The least significant bits are stored in EMAC_HSL and the most significant
- * bits in EMAC_HSH.
- *
- * The unicast hash enable and the multicast hash enable bits in the network configuration
- *  register enable the reception of hash matched frames. The destination address is
- *  reduced to a 6 bit index into the 64 bit hash register using the following hash function.
- * The hash function is an exclusive or of every sixth bit of the destination address.
- *   hash_index[5] = da[5] ^ da[11] ^ da[17] ^ da[23] ^ da[29] ^ da[35] ^ da[41] ^ da[47]
- *   hash_index[4] = da[4] ^ da[10] ^ da[16] ^ da[22] ^ da[28] ^ da[34] ^ da[40] ^ da[46]
- *   hash_index[3] = da[3] ^ da[09] ^ da[15] ^ da[21] ^ da[27] ^ da[33] ^ da[39] ^ da[45]
- *   hash_index[2] = da[2] ^ da[08] ^ da[14] ^ da[20] ^ da[26] ^ da[32] ^ da[38] ^ da[44]
- *   hash_index[1] = da[1] ^ da[07] ^ da[13] ^ da[19] ^ da[25] ^ da[31] ^ da[37] ^ da[43]
- *   hash_index[0] = da[0] ^ da[06] ^ da[12] ^ da[18] ^ da[24] ^ da[30] ^ da[36] ^ da[42]
- * da[0] represents the least significant bit of the first byte received, that is, the multicast/
- *  unicast indicator, and da[47] represents the most significant bit of the last byte
- *  received.
- * If the hash index points to a bit that is set in the hash register then the frame will be
- *  matched according to whether the frame is multicast or unicast.
- * A multicast match will be signalled if the multicast hash enable bit is set, da[0] is 1 and
- *  the hash index points to a bit set in the hash register.
- * A unicast match will be signalled if the unicast hash enable bit is set, da[0] is 0 and the
- *  hash index points to a bit set in the hash register.
- * To receive all multicast frames, the hash register should be set with all ones and the
- *  multicast hash enable bit should be set in the network configuration register.
- */
-
-/*
- * Return the hash index value for the specified address.
- */
-static int hash_get_index(__u8 *addr)
-{
-        int i, j, bitval;
-        int hash_index = 0;
-
-        for (j = 0; j < 6; j++) {
-                for (i = 0, bitval = 0; i < 8; i++)
-                        bitval ^= hash_bit_value(i*6 + j, addr);
-
-                hash_index |= (bitval << j);
-        }
-
-        return hash_index;
-}
-
-/*
- * Add multicast addresses to the internal multicast-hash table.
- */
-static void at91ether_sethashtable(struct net_device *dev)
+/* Initialize and start the Receiver and Transmit subsystems */
+static int at91ether_start(struct net_device *dev)
 {
-        struct at91_private *lp = netdev_priv(dev);
-        struct netdev_hw_addr *ha;
-        unsigned long mc_filter[2];
-        unsigned int bitnr;
-
-        mc_filter[0] = mc_filter[1] = 0;
-
-        netdev_for_each_mc_addr(ha, dev) {
-                bitnr = hash_get_index(ha->addr);
-                mc_filter[bitnr >> 5] |= 1 << (bitnr & 31);
-        }
-
-        at91_emac_write(lp, AT91_EMAC_HSL, mc_filter[0]);
-        at91_emac_write(lp, AT91_EMAC_HSH, mc_filter[1]);
-}
+        struct macb *lp = netdev_priv(dev);
+        dma_addr_t addr;
+        u32 ctl;
+        int i;
 
-/*
- * Enable/Disable promiscuous and multicast modes.
- */
-static void at91ether_set_multicast_list(struct net_device *dev)
-{
-        struct at91_private *lp = netdev_priv(dev);
-        unsigned long cfg;
-
-        cfg = at91_emac_read(lp, AT91_EMAC_CFG);
-
-        if (dev->flags & IFF_PROMISC)                   /* Enable promiscuous mode */
-                cfg |= AT91_EMAC_CAF;
-        else if (dev->flags & (~IFF_PROMISC))           /* Disable promiscuous mode */
-                cfg &= ~AT91_EMAC_CAF;
-
-        if (dev->flags & IFF_ALLMULTI) {                /* Enable all multicast mode */
-                at91_emac_write(lp, AT91_EMAC_HSH, -1);
-                at91_emac_write(lp, AT91_EMAC_HSL, -1);
-                cfg |= AT91_EMAC_MTI;
-        } else if (!netdev_mc_empty(dev)) { /* Enable specific multicasts */
-                at91ether_sethashtable(dev);
-                cfg |= AT91_EMAC_MTI;
-        } else if (dev->flags & (~IFF_ALLMULTI)) {      /* Disable all multicast mode */
-                at91_emac_write(lp, AT91_EMAC_HSH, 0);
-                at91_emac_write(lp, AT91_EMAC_HSL, 0);
-                cfg &= ~AT91_EMAC_MTI;
+        lp->rx_ring = dma_alloc_coherent(&lp->pdev->dev,
+                                        MAX_RX_DESCR * sizeof(struct macb_dma_desc),
+                                        &lp->rx_ring_dma, GFP_KERNEL);
+        if (!lp->rx_ring) {
+                netdev_err(dev, "unable to alloc rx ring DMA buffer\n");
+                return -ENOMEM;
         }
 
-        at91_emac_write(lp, AT91_EMAC_CFG, cfg);
-}
-
-/* ......................... ETHTOOL SUPPORT ........................... */
-
-static int mdio_read(struct net_device *dev, int phy_id, int location)
-{
-        struct at91_private *lp = netdev_priv(dev);
-        unsigned int value;
-
-        read_phy(lp, phy_id, location, &value);
-        return value;
-}
-
-static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
-{
-        struct at91_private *lp = netdev_priv(dev);
-
-        write_phy(lp, phy_id, location, value);
-}
-
-static int at91ether_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
-{
-        struct at91_private *lp = netdev_priv(dev);
-        int ret;
-
-        spin_lock_irq(&lp->lock);
-        enable_mdi(lp);
-
-        ret = mii_ethtool_gset(&lp->mii, cmd);
-
-        disable_mdi(lp);
-        spin_unlock_irq(&lp->lock);
+        lp->rx_buffers = dma_alloc_coherent(&lp->pdev->dev,
+                                        MAX_RX_DESCR * MAX_RBUFF_SZ,
+                                        &lp->rx_buffers_dma, GFP_KERNEL);
+        if (!lp->rx_buffers) {
+                netdev_err(dev, "unable to alloc rx data DMA buffer\n");
 
-        if (lp->phy_media == PORT_FIBRE) {              /* override media type since mii.c doesn't know */
-                cmd->supported = SUPPORTED_FIBRE;
-                cmd->port = PORT_FIBRE;
+                dma_free_coherent(&lp->pdev->dev,
+                                        MAX_RX_DESCR * sizeof(struct macb_dma_desc),
+                                        lp->rx_ring, lp->rx_ring_dma);
+                lp->rx_ring = NULL;
+                return -ENOMEM;
         }
 
-        return ret;
-}
-
-static int at91ether_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
-{
-        struct at91_private *lp = netdev_priv(dev);
-        int ret;
-
-        spin_lock_irq(&lp->lock);
-        enable_mdi(lp);
-
-        ret = mii_ethtool_sset(&lp->mii, cmd);
-
-        disable_mdi(lp);
-        spin_unlock_irq(&lp->lock);
-
-        return ret;
-}
-
-static int at91ether_nwayreset(struct net_device *dev)
-{
-        struct at91_private *lp = netdev_priv(dev);
-        int ret;
-
-        spin_lock_irq(&lp->lock);
-        enable_mdi(lp);
-
-        ret = mii_nway_restart(&lp->mii);
-
-        disable_mdi(lp);
-        spin_unlock_irq(&lp->lock);
-
-        return ret;
-}
-
-static void at91ether_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
-{
-        strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
-        strlcpy(info->version, DRV_VERSION, sizeof(info->version));
-        strlcpy(info->bus_info, dev_name(dev->dev.parent), sizeof(info->bus_info));
-}
-
-static const struct ethtool_ops at91ether_ethtool_ops = {
-        .get_settings   = at91ether_get_settings,
-        .set_settings   = at91ether_set_settings,
-        .get_drvinfo    = at91ether_get_drvinfo,
-        .nway_reset     = at91ether_nwayreset,
-        .get_link       = ethtool_op_get_link,
-};
-
-static int at91ether_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
-{
-        struct at91_private *lp = netdev_priv(dev);
-        int res;
-
-        if (!netif_running(dev))
-                return -EINVAL;
-
-        spin_lock_irq(&lp->lock);
-        enable_mdi(lp);
-        res = generic_mii_ioctl(&lp->mii, if_mii(rq), cmd, NULL);
-        disable_mdi(lp);
-        spin_unlock_irq(&lp->lock);
-
-        return res;
-}
-
-/* ................................ MAC ................................ */
-
-/*
- * Initialize and start the Receiver and Transmit subsystems
- */
-static void at91ether_start(struct net_device *dev)
-{
-        struct at91_private *lp = netdev_priv(dev);
-        struct recv_desc_bufs *dlist, *dlist_phys;
-        int i;
-        unsigned long ctl;
-
-        dlist = lp->dlist;
-        dlist_phys = lp->dlist_phys;
-
+        addr = lp->rx_buffers_dma;
         for (i = 0; i < MAX_RX_DESCR; i++) {
-                dlist->descriptors[i].addr = (unsigned int) &dlist_phys->recv_buf[i][0];
-                dlist->descriptors[i].size = 0;
+                lp->rx_ring[i].addr = addr;
+                lp->rx_ring[i].ctrl = 0;
+                addr += MAX_RBUFF_SZ;
         }
 
         /* Set the Wrap bit on the last descriptor */
-        dlist->descriptors[i-1].addr |= EMAC_DESC_WRAP;
+        lp->rx_ring[MAX_RX_DESCR - 1].addr |= MACB_BIT(RX_WRAP);
 
         /* Reset buffer index */
-        lp->rxBuffIndex = 0;
+        lp->rx_tail = 0;
 
         /* Program address of descriptor list in Rx Buffer Queue register */
-        at91_emac_write(lp, AT91_EMAC_RBQP, (unsigned long) dlist_phys);
+        macb_writel(lp, RBQP, lp->rx_ring_dma);
 
         /* Enable Receive and Transmit */
-        ctl = at91_emac_read(lp, AT91_EMAC_CTL);
-        at91_emac_write(lp, AT91_EMAC_CTL, ctl | AT91_EMAC_RE | AT91_EMAC_TE);
+        ctl = macb_readl(lp, NCR);
+        macb_writel(lp, NCR, ctl | MACB_BIT(RE) | MACB_BIT(TE));
+
+        return 0;
 }
 
-/*
- * Open the ethernet interface
- */
+/* Open the ethernet interface */
 static int at91ether_open(struct net_device *dev)
 {
-        struct at91_private *lp = netdev_priv(dev);
-        unsigned long ctl;
+        struct macb *lp = netdev_priv(dev);
+        u32 ctl;
+        int ret;
 
         if (!is_valid_ether_addr(dev->dev_addr))
                 return -EADDRNOTAVAIL;
 
-        clk_enable(lp->ether_clk);              /* Re-enable Peripheral clock */
-
         /* Clear internal statistics */
-        ctl = at91_emac_read(lp, AT91_EMAC_CTL);
-        at91_emac_write(lp, AT91_EMAC_CTL, ctl | AT91_EMAC_CSR);
+        ctl = macb_readl(lp, NCR);
+        macb_writel(lp, NCR, ctl | MACB_BIT(CLRSTAT));
 
-        /* Update the MAC address (incase user has changed it) */
-        update_mac_address(dev);
+        macb_set_hwaddr(lp);
 
-        /* Enable PHY interrupt */
-        enable_phyirq(dev);
+        ret = at91ether_start(dev);
+        if (ret)
+                return ret;
 
         /* Enable MAC interrupts */
-        at91_emac_write(lp, AT91_EMAC_IER, AT91_EMAC_RCOM | AT91_EMAC_RBNA
-                                | AT91_EMAC_TUND | AT91_EMAC_RTRY | AT91_EMAC_TCOM
-                                | AT91_EMAC_ROVR | AT91_EMAC_ABT);
-
-        /* Determine current link speed */
-        spin_lock_irq(&lp->lock);
-        enable_mdi(lp);
-        update_linkspeed(dev, 0);
-        disable_mdi(lp);
-        spin_unlock_irq(&lp->lock);
-
-        at91ether_start(dev);
+        macb_writel(lp, IER, MACB_BIT(RCOMP)    |
+                             MACB_BIT(RXUBR)    |
+                             MACB_BIT(ISR_TUND) |
+                             MACB_BIT(ISR_RLE)  |
+                             MACB_BIT(TCOMP)    |
+                             MACB_BIT(ISR_ROVR) |
+                             MACB_BIT(HRESP));
+
+        /* schedule a link state check */
+        phy_start(lp->phy_dev);
+
         netif_start_queue(dev);
+
         return 0;
 }
 
-/*
- * Close the interface
- */
+/* Close the interface */
 static int at91ether_close(struct net_device *dev)
 {
-        struct at91_private *lp = netdev_priv(dev);
-        unsigned long ctl;
+        struct macb *lp = netdev_priv(dev);
+        u32 ctl;
 
         /* Disable Receiver and Transmitter */
-        ctl = at91_emac_read(lp, AT91_EMAC_CTL);
-        at91_emac_write(lp, AT91_EMAC_CTL, ctl & ~(AT91_EMAC_TE | AT91_EMAC_RE));
-
-        /* Disable PHY interrupt */
-        disable_phyirq(dev);
+        ctl = macb_readl(lp, NCR);
+        macb_writel(lp, NCR, ctl & ~(MACB_BIT(TE) | MACB_BIT(RE)));
 
         /* Disable MAC interrupts */
-        at91_emac_write(lp, AT91_EMAC_IDR, AT91_EMAC_RCOM | AT91_EMAC_RBNA
-                                | AT91_EMAC_TUND | AT91_EMAC_RTRY | AT91_EMAC_TCOM
-                                | AT91_EMAC_ROVR | AT91_EMAC_ABT);
+        macb_writel(lp, IDR, MACB_BIT(RCOMP)    |
+                             MACB_BIT(RXUBR)    |
+                             MACB_BIT(ISR_TUND) |
+                             MACB_BIT(ISR_RLE)  |
+                             MACB_BIT(TCOMP)    |
+                             MACB_BIT(ISR_ROVR) |
+                             MACB_BIT(HRESP));
 
         netif_stop_queue(dev);
 
-        clk_disable(lp->ether_clk);             /* Disable Peripheral clock */
+        dma_free_coherent(&lp->pdev->dev,
+                                MAX_RX_DESCR * sizeof(struct macb_dma_desc),
+                                lp->rx_ring, lp->rx_ring_dma);
+        lp->rx_ring = NULL;
+
+        dma_free_coherent(&lp->pdev->dev,
+                                MAX_RX_DESCR * MAX_RBUFF_SZ,
+                                lp->rx_buffers, lp->rx_buffers_dma);
+        lp->rx_buffers = NULL;
 
         return 0;
 }
 
-/*
- * Transmit packet.
- */
+/* Transmit packet */
 static int at91ether_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-        struct at91_private *lp = netdev_priv(dev);
+        struct macb *lp = netdev_priv(dev);
 
-        if (at91_emac_read(lp, AT91_EMAC_TSR) & AT91_EMAC_TSR_BNQ) {
+        if (macb_readl(lp, TSR) & MACB_BIT(RM9200_BNQ)) {
                 netif_stop_queue(dev);
 
                 /* Store packet information (to free when Tx completed) */
                 lp->skb = skb;
                 lp->skb_length = skb->len;
-                lp->skb_physaddr = dma_map_single(NULL, skb->data, skb->len, DMA_TO_DEVICE);
-                dev->stats.tx_bytes += skb->len;
+                lp->skb_physaddr = dma_map_single(NULL, skb->data, skb->len,
+                                                        DMA_TO_DEVICE);
 
                 /* Set address of the data in the Transmit Address register */
-                at91_emac_write(lp, AT91_EMAC_TAR, lp->skb_physaddr);
+                macb_writel(lp, TAR, lp->skb_physaddr);
                 /* Set length of the packet in the Transmit Control register */
-                at91_emac_write(lp, AT91_EMAC_TCR, skb->len);
+                macb_writel(lp, TCR, skb->len);
 
         } else {
-                printk(KERN_ERR "at91_ether.c: at91ether_start_xmit() called, but device is busy!\n");
-                return NETDEV_TX_BUSY;  /* if we return anything but zero, dev.c:1055 calls kfree_skb(skb)
-                                on this skb, he also reports -ENETDOWN and printk's, so either
-                                we free and return(0) or don't free and return 1 */
+                netdev_err(dev, "%s called, but device is busy!\n", __func__);
+                return NETDEV_TX_BUSY;
         }
 
         return NETDEV_TX_OK;
 }
 
-/*
- * Update the current statistics from the internal statistics registers.
- */
-static struct net_device_stats *at91ether_stats(struct net_device *dev)
-{
-        struct at91_private *lp = netdev_priv(dev);
-        int ale, lenerr, seqe, lcol, ecol;
-
-        if (netif_running(dev)) {
-                dev->stats.rx_packets += at91_emac_read(lp, AT91_EMAC_OK);      /* Good frames received */
-                ale = at91_emac_read(lp, AT91_EMAC_ALE);
-                dev->stats.rx_frame_errors += ale;                              /* Alignment errors */
-                lenerr = at91_emac_read(lp, AT91_EMAC_ELR) + at91_emac_read(lp, AT91_EMAC_USF);
-                dev->stats.rx_length_errors += lenerr;                          /* Excessive Length or Undersize Frame error */
-                seqe = at91_emac_read(lp, AT91_EMAC_SEQE);
-                dev->stats.rx_crc_errors += seqe;                               /* CRC error */
-                dev->stats.rx_fifo_errors += at91_emac_read(lp, AT91_EMAC_DRFC);/* Receive buffer not available */
-                dev->stats.rx_errors += (ale + lenerr + seqe
-                        + at91_emac_read(lp, AT91_EMAC_CDE) + at91_emac_read(lp, AT91_EMAC_RJB));
-
-                dev->stats.tx_packets += at91_emac_read(lp, AT91_EMAC_FRA);     /* Frames successfully transmitted */
-                dev->stats.tx_fifo_errors += at91_emac_read(lp, AT91_EMAC_TUE); /* Transmit FIFO underruns */
-                dev->stats.tx_carrier_errors += at91_emac_read(lp, AT91_EMAC_CSE);      /* Carrier Sense errors */
-                dev->stats.tx_heartbeat_errors += at91_emac_read(lp, AT91_EMAC_SQEE);/* Heartbeat error */
-
-                lcol = at91_emac_read(lp, AT91_EMAC_LCOL);
-                ecol = at91_emac_read(lp, AT91_EMAC_ECOL);
-                dev->stats.tx_window_errors += lcol;                    /* Late collisions */
-                dev->stats.tx_aborted_errors += ecol;                   /* 16 collisions */
-
-                dev->stats.collisions += (at91_emac_read(lp, AT91_EMAC_SCOL) + at91_emac_read(lp, AT91_EMAC_MCOL) + lcol + ecol);
-        }
-        return &dev->stats;
-}
-
-/*
- * Extract received frame from buffer descriptors and sent to upper layers.
+/* Extract received frame from buffer descriptors and sent to upper layers.
  * (Called from interrupt context)
  */
 static void at91ether_rx(struct net_device *dev)
 {
-        struct at91_private *lp = netdev_priv(dev);
-        struct recv_desc_bufs *dlist;
+        struct macb *lp = netdev_priv(dev);
         unsigned char *p_recv;
         struct sk_buff *skb;
         unsigned int pktlen;
 
-        dlist = lp->dlist;
-        while (dlist->descriptors[lp->rxBuffIndex].addr & EMAC_DESC_DONE) {
-                p_recv = dlist->recv_buf[lp->rxBuffIndex];
-                pktlen = dlist->descriptors[lp->rxBuffIndex].size & 0x7ff;      /* Length of frame including FCS */
+        while (lp->rx_ring[lp->rx_tail].addr & MACB_BIT(RX_USED)) {
+                p_recv = lp->rx_buffers + lp->rx_tail * MAX_RBUFF_SZ;
+                pktlen = MACB_BF(RX_FRMLEN, lp->rx_ring[lp->rx_tail].ctrl);
                 skb = netdev_alloc_skb(dev, pktlen + 2);
-                if (skb != NULL) {
+                if (skb) {
                         skb_reserve(skb, 2);
                         memcpy(skb_put(skb, pktlen), p_recv, pktlen);
 
                         skb->protocol = eth_type_trans(skb, dev);
-                        dev->stats.rx_bytes += pktlen;
+                        lp->stats.rx_packets++;
+                        lp->stats.rx_bytes += pktlen;
                         netif_rx(skb);
+                } else {
+                        lp->stats.rx_dropped++;
+                        netdev_notice(dev, "Memory squeeze, dropping packet.\n");
                 }
-                else {
-                        dev->stats.rx_dropped += 1;
-                        printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name);
-                }
 
-                if (dlist->descriptors[lp->rxBuffIndex].size & EMAC_MULTICAST)
-                        dev->stats.multicast++;
+                if (lp->rx_ring[lp->rx_tail].ctrl & MACB_BIT(RX_MHASH_MATCH))
+                        lp->stats.multicast++;
+
+                /* reset ownership bit */
+                lp->rx_ring[lp->rx_tail].addr &= ~MACB_BIT(RX_USED);
 
-                dlist->descriptors[lp->rxBuffIndex].addr &= ~EMAC_DESC_DONE;    /* reset ownership bit */
-                if (lp->rxBuffIndex == MAX_RX_DESCR-1)                          /* wrap after last buffer */
-                        lp->rxBuffIndex = 0;
+                /* wrap after last buffer */
+                if (lp->rx_tail == MAX_RX_DESCR - 1)
+                        lp->rx_tail = 0;
                 else
-                        lp->rxBuffIndex++;
+                        lp->rx_tail++;
         }
 }
 
-/*
- * MAC interrupt handler
- */
+/* MAC interrupt handler */
 static irqreturn_t at91ether_interrupt(int irq, void *dev_id)
 {
-        struct net_device *dev = (struct net_device *) dev_id;
-        struct at91_private *lp = netdev_priv(dev);
-        unsigned long intstatus, ctl;
+        struct net_device *dev = dev_id;
+        struct macb *lp = netdev_priv(dev);
+        u32 intstatus, ctl;
 
         /* MAC Interrupt Status register indicates what interrupts are pending.
-           It is automatically cleared once read. */
-        intstatus = at91_emac_read(lp, AT91_EMAC_ISR);
+         * It is automatically cleared once read.
+         */
+        intstatus = macb_readl(lp, ISR);
 
-        if (intstatus & AT91_EMAC_RCOM)         /* Receive complete */
+        /* Receive complete */
+        if (intstatus & MACB_BIT(RCOMP))
                 at91ether_rx(dev);
 
-        if (intstatus & AT91_EMAC_TCOM) {       /* Transmit complete */
-                /* The TCOM bit is set even if the transmission failed. */
-                if (intstatus & (AT91_EMAC_TUND | AT91_EMAC_RTRY))
-                        dev->stats.tx_errors += 1;
+        /* Transmit complete */
+        if (intstatus & MACB_BIT(TCOMP)) {
+                /* The TCOM bit is set even if the transmission failed */
+                if (intstatus & (MACB_BIT(ISR_TUND) | MACB_BIT(ISR_RLE)))
+                        lp->stats.tx_errors++;
 
                 if (lp->skb) {
                         dev_kfree_skb_irq(lp->skb);
                         lp->skb = NULL;
                         dma_unmap_single(NULL, lp->skb_physaddr, lp->skb_length, DMA_TO_DEVICE);
+                        lp->stats.tx_packets++;
+                        lp->stats.tx_bytes += lp->skb_length;
                 }
                 netif_wake_queue(dev);
         }
 
-        /* Work-around for Errata #11 */
-        if (intstatus & AT91_EMAC_RBNA) {
-                ctl = at91_emac_read(lp, AT91_EMAC_CTL);
-                at91_emac_write(lp, AT91_EMAC_CTL, ctl & ~AT91_EMAC_RE);
-                at91_emac_write(lp, AT91_EMAC_CTL, ctl | AT91_EMAC_RE);
+        /* Work-around for EMAC Errata section 41.3.1 */
+        if (intstatus & MACB_BIT(RXUBR)) {
+                ctl = macb_readl(lp, NCR);
+                macb_writel(lp, NCR, ctl & ~MACB_BIT(RE));
+                macb_writel(lp, NCR, ctl | MACB_BIT(RE));
         }
 
-        if (intstatus & AT91_EMAC_ROVR)
-                printk("%s: ROVR error\n", dev->name);
+        if (intstatus & MACB_BIT(ISR_ROVR))
+                netdev_err(dev, "ROVR error\n");
 
         return IRQ_HANDLED;
 }
@@ -1000,10 +289,10 @@ static const struct net_device_ops at91ether_netdev_ops = {
         .ndo_open               = at91ether_open,
         .ndo_stop               = at91ether_close,
         .ndo_start_xmit         = at91ether_start_xmit,
-        .ndo_get_stats          = at91ether_stats,
-        .ndo_set_rx_mode        = at91ether_set_multicast_list,
-        .ndo_set_mac_address    = set_mac_address,
-        .ndo_do_ioctl           = at91ether_ioctl,
+        .ndo_get_stats          = macb_get_stats,
+        .ndo_set_rx_mode        = macb_set_rx_mode,
+        .ndo_set_mac_address    = eth_mac_addr,
+        .ndo_do_ioctl           = macb_ioctl,
         .ndo_validate_addr      = eth_validate_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
@@ -1011,197 +300,160 @@ static const struct net_device_ops at91ether_netdev_ops = {
 #endif
 };
 
-/*
- * Detect the PHY type, and its address.
- */
-static int __init at91ether_phy_detect(struct at91_private *lp)
+#if defined(CONFIG_OF)
+static const struct of_device_id at91ether_dt_ids[] = {
+        { .compatible = "cdns,at91rm9200-emac" },
+        { .compatible = "cdns,emac" },
+        { /* sentinel */ }
+};
+
+MODULE_DEVICE_TABLE(of, at91ether_dt_ids);
+
+static int at91ether_get_phy_mode_dt(struct platform_device *pdev)
 {
-        unsigned int phyid1, phyid2;
-        unsigned long phy_id;
-        unsigned short phy_address = 0;
-
-        while (phy_address < PHY_MAX_ADDR) {
-                /* Read the PHY ID registers */
-                enable_mdi(lp);
-                read_phy(lp, phy_address, MII_PHYSID1, &phyid1);
-                read_phy(lp, phy_address, MII_PHYSID2, &phyid2);
-                disable_mdi(lp);
-
-                phy_id = (phyid1 << 16) | (phyid2 & 0xfff0);
-                switch (phy_id) {
-                        case MII_DM9161_ID:             /* Davicom 9161: PHY_ID1 = 0x181, PHY_ID2 = B881 */
-                        case MII_DM9161A_ID:            /* Davicom 9161A: PHY_ID1 = 0x181, PHY_ID2 = B8A0 */
-                        case MII_LXT971A_ID:            /* Intel LXT971A: PHY_ID1 = 0x13, PHY_ID2 = 78E0 */
-                        case MII_RTL8201_ID:            /* Realtek RTL8201: PHY_ID1 = 0, PHY_ID2 = 0x8201 */
-                        case MII_BCM5221_ID:            /* Broadcom BCM5221: PHY_ID1 = 0x40, PHY_ID2 = 0x61e0 */
-                        case MII_DP83847_ID:            /* National Semiconductor DP83847:  */
-                        case MII_DP83848_ID:            /* National Semiconductor DP83848:  */
-                        case MII_AC101L_ID:             /* Altima AC101L: PHY_ID1 = 0x22, PHY_ID2 = 0x5520 */
-                        case MII_KS8721_ID:             /* Micrel KS8721: PHY_ID1 = 0x22, PHY_ID2 = 0x1610 */
-                        case MII_T78Q21x3_ID:           /* Teridian 78Q21x3: PHY_ID1 = 0x0E, PHY_ID2 = 7237 */
-                        case MII_LAN83C185_ID:          /* SMSC LAN83C185: PHY_ID1 = 0x0007, PHY_ID2 = 0xC0A1 */
-                                /* store detected values */
-                                lp->phy_type = phy_id;          /* Type of PHY connected */
-                                lp->phy_address = phy_address;  /* MDI address of PHY */
-                                return 1;
-                }
+        struct device_node *np = pdev->dev.of_node;
 
-                phy_address++;
-        }
+        if (np)
+                return of_get_phy_mode(np);
 
-        return 0;               /* not detected */
+        return -ENODEV;
 }
 
+static int at91ether_get_hwaddr_dt(struct macb *bp)
+{
+        struct device_node *np = bp->pdev->dev.of_node;
 
-/*
- * Detect MAC & PHY and perform ethernet interface initialization
- */
+        if (np) {
+                const char *mac = of_get_mac_address(np);
+                if (mac) {
+                        memcpy(bp->dev->dev_addr, mac, ETH_ALEN);
+                        return 0;
+                }
+        }
+
+        return -ENODEV;
+}
+#else
+static int at91ether_get_phy_mode_dt(struct platform_device *pdev)
+{
+        return -ENODEV;
+}
+static int at91ether_get_hwaddr_dt(struct macb *bp)
+{
+        return -ENODEV;
+}
+#endif
+
+/* Detect MAC & PHY and perform ethernet interface initialization */
 static int __init at91ether_probe(struct platform_device *pdev)
 {
         struct macb_platform_data *board_data = pdev->dev.platform_data;
         struct resource *regs;
         struct net_device *dev;
-        struct at91_private *lp;
+        struct phy_device *phydev;
+        struct pinctrl *pinctrl;
+        struct macb *lp;
         int res;
+        u32 reg;
 
         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!regs)
                 return -ENOENT;
 
-        dev = alloc_etherdev(sizeof(struct at91_private));
+        pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
+        if (IS_ERR(pinctrl)) {
+                res = PTR_ERR(pinctrl);
+                if (res == -EPROBE_DEFER)
+                        return res;
+
+                dev_warn(&pdev->dev, "No pinctrl provided\n");
+        }
+
+        dev = alloc_etherdev(sizeof(struct macb));
         if (!dev)
                 return -ENOMEM;
 
         lp = netdev_priv(dev);
-        lp->board_data = *board_data;
+        lp->pdev = pdev;
+        lp->dev = dev;
         spin_lock_init(&lp->lock);
 
-        dev->base_addr = regs->start;           /* physical base address */
-        lp->emac_base = ioremap(regs->start, regs->end - regs->start + 1);
-        if (!lp->emac_base) {
+        /* physical base address */
+        dev->base_addr = regs->start;
+        lp->regs = devm_ioremap(&pdev->dev, regs->start, resource_size(regs));
+        if (!lp->regs) {
                 res = -ENOMEM;
                 goto err_free_dev;
         }
 
         /* Clock */
-        lp->ether_clk = clk_get(&pdev->dev, "ether_clk");
-        if (IS_ERR(lp->ether_clk)) {
-                res = PTR_ERR(lp->ether_clk);
-                goto err_ioumap;
+        lp->pclk = devm_clk_get(&pdev->dev, "ether_clk");
+        if (IS_ERR(lp->pclk)) {
+                res = PTR_ERR(lp->pclk);
+                goto err_free_dev;
         }
-        clk_enable(lp->ether_clk);
+        clk_enable(lp->pclk);
 
         /* Install the interrupt handler */
         dev->irq = platform_get_irq(pdev, 0);
-        if (request_irq(dev->irq, at91ether_interrupt, 0, dev->name, dev)) {
-                res = -EBUSY;
+        res = devm_request_irq(&pdev->dev, dev->irq, at91ether_interrupt, 0, dev->name, dev);
+        if (res)
                 goto err_disable_clock;
-        }
-
-        /* Allocate memory for DMA Receive descriptors */
-        lp->dlist = (struct recv_desc_bufs *) dma_alloc_coherent(NULL, sizeof(struct recv_desc_bufs), (dma_addr_t *) &lp->dlist_phys, GFP_KERNEL);
-        if (lp->dlist == NULL) {
-                res = -ENOMEM;
-                goto err_free_irq;
-        }
 
         ether_setup(dev);
         dev->netdev_ops = &at91ether_netdev_ops;
-        dev->ethtool_ops = &at91ether_ethtool_ops;
+        dev->ethtool_ops = &macb_ethtool_ops;
         platform_set_drvdata(pdev, dev);
         SET_NETDEV_DEV(dev, &pdev->dev);
 
-        get_mac_address(dev);           /* Get ethernet address and store it in dev->dev_addr */
-        update_mac_address(dev);        /* Program ethernet address into MAC */
-
-        at91_emac_write(lp, AT91_EMAC_CTL, 0);
+        res = at91ether_get_hwaddr_dt(lp);
+        if (res < 0)
+                macb_get_hwaddr(lp);
 
-        if (board_data->is_rmii)
-                at91_emac_write(lp, AT91_EMAC_CFG, AT91_EMAC_CLK_DIV32 | AT91_EMAC_BIG | AT91_EMAC_RMII);
-        else
-                at91_emac_write(lp, AT91_EMAC_CFG, AT91_EMAC_CLK_DIV32 | AT91_EMAC_BIG);
-
-        /* Detect PHY */
-        if (!at91ether_phy_detect(lp)) {
-                printk(KERN_ERR "at91_ether: Could not detect ethernet PHY\n");
-                res = -ENODEV;
-                goto err_free_dmamem;
+        res = at91ether_get_phy_mode_dt(pdev);
+        if (res < 0) {
+                if (board_data && board_data->is_rmii)
+                        lp->phy_interface = PHY_INTERFACE_MODE_RMII;
+                else
+                        lp->phy_interface = PHY_INTERFACE_MODE_MII;
+        } else {
+                lp->phy_interface = res;
         }
 
-        initialize_phy(lp);
+        macb_writel(lp, NCR, 0);
+
+        reg = MACB_BF(CLK, MACB_CLK_DIV32) | MACB_BIT(BIG);
+        if (lp->phy_interface == PHY_INTERFACE_MODE_RMII)
+                reg |= MACB_BIT(RM9200_RMII);
 
-        lp->mii.dev = dev;              /* Support for ethtool */
-        lp->mii.mdio_read = mdio_read;
-        lp->mii.mdio_write = mdio_write;
-        lp->mii.phy_id = lp->phy_address;
-        lp->mii.phy_id_mask = 0x1f;
-        lp->mii.reg_num_mask = 0x1f;
+        macb_writel(lp, NCFGR, reg);
 
         /* Register the network interface */
         res = register_netdev(dev);
         if (res)
-                goto err_free_dmamem;
-
-        /* Determine current link speed */
-        spin_lock_irq(&lp->lock);
-        enable_mdi(lp);
-        update_linkspeed(dev, 0);
-        disable_mdi(lp);
-        spin_unlock_irq(&lp->lock);
-        netif_carrier_off(dev);         /* will be enabled in open() */
-
-        /* If board has no PHY IRQ, use a timer to poll the PHY */
-        if (gpio_is_valid(lp->board_data.phy_irq_pin)) {
-                gpio_request(board_data->phy_irq_pin, "ethernet_phy");
-        } else {
-                /* If board has no PHY IRQ, use a timer to poll the PHY */
-                init_timer(&lp->check_timer);
-                lp->check_timer.data = (unsigned long)dev;
-                lp->check_timer.function = at91ether_check_link;
-        }
+                goto err_disable_clock;
+
+        if (macb_mii_init(lp) != 0)
+                goto err_out_unregister_netdev;
+
+        /* will be enabled in open() */
+        netif_carrier_off(dev);
+
+        phydev = lp->phy_dev;
+        netdev_info(dev, "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
+                                phydev->drv->name, dev_name(&phydev->dev),
+                                phydev->irq);
 
         /* Display ethernet banner */
-        printk(KERN_INFO "%s: AT91 ethernet at 0x%08x int=%d %s%s (%pM)\n",
-               dev->name, (uint) dev->base_addr, dev->irq,
-               at91_emac_read(lp, AT91_EMAC_CFG) & AT91_EMAC_SPD ? "100-" : "10-",
-               at91_emac_read(lp, AT91_EMAC_CFG) & AT91_EMAC_FD ? "FullDuplex" : "HalfDuplex",
-               dev->dev_addr);
-        if ((lp->phy_type == MII_DM9161_ID) || (lp->phy_type == MII_DM9161A_ID))
-                printk(KERN_INFO "%s: Davicom 9161 PHY %s\n", dev->name, (lp->phy_media == PORT_FIBRE) ? "(Fiber)" : "(Copper)");
-        else if (lp->phy_type == MII_LXT971A_ID)
-                printk(KERN_INFO "%s: Intel LXT971A PHY\n", dev->name);
-        else if (lp->phy_type == MII_RTL8201_ID)
-                printk(KERN_INFO "%s: Realtek RTL8201(B)L PHY\n", dev->name);
-        else if (lp->phy_type == MII_BCM5221_ID)
-                printk(KERN_INFO "%s: Broadcom BCM5221 PHY\n", dev->name);
-        else if (lp->phy_type == MII_DP83847_ID)
-                printk(KERN_INFO "%s: National Semiconductor DP83847 PHY\n", dev->name);
-        else if (lp->phy_type == MII_DP83848_ID)
-                printk(KERN_INFO "%s: National Semiconductor DP83848 PHY\n", dev->name);
-        else if (lp->phy_type == MII_AC101L_ID)
-                printk(KERN_INFO "%s: Altima AC101L PHY\n", dev->name);
-        else if (lp->phy_type == MII_KS8721_ID)
-                printk(KERN_INFO "%s: Micrel KS8721 PHY\n", dev->name);
-        else if (lp->phy_type == MII_T78Q21x3_ID)
-                printk(KERN_INFO "%s: Teridian 78Q21x3 PHY\n", dev->name);
-        else if (lp->phy_type == MII_LAN83C185_ID)
-                printk(KERN_INFO "%s: SMSC LAN83C185 PHY\n", dev->name);
-
-        clk_disable(lp->ether_clk);                                     /* Disable Peripheral clock */
+        netdev_info(dev, "AT91 ethernet at 0x%08lx int=%d (%pM)\n",
+                                dev->base_addr, dev->irq, dev->dev_addr);
 
         return 0;
 
-
-err_free_dmamem:
-        platform_set_drvdata(pdev, NULL);
-        dma_free_coherent(NULL, sizeof(struct recv_desc_bufs), lp->dlist, (dma_addr_t)lp->dlist_phys);
-err_free_irq:
-        free_irq(dev->irq, dev);
+err_out_unregister_netdev:
+        unregister_netdev(dev);
 err_disable_clock:
-        clk_disable(lp->ether_clk);
-        clk_put(lp->ether_clk);
-err_ioumap:
-        iounmap(lp->emac_base);
+        clk_disable(lp->pclk);
 err_free_dev:
         free_netdev(dev);
         return res;
@@ -1210,38 +462,33 @@ err_free_dev:
 static int __devexit at91ether_remove(struct platform_device *pdev)
 {
         struct net_device *dev = platform_get_drvdata(pdev);
-        struct at91_private *lp = netdev_priv(dev);
+        struct macb *lp = netdev_priv(dev);
 
-        if (gpio_is_valid(lp->board_data.phy_irq_pin))
-                gpio_free(lp->board_data.phy_irq_pin);
+        if (lp->phy_dev)
+                phy_disconnect(lp->phy_dev);
 
+        mdiobus_unregister(lp->mii_bus);
+        kfree(lp->mii_bus->irq);
+        mdiobus_free(lp->mii_bus);
         unregister_netdev(dev);
-        free_irq(dev->irq, dev);
-        dma_free_coherent(NULL, sizeof(struct recv_desc_bufs), lp->dlist, (dma_addr_t)lp->dlist_phys);
-        clk_put(lp->ether_clk);
-
-        platform_set_drvdata(pdev, NULL);
+        clk_disable(lp->pclk);
         free_netdev(dev);
+        platform_set_drvdata(pdev, NULL);
+
         return 0;
 }
 
 #ifdef CONFIG_PM
-
 static int at91ether_suspend(struct platform_device *pdev, pm_message_t mesg)
 {
         struct net_device *net_dev = platform_get_drvdata(pdev);
-        struct at91_private *lp = netdev_priv(net_dev);
+        struct macb *lp = netdev_priv(net_dev);
 
         if (netif_running(net_dev)) {
-                if (gpio_is_valid(lp->board_data.phy_irq_pin)) {
-                        int phy_irq = gpio_to_irq(lp->board_data.phy_irq_pin);
-                        disable_irq(phy_irq);
-                }
-
                 netif_stop_queue(net_dev);
                 netif_device_detach(net_dev);
 
-                clk_disable(lp->ether_clk);
+                clk_disable(lp->pclk);
         }
         return 0;
 }
@@ -1249,22 +496,16 @@ static int at91ether_suspend(struct platform_device *pdev, pm_message_t mesg)
 static int at91ether_resume(struct platform_device *pdev)
 {
         struct net_device *net_dev = platform_get_drvdata(pdev);
-        struct at91_private *lp = netdev_priv(net_dev);
+        struct macb *lp = netdev_priv(net_dev);
 
         if (netif_running(net_dev)) {
-                clk_enable(lp->ether_clk);
+                clk_enable(lp->pclk);
 
                 netif_device_attach(net_dev);
                 netif_start_queue(net_dev);
-
-                if (gpio_is_valid(lp->board_data.phy_irq_pin)) {
-                        int phy_irq = gpio_to_irq(lp->board_data.phy_irq_pin);
-                        enable_irq(phy_irq);
-                }
         }
         return 0;
 }
-
 #else
 #define at91ether_suspend       NULL
 #define at91ether_resume        NULL
@@ -1275,8 +516,9 @@ static struct platform_driver at91ether_driver = {
         .suspend        = at91ether_suspend,
         .resume         = at91ether_resume,
         .driver         = {
-                .name   = DRV_NAME,
+                .name   = "at91_ether",
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(at91ether_dt_ids),
         },
 };
 
@@ -1296,4 +538,4 @@ module_exit(at91ether_exit)
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("AT91RM9200 EMAC Ethernet driver");
 MODULE_AUTHOR("Andrew Victor");
-MODULE_ALIAS("platform:" DRV_NAME);
+MODULE_ALIAS("platform:at91_ether");
diff --git a/drivers/net/ethernet/cadence/at91_ether.h b/drivers/net/ethernet/cadence/at91_ether.h
deleted file mode 100644
index 0ef6328fa7f8..000000000000
--- a/drivers/net/ethernet/cadence/at91_ether.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Ethernet driver for the Atmel AT91RM9200 (Thunder)
- *
- *  Copyright (C) SAN People (Pty) Ltd
- *
- * Based on an earlier Atmel EMAC macrocell driver by Atmel and Lineo Inc.
- * Initial version by Rick Bronson.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
- */
-
-#ifndef AT91_ETHERNET
-#define AT91_ETHERNET
-
-
-/* Davicom 9161 PHY */
-#define MII_DM9161_ID           0x0181b880
-#define MII_DM9161A_ID          0x0181b8a0
-#define MII_DSCR_REG            16
-#define MII_DSCSR_REG           17
-#define MII_DSINTR_REG          21
-
-/* Intel LXT971A PHY */
-#define MII_LXT971A_ID          0x001378E0
-#define MII_ISINTE_REG          18
-#define MII_ISINTS_REG          19
-#define MII_LEDCTRL_REG         20
-
-/* Realtek RTL8201 PHY */
-#define MII_RTL8201_ID          0x00008200
-
-/* Broadcom BCM5221 PHY */
-#define MII_BCM5221_ID          0x004061e0
-#define MII_BCMINTR_REG         26
-
-/* National Semiconductor DP83847 */
-#define MII_DP83847_ID          0x20005c30
-
-/* National Semiconductor DP83848 */
-#define MII_DP83848_ID          0x20005c90
-#define MII_DPPHYSTS_REG        16
-#define MII_DPMICR_REG          17
-#define MII_DPMISR_REG          18
-
-/* Altima AC101L PHY */
-#define MII_AC101L_ID           0x00225520
-
-/* Micrel KS8721 PHY */
-#define MII_KS8721_ID           0x00221610
-
-/* Teridian 78Q2123/78Q2133 */
-#define MII_T78Q21x3_ID         0x000e7230
-#define MII_T78Q21INT_REG       17
-
-/* SMSC LAN83C185 */
-#define MII_LAN83C185_ID        0x0007C0A0
-
-/* ........................................................................ */
-
-#define MAX_RBUFF_SZ    0x600           /* 1518 rounded up */
-#define MAX_RX_DESCR    9               /* max number of receive buffers */
-
-#define EMAC_DESC_DONE  0x00000001      /* bit for if DMA is done */
-#define EMAC_DESC_WRAP  0x00000002      /* bit for wrap */
-
-#define EMAC_BROADCAST  0x80000000      /* broadcast address */
-#define EMAC_MULTICAST  0x40000000      /* multicast address */
-#define EMAC_UNICAST    0x20000000      /* unicast address */
-
-struct rbf_t
-{
-        unsigned int addr;
-        unsigned long size;
-};
-
-struct recv_desc_bufs
-{
-        struct rbf_t descriptors[MAX_RX_DESCR];         /* must be on sizeof (rbf_t) boundary */
-        char recv_buf[MAX_RX_DESCR][MAX_RBUFF_SZ];      /* must be on long boundary */
-};
-
-struct at91_private
-{
-        struct mii_if_info mii;                 /* ethtool support */
-        struct macb_platform_data board_data;   /* board-specific
-                                                 * configuration (shared with
-                                                 * macb for common data */
-        void __iomem *emac_base;                /* base register address */
-        struct clk *ether_clk;                  /* clock */
-
-        /* PHY */
-        unsigned long phy_type;                 /* type of PHY (PHY_ID) */
-        spinlock_t lock;                        /* lock for MDI interface */
-        short phy_media;                        /* media interface type */
-        unsigned short phy_address;             /* 5-bit MDI address of PHY (0..31) */
-        struct timer_list check_timer;          /* Poll link status */
-
-        /* Transmit */
-        struct sk_buff *skb;                    /* holds skb until xmit interrupt completes */
-        dma_addr_t skb_physaddr;                /* phys addr from pci_map_single */
-        int skb_length;                         /* saved skb length for pci_unmap_single */
-
-        /* Receive */
-        int rxBuffIndex;                        /* index into receive descriptor list */
-        struct recv_desc_bufs *dlist;           /* descriptor list address */
-        struct recv_desc_bufs *dlist_phys;      /* descriptor list physical address */
-};
-
-#endif
diff --git a/drivers/net/ethernet/cadence/macb.c b/drivers/net/ethernet/cadence/macb.c
index 033064b7b576..1fac769989ad 100644
--- a/drivers/net/ethernet/cadence/macb.c
+++ b/drivers/net/ethernet/cadence/macb.c
@@ -26,37 +26,79 @@
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/of_net.h>
+#include <linux/pinctrl/consumer.h>
 
 #include "macb.h"
 
 #define RX_BUFFER_SIZE          128
-#define RX_RING_SIZE            512
-#define RX_RING_BYTES           (sizeof(struct dma_desc) * RX_RING_SIZE)
+#define RX_RING_SIZE            512 /* must be power of 2 */
+#define RX_RING_BYTES           (sizeof(struct macb_dma_desc) * RX_RING_SIZE)
 
-/* Make the IP header word-aligned (the ethernet header is 14 bytes) */
-#define RX_OFFSET               2
-
-#define TX_RING_SIZE            128
-#define DEF_TX_RING_PENDING     (TX_RING_SIZE - 1)
-#define TX_RING_BYTES           (sizeof(struct dma_desc) * TX_RING_SIZE)
-
-#define TX_RING_GAP(bp)                                         \
-        (TX_RING_SIZE - (bp)->tx_pending)
-#define TX_BUFFS_AVAIL(bp)                                      \
-        (((bp)->tx_tail <= (bp)->tx_head) ?                     \
-         (bp)->tx_tail + (bp)->tx_pending - (bp)->tx_head :     \
-         (bp)->tx_tail - (bp)->tx_head - TX_RING_GAP(bp))
-#define NEXT_TX(n)              (((n) + 1) & (TX_RING_SIZE - 1))
-
-#define NEXT_RX(n)              (((n) + 1) & (RX_RING_SIZE - 1))
+#define TX_RING_SIZE            128 /* must be power of 2 */
+#define TX_RING_BYTES           (sizeof(struct macb_dma_desc) * TX_RING_SIZE)
 
 /* minimum number of free TX descriptors before waking up TX process */
 #define MACB_TX_WAKEUP_THRESH   (TX_RING_SIZE / 4)
 
 #define MACB_RX_INT_FLAGS       (MACB_BIT(RCOMP) | MACB_BIT(RXUBR)      \
                                  | MACB_BIT(ISR_ROVR))
+#define MACB_TX_ERR_FLAGS       (MACB_BIT(ISR_TUND)                     \
+                                        | MACB_BIT(ISR_RLE)             \
+                                        | MACB_BIT(TXERR))
+#define MACB_TX_INT_FLAGS       (MACB_TX_ERR_FLAGS | MACB_BIT(TCOMP))
+
+/*
+ * Graceful stop timeouts in us. We should allow up to
+ * 1 frame time (10 Mbits/s, full-duplex, ignoring collisions)
+ */
+#define MACB_HALT_TIMEOUT       1230
+
+/* Ring buffer accessors */
+static unsigned int macb_tx_ring_wrap(unsigned int index)
+{
+        return index & (TX_RING_SIZE - 1);
+}
+
+static unsigned int macb_tx_ring_avail(struct macb *bp)
+{
+        return (bp->tx_tail - bp->tx_head) & (TX_RING_SIZE - 1);
+}
+
+static struct macb_dma_desc *macb_tx_desc(struct macb *bp, unsigned int index)
+{
+        return &bp->tx_ring[macb_tx_ring_wrap(index)];
+}
+
+static struct macb_tx_skb *macb_tx_skb(struct macb *bp, unsigned int index)
+{
+        return &bp->tx_skb[macb_tx_ring_wrap(index)];
+}
+
+static dma_addr_t macb_tx_dma(struct macb *bp, unsigned int index)
+{
+        dma_addr_t offset;
+
+        offset = macb_tx_ring_wrap(index) * sizeof(struct macb_dma_desc);
+
+        return bp->tx_ring_dma + offset;
+}
+
+static unsigned int macb_rx_ring_wrap(unsigned int index)
+{
+        return index & (RX_RING_SIZE - 1);
+}
+
+static struct macb_dma_desc *macb_rx_desc(struct macb *bp, unsigned int index)
+{
+        return &bp->rx_ring[macb_rx_ring_wrap(index)];
+}
 
-static void __macb_set_hwaddr(struct macb *bp)
+static void *macb_rx_buffer(struct macb *bp, unsigned int index)
+{
+        return bp->rx_buffers + RX_BUFFER_SIZE * macb_rx_ring_wrap(index);
+}
+
+void macb_set_hwaddr(struct macb *bp)
 {
         u32 bottom;
         u16 top;
@@ -66,30 +108,49 @@ static void __macb_set_hwaddr(struct macb *bp)
         top = cpu_to_le16(*((u16 *)(bp->dev->dev_addr + 4)));
         macb_or_gem_writel(bp, SA1T, top);
 }
+EXPORT_SYMBOL_GPL(macb_set_hwaddr);
 
-static void __init macb_get_hwaddr(struct macb *bp)
+void macb_get_hwaddr(struct macb *bp)
 {
+        struct macb_platform_data *pdata;
         u32 bottom;
         u16 top;
         u8 addr[6];
+        int i;
 
-        bottom = macb_or_gem_readl(bp, SA1B);
-        top = macb_or_gem_readl(bp, SA1T);
+        pdata = bp->pdev->dev.platform_data;
 
-        addr[0] = bottom & 0xff;
-        addr[1] = (bottom >> 8) & 0xff;
-        addr[2] = (bottom >> 16) & 0xff;
-        addr[3] = (bottom >> 24) & 0xff;
-        addr[4] = top & 0xff;
-        addr[5] = (top >> 8) & 0xff;
+        /* Check all 4 address register for vaild address */
+        for (i = 0; i < 4; i++) {
+                bottom = macb_or_gem_readl(bp, SA1B + i * 8);
+                top = macb_or_gem_readl(bp, SA1T + i * 8);
+
+                if (pdata && pdata->rev_eth_addr) {
+                        addr[5] = bottom & 0xff;
+                        addr[4] = (bottom >> 8) & 0xff;
+                        addr[3] = (bottom >> 16) & 0xff;
+                        addr[2] = (bottom >> 24) & 0xff;
+                        addr[1] = top & 0xff;
+                        addr[0] = (top & 0xff00) >> 8;
+                } else {
+                        addr[0] = bottom & 0xff;
+                        addr[1] = (bottom >> 8) & 0xff;
+                        addr[2] = (bottom >> 16) & 0xff;
+                        addr[3] = (bottom >> 24) & 0xff;
+                        addr[4] = top & 0xff;
+                        addr[5] = (top >> 8) & 0xff;
+                }
 
-        if (is_valid_ether_addr(addr)) {
-                memcpy(bp->dev->dev_addr, addr, sizeof(addr));
-        } else {
-                netdev_info(bp->dev, "invalid hw address, using random\n");
-                eth_hw_addr_random(bp->dev);
+                if (is_valid_ether_addr(addr)) {
+                        memcpy(bp->dev->dev_addr, addr, sizeof(addr));
+                        return;
+                }
         }
+
+        netdev_info(bp->dev, "invalid hw address, using random\n");
+        eth_hw_addr_random(bp->dev);
 }
+EXPORT_SYMBOL_GPL(macb_get_hwaddr);
 
 static int macb_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
 {
@@ -152,13 +213,17 @@ static void macb_handle_link_change(struct net_device *dev)
 
                         reg = macb_readl(bp, NCFGR);
                         reg &= ~(MACB_BIT(SPD) | MACB_BIT(FD));
+                        if (macb_is_gem(bp))
+                                reg &= ~GEM_BIT(GBE);
 
                         if (phydev->duplex)
                                 reg |= MACB_BIT(FD);
                         if (phydev->speed == SPEED_100)
                                 reg |= MACB_BIT(SPD);
+                        if (phydev->speed == SPEED_1000)
+                                reg |= GEM_BIT(GBE);
 
-                        macb_writel(bp, NCFGR, reg);
+                        macb_or_gem_writel(bp, NCFGR, reg);
 
                         bp->speed = phydev->speed;
                         bp->duplex = phydev->duplex;
@@ -216,7 +281,10 @@ static int macb_mii_probe(struct net_device *dev)
         }
 
         /* mask with MAC supported features */
-        phydev->supported &= PHY_BASIC_FEATURES;
+        if (macb_is_gem(bp))
+                phydev->supported &= PHY_GBIT_FEATURES;
+        else
+                phydev->supported &= PHY_BASIC_FEATURES;
 
         phydev->advertising = phydev->supported;
 
@@ -228,7 +296,7 @@ static int macb_mii_probe(struct net_device *dev)
         return 0;
 }
 
-static int macb_mii_init(struct macb *bp)
+int macb_mii_init(struct macb *bp)
 {
         struct macb_platform_data *pdata;
         int err = -ENXIO, i;
@@ -284,6 +352,7 @@ err_out_free_mdiobus:
 err_out:
         return err;
 }
+EXPORT_SYMBOL_GPL(macb_mii_init);
 
 static void macb_update_stats(struct macb *bp)
 {
@@ -297,93 +366,147 @@ static void macb_update_stats(struct macb *bp)
                 *p += __raw_readl(reg);
 }
 
-static void macb_tx(struct macb *bp)
+static int macb_halt_tx(struct macb *bp)
 {
-        unsigned int tail;
-        unsigned int head;
-        u32 status;
+        unsigned long   halt_time, timeout;
+        u32             status;
 
-        status = macb_readl(bp, TSR);
-        macb_writel(bp, TSR, status);
+        macb_writel(bp, NCR, macb_readl(bp, NCR) | MACB_BIT(THALT));
 
-        netdev_dbg(bp->dev, "macb_tx status = %02lx\n", (unsigned long)status);
+        timeout = jiffies + usecs_to_jiffies(MACB_HALT_TIMEOUT);
+        do {
+                halt_time = jiffies;
+                status = macb_readl(bp, TSR);
+                if (!(status & MACB_BIT(TGO)))
+                        return 0;
 
-        if (status & (MACB_BIT(UND) | MACB_BIT(TSR_RLE))) {
-                int i;
-                netdev_err(bp->dev, "TX %s, resetting buffers\n",
-                           status & MACB_BIT(UND) ?
-                           "underrun" : "retry limit exceeded");
+                usleep_range(10, 250);
+        } while (time_before(halt_time, timeout));
 
-                /* Transfer ongoing, disable transmitter, to avoid confusion */
-                if (status & MACB_BIT(TGO))
-                        macb_writel(bp, NCR, macb_readl(bp, NCR) & ~MACB_BIT(TE));
+        return -ETIMEDOUT;
+}
 
-                head = bp->tx_head;
+static void macb_tx_error_task(struct work_struct *work)
+{
+        struct macb     *bp = container_of(work, struct macb, tx_error_task);
+        struct macb_tx_skb      *tx_skb;
+        struct sk_buff          *skb;
+        unsigned int            tail;
 
-                /*Mark all the buffer as used to avoid sending a lost buffer*/
-                for (i = 0; i < TX_RING_SIZE; i++)
-                        bp->tx_ring[i].ctrl = MACB_BIT(TX_USED);
+        netdev_vdbg(bp->dev, "macb_tx_error_task: t = %u, h = %u\n",
+                    bp->tx_tail, bp->tx_head);
 
-                /* Add wrap bit */
-                bp->tx_ring[TX_RING_SIZE - 1].ctrl |= MACB_BIT(TX_WRAP);
+        /* Make sure nobody is trying to queue up new packets */
+        netif_stop_queue(bp->dev);
 
-                /* free transmit buffer in upper layer*/
-                for (tail = bp->tx_tail; tail != head; tail = NEXT_TX(tail)) {
-                        struct ring_info *rp = &bp->tx_skb[tail];
-                        struct sk_buff *skb = rp->skb;
+        /*
+         * Stop transmission now
+         * (in case we have just queued new packets)
+         */
+        if (macb_halt_tx(bp))
+                /* Just complain for now, reinitializing TX path can be good */
+                netdev_err(bp->dev, "BUG: halt tx timed out\n");
 
-                        BUG_ON(skb == NULL);
+        /* No need for the lock here as nobody will interrupt us anymore */
 
-                        rmb();
+        /*
+         * Treat frames in TX queue including the ones that caused the error.
+         * Free transmit buffers in upper layer.
+         */
+        for (tail = bp->tx_tail; tail != bp->tx_head; tail++) {
+                struct macb_dma_desc    *desc;
+                u32                     ctrl;
+
+                desc = macb_tx_desc(bp, tail);
+                ctrl = desc->ctrl;
+                tx_skb = macb_tx_skb(bp, tail);
+                skb = tx_skb->skb;
+
+                if (ctrl & MACB_BIT(TX_USED)) {
+                        netdev_vdbg(bp->dev, "txerr skb %u (data %p) TX complete\n",
+                                    macb_tx_ring_wrap(tail), skb->data);
+                        bp->stats.tx_packets++;
+                        bp->stats.tx_bytes += skb->len;
+                } else {
+                        /*
+                         * "Buffers exhausted mid-frame" errors may only happen
+                         * if the driver is buggy, so complain loudly about those.
+                         * Statistics are updated by hardware.
+                         */
+                        if (ctrl & MACB_BIT(TX_BUF_EXHAUSTED))
+                                netdev_err(bp->dev,
+                                           "BUG: TX buffers exhausted mid-frame\n");
 
-                        dma_unmap_single(&bp->pdev->dev, rp->mapping, skb->len,
-                                                         DMA_TO_DEVICE);
-                        rp->skb = NULL;
-                        dev_kfree_skb_irq(skb);
+                        desc->ctrl = ctrl | MACB_BIT(TX_USED);
                 }
 
-                bp->tx_head = bp->tx_tail = 0;
-
-                /* Enable the transmitter again */
-                if (status & MACB_BIT(TGO))
-                        macb_writel(bp, NCR, macb_readl(bp, NCR) | MACB_BIT(TE));
+                dma_unmap_single(&bp->pdev->dev, tx_skb->mapping, skb->len,
+                                 DMA_TO_DEVICE);
+                tx_skb->skb = NULL;
+                dev_kfree_skb(skb);
         }
 
-        if (!(status & MACB_BIT(COMP)))
-                /*
-                 * This may happen when a buffer becomes complete
-                 * between reading the ISR and scanning the
-                 * descriptors.  Nothing to worry about.
-                 */
-                return;
+        /* Make descriptor updates visible to hardware */
+        wmb();
+
+        /* Reinitialize the TX desc queue */
+        macb_writel(bp, TBQP, bp->tx_ring_dma);
+        /* Make TX ring reflect state of hardware */
+        bp->tx_head = bp->tx_tail = 0;
+
+        /* Now we are ready to start transmission again */
+        netif_wake_queue(bp->dev);
+
+        /* Housework before enabling TX IRQ */
+        macb_writel(bp, TSR, macb_readl(bp, TSR));
+        macb_writel(bp, IER, MACB_TX_INT_FLAGS);
+}
+
+static void macb_tx_interrupt(struct macb *bp)
+{
+        unsigned int tail;
+        unsigned int head;
+        u32 status;
+
+        status = macb_readl(bp, TSR);
+        macb_writel(bp, TSR, status);
+
+        netdev_vdbg(bp->dev, "macb_tx_interrupt status = 0x%03lx\n",
+                (unsigned long)status);
 
         head = bp->tx_head;
-        for (tail = bp->tx_tail; tail != head; tail = NEXT_TX(tail)) {
-                struct ring_info *rp = &bp->tx_skb[tail];
-                struct sk_buff *skb = rp->skb;
-                u32 bufstat;
+        for (tail = bp->tx_tail; tail != head; tail++) {
+                struct macb_tx_skb      *tx_skb;
+                struct sk_buff          *skb;
+                struct macb_dma_desc    *desc;
+                u32                     ctrl;
 
-                BUG_ON(skb == NULL);
+                desc = macb_tx_desc(bp, tail);
 
+                /* Make hw descriptor updates visible to CPU */
                 rmb();
-                bufstat = bp->tx_ring[tail].ctrl;
 
-                if (!(bufstat & MACB_BIT(TX_USED)))
+                ctrl = desc->ctrl;
+
+                if (!(ctrl & MACB_BIT(TX_USED)))
                         break;
 
-                netdev_dbg(bp->dev, "skb %u (data %p) TX complete\n",
-                           tail, skb->data);
-                dma_unmap_single(&bp->pdev->dev, rp->mapping, skb->len,
+                tx_skb = macb_tx_skb(bp, tail);
+                skb = tx_skb->skb;
+
+                netdev_vdbg(bp->dev, "skb %u (data %p) TX complete\n",
+                        macb_tx_ring_wrap(tail), skb->data);
+                dma_unmap_single(&bp->pdev->dev, tx_skb->mapping, skb->len,
                                  DMA_TO_DEVICE);
                 bp->stats.tx_packets++;
                 bp->stats.tx_bytes += skb->len;
-                rp->skb = NULL;
+                tx_skb->skb = NULL;
                 dev_kfree_skb_irq(skb);
         }
 
         bp->tx_tail = tail;
-        if (netif_queue_stopped(bp->dev) &&
-            TX_BUFFS_AVAIL(bp) > MACB_TX_WAKEUP_THRESH)
+        if (netif_queue_stopped(bp->dev)
+                        && macb_tx_ring_avail(bp) > MACB_TX_WAKEUP_THRESH)
                 netif_wake_queue(bp->dev);
 }
 
@@ -392,31 +515,48 @@ static int macb_rx_frame(struct macb *bp, unsigned int first_frag,
 {
         unsigned int len;
         unsigned int frag;
-        unsigned int offset = 0;
+        unsigned int offset;
         struct sk_buff *skb;
+        struct macb_dma_desc *desc;
 
-        len = MACB_BFEXT(RX_FRMLEN, bp->rx_ring[last_frag].ctrl);
+        desc = macb_rx_desc(bp, last_frag);
+        len = MACB_BFEXT(RX_FRMLEN, desc->ctrl);
 
-        netdev_dbg(bp->dev, "macb_rx_frame frags %u - %u (len %u)\n",
-                   first_frag, last_frag, len);
+        netdev_vdbg(bp->dev, "macb_rx_frame frags %u - %u (len %u)\n",
+                macb_rx_ring_wrap(first_frag),
+                macb_rx_ring_wrap(last_frag), len);
 
-        skb = netdev_alloc_skb(bp->dev, len + RX_OFFSET);
+        /*
+         * The ethernet header starts NET_IP_ALIGN bytes into the
+         * first buffer. Since the header is 14 bytes, this makes the
+         * payload word-aligned.
+         *
+         * Instead of calling skb_reserve(NET_IP_ALIGN), we just copy
+         * the two padding bytes into the skb so that we avoid hitting
+         * the slowpath in memcpy(), and pull them off afterwards.
+         */
+        skb = netdev_alloc_skb(bp->dev, len + NET_IP_ALIGN);
         if (!skb) {
                 bp->stats.rx_dropped++;
-                for (frag = first_frag; ; frag = NEXT_RX(frag)) {
-                        bp->rx_ring[frag].addr &= ~MACB_BIT(RX_USED);
+                for (frag = first_frag; ; frag++) {
+                        desc = macb_rx_desc(bp, frag);
+                        desc->addr &= ~MACB_BIT(RX_USED);
                         if (frag == last_frag)
                                 break;
                 }
+
+                /* Make descriptor updates visible to hardware */
                 wmb();
+
                 return 1;
         }
 
-        skb_reserve(skb, RX_OFFSET);
+        offset = 0;
+        len += NET_IP_ALIGN;
         skb_checksum_none_assert(skb);
         skb_put(skb, len);
 
-        for (frag = first_frag; ; frag = NEXT_RX(frag)) {
+        for (frag = first_frag; ; frag++) {
                 unsigned int frag_len = RX_BUFFER_SIZE;
 
                 if (offset + frag_len > len) {
@@ -424,22 +564,24 @@ static int macb_rx_frame(struct macb *bp, unsigned int first_frag,
                         frag_len = len - offset;
                 }
                 skb_copy_to_linear_data_offset(skb, offset,
-                                               (bp->rx_buffers +
-                                                (RX_BUFFER_SIZE * frag)),
-                                               frag_len);
+                                macb_rx_buffer(bp, frag), frag_len);
                 offset += RX_BUFFER_SIZE;
-                bp->rx_ring[frag].addr &= ~MACB_BIT(RX_USED);
-                wmb();
+                desc = macb_rx_desc(bp, frag);
+                desc->addr &= ~MACB_BIT(RX_USED);
 
                 if (frag == last_frag)
                         break;
         }
 
+        /* Make descriptor updates visible to hardware */
+        wmb();
+
+        __skb_pull(skb, NET_IP_ALIGN);
         skb->protocol = eth_type_trans(skb, bp->dev);
 
         bp->stats.rx_packets++;
-        bp->stats.rx_bytes += len;
-        netdev_dbg(bp->dev, "received skb of length %u, csum: %08x\n",
+        bp->stats.rx_bytes += skb->len;
+        netdev_vdbg(bp->dev, "received skb of length %u, csum: %08x\n",
                    skb->len, skb->csum);
         netif_receive_skb(skb);
 
@@ -452,8 +594,12 @@ static void discard_partial_frame(struct macb *bp, unsigned int begin,
 {
         unsigned int frag;
 
-        for (frag = begin; frag != end; frag = NEXT_RX(frag))
-                bp->rx_ring[frag].addr &= ~MACB_BIT(RX_USED);
+        for (frag = begin; frag != end; frag++) {
+                struct macb_dma_desc *desc = macb_rx_desc(bp, frag);
+                desc->addr &= ~MACB_BIT(RX_USED);
+        }
+
+        /* Make descriptor updates visible to hardware */
         wmb();
 
         /*
@@ -466,15 +612,18 @@ static void discard_partial_frame(struct macb *bp, unsigned int begin,
 static int macb_rx(struct macb *bp, int budget)
 {
         int received = 0;
-        unsigned int tail = bp->rx_tail;
+        unsigned int tail;
         int first_frag = -1;
 
-        for (; budget > 0; tail = NEXT_RX(tail)) {
+        for (tail = bp->rx_tail; budget > 0; tail++) {
+                struct macb_dma_desc *desc = macb_rx_desc(bp, tail);
                 u32 addr, ctrl;
 
+                /* Make hw descriptor updates visible to CPU */
                 rmb();
-                addr = bp->rx_ring[tail].addr;
-                ctrl = bp->rx_ring[tail].ctrl;
+
+                addr = desc->addr;
+                ctrl = desc->ctrl;
 
                 if (!(addr & MACB_BIT(RX_USED)))
                         break;
@@ -517,7 +666,7 @@ static int macb_poll(struct napi_struct *napi, int budget)
 
         work_done = 0;
 
-        netdev_dbg(bp->dev, "poll: status = %08lx, budget = %d\n",
+        netdev_vdbg(bp->dev, "poll: status = %08lx, budget = %d\n",
                    (unsigned long)status, budget);
 
         work_done = macb_rx(bp, budget);
@@ -552,10 +701,12 @@ static irqreturn_t macb_interrupt(int irq, void *dev_id)
         while (status) {
                 /* close possible race with dev_close */
                 if (unlikely(!netif_running(dev))) {
-                        macb_writel(bp, IDR, ~0UL);
+                        macb_writel(bp, IDR, -1);
                         break;
                 }
 
+                netdev_vdbg(bp->dev, "isr = 0x%08lx\n", (unsigned long)status);
+
                 if (status & MACB_RX_INT_FLAGS) {
                         /*
                          * There's no point taking any more interrupts
@@ -567,14 +718,19 @@ static irqreturn_t macb_interrupt(int irq, void *dev_id)
                         macb_writel(bp, IDR, MACB_RX_INT_FLAGS);
 
                         if (napi_schedule_prep(&bp->napi)) {
-                                netdev_dbg(bp->dev, "scheduling RX softirq\n");
+                                netdev_vdbg(bp->dev, "scheduling RX softirq\n");
                                 __napi_schedule(&bp->napi);
                         }
                 }
 
-                if (status & (MACB_BIT(TCOMP) | MACB_BIT(ISR_TUND) |
-                            MACB_BIT(ISR_RLE)))
-                        macb_tx(bp);
+                if (unlikely(status & (MACB_TX_ERR_FLAGS))) {
+                        macb_writel(bp, IDR, MACB_TX_INT_FLAGS);
+                        schedule_work(&bp->tx_error_task);
+                        break;
+                }
+
+                if (status & MACB_BIT(TCOMP))
+                        macb_tx_interrupt(bp);
 
                 /*
                  * Link change detection isn't possible with RMII, so we'll
@@ -626,11 +782,13 @@ static int macb_start_xmit(struct sk_buff *skb, struct net_device *dev)
         struct macb *bp = netdev_priv(dev);
         dma_addr_t mapping;
         unsigned int len, entry;
+        struct macb_dma_desc *desc;
+        struct macb_tx_skb *tx_skb;
         u32 ctrl;
         unsigned long flags;
 
-#ifdef DEBUG
-        netdev_dbg(bp->dev,
+#if defined(DEBUG) && defined(VERBOSE_DEBUG)
+        netdev_vdbg(bp->dev,
                    "start_xmit: len %u head %p data %p tail %p end %p\n",
                    skb->len, skb->head, skb->data,
                    skb_tail_pointer(skb), skb_end_pointer(skb));
@@ -642,7 +800,7 @@ static int macb_start_xmit(struct sk_buff *skb, struct net_device *dev)
         spin_lock_irqsave(&bp->lock, flags);
 
         /* This is a hard error, log it. */
-        if (TX_BUFFS_AVAIL(bp) < 1) {
+        if (macb_tx_ring_avail(bp) < 1) {
                 netif_stop_queue(dev);
                 spin_unlock_irqrestore(&bp->lock, flags);
                 netdev_err(bp->dev, "BUG! Tx Ring full when queue awake!\n");
@@ -651,13 +809,16 @@ static int macb_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 return NETDEV_TX_BUSY;
         }
 
-        entry = bp->tx_head;
-        netdev_dbg(bp->dev, "Allocated ring entry %u\n", entry);
+        entry = macb_tx_ring_wrap(bp->tx_head);
+        bp->tx_head++;
+        netdev_vdbg(bp->dev, "Allocated ring entry %u\n", entry);
         mapping = dma_map_single(&bp->pdev->dev, skb->data,
                                  len, DMA_TO_DEVICE);
-        bp->tx_skb[entry].skb = skb;
-        bp->tx_skb[entry].mapping = mapping;
-        netdev_dbg(bp->dev, "Mapped skb data %p to DMA addr %08lx\n",
+
+        tx_skb = &bp->tx_skb[entry];
+        tx_skb->skb = skb;
+        tx_skb->mapping = mapping;
+        netdev_vdbg(bp->dev, "Mapped skb data %p to DMA addr %08lx\n",
                    skb->data, (unsigned long)mapping);
 
         ctrl = MACB_BF(TX_FRMLEN, len);
@@ -665,18 +826,18 @@ static int macb_start_xmit(struct sk_buff *skb, struct net_device *dev)
         if (entry == (TX_RING_SIZE - 1))
                 ctrl |= MACB_BIT(TX_WRAP);
 
-        bp->tx_ring[entry].addr = mapping;
-        bp->tx_ring[entry].ctrl = ctrl;
-        wmb();
+        desc = &bp->tx_ring[entry];
+        desc->addr = mapping;
+        desc->ctrl = ctrl;
 
-        entry = NEXT_TX(entry);
-        bp->tx_head = entry;
+        /* Make newly initialized descriptor visible to hardware */
+        wmb();
 
         skb_tx_timestamp(skb);
 
         macb_writel(bp, NCR, macb_readl(bp, NCR) | MACB_BIT(TSTART));
 
-        if (TX_BUFFS_AVAIL(bp) < 1)
+        if (macb_tx_ring_avail(bp) < 1)
                 netif_stop_queue(dev);
 
         spin_unlock_irqrestore(&bp->lock, flags);
@@ -712,7 +873,7 @@ static int macb_alloc_consistent(struct macb *bp)
 {
         int size;
 
-        size = TX_RING_SIZE * sizeof(struct ring_info);
+        size = TX_RING_SIZE * sizeof(struct macb_tx_skb);
         bp->tx_skb = kmalloc(size, GFP_KERNEL);
         if (!bp->tx_skb)
                 goto out_err;
@@ -775,9 +936,6 @@ static void macb_init_rings(struct macb *bp)
 
 static void macb_reset_hw(struct macb *bp)
 {
-        /* Make sure we have the write buffer for ourselves */
-        wmb();
-
         /*
          * Disable RX and TX (XXX: Should we halt the transmission
          * more gracefully?)
@@ -788,11 +946,11 @@ static void macb_reset_hw(struct macb *bp)
         macb_writel(bp, NCR, MACB_BIT(CLRSTAT));
 
         /* Clear all status flags */
-        macb_writel(bp, TSR, ~0UL);
-        macb_writel(bp, RSR, ~0UL);
+        macb_writel(bp, TSR, -1);
+        macb_writel(bp, RSR, -1);
 
         /* Disable all interrupts */
-        macb_writel(bp, IDR, ~0UL);
+        macb_writel(bp, IDR, -1);
         macb_readl(bp, ISR);
 }
 
@@ -879,9 +1037,10 @@ static void macb_init_hw(struct macb *bp)
         u32 config;
 
         macb_reset_hw(bp);
-        __macb_set_hwaddr(bp);
+        macb_set_hwaddr(bp);
 
         config = macb_mdc_clk_div(bp);
+        config |= MACB_BF(RBOF, NET_IP_ALIGN);  /* Make eth data aligned */
         config |= MACB_BIT(PAE);                /* PAuse Enable */
         config |= MACB_BIT(DRFCS);              /* Discard Rx FCS */
         config |= MACB_BIT(BIG);                /* Receive oversized frames */
@@ -891,6 +1050,8 @@ static void macb_init_hw(struct macb *bp)
                 config |= MACB_BIT(NBC);        /* No BroadCast */
         config |= macb_dbw(bp);
         macb_writel(bp, NCFGR, config);
+        bp->speed = SPEED_10;
+        bp->duplex = DUPLEX_HALF;
 
         macb_configure_dma(bp);
 
@@ -902,13 +1063,8 @@ static void macb_init_hw(struct macb *bp)
         macb_writel(bp, NCR, MACB_BIT(RE) | MACB_BIT(TE) | MACB_BIT(MPE));
 
         /* Enable interrupts */
-        macb_writel(bp, IER, (MACB_BIT(RCOMP)
-                              | MACB_BIT(RXUBR)
-                              | MACB_BIT(ISR_TUND)
-                              | MACB_BIT(ISR_RLE)
-                              | MACB_BIT(TXERR)
-                              | MACB_BIT(TCOMP)
-                              | MACB_BIT(ISR_ROVR)
+        macb_writel(bp, IER, (MACB_RX_INT_FLAGS
+                              | MACB_TX_INT_FLAGS
                               | MACB_BIT(HRESP)));
 
 }
@@ -996,7 +1152,7 @@ static void macb_sethashtable(struct net_device *dev)
 /*
  * Enable/Disable promiscuous and multicast modes.
  */
-static void macb_set_rx_mode(struct net_device *dev)
+void macb_set_rx_mode(struct net_device *dev)
 {
         unsigned long cfg;
         struct macb *bp = netdev_priv(dev);
@@ -1028,6 +1184,7 @@ static void macb_set_rx_mode(struct net_device *dev)
 
         macb_writel(bp, NCFGR, cfg);
 }
+EXPORT_SYMBOL_GPL(macb_set_rx_mode);
 
 static int macb_open(struct net_device *dev)
 {
@@ -1135,7 +1292,7 @@ static struct net_device_stats *gem_get_stats(struct macb *bp)
         return nstat;
 }
 
-static struct net_device_stats *macb_get_stats(struct net_device *dev)
+struct net_device_stats *macb_get_stats(struct net_device *dev)
 {
         struct macb *bp = netdev_priv(dev);
         struct net_device_stats *nstat = &bp->stats;
@@ -1181,6 +1338,7 @@ static struct net_device_stats *macb_get_stats(struct net_device *dev)
 
         return nstat;
 }
+EXPORT_SYMBOL_GPL(macb_get_stats);
 
 static int macb_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
@@ -1204,25 +1362,55 @@ static int macb_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
         return phy_ethtool_sset(phydev, cmd);
 }
 
-static void macb_get_drvinfo(struct net_device *dev,
-                             struct ethtool_drvinfo *info)
+static int macb_get_regs_len(struct net_device *netdev)
+{
+        return MACB_GREGS_NBR * sizeof(u32);
+}
+
+static void macb_get_regs(struct net_device *dev, struct ethtool_regs *regs,
+                          void *p)
 {
         struct macb *bp = netdev_priv(dev);
+        unsigned int tail, head;
+        u32 *regs_buff = p;
+
+        regs->version = (macb_readl(bp, MID) & ((1 << MACB_REV_SIZE) - 1))
+                        | MACB_GREGS_VERSION;
+
+        tail = macb_tx_ring_wrap(bp->tx_tail);
+        head = macb_tx_ring_wrap(bp->tx_head);
+
+        regs_buff[0]  = macb_readl(bp, NCR);
+        regs_buff[1]  = macb_or_gem_readl(bp, NCFGR);
+        regs_buff[2]  = macb_readl(bp, NSR);
+        regs_buff[3]  = macb_readl(bp, TSR);
+        regs_buff[4]  = macb_readl(bp, RBQP);
+        regs_buff[5]  = macb_readl(bp, TBQP);
+        regs_buff[6]  = macb_readl(bp, RSR);
+        regs_buff[7]  = macb_readl(bp, IMR);
 
-        strcpy(info->driver, bp->pdev->dev.driver->name);
-        strcpy(info->version, "$Revision: 1.14 $");
-        strcpy(info->bus_info, dev_name(&bp->pdev->dev));
+        regs_buff[8]  = tail;
+        regs_buff[9]  = head;
+        regs_buff[10] = macb_tx_dma(bp, tail);
+        regs_buff[11] = macb_tx_dma(bp, head);
+
+        if (macb_is_gem(bp)) {
+                regs_buff[12] = gem_readl(bp, USRIO);
+                regs_buff[13] = gem_readl(bp, DMACFG);
+        }
 }
 
-static const struct ethtool_ops macb_ethtool_ops = {
+const struct ethtool_ops macb_ethtool_ops = {
         .get_settings           = macb_get_settings,
         .set_settings           = macb_set_settings,
-        .get_drvinfo            = macb_get_drvinfo,
+        .get_regs_len           = macb_get_regs_len,
+        .get_regs               = macb_get_regs,
         .get_link               = ethtool_op_get_link,
         .get_ts_info            = ethtool_op_get_ts_info,
 };
+EXPORT_SYMBOL_GPL(macb_ethtool_ops);
 
-static int macb_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
+int macb_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
         struct macb *bp = netdev_priv(dev);
         struct phy_device *phydev = bp->phy_dev;
@@ -1235,6 +1423,7 @@ static int macb_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 
         return phy_mii_ioctl(phydev, rq, cmd);
 }
+EXPORT_SYMBOL_GPL(macb_ioctl);
 
 static const struct net_device_ops macb_netdev_ops = {
         .ndo_open               = macb_open,
@@ -1306,6 +1495,7 @@ static int __init macb_probe(struct platform_device *pdev)
         struct phy_device *phydev;
         u32 config;
         int err = -ENXIO;
+        struct pinctrl *pinctrl;
 
         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!regs) {
@@ -1313,6 +1503,15 @@ static int __init macb_probe(struct platform_device *pdev)
                 goto err_out;
         }
 
+        pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
+        if (IS_ERR(pinctrl)) {
+                err = PTR_ERR(pinctrl);
+                if (err == -EPROBE_DEFER)
+                        goto err_out;
+
+                dev_warn(&pdev->dev, "No pinctrl provided\n");
+        }
+
         err = -ENOMEM;
         dev = alloc_etherdev(sizeof(*bp));
         if (!dev)
@@ -1328,6 +1527,7 @@ static int __init macb_probe(struct platform_device *pdev)
         bp->dev = dev;
 
         spin_lock_init(&bp->lock);
+        INIT_WORK(&bp->tx_error_task, macb_tx_error_task);
 
         bp->pclk = clk_get(&pdev->dev, "pclk");
         if (IS_ERR(bp->pclk)) {
@@ -1384,7 +1584,9 @@ static int __init macb_probe(struct platform_device *pdev)
                 bp->phy_interface = err;
         }
 
-        if (bp->phy_interface == PHY_INTERFACE_MODE_RMII)
+        if (bp->phy_interface == PHY_INTERFACE_MODE_RGMII)
+                macb_or_gem_writel(bp, USRIO, GEM_BIT(RGMII));
+        else if (bp->phy_interface == PHY_INTERFACE_MODE_RMII)
 #if defined(CONFIG_ARCH_AT91)
                 macb_or_gem_writel(bp, USRIO, (MACB_BIT(RMII) |
                                                MACB_BIT(CLKEN)));
@@ -1398,8 +1600,6 @@ static int __init macb_probe(struct platform_device *pdev)
                 macb_or_gem_writel(bp, USRIO, MACB_BIT(MII));
 #endif
 
-        bp->tx_pending = DEF_TX_RING_PENDING;
-
         err = register_netdev(dev);
         if (err) {
                 dev_err(&pdev->dev, "Cannot register net device, aborting.\n");
diff --git a/drivers/net/ethernet/cadence/macb.h b/drivers/net/ethernet/cadence/macb.h
index 335e288f5314..864e38042b2d 100644
--- a/drivers/net/ethernet/cadence/macb.h
+++ b/drivers/net/ethernet/cadence/macb.h
@@ -10,10 +10,15 @@
 #ifndef _MACB_H
 #define _MACB_H
 
+#define MACB_GREGS_NBR 16
+#define MACB_GREGS_VERSION 1
+
 /* MACB register offsets */
 #define MACB_NCR                                0x0000
 #define MACB_NCFGR                              0x0004
 #define MACB_NSR                                0x0008
+#define MACB_TAR                                0x000c /* AT91RM9200 only */
+#define MACB_TCR                                0x0010 /* AT91RM9200 only */
 #define MACB_TSR                                0x0014
 #define MACB_RBQP                               0x0018
 #define MACB_TBQP                               0x001c
@@ -133,6 +138,8 @@
 #define MACB_RTY_SIZE                           1
 #define MACB_PAE_OFFSET                         13
 #define MACB_PAE_SIZE                           1
+#define MACB_RM9200_RMII_OFFSET                 13 /* AT91RM9200 only */
+#define MACB_RM9200_RMII_SIZE                   1  /* AT91RM9200 only */
 #define MACB_RBOF_OFFSET                        14
 #define MACB_RBOF_SIZE                          2
 #define MACB_RLCE_OFFSET                        16
@@ -145,6 +152,8 @@
 #define MACB_IRXFCS_SIZE                        1
 
 /* GEM specific NCFGR bitfields. */
+#define GEM_GBE_OFFSET                          10
+#define GEM_GBE_SIZE                            1
 #define GEM_CLK_OFFSET                          18
 #define GEM_CLK_SIZE                            3
 #define GEM_DBW_OFFSET                          21
@@ -178,6 +187,8 @@
 #define MACB_TGO_SIZE                           1
 #define MACB_BEX_OFFSET                         4
 #define MACB_BEX_SIZE                           1
+#define MACB_RM9200_BNQ_OFFSET                  4 /* AT91RM9200 only */
+#define MACB_RM9200_BNQ_SIZE                    1 /* AT91RM9200 only */
 #define MACB_COMP_OFFSET                        5
 #define MACB_COMP_SIZE                          1
 #define MACB_UND_OFFSET                         6
@@ -246,6 +257,8 @@
 /* Bitfields in USRIO (AT91) */
 #define MACB_RMII_OFFSET                        0
 #define MACB_RMII_SIZE                          1
+#define GEM_RGMII_OFFSET                        0       /* GEM gigabit mode */
+#define GEM_RGMII_SIZE                          1
 #define MACB_CLKEN_OFFSET                       1
 #define MACB_CLKEN_SIZE                         1
 
@@ -352,7 +365,12 @@
                 __v; \
         })
 
-struct dma_desc {
+/**
+ * struct macb_dma_desc - Hardware DMA descriptor
+ * @addr: DMA address of data buffer
+ * @ctrl: Control and status bits
+ */
+struct macb_dma_desc {
         u32     addr;
         u32     ctrl;
 };
@@ -417,7 +435,12 @@ struct dma_desc {
 #define MACB_TX_USED_OFFSET                     31
 #define MACB_TX_USED_SIZE                       1
 
-struct ring_info {
+/**
+ * struct macb_tx_skb - data about an skb which is being transmitted
+ * @skb: skb currently being transmitted
+ * @mapping: DMA address of the skb's data buffer
+ */
+struct macb_tx_skb {
         struct sk_buff          *skb;
         dma_addr_t              mapping;
 };
@@ -502,12 +525,12 @@ struct macb {
         void __iomem            *regs;
 
         unsigned int            rx_tail;
-        struct dma_desc         *rx_ring;
+        struct macb_dma_desc    *rx_ring;
         void                    *rx_buffers;
 
         unsigned int            tx_head, tx_tail;
-        struct dma_desc         *tx_ring;
-        struct ring_info        *tx_skb;
+        struct macb_dma_desc    *tx_ring;
+        struct macb_tx_skb      *tx_skb;
 
         spinlock_t              lock;
         struct platform_device  *pdev;
@@ -515,6 +538,7 @@ struct macb {
         struct clk              *hclk;
         struct net_device       *dev;
         struct napi_struct      napi;
+        struct work_struct      tx_error_task;
         struct net_device_stats stats;
         union {
                 struct macb_stats       macb;
@@ -525,8 +549,6 @@ struct macb {
         dma_addr_t              tx_ring_dma;
         dma_addr_t              rx_buffers_dma;
 
-        unsigned int            rx_pending, tx_pending;
-
         struct mii_bus          *mii_bus;
         struct phy_device       *phy_dev;
         unsigned int            link;
@@ -534,8 +556,22 @@ struct macb {
         unsigned int            duplex;
 
         phy_interface_t         phy_interface;
+
+        /* AT91RM9200 transmit */
+        struct sk_buff *skb;                    /* holds skb until xmit interrupt completes */
+        dma_addr_t skb_physaddr;                /* phys addr from pci_map_single */
+        int skb_length;                         /* saved skb length for pci_unmap_single */
 };
 
+extern const struct ethtool_ops macb_ethtool_ops;
+
+int macb_mii_init(struct macb *bp);
+int macb_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
+struct net_device_stats *macb_get_stats(struct net_device *dev);
+void macb_set_rx_mode(struct net_device *dev);
+void macb_set_hwaddr(struct macb *bp);
+void macb_get_hwaddr(struct macb *bp);
+
 static inline bool macb_is_gem(struct macb *bp)
 {
         return MACB_BFEXT(IDNUM, macb_readl(bp, MID)) == 0x2;
diff --git a/drivers/net/ethernet/calxeda/xgmac.c b/drivers/net/ethernet/calxeda/xgmac.c
index 16814b34d4b6..b407043ce9b0 100644
--- a/drivers/net/ethernet/calxeda/xgmac.c
+++ b/drivers/net/ethernet/calxeda/xgmac.c
@@ -191,6 +191,7 @@
 #define DMA_CONTROL_ST          0x00002000      /* Start/Stop Transmission */
 #define DMA_CONTROL_SR          0x00000002      /* Start/Stop Receive */
 #define DMA_CONTROL_DFF         0x01000000      /* Disable flush of rx frames */
+#define DMA_CONTROL_OSF         0x00000004      /* Operate on 2nd tx frame */
 
 /* DMA Normal interrupt */
 #define DMA_INTR_ENA_NIE        0x00010000      /* Normal Summary */
@@ -210,7 +211,7 @@
 #define DMA_INTR_ENA_TIE        0x00000001      /* Transmit Interrupt */
 
 #define DMA_INTR_NORMAL         (DMA_INTR_ENA_NIE | DMA_INTR_ENA_RIE | \
-                                 DMA_INTR_ENA_TUE)
+                                 DMA_INTR_ENA_TUE | DMA_INTR_ENA_TIE)
 
 #define DMA_INTR_ABNORMAL       (DMA_INTR_ENA_AIE | DMA_INTR_ENA_FBE | \
                                  DMA_INTR_ENA_RWE | DMA_INTR_ENA_RSE | \
@@ -373,6 +374,7 @@ struct xgmac_priv {
         struct sk_buff **tx_skbuff;
         unsigned int tx_head;
         unsigned int tx_tail;
+        int tx_irq_cnt;
 
         void __iomem *base;
         unsigned int dma_buf_sz;
@@ -663,6 +665,7 @@ static void xgmac_rx_refill(struct xgmac_priv *priv)
 {
         struct xgmac_dma_desc *p;
         dma_addr_t paddr;
+        int bufsz = priv->dev->mtu + ETH_HLEN + ETH_FCS_LEN;
 
         while (dma_ring_space(priv->rx_head, priv->rx_tail, DMA_RX_RING_SZ) > 1) {
                 int entry = priv->rx_head;
@@ -671,13 +674,13 @@ static void xgmac_rx_refill(struct xgmac_priv *priv)
                 p = priv->dma_rx + entry;
 
                 if (priv->rx_skbuff[entry] == NULL) {
-                        skb = netdev_alloc_skb(priv->dev, priv->dma_buf_sz);
+                        skb = netdev_alloc_skb_ip_align(priv->dev, bufsz);
                         if (unlikely(skb == NULL))
                                 break;
 
                         priv->rx_skbuff[entry] = skb;
                         paddr = dma_map_single(priv->device, skb->data,
-                                               priv->dma_buf_sz, DMA_FROM_DEVICE);
+                                               bufsz, DMA_FROM_DEVICE);
                         desc_set_buf_addr(p, paddr, priv->dma_buf_sz);
                 }
 
@@ -701,10 +704,10 @@ static int xgmac_dma_desc_rings_init(struct net_device *dev)
         unsigned int bfsize;
 
         /* Set the Buffer size according to the MTU;
-         * indeed, in case of jumbo we need to bump-up the buffer sizes.
+         * The total buffer size including any IP offset must be a multiple
+         * of 8 bytes.
          */
-        bfsize = ALIGN(dev->mtu + ETH_HLEN + ETH_FCS_LEN + NET_IP_ALIGN + 64,
-                       64);
+        bfsize = ALIGN(dev->mtu + ETH_HLEN + ETH_FCS_LEN + NET_IP_ALIGN, 8);
 
         netdev_dbg(priv->dev, "mtu [%d] bfsize [%d]\n", dev->mtu, bfsize);
 
@@ -845,9 +848,6 @@ static void xgmac_free_dma_desc_rings(struct xgmac_priv *priv)
 static void xgmac_tx_complete(struct xgmac_priv *priv)
 {
         int i;
-        void __iomem *ioaddr = priv->base;
-
-        writel(DMA_STATUS_TU | DMA_STATUS_NIS, ioaddr + XGMAC_DMA_STATUS);
 
         while (dma_ring_cnt(priv->tx_head, priv->tx_tail, DMA_TX_RING_SZ)) {
                 unsigned int entry = priv->tx_tail;
@@ -888,7 +888,7 @@ static void xgmac_tx_complete(struct xgmac_priv *priv)
         }
 
         if (dma_ring_space(priv->tx_head, priv->tx_tail, DMA_TX_RING_SZ) >
-            TX_THRESH)
+            MAX_SKB_FRAGS)
                 netif_wake_queue(priv->dev);
 }
 
@@ -965,8 +965,7 @@ static int xgmac_hw_init(struct net_device *dev)
                 ctrl |= XGMAC_CONTROL_IPC;
         writel(ctrl, ioaddr + XGMAC_CONTROL);
 
-        value = DMA_CONTROL_DFF;
-        writel(value, ioaddr + XGMAC_DMA_CONTROL);
+        writel(DMA_CONTROL_OSF, ioaddr + XGMAC_DMA_CONTROL);
 
         /* Set the HW DMA mode and the COE */
         writel(XGMAC_OMR_TSF | XGMAC_OMR_RFD | XGMAC_OMR_RFA |
@@ -1060,19 +1059,15 @@ static netdev_tx_t xgmac_xmit(struct sk_buff *skb, struct net_device *dev)
         struct xgmac_priv *priv = netdev_priv(dev);
         unsigned int entry;
         int i;
+        u32 irq_flag;
         int nfrags = skb_shinfo(skb)->nr_frags;
         struct xgmac_dma_desc *desc, *first;
         unsigned int desc_flags;
         unsigned int len;
         dma_addr_t paddr;
 
-        if (dma_ring_space(priv->tx_head, priv->tx_tail, DMA_TX_RING_SZ) <
-            (nfrags + 1)) {
-                writel(DMA_INTR_DEFAULT_MASK | DMA_INTR_ENA_TIE,
-                        priv->base + XGMAC_DMA_INTR_ENA);
-                netif_stop_queue(dev);
-                return NETDEV_TX_BUSY;
-        }
+        priv->tx_irq_cnt = (priv->tx_irq_cnt + 1) & (DMA_TX_RING_SZ/4 - 1);
+        irq_flag = priv->tx_irq_cnt ? 0 : TXDESC_INTERRUPT;
 
         desc_flags = (skb->ip_summed == CHECKSUM_PARTIAL) ?
                 TXDESC_CSUM_ALL : 0;
@@ -1113,9 +1108,9 @@ static netdev_tx_t xgmac_xmit(struct sk_buff *skb, struct net_device *dev)
         /* Interrupt on completition only for the latest segment */
         if (desc != first)
                 desc_set_tx_owner(desc, desc_flags |
-                        TXDESC_LAST_SEG | TXDESC_INTERRUPT);
+                        TXDESC_LAST_SEG | irq_flag);
         else
-                desc_flags |= TXDESC_LAST_SEG | TXDESC_INTERRUPT;
+                desc_flags |= TXDESC_LAST_SEG | irq_flag;
 
         /* Set owner on first desc last to avoid race condition */
         wmb();
@@ -1124,6 +1119,9 @@ static netdev_tx_t xgmac_xmit(struct sk_buff *skb, struct net_device *dev)
         priv->tx_head = dma_ring_incr(entry, DMA_TX_RING_SZ);
 
         writel(1, priv->base + XGMAC_DMA_TX_POLL);
+        if (dma_ring_space(priv->tx_head, priv->tx_tail, DMA_TX_RING_SZ) <
+            MAX_SKB_FRAGS)
+                netif_stop_queue(dev);
 
         return NETDEV_TX_OK;
 }
@@ -1139,9 +1137,6 @@ static int xgmac_rx(struct xgmac_priv *priv, int limit)
                 struct sk_buff *skb;
                 int frame_len;
 
-                writel(DMA_STATUS_RI | DMA_STATUS_NIS,
-                       priv->base + XGMAC_DMA_STATUS);
-
                 entry = priv->rx_tail;
                 p = priv->dma_rx + entry;
                 if (desc_get_owner(p))
@@ -1180,8 +1175,6 @@ static int xgmac_rx(struct xgmac_priv *priv, int limit)
 
         xgmac_rx_refill(priv);
 
-        writel(1, priv->base + XGMAC_DMA_RX_POLL);
-
         return count;
 }
 
@@ -1205,7 +1198,7 @@ static int xgmac_poll(struct napi_struct *napi, int budget)
 
         if (work_done < budget) {
                 napi_complete(napi);
-                writel(DMA_INTR_DEFAULT_MASK, priv->base + XGMAC_DMA_INTR_ENA);
+                __raw_writel(DMA_INTR_DEFAULT_MASK, priv->base + XGMAC_DMA_INTR_ENA);
         }
         return work_done;
 }
@@ -1350,7 +1343,7 @@ static irqreturn_t xgmac_pmt_interrupt(int irq, void *dev_id)
         struct xgmac_priv *priv = netdev_priv(dev);
         void __iomem *ioaddr = priv->base;
 
-        intr_status = readl(ioaddr + XGMAC_INT_STAT);
+        intr_status = __raw_readl(ioaddr + XGMAC_INT_STAT);
         if (intr_status & XGMAC_INT_STAT_PMT) {
                 netdev_dbg(priv->dev, "received Magic frame\n");
                 /* clear the PMT bits 5 and 6 by reading the PMT */
@@ -1368,9 +1361,9 @@ static irqreturn_t xgmac_interrupt(int irq, void *dev_id)
         struct xgmac_extra_stats *x = &priv->xstats;
 
         /* read the status register (CSR5) */
-        intr_status = readl(priv->base + XGMAC_DMA_STATUS);
-        intr_status &= readl(priv->base + XGMAC_DMA_INTR_ENA);
-        writel(intr_status, priv->base + XGMAC_DMA_STATUS);
+        intr_status = __raw_readl(priv->base + XGMAC_DMA_STATUS);
+        intr_status &= __raw_readl(priv->base + XGMAC_DMA_INTR_ENA);
+        __raw_writel(intr_status, priv->base + XGMAC_DMA_STATUS);
 
         /* It displays the DMA process states (CSR5 register) */
         /* ABNORMAL interrupts */
@@ -1405,8 +1398,8 @@ static irqreturn_t xgmac_interrupt(int irq, void *dev_id)
         }
 
         /* TX/RX NORMAL interrupts */
-        if (intr_status & (DMA_STATUS_RI | DMA_STATUS_TU)) {
-                writel(DMA_INTR_ABNORMAL, priv->base + XGMAC_DMA_INTR_ENA);
+        if (intr_status & (DMA_STATUS_RI | DMA_STATUS_TU | DMA_STATUS_TI)) {
+                __raw_writel(DMA_INTR_ABNORMAL, priv->base + XGMAC_DMA_INTR_ENA);
                 napi_schedule(&priv->napi);
         }
 
diff --git a/drivers/net/ethernet/chelsio/cxgb3/common.h b/drivers/net/ethernet/chelsio/cxgb3/common.h
index df01b6343241..8c82248ce416 100644
--- a/drivers/net/ethernet/chelsio/cxgb3/common.h
+++ b/drivers/net/ethernet/chelsio/cxgb3/common.h
@@ -42,10 +42,9 @@
 #include <linux/mdio.h>
 #include "version.h"
 
-#define CH_ERR(adap, fmt, ...)   dev_err(&adap->pdev->dev, fmt, ## __VA_ARGS__)
-#define CH_WARN(adap, fmt, ...)  dev_warn(&adap->pdev->dev, fmt, ## __VA_ARGS__)
-#define CH_ALERT(adap, fmt, ...) \
-        dev_printk(KERN_ALERT, &adap->pdev->dev, fmt, ## __VA_ARGS__)
+#define CH_ERR(adap, fmt, ...)   dev_err(&adap->pdev->dev, fmt, ##__VA_ARGS__)
+#define CH_WARN(adap, fmt, ...)  dev_warn(&adap->pdev->dev, fmt, ##__VA_ARGS__)
+#define CH_ALERT(adap, fmt, ...) dev_alert(&adap->pdev->dev, fmt, ##__VA_ARGS__)
 
 /*
  * More powerful macro that selectively prints messages based on msg_enable.
diff --git a/drivers/net/ethernet/dlink/dl2k.c b/drivers/net/ethernet/dlink/dl2k.c
index a059f0c27e28..2fb01bf18155 100644
--- a/drivers/net/ethernet/dlink/dl2k.c
+++ b/drivers/net/ethernet/dlink/dl2k.c
@@ -1758,21 +1758,7 @@ static struct pci_driver rio_driver = {
         .remove         = __devexit_p(rio_remove1),
 };
 
-static int __init
-rio_init (void)
-{
-        return pci_register_driver(&rio_driver);
-}
-
-static void __exit
-rio_exit (void)
-{
-        pci_unregister_driver (&rio_driver);
-}
-
-module_init (rio_init);
-module_exit (rio_exit);
-
+module_pci_driver(rio_driver);
 /*
 
 Compile command:
diff --git a/drivers/net/ethernet/emulex/benet/be.h b/drivers/net/ethernet/emulex/benet/be.h
index cf4c05bdf5fe..abf26c7c1d19 100644
--- a/drivers/net/ethernet/emulex/benet/be.h
+++ b/drivers/net/ethernet/emulex/benet/be.h
@@ -34,7 +34,7 @@
 #include "be_hw.h"
 #include "be_roce.h"
 
-#define DRV_VER                 "4.4.31.0u"
+#define DRV_VER                 "4.4.161.0u"
 #define DRV_NAME                "be2net"
 #define BE_NAME                 "ServerEngines BladeEngine2 10Gbps NIC"
 #define BE3_NAME                "ServerEngines BladeEngine3 10Gbps NIC"
@@ -53,6 +53,7 @@
 #define OC_DEVICE_ID3           0xe220  /* Device id for Lancer cards */
 #define OC_DEVICE_ID4           0xe228   /* Device id for VF in Lancer */
 #define OC_DEVICE_ID5           0x720   /* Device Id for Skyhawk cards */
+#define OC_DEVICE_ID6           0x728   /* Device id for VF in SkyHawk */
 #define OC_SUBSYS_DEVICE_ID1    0xE602
 #define OC_SUBSYS_DEVICE_ID2    0xE642
 #define OC_SUBSYS_DEVICE_ID3    0xE612
@@ -71,6 +72,7 @@ static inline char *nic_name(struct pci_dev *pdev)
         case BE_DEVICE_ID2:
                 return BE3_NAME;
         case OC_DEVICE_ID5:
+        case OC_DEVICE_ID6:
                 return OC_NAME_SH;
         default:
                 return BE_NAME;
@@ -346,7 +348,6 @@ struct be_adapter {
         struct pci_dev *pdev;
         struct net_device *netdev;
 
-        u8 __iomem *csr;
         u8 __iomem *db;         /* Door Bell */
 
         struct mutex mbox_lock; /* For serializing mbox cmds to BE card */
@@ -374,11 +375,8 @@ struct be_adapter {
         struct be_rx_obj rx_obj[MAX_RX_QS];
         u32 big_page_size;      /* Compounded page size shared by rx wrbs */
 
-        u8 eq_next_idx;
         struct be_drv_stats drv_stats;
-
         u16 vlans_added;
-        u16 max_vlans;  /* Number of vlans supported */
         u8 vlan_tag[VLAN_N_VID];
         u8 vlan_prio_bmap;      /* Available Priority BitMap */
         u16 recommended_prio;   /* Recommended Priority */
@@ -391,6 +389,7 @@ struct be_adapter {
 
         struct delayed_work func_recovery_work;
         u32 flags;
+        u32 cmd_privileges;
         /* Ethtool knobs and info */
         char fw_ver[FW_VER_LEN];
         int if_handle;          /* Used to configure filtering */
@@ -408,10 +407,8 @@ struct be_adapter {
         u32 rx_fc;              /* Rx flow control */
         u32 tx_fc;              /* Tx flow control */
         bool stats_cmd_sent;
-        u8 generation;          /* BladeEngine ASIC generation */
         u32 if_type;
         struct {
-                u8 __iomem *base;       /* Door Bell */
                 u32 size;
                 u32 total_size;
                 u64 io_addr;
@@ -434,10 +431,18 @@ struct be_adapter {
         struct phy_info phy;
         u8 wol_cap;
         bool wol;
-        u32 max_pmac_cnt;       /* Max secondary UC MACs programmable */
         u32 uc_macs;            /* Count of secondary UC MAC programmed */
         u32 msg_enable;
         int be_get_temp_freq;
+        u16 max_mcast_mac;
+        u16 max_tx_queues;
+        u16 max_rss_queues;
+        u16 max_rx_queues;
+        u16 max_pmac_cnt;
+        u16 max_vlans;
+        u16 max_event_queues;
+        u32 if_cap_flags;
+        u8 pf_number;
 };
 
 #define be_physfn(adapter)              (!adapter->virtfn)
@@ -448,21 +453,25 @@ struct be_adapter {
         for (i = 0, vf_cfg = &adapter->vf_cfg[i]; i < adapter->num_vfs; \
                 i++, vf_cfg++)
 
-/* BladeEngine Generation numbers */
-#define BE_GEN2 2
-#define BE_GEN3 3
-
 #define ON                              1
 #define OFF                             0
-#define lancer_chip(adapter)    ((adapter->pdev->device == OC_DEVICE_ID3) || \
-                                 (adapter->pdev->device == OC_DEVICE_ID4))
 
-#define skyhawk_chip(adapter)   (adapter->pdev->device == OC_DEVICE_ID5)
+#define lancer_chip(adapter)    (adapter->pdev->device == OC_DEVICE_ID3 || \
+                                 adapter->pdev->device == OC_DEVICE_ID4)
+
+#define skyhawk_chip(adapter)   (adapter->pdev->device == OC_DEVICE_ID5 || \
+                                 adapter->pdev->device == OC_DEVICE_ID6)
+
+#define BE3_chip(adapter)       (adapter->pdev->device == BE_DEVICE_ID2 || \
+                                 adapter->pdev->device == OC_DEVICE_ID2)
 
+#define BE2_chip(adapter)       (adapter->pdev->device == BE_DEVICE_ID1 || \
+                                 adapter->pdev->device == OC_DEVICE_ID1)
 
-#define be_roce_supported(adapter) ((adapter->if_type == SLI_INTF_TYPE_3 || \
-                                adapter->sli_family == SKYHAWK_SLI_FAMILY) && \
-                                (adapter->function_mode & RDMA_ENABLED))
+#define BEx_chip(adapter)       (BE3_chip(adapter) || BE2_chip(adapter))
+
+#define be_roce_supported(adapter)      (skyhawk_chip(adapter) && \
+                                        (adapter->function_mode & RDMA_ENABLED))
 
 extern const struct ethtool_ops be_ethtool_ops;
 
@@ -637,12 +646,6 @@ static inline bool be_is_wol_excluded(struct be_adapter *adapter)
         }
 }
 
-static inline bool be_type_2_3(struct be_adapter *adapter)
-{
-        return (adapter->if_type == SLI_INTF_TYPE_2 ||
-                adapter->if_type == SLI_INTF_TYPE_3) ? true : false;
-}
-
 extern void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm,
                 u16 num_popped);
 extern void be_link_status_update(struct be_adapter *adapter, u8 link_status);
diff --git a/drivers/net/ethernet/emulex/benet/be_cmds.c b/drivers/net/ethernet/emulex/benet/be_cmds.c
index af60bb26e330..f2875aa47661 100644
--- a/drivers/net/ethernet/emulex/benet/be_cmds.c
+++ b/drivers/net/ethernet/emulex/benet/be_cmds.c
@@ -19,6 +19,55 @@
 #include "be.h"
 #include "be_cmds.h"
 
+static struct be_cmd_priv_map cmd_priv_map[] = {
+        {
+                OPCODE_ETH_ACPI_WOL_MAGIC_CONFIG,
+                CMD_SUBSYSTEM_ETH,
+                BE_PRIV_LNKMGMT | BE_PRIV_VHADM |
+                BE_PRIV_DEVCFG | BE_PRIV_DEVSEC
+        },
+        {
+                OPCODE_COMMON_GET_FLOW_CONTROL,
+                CMD_SUBSYSTEM_COMMON,
+                BE_PRIV_LNKQUERY | BE_PRIV_VHADM |
+                BE_PRIV_DEVCFG | BE_PRIV_DEVSEC
+        },
+        {
+                OPCODE_COMMON_SET_FLOW_CONTROL,
+                CMD_SUBSYSTEM_COMMON,
+                BE_PRIV_LNKMGMT | BE_PRIV_VHADM |
+                BE_PRIV_DEVCFG | BE_PRIV_DEVSEC
+        },
+        {
+                OPCODE_ETH_GET_PPORT_STATS,
+                CMD_SUBSYSTEM_ETH,
+                BE_PRIV_LNKMGMT | BE_PRIV_VHADM |
+                BE_PRIV_DEVCFG | BE_PRIV_DEVSEC
+        },
+        {
+                OPCODE_COMMON_GET_PHY_DETAILS,
+                CMD_SUBSYSTEM_COMMON,
+                BE_PRIV_LNKMGMT | BE_PRIV_VHADM |
+                BE_PRIV_DEVCFG | BE_PRIV_DEVSEC
+        }
+};
+
+static bool be_cmd_allowed(struct be_adapter *adapter, u8 opcode,
+                           u8 subsystem)
+{
+        int i;
+        int num_entries = sizeof(cmd_priv_map)/sizeof(struct be_cmd_priv_map);
+        u32 cmd_privileges = adapter->cmd_privileges;
+
+        for (i = 0; i < num_entries; i++)
+                if (opcode == cmd_priv_map[i].opcode &&
+                    subsystem == cmd_priv_map[i].subsystem)
+                        if (!(cmd_privileges & cmd_priv_map[i].priv_mask))
+                                return false;
+
+        return true;
+}
+
 static inline void *embedded_payload(struct be_mcc_wrb *wrb)
 {
         return wrb->payload.embedded_payload;
@@ -419,14 +468,13 @@ static int be_mbox_notify_wait(struct be_adapter *adapter)
 static int be_POST_stage_get(struct be_adapter *adapter, u16 *stage)
 {
         u32 sem;
+        u32 reg = skyhawk_chip(adapter) ? SLIPORT_SEMAPHORE_OFFSET_SH :
+                                          SLIPORT_SEMAPHORE_OFFSET_BE;
 
-        if (lancer_chip(adapter))
-                sem  = ioread32(adapter->db + MPU_EP_SEMAPHORE_IF_TYPE2_OFFSET);
-        else
-                sem  = ioread32(adapter->csr + MPU_EP_SEMAPHORE_OFFSET);
+        pci_read_config_dword(adapter->pdev, reg, &sem);
+        *stage = sem & POST_STAGE_MASK;
 
-        *stage = sem & EP_SEMAPHORE_POST_STAGE_MASK;
-        if ((sem >> EP_SEMAPHORE_POST_ERR_SHIFT) & EP_SEMAPHORE_POST_ERR_MASK)
+        if ((sem >> POST_ERR_SHIFT) & POST_ERR_MASK)
                 return -1;
         else
                 return 0;
@@ -452,10 +500,33 @@ int lancer_wait_ready(struct be_adapter *adapter)
         return status;
 }
 
+static bool lancer_provisioning_error(struct be_adapter *adapter)
+{
+        u32 sliport_status = 0, sliport_err1 = 0, sliport_err2 = 0;
+        sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);
+        if (sliport_status & SLIPORT_STATUS_ERR_MASK) {
+                sliport_err1 = ioread32(adapter->db +
+                                        SLIPORT_ERROR1_OFFSET);
+                sliport_err2 = ioread32(adapter->db +
+                                        SLIPORT_ERROR2_OFFSET);
+
+                if (sliport_err1 == SLIPORT_ERROR_NO_RESOURCE1 &&
+                    sliport_err2 == SLIPORT_ERROR_NO_RESOURCE2)
+                        return true;
+        }
+        return false;
+}
+
 int lancer_test_and_set_rdy_state(struct be_adapter *adapter)
 {
         int status;
         u32 sliport_status, err, reset_needed;
+        bool resource_error;
+
+        resource_error = lancer_provisioning_error(adapter);
+        if (resource_error)
+                return -1;
+
         status = lancer_wait_ready(adapter);
         if (!status) {
                 sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);
@@ -477,6 +548,14 @@ int lancer_test_and_set_rdy_state(struct be_adapter *adapter)
                         status = -1;
                 }
         }
+        /* Stop error recovery if error is not recoverable.
+         * No resource error is temporary errors and will go away
+         * when PF provisions resources.
+         */
+        resource_error = lancer_provisioning_error(adapter);
+        if (status == -1 && !resource_error)
+                adapter->eeh_error = true;
+
         return status;
 }
 
@@ -601,6 +680,9 @@ static struct be_mcc_wrb *wrb_from_mccq(struct be_adapter *adapter)
         struct be_queue_info *mccq = &adapter->mcc_obj.q;
         struct be_mcc_wrb *wrb;
 
+        if (!mccq->created)
+                return NULL;
+
         if (atomic_read(&mccq->used) >= mccq->len) {
                 dev_err(&adapter->pdev->dev, "Out of MCCQ wrbs\n");
                 return NULL;
@@ -1155,8 +1237,7 @@ int be_cmd_q_destroy(struct be_adapter *adapter, struct be_queue_info *q,
         req->id = cpu_to_le16(q->id);
 
         status = be_mbox_notify_wait(adapter);
-        if (!status)
-                q->created = false;
+        q->created = false;
 
         mutex_unlock(&adapter->mbox_lock);
         return status;
@@ -1183,8 +1264,7 @@ int be_cmd_rxq_destroy(struct be_adapter *adapter, struct be_queue_info *q)
         req->id = cpu_to_le16(q->id);
 
         status = be_mcc_notify_wait(adapter);
-        if (!status)
-                q->created = false;
+        q->created = false;
 
 err:
         spin_unlock_bh(&adapter->mcc_lock);
@@ -1281,7 +1361,8 @@ int be_cmd_get_stats(struct be_adapter *adapter, struct be_dma_mem *nonemb_cmd)
         be_wrb_cmd_hdr_prepare(hdr, CMD_SUBSYSTEM_ETH,
                 OPCODE_ETH_GET_STATISTICS, nonemb_cmd->size, wrb, nonemb_cmd);
 
-        if (adapter->generation == BE_GEN3)
+        /* version 1 of the cmd is not supported only by BE2 */
+        if (!BE2_chip(adapter))
                 hdr->version = 1;
 
         be_mcc_notify(adapter);
@@ -1301,6 +1382,10 @@ int lancer_cmd_get_pport_stats(struct be_adapter *adapter,
         struct lancer_cmd_req_pport_stats *req;
         int status = 0;
 
+        if (!be_cmd_allowed(adapter, OPCODE_ETH_GET_PPORT_STATS,
+                            CMD_SUBSYSTEM_ETH))
+                return -EPERM;
+
         spin_lock_bh(&adapter->mcc_lock);
 
         wrb = wrb_from_mccq(adapter);
@@ -1367,7 +1452,8 @@ int be_cmd_link_status_query(struct be_adapter *adapter, u16 *link_speed,
         be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
                 OPCODE_COMMON_NTWK_LINK_STATUS_QUERY, sizeof(*req), wrb, NULL);
 
-        if (adapter->generation == BE_GEN3 || lancer_chip(adapter))
+        /* version 1 of the cmd is not supported only by BE2 */
+        if (!BE2_chip(adapter))
                 req->hdr.version = 1;
 
         req->hdr.domain = dom;
@@ -1658,9 +1744,9 @@ int be_cmd_rx_filter(struct be_adapter *adapter, u32 flags, u32 value)
                 /* Reset mcast promisc mode if already set by setting mask
                  * and not setting flags field
                  */
-                if (!lancer_chip(adapter) || be_physfn(adapter))
-                        req->if_flags_mask |=
-                                cpu_to_le32(BE_IF_FLAGS_MCAST_PROMISCUOUS);
+                req->if_flags_mask |=
+                        cpu_to_le32(BE_IF_FLAGS_MCAST_PROMISCUOUS &
+                                    adapter->if_cap_flags);
 
                 req->mcast_num = cpu_to_le32(netdev_mc_count(adapter->netdev));
                 netdev_for_each_mc_addr(ha, adapter->netdev)
@@ -1680,6 +1766,10 @@ int be_cmd_set_flow_control(struct be_adapter *adapter, u32 tx_fc, u32 rx_fc)
         struct be_cmd_req_set_flow_control *req;
         int status;
 
+        if (!be_cmd_allowed(adapter, OPCODE_COMMON_SET_FLOW_CONTROL,
+                            CMD_SUBSYSTEM_COMMON))
+                return -EPERM;
+
         spin_lock_bh(&adapter->mcc_lock);
 
         wrb = wrb_from_mccq(adapter);
@@ -1709,6 +1799,10 @@ int be_cmd_get_flow_control(struct be_adapter *adapter, u32 *tx_fc, u32 *rx_fc)
         struct be_cmd_req_get_flow_control *req;
         int status;
 
+        if (!be_cmd_allowed(adapter, OPCODE_COMMON_GET_FLOW_CONTROL,
+                            CMD_SUBSYSTEM_COMMON))
+                return -EPERM;
+
         spin_lock_bh(&adapter->mcc_lock);
 
         wrb = wrb_from_mccq(adapter);
@@ -2067,7 +2161,7 @@ int be_cmd_get_flash_crc(struct be_adapter *adapter, u8 *flashed_crc,
                          int offset)
 {
         struct be_mcc_wrb *wrb;
-        struct be_cmd_write_flashrom *req;
+        struct be_cmd_read_flash_crc *req;
         int status;
 
         spin_lock_bh(&adapter->mcc_lock);
@@ -2080,7 +2174,8 @@ int be_cmd_get_flash_crc(struct be_adapter *adapter, u8 *flashed_crc,
         req = embedded_payload(wrb);
 
         be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
-                OPCODE_COMMON_READ_FLASHROM, sizeof(*req)+4, wrb, NULL);
+                               OPCODE_COMMON_READ_FLASHROM, sizeof(*req),
+                               wrb, NULL);
 
         req->params.op_type = cpu_to_le32(OPTYPE_REDBOOT);
         req->params.op_code = cpu_to_le32(FLASHROM_OPER_REPORT);
@@ -2089,7 +2184,7 @@ int be_cmd_get_flash_crc(struct be_adapter *adapter, u8 *flashed_crc,
 
         status = be_mcc_notify_wait(adapter);
         if (!status)
-                memcpy(flashed_crc, req->params.data_buf, 4);
+                memcpy(flashed_crc, req->crc, 4);
 
 err:
         spin_unlock_bh(&adapter->mcc_lock);
@@ -2275,6 +2370,10 @@ int be_cmd_get_phy_info(struct be_adapter *adapter)
         struct be_dma_mem cmd;
         int status;
 
+        if (!be_cmd_allowed(adapter, OPCODE_COMMON_GET_PHY_DETAILS,
+                            CMD_SUBSYSTEM_COMMON))
+                return -EPERM;
+
         spin_lock_bh(&adapter->mcc_lock);
 
         wrb = wrb_from_mccq(adapter);
@@ -2434,6 +2533,42 @@ err:
         return status;
 }
 
+/* Get privilege(s) for a function */
+int be_cmd_get_fn_privileges(struct be_adapter *adapter, u32 *privilege,
+                             u32 domain)
+{
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_req_get_fn_privileges *req;
+        int status;
+
+        spin_lock_bh(&adapter->mcc_lock);
+
+        wrb = wrb_from_mccq(adapter);
+        if (!wrb) {
+                status = -EBUSY;
+                goto err;
+        }
+
+        req = embedded_payload(wrb);
+
+        be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
+                               OPCODE_COMMON_GET_FN_PRIVILEGES, sizeof(*req),
+                               wrb, NULL);
+
+        req->hdr.domain = domain;
+
+        status = be_mcc_notify_wait(adapter);
+        if (!status) {
+                struct be_cmd_resp_get_fn_privileges *resp =
+                                                embedded_payload(wrb);
+                *privilege = le32_to_cpu(resp->privilege_mask);
+        }
+
+err:
+        spin_unlock_bh(&adapter->mcc_lock);
+        return status;
+}
+
 /* Uses synchronous MCCQ */
 int be_cmd_get_mac_from_list(struct be_adapter *adapter, u8 *mac,
                              bool *pmac_id_active, u32 *pmac_id, u8 domain)
@@ -2651,6 +2786,10 @@ int be_cmd_get_acpi_wol_cap(struct be_adapter *adapter)
         int payload_len = sizeof(*req);
         struct be_dma_mem cmd;
 
+        if (!be_cmd_allowed(adapter, OPCODE_ETH_ACPI_WOL_MAGIC_CONFIG,
+                            CMD_SUBSYSTEM_ETH))
+                return -EPERM;
+
         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,
@@ -2792,6 +2931,240 @@ err:
         return status;
 }
 
+static struct be_nic_resource_desc *be_get_nic_desc(u8 *buf, u32 desc_count,
+                                                    u32 max_buf_size)
+{
+        struct be_nic_resource_desc *desc = (struct be_nic_resource_desc *)buf;
+        int i;
+
+        for (i = 0; i < desc_count; i++) {
+                desc->desc_len = RESOURCE_DESC_SIZE;
+                if (((void *)desc + desc->desc_len) >
+                    (void *)(buf + max_buf_size)) {
+                        desc = NULL;
+                        break;
+                }
+
+                if (desc->desc_type == NIC_RESOURCE_DESC_TYPE_ID)
+                        break;
+
+                desc = (void *)desc + desc->desc_len;
+        }
+
+        if (!desc || i == MAX_RESOURCE_DESC)
+                return NULL;
+
+        return desc;
+}
+
+/* Uses Mbox */
+int be_cmd_get_func_config(struct be_adapter *adapter)
+{
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_req_get_func_config *req;
+        int status;
+        struct be_dma_mem cmd;
+
+        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);
+        if (!cmd.va) {
+                dev_err(&adapter->pdev->dev, "Memory alloc failure\n");
+                return -ENOMEM;
+        }
+        if (mutex_lock_interruptible(&adapter->mbox_lock))
+                return -1;
+
+        wrb = wrb_from_mbox(adapter);
+        if (!wrb) {
+                status = -EBUSY;
+                goto err;
+        }
+
+        req = cmd.va;
+
+        be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
+                               OPCODE_COMMON_GET_FUNC_CONFIG,
+                               cmd.size, wrb, &cmd);
+
+        status = be_mbox_notify_wait(adapter);
+        if (!status) {
+                struct be_cmd_resp_get_func_config *resp = cmd.va;
+                u32 desc_count = le32_to_cpu(resp->desc_count);
+                struct be_nic_resource_desc *desc;
+
+                desc = be_get_nic_desc(resp->func_param, desc_count,
+                                       sizeof(resp->func_param));
+                if (!desc) {
+                        status = -EINVAL;
+                        goto err;
+                }
+
+                adapter->pf_number = desc->pf_num;
+                adapter->max_pmac_cnt = le16_to_cpu(desc->unicast_mac_count);
+                adapter->max_vlans = le16_to_cpu(desc->vlan_count);
+                adapter->max_mcast_mac = le16_to_cpu(desc->mcast_mac_count);
+                adapter->max_tx_queues = le16_to_cpu(desc->txq_count);
+                adapter->max_rss_queues = le16_to_cpu(desc->rssq_count);
+                adapter->max_rx_queues = le16_to_cpu(desc->rq_count);
+
+                adapter->max_event_queues = le16_to_cpu(desc->eq_count);
+                adapter->if_cap_flags = le32_to_cpu(desc->cap_flags);
+        }
+err:
+        mutex_unlock(&adapter->mbox_lock);
+        pci_free_consistent(adapter->pdev, cmd.size,
+                            cmd.va, cmd.dma);
+        return status;
+}
+
+ /* Uses sync mcc */
+int be_cmd_get_profile_config(struct be_adapter *adapter, u32 *cap_flags,
+                              u8 domain)
+{
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_req_get_profile_config *req;
+        int status;
+        struct be_dma_mem cmd;
+
+        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);
+        if (!cmd.va) {
+                dev_err(&adapter->pdev->dev, "Memory alloc failure\n");
+                return -ENOMEM;
+        }
+
+        spin_lock_bh(&adapter->mcc_lock);
+
+        wrb = wrb_from_mccq(adapter);
+        if (!wrb) {
+                status = -EBUSY;
+                goto err;
+        }
+
+        req = cmd.va;
+
+        be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
+                               OPCODE_COMMON_GET_PROFILE_CONFIG,
+                               cmd.size, wrb, &cmd);
+
+        req->type = ACTIVE_PROFILE_TYPE;
+        req->hdr.domain = domain;
+
+        status = be_mcc_notify_wait(adapter);
+        if (!status) {
+                struct be_cmd_resp_get_profile_config *resp = cmd.va;
+                u32 desc_count = le32_to_cpu(resp->desc_count);
+                struct be_nic_resource_desc *desc;
+
+                desc = be_get_nic_desc(resp->func_param, desc_count,
+                                       sizeof(resp->func_param));
+
+                if (!desc) {
+                        status = -EINVAL;
+                        goto err;
+                }
+                *cap_flags = le32_to_cpu(desc->cap_flags);
+        }
+err:
+        spin_unlock_bh(&adapter->mcc_lock);
+        pci_free_consistent(adapter->pdev, cmd.size,
+                            cmd.va, cmd.dma);
+        return status;
+}
+
+/* Uses sync mcc */
+int be_cmd_set_profile_config(struct be_adapter *adapter, u32 bps,
+                              u8 domain)
+{
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_req_set_profile_config *req;
+        int status;
+
+        spin_lock_bh(&adapter->mcc_lock);
+
+        wrb = wrb_from_mccq(adapter);
+        if (!wrb) {
+                status = -EBUSY;
+                goto err;
+        }
+
+        req = embedded_payload(wrb);
+
+        be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
+                               OPCODE_COMMON_SET_PROFILE_CONFIG, sizeof(*req),
+                               wrb, NULL);
+
+        req->hdr.domain = domain;
+        req->desc_count = cpu_to_le32(1);
+
+        req->nic_desc.desc_type = NIC_RESOURCE_DESC_TYPE_ID;
+        req->nic_desc.desc_len = RESOURCE_DESC_SIZE;
+        req->nic_desc.flags = (1 << QUN) | (1 << IMM) | (1 << NOSV);
+        req->nic_desc.pf_num = adapter->pf_number;
+        req->nic_desc.vf_num = domain;
+
+        /* Mark fields invalid */
+        req->nic_desc.unicast_mac_count = 0xFFFF;
+        req->nic_desc.mcc_count = 0xFFFF;
+        req->nic_desc.vlan_count = 0xFFFF;
+        req->nic_desc.mcast_mac_count = 0xFFFF;
+        req->nic_desc.txq_count = 0xFFFF;
+        req->nic_desc.rq_count = 0xFFFF;
+        req->nic_desc.rssq_count = 0xFFFF;
+        req->nic_desc.lro_count = 0xFFFF;
+        req->nic_desc.cq_count = 0xFFFF;
+        req->nic_desc.toe_conn_count = 0xFFFF;
+        req->nic_desc.eq_count = 0xFFFF;
+        req->nic_desc.link_param = 0xFF;
+        req->nic_desc.bw_min = 0xFFFFFFFF;
+        req->nic_desc.acpi_params = 0xFF;
+        req->nic_desc.wol_param = 0x0F;
+
+        /* Change BW */
+        req->nic_desc.bw_min = cpu_to_le32(bps);
+        req->nic_desc.bw_max = cpu_to_le32(bps);
+        status = be_mcc_notify_wait(adapter);
+err:
+        spin_unlock_bh(&adapter->mcc_lock);
+        return status;
+}
+
+/* Uses sync mcc */
+int be_cmd_enable_vf(struct be_adapter *adapter, u8 domain)
+{
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_enable_disable_vf *req;
+        int status;
+
+        if (!lancer_chip(adapter))
+                return 0;
+
+        spin_lock_bh(&adapter->mcc_lock);
+
+        wrb = wrb_from_mccq(adapter);
+        if (!wrb) {
+                status = -EBUSY;
+                goto err;
+        }
+
+        req = embedded_payload(wrb);
+
+        be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
+                               OPCODE_COMMON_ENABLE_DISABLE_VF, sizeof(*req),
+                               wrb, NULL);
+
+        req->hdr.domain = domain;
+        req->enable = 1;
+        status = be_mcc_notify_wait(adapter);
+err:
+        spin_unlock_bh(&adapter->mcc_lock);
+        return status;
+}
+
 int be_roce_mcc_cmd(void *netdev_handle, void *wrb_payload,
                         int wrb_payload_size, u16 *cmd_status, u16 *ext_status)
 {
diff --git a/drivers/net/ethernet/emulex/benet/be_cmds.h b/drivers/net/ethernet/emulex/benet/be_cmds.h
index 0936e21e3cff..d6552e19ffee 100644
--- a/drivers/net/ethernet/emulex/benet/be_cmds.h
+++ b/drivers/net/ethernet/emulex/benet/be_cmds.h
@@ -196,9 +196,14 @@ struct be_mcc_mailbox {
 #define OPCODE_COMMON_GET_MAC_LIST                      147
 #define OPCODE_COMMON_SET_MAC_LIST                      148
 #define OPCODE_COMMON_GET_HSW_CONFIG                    152
+#define OPCODE_COMMON_GET_FUNC_CONFIG                   160
+#define OPCODE_COMMON_GET_PROFILE_CONFIG                164
+#define OPCODE_COMMON_SET_PROFILE_CONFIG                165
 #define OPCODE_COMMON_SET_HSW_CONFIG                    153
+#define OPCODE_COMMON_GET_FN_PRIVILEGES                 170
 #define OPCODE_COMMON_READ_OBJECT                       171
 #define OPCODE_COMMON_WRITE_OBJECT                      172
+#define OPCODE_COMMON_ENABLE_DISABLE_VF                 196
 
 #define OPCODE_ETH_RSS_CONFIG                           1
 #define OPCODE_ETH_ACPI_CONFIG                          2
@@ -1151,14 +1156,22 @@ struct flashrom_params {
         u32 op_type;
         u32 data_buf_size;
         u32 offset;
-        u8 data_buf[4];
 };
 
 struct be_cmd_write_flashrom {
         struct be_cmd_req_hdr hdr;
         struct flashrom_params params;
-};
+        u8 data_buf[32768];
+        u8 rsvd[4];
+} __packed;
 
+/* cmd to read flash crc */
+struct be_cmd_read_flash_crc {
+        struct be_cmd_req_hdr hdr;
+        struct flashrom_params params;
+        u8 crc[4];
+        u8 rsvd[4];
+};
 /**************** Lancer Firmware Flash ************/
 struct amap_lancer_write_obj_context {
         u8 write_length[24];
@@ -1429,6 +1442,41 @@ struct be_cmd_resp_set_func_cap {
         u8 rsvd[212];
 };
 
+/*********************** Function Privileges ***********************/
+enum {
+        BE_PRIV_DEFAULT = 0x1,
+        BE_PRIV_LNKQUERY = 0x2,
+        BE_PRIV_LNKSTATS = 0x4,
+        BE_PRIV_LNKMGMT = 0x8,
+        BE_PRIV_LNKDIAG = 0x10,
+        BE_PRIV_UTILQUERY = 0x20,
+        BE_PRIV_FILTMGMT = 0x40,
+        BE_PRIV_IFACEMGMT = 0x80,
+        BE_PRIV_VHADM = 0x100,
+        BE_PRIV_DEVCFG = 0x200,
+        BE_PRIV_DEVSEC = 0x400
+};
+#define MAX_PRIVILEGES          (BE_PRIV_VHADM | BE_PRIV_DEVCFG | \
+                                 BE_PRIV_DEVSEC)
+#define MIN_PRIVILEGES          BE_PRIV_DEFAULT
+
+struct be_cmd_priv_map {
+        u8 opcode;
+        u8 subsystem;
+        u32 priv_mask;
+};
+
+struct be_cmd_req_get_fn_privileges {
+        struct be_cmd_req_hdr hdr;
+        u32 rsvd;
+};
+
+struct be_cmd_resp_get_fn_privileges {
+        struct be_cmd_resp_hdr hdr;
+        u32 privilege_mask;
+};
+
+
 /******************** GET/SET_MACLIST  **************************/
 #define BE_MAX_MAC                      64
 struct be_cmd_req_get_mac_list {
@@ -1608,33 +1656,6 @@ struct be_cmd_resp_get_stats_v1 {
         struct be_hw_stats_v1 hw_stats;
 };
 
-static inline void *hw_stats_from_cmd(struct be_adapter *adapter)
-{
-        if (adapter->generation == BE_GEN3) {
-                struct be_cmd_resp_get_stats_v1 *cmd = adapter->stats_cmd.va;
-
-                return &cmd->hw_stats;
-        } else {
-                struct be_cmd_resp_get_stats_v0 *cmd = adapter->stats_cmd.va;
-
-                return &cmd->hw_stats;
-        }
-}
-
-static inline void *be_erx_stats_from_cmd(struct be_adapter *adapter)
-{
-        if (adapter->generation == BE_GEN3) {
-                struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);
-
-                return &hw_stats->erx;
-        } else {
-                struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);
-
-                return &hw_stats->erx;
-        }
-}
-
-
 /************** get fat capabilites *******************/
 #define MAX_MODULES 27
 #define MAX_MODES 4
@@ -1684,6 +1705,96 @@ struct be_cmd_req_set_ext_fat_caps {
         struct be_fat_conf_params set_params;
 };
 
+#define RESOURCE_DESC_SIZE                      72
+#define NIC_RESOURCE_DESC_TYPE_ID               0x41
+#define MAX_RESOURCE_DESC                       4
+
+/* QOS unit number */
+#define QUN                                     4
+/* Immediate */
+#define IMM                                     6
+/* No save */
+#define NOSV                                    7
+
+struct be_nic_resource_desc {
+        u8 desc_type;
+        u8 desc_len;
+        u8 rsvd1;
+        u8 flags;
+        u8 vf_num;
+        u8 rsvd2;
+        u8 pf_num;
+        u8 rsvd3;
+        u16 unicast_mac_count;
+        u8 rsvd4[6];
+        u16 mcc_count;
+        u16 vlan_count;
+        u16 mcast_mac_count;
+        u16 txq_count;
+        u16 rq_count;
+        u16 rssq_count;
+        u16 lro_count;
+        u16 cq_count;
+        u16 toe_conn_count;
+        u16 eq_count;
+        u32 rsvd5;
+        u32 cap_flags;
+        u8 link_param;
+        u8 rsvd6[3];
+        u32 bw_min;
+        u32 bw_max;
+        u8 acpi_params;
+        u8 wol_param;
+        u16 rsvd7;
+        u32 rsvd8[3];
+};
+
+struct be_cmd_req_get_func_config {
+        struct be_cmd_req_hdr hdr;
+};
+
+struct be_cmd_resp_get_func_config {
+        struct be_cmd_req_hdr hdr;
+        u32 desc_count;
+        u8 func_param[MAX_RESOURCE_DESC * RESOURCE_DESC_SIZE];
+};
+
+#define ACTIVE_PROFILE_TYPE                     0x2
+struct be_cmd_req_get_profile_config {
+        struct be_cmd_req_hdr hdr;
+        u8 rsvd;
+        u8 type;
+        u16 rsvd1;
+};
+
+struct be_cmd_resp_get_profile_config {
+        struct be_cmd_req_hdr hdr;
+        u32 desc_count;
+        u8 func_param[MAX_RESOURCE_DESC * RESOURCE_DESC_SIZE];
+};
+
+struct be_cmd_req_set_profile_config {
+        struct be_cmd_req_hdr hdr;
+        u32 rsvd;
+        u32 desc_count;
+        struct be_nic_resource_desc nic_desc;
+};
+
+struct be_cmd_resp_set_profile_config {
+        struct be_cmd_req_hdr hdr;
+};
+
+struct be_cmd_enable_disable_vf {
+        struct be_cmd_req_hdr hdr;
+        u8 enable;
+        u8 rsvd[3];
+};
+
+static inline bool check_privilege(struct be_adapter *adapter, u32 flags)
+{
+        return flags & adapter->cmd_privileges ? true : false;
+}
+
 extern int be_pci_fnum_get(struct be_adapter *adapter);
 extern int be_fw_wait_ready(struct be_adapter *adapter);
 extern int be_cmd_mac_addr_query(struct be_adapter *adapter, u8 *mac_addr,
@@ -1780,6 +1891,8 @@ extern int be_cmd_get_cntl_attributes(struct be_adapter *adapter);
 extern int be_cmd_req_native_mode(struct be_adapter *adapter);
 extern int be_cmd_get_reg_len(struct be_adapter *adapter, u32 *log_size);
 extern void be_cmd_get_regs(struct be_adapter *adapter, u32 buf_len, void *buf);
+extern int be_cmd_get_fn_privileges(struct be_adapter *adapter,
+                                    u32 *privilege, u32 domain);
 extern int be_cmd_get_mac_from_list(struct be_adapter *adapter, u8 *mac,
                                     bool *pmac_id_active, u32 *pmac_id,
                                     u8 domain);
@@ -1798,4 +1911,10 @@ extern int be_cmd_set_ext_fat_capabilites(struct be_adapter *adapter,
 extern int lancer_wait_ready(struct be_adapter *adapter);
 extern int lancer_test_and_set_rdy_state(struct be_adapter *adapter);
 extern int be_cmd_query_port_name(struct be_adapter *adapter, u8 *port_name);
+extern int be_cmd_get_func_config(struct be_adapter *adapter);
+extern int be_cmd_get_profile_config(struct be_adapter *adapter, u32 *cap_flags,
+                                     u8 domain);
 
+extern int be_cmd_set_profile_config(struct be_adapter *adapter, u32 bps,
+                                     u8 domain);
+extern int be_cmd_enable_vf(struct be_adapter *adapter, u8 domain);
diff --git a/drivers/net/ethernet/emulex/benet/be_ethtool.c b/drivers/net/ethernet/emulex/benet/be_ethtool.c
index 8e6fb0ba6aa9..00454a10f88d 100644
--- a/drivers/net/ethernet/emulex/benet/be_ethtool.c
+++ b/drivers/net/ethernet/emulex/benet/be_ethtool.c
@@ -261,6 +261,9 @@ be_get_reg_len(struct net_device *netdev)
         struct be_adapter *adapter = netdev_priv(netdev);
         u32 log_size = 0;
 
+        if (!check_privilege(adapter, MAX_PRIVILEGES))
+                return 0;
+
         if (be_physfn(adapter)) {
                 if (lancer_chip(adapter))
                         log_size = lancer_cmd_get_file_len(adapter,
@@ -525,6 +528,10 @@ static int be_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
         u8 link_status;
         u16 link_speed = 0;
         int status;
+        u32 auto_speeds;
+        u32 fixed_speeds;
+        u32 dac_cable_len;
+        u16 interface_type;
 
         if (adapter->phy.link_speed < 0) {
                 status = be_cmd_link_status_query(adapter, &link_speed,
@@ -534,39 +541,46 @@ static int be_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
                 ethtool_cmd_speed_set(ecmd, link_speed);
 
                 status = be_cmd_get_phy_info(adapter);
-                if (status)
-                        return status;
-
-                ecmd->supported =
-                        convert_to_et_setting(adapter->phy.interface_type,
-                                        adapter->phy.auto_speeds_supported |
-                                        adapter->phy.fixed_speeds_supported);
-                ecmd->advertising =
-                        convert_to_et_setting(adapter->phy.interface_type,
-                                        adapter->phy.auto_speeds_supported);
-
-                ecmd->port = be_get_port_type(adapter->phy.interface_type,
-                                              adapter->phy.dac_cable_len);
-
-                if (adapter->phy.auto_speeds_supported) {
-                        ecmd->supported |= SUPPORTED_Autoneg;
-                        ecmd->autoneg = AUTONEG_ENABLE;
-                        ecmd->advertising |= ADVERTISED_Autoneg;
-                }
+                if (!status) {
+                        interface_type = adapter->phy.interface_type;
+                        auto_speeds = adapter->phy.auto_speeds_supported;
+                        fixed_speeds = adapter->phy.fixed_speeds_supported;
+                        dac_cable_len = adapter->phy.dac_cable_len;
+
+                        ecmd->supported =
+                                convert_to_et_setting(interface_type,
+                                                      auto_speeds |
+                                                      fixed_speeds);
+                        ecmd->advertising =
+                                convert_to_et_setting(interface_type,
+                                                      auto_speeds);
+
+                        ecmd->port = be_get_port_type(interface_type,
+                                                      dac_cable_len);
+
+                        if (adapter->phy.auto_speeds_supported) {
+                                ecmd->supported |= SUPPORTED_Autoneg;
+                                ecmd->autoneg = AUTONEG_ENABLE;
+                                ecmd->advertising |= ADVERTISED_Autoneg;
+                        }
 
-                if (be_pause_supported(adapter)) {
                         ecmd->supported |= SUPPORTED_Pause;
-                        ecmd->advertising |= ADVERTISED_Pause;
-                }
-
-                switch (adapter->phy.interface_type) {
-                case PHY_TYPE_KR_10GB:
-                case PHY_TYPE_KX4_10GB:
-                        ecmd->transceiver = XCVR_INTERNAL;
-                        break;
-                default:
-                        ecmd->transceiver = XCVR_EXTERNAL;
-                        break;
+                        if (be_pause_supported(adapter))
+                                ecmd->advertising |= ADVERTISED_Pause;
+
+                        switch (adapter->phy.interface_type) {
+                        case PHY_TYPE_KR_10GB:
+                        case PHY_TYPE_KX4_10GB:
+                                ecmd->transceiver = XCVR_INTERNAL;
+                                break;
+                        default:
+                                ecmd->transceiver = XCVR_EXTERNAL;
+                                break;
+                        }
+                } else {
+                        ecmd->port = PORT_OTHER;
+                        ecmd->autoneg = AUTONEG_DISABLE;
+                        ecmd->transceiver = XCVR_DUMMY1;
                 }
 
                 /* Save for future use */
@@ -787,6 +801,10 @@ static int
 be_get_eeprom_len(struct net_device *netdev)
 {
         struct be_adapter *adapter = netdev_priv(netdev);
+
+        if (!check_privilege(adapter, MAX_PRIVILEGES))
+                return 0;
+
         if (lancer_chip(adapter)) {
                 if (be_physfn(adapter))
                         return lancer_cmd_get_file_len(adapter,
diff --git a/drivers/net/ethernet/emulex/benet/be_hw.h b/drivers/net/ethernet/emulex/benet/be_hw.h
index b755f7061dce..541d4530d5bf 100644
--- a/drivers/net/ethernet/emulex/benet/be_hw.h
+++ b/drivers/net/ethernet/emulex/benet/be_hw.h
@@ -31,12 +31,12 @@
 
 #define MPU_EP_CONTROL          0
 
-/********** MPU semphore ******************/
-#define MPU_EP_SEMAPHORE_OFFSET         0xac
-#define MPU_EP_SEMAPHORE_IF_TYPE2_OFFSET        0x400
-#define EP_SEMAPHORE_POST_STAGE_MASK            0x0000FFFF
-#define EP_SEMAPHORE_POST_ERR_MASK              0x1
-#define EP_SEMAPHORE_POST_ERR_SHIFT             31
+/********** MPU semphore: used for SH & BE  *************/
+#define SLIPORT_SEMAPHORE_OFFSET_BE             0x7c
+#define SLIPORT_SEMAPHORE_OFFSET_SH             0x94
+#define POST_STAGE_MASK                         0x0000FFFF
+#define POST_ERR_MASK                           0x1
+#define POST_ERR_SHIFT                          31
 
 /* MPU semphore POST stage values */
 #define POST_STAGE_AWAITING_HOST_RDY    0x1 /* FW awaiting goahead from host */
@@ -59,6 +59,9 @@
 #define PHYSDEV_CONTROL_FW_RESET_MASK   0x00000002
 #define PHYSDEV_CONTROL_INP_MASK        0x40000000
 
+#define SLIPORT_ERROR_NO_RESOURCE1      0x2
+#define SLIPORT_ERROR_NO_RESOURCE2      0x9
+
 /********* Memory BAR register ************/
 #define PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET      0xfc
 /* Host Interrupt Enable, if set interrupts are enabled although "PCI Interrupt
@@ -102,11 +105,6 @@
 #define SLI_INTF_TYPE_2         2
 #define SLI_INTF_TYPE_3         3
 
-/* SLI family */
-#define BE_SLI_FAMILY           0x0
-#define LANCER_A0_SLI_FAMILY    0xA
-#define SKYHAWK_SLI_FAMILY      0x2
-
 /********* ISR0 Register offset **********/
 #define CEV_ISR0_OFFSET                         0xC18
 #define CEV_ISR_SIZE                            4
diff --git a/drivers/net/ethernet/emulex/benet/be_main.c b/drivers/net/ethernet/emulex/benet/be_main.c
index d1b6cc587639..c365722218ff 100644
--- a/drivers/net/ethernet/emulex/benet/be_main.c
+++ b/drivers/net/ethernet/emulex/benet/be_main.c
@@ -44,6 +44,7 @@ static DEFINE_PCI_DEVICE_TABLE(be_dev_ids) = {
         { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID3)},
         { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID4)},
         { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID5)},
+        { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID6)},
         { 0 }
 };
 MODULE_DEVICE_TABLE(pci, be_dev_ids);
@@ -237,23 +238,46 @@ static int be_mac_addr_set(struct net_device *netdev, void *p)
         int status = 0;
         u8 current_mac[ETH_ALEN];
         u32 pmac_id = adapter->pmac_id[0];
+        bool active_mac = true;
 
         if (!is_valid_ether_addr(addr->sa_data))
                 return -EADDRNOTAVAIL;
 
-        status = be_cmd_mac_addr_query(adapter, current_mac, false,
-                                       adapter->if_handle, 0);
+        /* For BE VF, MAC address is already activated by PF.
+         * Hence only operation left is updating netdev->devaddr.
+         * Update it if user is passing the same MAC which was used
+         * during configuring VF MAC from PF(Hypervisor).
+         */
+        if (!lancer_chip(adapter) && !be_physfn(adapter)) {
+                status = be_cmd_mac_addr_query(adapter, current_mac,
+                                               false, adapter->if_handle, 0);
+                if (!status && !memcmp(current_mac, addr->sa_data, ETH_ALEN))
+                        goto done;
+                else
+                        goto err;
+        }
+
+        if (!memcmp(addr->sa_data, netdev->dev_addr, ETH_ALEN))
+                goto done;
+
+        /* For Lancer check if any MAC is active.
+         * If active, get its mac id.
+         */
+        if (lancer_chip(adapter) && !be_physfn(adapter))
+                be_cmd_get_mac_from_list(adapter, current_mac, &active_mac,
+                                         &pmac_id, 0);
+
+        status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data,
+                                 adapter->if_handle,
+                                 &adapter->pmac_id[0], 0);
+
         if (status)
                 goto err;
 
-        if (memcmp(addr->sa_data, current_mac, ETH_ALEN)) {
-                status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data,
-                                adapter->if_handle, &adapter->pmac_id[0], 0);
-                if (status)
-                        goto err;
-
-                be_cmd_pmac_del(adapter, adapter->if_handle, pmac_id, 0);
-        }
+        if (active_mac)
+                be_cmd_pmac_del(adapter, adapter->if_handle,
+                                pmac_id, 0);
+done:
         memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
         return 0;
 err:
@@ -261,7 +285,35 @@ err:
         return status;
 }
 
-static void populate_be2_stats(struct be_adapter *adapter)
+/* BE2 supports only v0 cmd */
+static void *hw_stats_from_cmd(struct be_adapter *adapter)
+{
+        if (BE2_chip(adapter)) {
+                struct be_cmd_resp_get_stats_v0 *cmd = adapter->stats_cmd.va;
+
+                return &cmd->hw_stats;
+        } else  {
+                struct be_cmd_resp_get_stats_v1 *cmd = adapter->stats_cmd.va;
+
+                return &cmd->hw_stats;
+        }
+}
+
+/* BE2 supports only v0 cmd */
+static void *be_erx_stats_from_cmd(struct be_adapter *adapter)
+{
+        if (BE2_chip(adapter)) {
+                struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);
+
+                return &hw_stats->erx;
+        } else {
+                struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);
+
+                return &hw_stats->erx;
+        }
+}
+
+static void populate_be_v0_stats(struct be_adapter *adapter)
 {
         struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);
         struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
@@ -310,7 +362,7 @@ static void populate_be2_stats(struct be_adapter *adapter)
         adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
 }
 
-static void populate_be3_stats(struct be_adapter *adapter)
+static void populate_be_v1_stats(struct be_adapter *adapter)
 {
         struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);
         struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
@@ -412,28 +464,25 @@ void be_parse_stats(struct be_adapter *adapter)
         struct be_rx_obj *rxo;
         int i;
 
-        if (adapter->generation == BE_GEN3) {
-                if (lancer_chip(adapter))
-                        populate_lancer_stats(adapter);
-                 else
-                        populate_be3_stats(adapter);
+        if (lancer_chip(adapter)) {
+                populate_lancer_stats(adapter);
         } else {
-                populate_be2_stats(adapter);
-        }
-
-        if (lancer_chip(adapter))
-                goto done;
+                if (BE2_chip(adapter))
+                        populate_be_v0_stats(adapter);
+                else
+                        /* for BE3 and Skyhawk */
+                        populate_be_v1_stats(adapter);
 
-        /* as erx_v1 is longer than v0, ok to use v1 defn for v0 access */
-        for_all_rx_queues(adapter, rxo, i) {
-                /* below erx HW counter can actually wrap around after
-                 * 65535. Driver accumulates a 32-bit value
-                 */
-                accumulate_16bit_val(&rx_stats(rxo)->rx_drops_no_frags,
-                                (u16)erx->rx_drops_no_fragments[rxo->q.id]);
+                /* as erx_v1 is longer than v0, ok to use v1 for v0 access */
+                for_all_rx_queues(adapter, rxo, i) {
+                        /* below erx HW counter can actually wrap around after
+                         * 65535. Driver accumulates a 32-bit value
+                         */
+                        accumulate_16bit_val(&rx_stats(rxo)->rx_drops_no_frags,
+                                             (u16)erx->rx_drops_no_fragments \
+                                             [rxo->q.id]);
+                }
         }
-done:
-        return;
 }
 
 static struct rtnl_link_stats64 *be_get_stats64(struct net_device *netdev,
@@ -597,16 +646,6 @@ static void wrb_fill_hdr(struct be_adapter *adapter, struct be_eth_hdr_wrb *hdr,
                         hdr, skb_shinfo(skb)->gso_size);
                 if (skb_is_gso_v6(skb) && !lancer_chip(adapter))
                         AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso6, hdr, 1);
-                if (lancer_chip(adapter) && adapter->sli_family  ==
-                                                        LANCER_A0_SLI_FAMILY) {
-                        AMAP_SET_BITS(struct amap_eth_hdr_wrb, ipcs, hdr, 1);
-                        if (is_tcp_pkt(skb))
-                                AMAP_SET_BITS(struct amap_eth_hdr_wrb,
-                                                                tcpcs, hdr, 1);
-                        else if (is_udp_pkt(skb))
-                                AMAP_SET_BITS(struct amap_eth_hdr_wrb,
-                                                                udpcs, hdr, 1);
-                }
         } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
                 if (is_tcp_pkt(skb))
                         AMAP_SET_BITS(struct amap_eth_hdr_wrb, tcpcs, hdr, 1);
@@ -856,11 +895,15 @@ static int be_vlan_add_vid(struct net_device *netdev, u16 vid)
         struct be_adapter *adapter = netdev_priv(netdev);
         int status = 0;
 
-        if (!be_physfn(adapter)) {
+        if (!lancer_chip(adapter) && !be_physfn(adapter)) {
                 status = -EINVAL;
                 goto ret;
         }
 
+        /* Packets with VID 0 are always received by Lancer by default */
+        if (lancer_chip(adapter) && vid == 0)
+                goto ret;
+
         adapter->vlan_tag[vid] = 1;
         if (adapter->vlans_added <= (adapter->max_vlans + 1))
                 status = be_vid_config(adapter);
@@ -878,11 +921,15 @@ static int be_vlan_rem_vid(struct net_device *netdev, u16 vid)
         struct be_adapter *adapter = netdev_priv(netdev);
         int status = 0;
 
-        if (!be_physfn(adapter)) {
+        if (!lancer_chip(adapter) && !be_physfn(adapter)) {
                 status = -EINVAL;
                 goto ret;
         }
 
+        /* Packets with VID 0 are always received by Lancer by default */
+        if (lancer_chip(adapter) && vid == 0)
+                goto ret;
+
         adapter->vlan_tag[vid] = 0;
         if (adapter->vlans_added <= adapter->max_vlans)
                 status = be_vid_config(adapter);
@@ -917,7 +964,7 @@ static void be_set_rx_mode(struct net_device *netdev)
 
         /* Enable multicast promisc if num configured exceeds what we support */
         if (netdev->flags & IFF_ALLMULTI ||
-                        netdev_mc_count(netdev) > BE_MAX_MC) {
+            netdev_mc_count(netdev) > adapter->max_mcast_mac) {
                 be_cmd_rx_filter(adapter, IFF_ALLMULTI, ON);
                 goto done;
         }
@@ -962,6 +1009,9 @@ static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
         struct be_adapter *adapter = netdev_priv(netdev);
         struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
         int status;
+        bool active_mac = false;
+        u32 pmac_id;
+        u8 old_mac[ETH_ALEN];
 
         if (!sriov_enabled(adapter))
                 return -EPERM;
@@ -970,6 +1020,12 @@ static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
                 return -EINVAL;
 
         if (lancer_chip(adapter)) {
+                status = be_cmd_get_mac_from_list(adapter, old_mac, &active_mac,
+                                                  &pmac_id, vf + 1);
+                if (!status && active_mac)
+                        be_cmd_pmac_del(adapter, vf_cfg->if_handle,
+                                        pmac_id, vf + 1);
+
                 status = be_cmd_set_mac_list(adapter,  mac, 1, vf + 1);
         } else {
                 status = be_cmd_pmac_del(adapter, vf_cfg->if_handle,
@@ -1062,7 +1118,10 @@ static int be_set_vf_tx_rate(struct net_device *netdev,
                 return -EINVAL;
         }
 
-        status = be_cmd_set_qos(adapter, rate / 10, vf + 1);
+        if (lancer_chip(adapter))
+                status = be_cmd_set_profile_config(adapter, rate / 10, vf + 1);
+        else
+                status = be_cmd_set_qos(adapter, rate / 10, vf + 1);
 
         if (status)
                 dev_err(&adapter->pdev->dev,
@@ -1837,12 +1896,13 @@ static void be_tx_queues_destroy(struct be_adapter *adapter)
 
 static int be_num_txqs_want(struct be_adapter *adapter)
 {
-        if (sriov_want(adapter) || be_is_mc(adapter) ||
-            lancer_chip(adapter) || !be_physfn(adapter) ||
-            adapter->generation == BE_GEN2)
+        if ((!lancer_chip(adapter) && sriov_want(adapter)) ||
+            be_is_mc(adapter) ||
+            (!lancer_chip(adapter) && !be_physfn(adapter)) ||
+            BE2_chip(adapter))
                 return 1;
         else
-                return MAX_TX_QS;
+                return adapter->max_tx_queues;
 }
 
 static int be_tx_cqs_create(struct be_adapter *adapter)
@@ -2177,9 +2237,11 @@ static void be_msix_disable(struct be_adapter *adapter)
 static uint be_num_rss_want(struct be_adapter *adapter)
 {
         u32 num = 0;
+
         if ((adapter->function_caps & BE_FUNCTION_CAPS_RSS) &&
-             !sriov_want(adapter) && be_physfn(adapter)) {
-                num = (adapter->be3_native) ? BE3_MAX_RSS_QS : BE2_MAX_RSS_QS;
+            (lancer_chip(adapter) ||
+             (!sriov_want(adapter) && be_physfn(adapter)))) {
+                num = adapter->max_rss_queues;
                 num = min_t(u32, num, (u32)netif_get_num_default_rss_queues());
         }
         return num;
@@ -2579,10 +2641,30 @@ static int be_clear(struct be_adapter *adapter)
         be_tx_queues_destroy(adapter);
         be_evt_queues_destroy(adapter);
 
+        kfree(adapter->pmac_id);
+        adapter->pmac_id = NULL;
+
         be_msix_disable(adapter);
         return 0;
 }
 
+static void be_get_vf_if_cap_flags(struct be_adapter *adapter,
+                                   u32 *cap_flags, u8 domain)
+{
+        bool profile_present = false;
+        int status;
+
+        if (lancer_chip(adapter)) {
+                status = be_cmd_get_profile_config(adapter, cap_flags, domain);
+                if (!status)
+                        profile_present = true;
+        }
+
+        if (!profile_present)
+                *cap_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
+                             BE_IF_FLAGS_MULTICAST;
+}
+
 static int be_vf_setup_init(struct be_adapter *adapter)
 {
         struct be_vf_cfg *vf_cfg;
@@ -2634,9 +2716,13 @@ static int be_vf_setup(struct be_adapter *adapter)
         if (status)
                 goto err;
 
-        cap_flags = en_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
-                                BE_IF_FLAGS_MULTICAST;
         for_all_vfs(adapter, vf_cfg, vf) {
+                be_get_vf_if_cap_flags(adapter, &cap_flags, vf + 1);
+
+                en_flags = cap_flags & (BE_IF_FLAGS_UNTAGGED |
+                                        BE_IF_FLAGS_BROADCAST |
+                                        BE_IF_FLAGS_MULTICAST);
+
                 status = be_cmd_if_create(adapter, cap_flags, en_flags,
                                           &vf_cfg->if_handle, vf + 1);
                 if (status)
@@ -2661,6 +2747,8 @@ static int be_vf_setup(struct be_adapter *adapter)
                 if (status)
                         goto err;
                 vf_cfg->def_vid = def_vlan;
+
+                be_cmd_enable_vf(adapter, vf + 1);
         }
         return 0;
 err:
@@ -2674,7 +2762,10 @@ static void be_setup_init(struct be_adapter *adapter)
         adapter->if_handle = -1;
         adapter->be3_native = false;
         adapter->promiscuous = false;
-        adapter->eq_next_idx = 0;
+        if (be_physfn(adapter))
+                adapter->cmd_privileges = MAX_PRIVILEGES;
+        else
+                adapter->cmd_privileges = MIN_PRIVILEGES;
 }
 
 static int be_get_mac_addr(struct be_adapter *adapter, u8 *mac, u32 if_handle,
@@ -2712,12 +2803,93 @@ static int be_get_mac_addr(struct be_adapter *adapter, u8 *mac, u32 if_handle,
         return status;
 }
 
+static void be_get_resources(struct be_adapter *adapter)
+{
+        int status;
+        bool profile_present = false;
+
+        if (lancer_chip(adapter)) {
+                status = be_cmd_get_func_config(adapter);
+
+                if (!status)
+                        profile_present = true;
+        }
+
+        if (profile_present) {
+                /* Sanity fixes for Lancer */
+                adapter->max_pmac_cnt = min_t(u16, adapter->max_pmac_cnt,
+                                              BE_UC_PMAC_COUNT);
+                adapter->max_vlans = min_t(u16, adapter->max_vlans,
+                                           BE_NUM_VLANS_SUPPORTED);
+                adapter->max_mcast_mac = min_t(u16, adapter->max_mcast_mac,
+                                               BE_MAX_MC);
+                adapter->max_tx_queues = min_t(u16, adapter->max_tx_queues,
+                                               MAX_TX_QS);
+                adapter->max_rss_queues = min_t(u16, adapter->max_rss_queues,
+                                                BE3_MAX_RSS_QS);
+                adapter->max_event_queues = min_t(u16,
+                                                  adapter->max_event_queues,
+                                                  BE3_MAX_RSS_QS);
+
+                if (adapter->max_rss_queues &&
+                    adapter->max_rss_queues == adapter->max_rx_queues)
+                        adapter->max_rss_queues -= 1;
+
+                if (adapter->max_event_queues < adapter->max_rss_queues)
+                        adapter->max_rss_queues = adapter->max_event_queues;
+
+        } else {
+                if (be_physfn(adapter))
+                        adapter->max_pmac_cnt = BE_UC_PMAC_COUNT;
+                else
+                        adapter->max_pmac_cnt = BE_VF_UC_PMAC_COUNT;
+
+                if (adapter->function_mode & FLEX10_MODE)
+                        adapter->max_vlans = BE_NUM_VLANS_SUPPORTED/8;
+                else
+                        adapter->max_vlans = BE_NUM_VLANS_SUPPORTED;
+
+                adapter->max_mcast_mac = BE_MAX_MC;
+                adapter->max_tx_queues = MAX_TX_QS;
+                adapter->max_rss_queues = (adapter->be3_native) ?
+                                           BE3_MAX_RSS_QS : BE2_MAX_RSS_QS;
+                adapter->max_event_queues = BE3_MAX_RSS_QS;
+
+                adapter->if_cap_flags = BE_IF_FLAGS_UNTAGGED |
+                                        BE_IF_FLAGS_BROADCAST |
+                                        BE_IF_FLAGS_MULTICAST |
+                                        BE_IF_FLAGS_PASS_L3L4_ERRORS |
+                                        BE_IF_FLAGS_MCAST_PROMISCUOUS |
+                                        BE_IF_FLAGS_VLAN_PROMISCUOUS |
+                                        BE_IF_FLAGS_PROMISCUOUS;
+
+                if (adapter->function_caps & BE_FUNCTION_CAPS_RSS)
+                        adapter->if_cap_flags |= BE_IF_FLAGS_RSS;
+        }
+}
+
 /* Routine to query per function resource limits */
 static int be_get_config(struct be_adapter *adapter)
 {
-        int pos;
+        int pos, status;
         u16 dev_num_vfs;
 
+        status = be_cmd_query_fw_cfg(adapter, &adapter->port_num,
+                                     &adapter->function_mode,
+                                     &adapter->function_caps);
+        if (status)
+                goto err;
+
+        be_get_resources(adapter);
+
+        /* primary mac needs 1 pmac entry */
+        adapter->pmac_id = kcalloc(adapter->max_pmac_cnt + 1,
+                                   sizeof(u32), GFP_KERNEL);
+        if (!adapter->pmac_id) {
+                status = -ENOMEM;
+                goto err;
+        }
+
         pos = pci_find_ext_capability(adapter->pdev, PCI_EXT_CAP_ID_SRIOV);
         if (pos) {
                 pci_read_config_word(adapter->pdev, pos + PCI_SRIOV_TOTAL_VF,
@@ -2726,13 +2898,14 @@ static int be_get_config(struct be_adapter *adapter)
                         dev_num_vfs = min_t(u16, dev_num_vfs, MAX_VFS);
                 adapter->dev_num_vfs = dev_num_vfs;
         }
-        return 0;
+err:
+        return status;
 }
 
 static int be_setup(struct be_adapter *adapter)
 {
         struct device *dev = &adapter->pdev->dev;
-        u32 cap_flags, en_flags;
+        u32 en_flags;
         u32 tx_fc, rx_fc;
         int status;
         u8 mac[ETH_ALEN];
@@ -2740,9 +2913,12 @@ static int be_setup(struct be_adapter *adapter)
 
         be_setup_init(adapter);
 
-        be_get_config(adapter);
+        if (!lancer_chip(adapter))
+                be_cmd_req_native_mode(adapter);
 
-        be_cmd_req_native_mode(adapter);
+        status = be_get_config(adapter);
+        if (status)
+                goto err;
 
         be_msix_enable(adapter);
 
@@ -2762,24 +2938,22 @@ static int be_setup(struct be_adapter *adapter)
         if (status)
                 goto err;
 
+        be_cmd_get_fn_privileges(adapter, &adapter->cmd_privileges, 0);
+        /* In UMC mode FW does not return right privileges.
+         * Override with correct privilege equivalent to PF.
+         */
+        if (be_is_mc(adapter))
+                adapter->cmd_privileges = MAX_PRIVILEGES;
+
         en_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
                         BE_IF_FLAGS_MULTICAST | BE_IF_FLAGS_PASS_L3L4_ERRORS;
-        cap_flags = en_flags | BE_IF_FLAGS_MCAST_PROMISCUOUS |
-                        BE_IF_FLAGS_VLAN_PROMISCUOUS | BE_IF_FLAGS_PROMISCUOUS;
 
-        if (adapter->function_caps & BE_FUNCTION_CAPS_RSS) {
-                cap_flags |= BE_IF_FLAGS_RSS;
+        if (adapter->function_caps & BE_FUNCTION_CAPS_RSS)
                 en_flags |= BE_IF_FLAGS_RSS;
-        }
 
-        if (lancer_chip(adapter) && !be_physfn(adapter)) {
-                en_flags = BE_IF_FLAGS_UNTAGGED |
-                            BE_IF_FLAGS_BROADCAST |
-                            BE_IF_FLAGS_MULTICAST;
-                cap_flags = en_flags;
-        }
+        en_flags = en_flags & adapter->if_cap_flags;
 
-        status = be_cmd_if_create(adapter, cap_flags, en_flags,
+        status = be_cmd_if_create(adapter, adapter->if_cap_flags, en_flags,
                                   &adapter->if_handle, 0);
         if (status != 0)
                 goto err;
@@ -2827,8 +3001,8 @@ static int be_setup(struct be_adapter *adapter)
                         dev_warn(dev, "device doesn't support SRIOV\n");
         }
 
-        be_cmd_get_phy_info(adapter);
-        if (be_pause_supported(adapter))
+        status = be_cmd_get_phy_info(adapter);
+        if (!status && be_pause_supported(adapter))
                 adapter->phy.fc_autoneg = 1;
 
         schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
@@ -2895,7 +3069,7 @@ static bool is_comp_in_ufi(struct be_adapter *adapter,
         int i = 0, img_type = 0;
         struct flash_section_info_g2 *fsec_g2 = NULL;
 
-        if (adapter->generation != BE_GEN3)
+        if (BE2_chip(adapter))
                 fsec_g2 = (struct flash_section_info_g2 *)fsec;
 
         for (i = 0; i < MAX_FLASH_COMP; i++) {
@@ -2928,7 +3102,49 @@ struct flash_section_info *get_fsec_info(struct be_adapter *adapter,
         return NULL;
 }
 
-static int be_flash_data(struct be_adapter *adapter,
+static int be_flash(struct be_adapter *adapter, const u8 *img,
+                struct be_dma_mem *flash_cmd, int optype, int img_size)
+{
+        u32 total_bytes = 0, flash_op, num_bytes = 0;
+        int status = 0;
+        struct be_cmd_write_flashrom *req = flash_cmd->va;
+
+        total_bytes = img_size;
+        while (total_bytes) {
+                num_bytes = min_t(u32, 32*1024, total_bytes);
+
+                total_bytes -= num_bytes;
+
+                if (!total_bytes) {
+                        if (optype == OPTYPE_PHY_FW)
+                                flash_op = FLASHROM_OPER_PHY_FLASH;
+                        else
+                                flash_op = FLASHROM_OPER_FLASH;
+                } else {
+                        if (optype == OPTYPE_PHY_FW)
+                                flash_op = FLASHROM_OPER_PHY_SAVE;
+                        else
+                                flash_op = FLASHROM_OPER_SAVE;
+                }
+
+                memcpy(req->data_buf, img, num_bytes);
+                img += num_bytes;
+                status = be_cmd_write_flashrom(adapter, flash_cmd, optype,
+                                                flash_op, num_bytes);
+                if (status) {
+                        if (status == ILLEGAL_IOCTL_REQ &&
+                            optype == OPTYPE_PHY_FW)
+                                break;
+                        dev_err(&adapter->pdev->dev,
+                                "cmd to write to flash rom failed.\n");
+                        return status;
+                }
+        }
+        return 0;
+}
+
+/* For BE2 and BE3 */
+static int be_flash_BEx(struct be_adapter *adapter,
                          const struct firmware *fw,
                          struct be_dma_mem *flash_cmd,
                          int num_of_images)
@@ -2936,12 +3152,9 @@ static int be_flash_data(struct be_adapter *adapter,
 {
         int status = 0, i, filehdr_size = 0;
         int img_hdrs_size = (num_of_images * sizeof(struct image_hdr));
-        u32 total_bytes = 0, flash_op;
-        int num_bytes;
         const u8 *p = fw->data;
-        struct be_cmd_write_flashrom *req = flash_cmd->va;
         const struct flash_comp *pflashcomp;
-        int num_comp, hdr_size;
+        int num_comp, redboot;
         struct flash_section_info *fsec = NULL;
 
         struct flash_comp gen3_flash_types[] = {
@@ -2986,7 +3199,7 @@ static int be_flash_data(struct be_adapter *adapter,
                          FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_BACKUP_FCoE}
         };
 
-        if (adapter->generation == BE_GEN3) {
+        if (BE3_chip(adapter)) {
                 pflashcomp = gen3_flash_types;
                 filehdr_size = sizeof(struct flash_file_hdr_g3);
                 num_comp = ARRAY_SIZE(gen3_flash_types);
@@ -2995,6 +3208,7 @@ static int be_flash_data(struct be_adapter *adapter,
                 filehdr_size = sizeof(struct flash_file_hdr_g2);
                 num_comp = ARRAY_SIZE(gen2_flash_types);
         }
+
         /* Get flash section info*/
         fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw);
         if (!fsec) {
@@ -3010,70 +3224,105 @@ static int be_flash_data(struct be_adapter *adapter,
                     memcmp(adapter->fw_ver, "3.102.148.0", 11) < 0)
                         continue;
 
-                if (pflashcomp[i].optype == OPTYPE_PHY_FW) {
-                        if (!phy_flashing_required(adapter))
+                if (pflashcomp[i].optype == OPTYPE_PHY_FW  &&
+                    !phy_flashing_required(adapter))
                                 continue;
-                }
-
-                hdr_size = filehdr_size +
-                           (num_of_images * sizeof(struct image_hdr));
 
-                if ((pflashcomp[i].optype == OPTYPE_REDBOOT) &&
-                    (!be_flash_redboot(adapter, fw->data, pflashcomp[i].offset,
-                                       pflashcomp[i].size, hdr_size)))
-                        continue;
+                if (pflashcomp[i].optype == OPTYPE_REDBOOT) {
+                        redboot = be_flash_redboot(adapter, fw->data,
+                                pflashcomp[i].offset, pflashcomp[i].size,
+                                filehdr_size + img_hdrs_size);
+                        if (!redboot)
+                                continue;
+                }
 
-                /* Flash the component */
                 p = fw->data;
                 p += filehdr_size + pflashcomp[i].offset + img_hdrs_size;
                 if (p + pflashcomp[i].size > fw->data + fw->size)
                         return -1;
-                total_bytes = pflashcomp[i].size;
-                while (total_bytes) {
-                        if (total_bytes > 32*1024)
-                                num_bytes = 32*1024;
-                        else
-                                num_bytes = total_bytes;
-                        total_bytes -= num_bytes;
-                        if (!total_bytes) {
-                                if (pflashcomp[i].optype == OPTYPE_PHY_FW)
-                                        flash_op = FLASHROM_OPER_PHY_FLASH;
-                                else
-                                        flash_op = FLASHROM_OPER_FLASH;
-                        } else {
-                                if (pflashcomp[i].optype == OPTYPE_PHY_FW)
-                                        flash_op = FLASHROM_OPER_PHY_SAVE;
-                                else
-                                        flash_op = FLASHROM_OPER_SAVE;
-                        }
-                        memcpy(req->params.data_buf, p, num_bytes);
-                        p += num_bytes;
-                        status = be_cmd_write_flashrom(adapter, flash_cmd,
-                                pflashcomp[i].optype, flash_op, num_bytes);
-                        if (status) {
-                                if ((status == ILLEGAL_IOCTL_REQ) &&
-                                        (pflashcomp[i].optype ==
-                                                OPTYPE_PHY_FW))
-                                        break;
-                                dev_err(&adapter->pdev->dev,
-                                        "cmd to write to flash rom failed.\n");
-                                return -1;
-                        }
+
+                status = be_flash(adapter, p, flash_cmd, pflashcomp[i].optype,
+                                        pflashcomp[i].size);
+                if (status) {
+                        dev_err(&adapter->pdev->dev,
+                                "Flashing section type %d failed.\n",
+                                pflashcomp[i].img_type);
+                        return status;
                 }
         }
         return 0;
 }
 
-static int get_ufigen_type(struct flash_file_hdr_g2 *fhdr)
+static int be_flash_skyhawk(struct be_adapter *adapter,
+                const struct firmware *fw,
+                struct be_dma_mem *flash_cmd, int num_of_images)
 {
-        if (fhdr == NULL)
-                return 0;
-        if (fhdr->build[0] == '3')
-                return BE_GEN3;
-        else if (fhdr->build[0] == '2')
-                return BE_GEN2;
-        else
-                return 0;
+        int status = 0, i, filehdr_size = 0;
+        int img_offset, img_size, img_optype, redboot;
+        int img_hdrs_size = num_of_images * sizeof(struct image_hdr);
+        const u8 *p = fw->data;
+        struct flash_section_info *fsec = NULL;
+
+        filehdr_size = sizeof(struct flash_file_hdr_g3);
+        fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw);
+        if (!fsec) {
+                dev_err(&adapter->pdev->dev,
+                        "Invalid Cookie. UFI corrupted ?\n");
+                return -1;
+        }
+
+        for (i = 0; i < le32_to_cpu(fsec->fsec_hdr.num_images); i++) {
+                img_offset = le32_to_cpu(fsec->fsec_entry[i].offset);
+                img_size   = le32_to_cpu(fsec->fsec_entry[i].pad_size);
+
+                switch (le32_to_cpu(fsec->fsec_entry[i].type)) {
+                case IMAGE_FIRMWARE_iSCSI:
+                        img_optype = OPTYPE_ISCSI_ACTIVE;
+                        break;
+                case IMAGE_BOOT_CODE:
+                        img_optype = OPTYPE_REDBOOT;
+                        break;
+                case IMAGE_OPTION_ROM_ISCSI:
+                        img_optype = OPTYPE_BIOS;
+                        break;
+                case IMAGE_OPTION_ROM_PXE:
+                        img_optype = OPTYPE_PXE_BIOS;
+                        break;
+                case IMAGE_OPTION_ROM_FCoE:
+                        img_optype = OPTYPE_FCOE_BIOS;
+                        break;
+                case IMAGE_FIRMWARE_BACKUP_iSCSI:
+                        img_optype = OPTYPE_ISCSI_BACKUP;
+                        break;
+                case IMAGE_NCSI:
+                        img_optype = OPTYPE_NCSI_FW;
+                        break;
+                default:
+                        continue;
+                }
+
+                if (img_optype == OPTYPE_REDBOOT) {
+                        redboot = be_flash_redboot(adapter, fw->data,
+                                        img_offset, img_size,
+                                        filehdr_size + img_hdrs_size);
+                        if (!redboot)
+                                continue;
+                }
+
+                p = fw->data;
+                p += filehdr_size + img_offset + img_hdrs_size;
+                if (p + img_size > fw->data + fw->size)
+                        return -1;
+
+                status = be_flash(adapter, p, flash_cmd, img_optype, img_size);
+                if (status) {
+                        dev_err(&adapter->pdev->dev,
+                                "Flashing section type %d failed.\n",
+                                fsec->fsec_entry[i].type);
+                        return status;
+                }
+        }
+        return 0;
 }
 
 static int lancer_wait_idle(struct be_adapter *adapter)
@@ -3207,6 +3456,28 @@ lancer_fw_exit:
         return status;
 }
 
+#define UFI_TYPE2               2
+#define UFI_TYPE3               3
+#define UFI_TYPE4               4
+static int be_get_ufi_type(struct be_adapter *adapter,
+                           struct flash_file_hdr_g2 *fhdr)
+{
+        if (fhdr == NULL)
+                goto be_get_ufi_exit;
+
+        if (skyhawk_chip(adapter) && fhdr->build[0] == '4')
+                return UFI_TYPE4;
+        else if (BE3_chip(adapter) && fhdr->build[0] == '3')
+                return UFI_TYPE3;
+        else if (BE2_chip(adapter) && fhdr->build[0] == '2')
+                return UFI_TYPE2;
+
+be_get_ufi_exit:
+        dev_err(&adapter->pdev->dev,
+                "UFI and Interface are not compatible for flashing\n");
+        return -1;
+}
+
 static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)
 {
         struct flash_file_hdr_g2 *fhdr;
@@ -3214,12 +3485,9 @@ static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)
         struct image_hdr *img_hdr_ptr = NULL;
         struct be_dma_mem flash_cmd;
         const u8 *p;
-        int status = 0, i = 0, num_imgs = 0;
+        int status = 0, i = 0, num_imgs = 0, ufi_type = 0;
 
-        p = fw->data;
-        fhdr = (struct flash_file_hdr_g2 *) p;
-
-        flash_cmd.size = sizeof(struct be_cmd_write_flashrom) + 32*1024;
+        flash_cmd.size = sizeof(struct be_cmd_write_flashrom);
         flash_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, flash_cmd.size,
                                           &flash_cmd.dma, GFP_KERNEL);
         if (!flash_cmd.va) {
@@ -3229,27 +3497,32 @@ static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)
                 goto be_fw_exit;
         }
 
-        if ((adapter->generation == BE_GEN3) &&
-                        (get_ufigen_type(fhdr) == BE_GEN3)) {
-                fhdr3 = (struct flash_file_hdr_g3 *) fw->data;
-                num_imgs = le32_to_cpu(fhdr3->num_imgs);
-                for (i = 0; i < num_imgs; i++) {
-                        img_hdr_ptr = (struct image_hdr *) (fw->data +
-                                        (sizeof(struct flash_file_hdr_g3) +
-                                         i * sizeof(struct image_hdr)));
-                        if (le32_to_cpu(img_hdr_ptr->imageid) == 1)
-                                status = be_flash_data(adapter, fw, &flash_cmd,
-                                                        num_imgs);
+        p = fw->data;
+        fhdr = (struct flash_file_hdr_g2 *)p;
+
+        ufi_type = be_get_ufi_type(adapter, fhdr);
+
+        fhdr3 = (struct flash_file_hdr_g3 *)fw->data;
+        num_imgs = le32_to_cpu(fhdr3->num_imgs);
+        for (i = 0; i < num_imgs; i++) {
+                img_hdr_ptr = (struct image_hdr *)(fw->data +
+                                (sizeof(struct flash_file_hdr_g3) +
+                                 i * sizeof(struct image_hdr)));
+                if (le32_to_cpu(img_hdr_ptr->imageid) == 1) {
+                        if (ufi_type == UFI_TYPE4)
+                                status = be_flash_skyhawk(adapter, fw,
+                                                        &flash_cmd, num_imgs);
+                        else if (ufi_type == UFI_TYPE3)
+                                status = be_flash_BEx(adapter, fw, &flash_cmd,
+                                                      num_imgs);
                 }
-        } else if ((adapter->generation == BE_GEN2) &&
-                        (get_ufigen_type(fhdr) == BE_GEN2)) {
-                status = be_flash_data(adapter, fw, &flash_cmd, 0);
-        } else {
-                dev_err(&adapter->pdev->dev,
-                        "UFI and Interface are not compatible for flashing\n");
-                status = -1;
         }
 
+        if (ufi_type == UFI_TYPE2)
+                status = be_flash_BEx(adapter, fw, &flash_cmd, 0);
+        else if (ufi_type == -1)
+                status = -1;
+
         dma_free_coherent(&adapter->pdev->dev, flash_cmd.size, flash_cmd.va,
                           flash_cmd.dma);
         if (status) {
@@ -3344,80 +3617,47 @@ static void be_netdev_init(struct net_device *netdev)
 
 static void be_unmap_pci_bars(struct be_adapter *adapter)
 {
-        if (adapter->csr)
-                iounmap(adapter->csr);
         if (adapter->db)
-                iounmap(adapter->db);
-        if (adapter->roce_db.base)
-                pci_iounmap(adapter->pdev, adapter->roce_db.base);
+                pci_iounmap(adapter->pdev, adapter->db);
 }
 
-static int lancer_roce_map_pci_bars(struct be_adapter *adapter)
+static int db_bar(struct be_adapter *adapter)
 {
-        struct pci_dev *pdev = adapter->pdev;
-        u8 __iomem *addr;
-
-        addr = pci_iomap(pdev, 2, 0);
-        if (addr == NULL)
-                return -ENOMEM;
+        if (lancer_chip(adapter) || !be_physfn(adapter))
+                return 0;
+        else
+                return 4;
+}
 
-        adapter->roce_db.base = addr;
-        adapter->roce_db.io_addr = pci_resource_start(pdev, 2);
-        adapter->roce_db.size = 8192;
-        adapter->roce_db.total_size = pci_resource_len(pdev, 2);
+static int be_roce_map_pci_bars(struct be_adapter *adapter)
+{
+        if (skyhawk_chip(adapter)) {
+                adapter->roce_db.size = 4096;
+                adapter->roce_db.io_addr = pci_resource_start(adapter->pdev,
+                                                              db_bar(adapter));
+                adapter->roce_db.total_size = pci_resource_len(adapter->pdev,
+                                                               db_bar(adapter));
+        }
         return 0;
 }
 
 static int be_map_pci_bars(struct be_adapter *adapter)
 {
         u8 __iomem *addr;
-        int db_reg;
+        u32 sli_intf;
 
-        if (lancer_chip(adapter)) {
-                if (be_type_2_3(adapter)) {
-                        addr = ioremap_nocache(
-                                        pci_resource_start(adapter->pdev, 0),
-                                        pci_resource_len(adapter->pdev, 0));
-                        if (addr == NULL)
-                                return -ENOMEM;
-                        adapter->db = addr;
-                }
-                if (adapter->if_type == SLI_INTF_TYPE_3) {
-                        if (lancer_roce_map_pci_bars(adapter))
-                                goto pci_map_err;
-                }
-                return 0;
-        }
-
-        if (be_physfn(adapter)) {
-                addr = ioremap_nocache(pci_resource_start(adapter->pdev, 2),
-                                pci_resource_len(adapter->pdev, 2));
-                if (addr == NULL)
-                        return -ENOMEM;
-                adapter->csr = addr;
-        }
+        pci_read_config_dword(adapter->pdev, SLI_INTF_REG_OFFSET, &sli_intf);
+        adapter->if_type = (sli_intf & SLI_INTF_IF_TYPE_MASK) >>
+                                SLI_INTF_IF_TYPE_SHIFT;
 
-        if (adapter->generation == BE_GEN2) {
-                db_reg = 4;
-        } else {
-                if (be_physfn(adapter))
-                        db_reg = 4;
-                else
-                        db_reg = 0;
-        }
-        addr = ioremap_nocache(pci_resource_start(adapter->pdev, db_reg),
-                                pci_resource_len(adapter->pdev, db_reg));
+        addr = pci_iomap(adapter->pdev, db_bar(adapter), 0);
         if (addr == NULL)
                 goto pci_map_err;
         adapter->db = addr;
-        if (adapter->sli_family == SKYHAWK_SLI_FAMILY) {
-                adapter->roce_db.size = 4096;
-                adapter->roce_db.io_addr =
-                                pci_resource_start(adapter->pdev, db_reg);
-                adapter->roce_db.total_size =
-                                pci_resource_len(adapter->pdev, db_reg);
-        }
+
+        be_roce_map_pci_bars(adapter);
         return 0;
+
 pci_map_err:
         be_unmap_pci_bars(adapter);
         return -ENOMEM;
@@ -3437,7 +3677,6 @@ static void be_ctrl_cleanup(struct be_adapter *adapter)
         if (mem->va)
                 dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
                                   mem->dma);
-        kfree(adapter->pmac_id);
 }
 
 static int be_ctrl_init(struct be_adapter *adapter)
@@ -3445,8 +3684,14 @@ static int be_ctrl_init(struct be_adapter *adapter)
         struct be_dma_mem *mbox_mem_alloc = &adapter->mbox_mem_alloced;
         struct be_dma_mem *mbox_mem_align = &adapter->mbox_mem;
         struct be_dma_mem *rx_filter = &adapter->rx_filter;
+        u32 sli_intf;
         int status;
 
+        pci_read_config_dword(adapter->pdev, SLI_INTF_REG_OFFSET, &sli_intf);
+        adapter->sli_family = (sli_intf & SLI_INTF_FAMILY_MASK) >>
+                                 SLI_INTF_FAMILY_SHIFT;
+        adapter->virtfn = (sli_intf & SLI_INTF_FT_MASK) ? 1 : 0;
+
         status = be_map_pci_bars(adapter);
         if (status)
                 goto done;
@@ -3473,13 +3718,6 @@ static int be_ctrl_init(struct be_adapter *adapter)
                 goto free_mbox;
         }
         memset(rx_filter->va, 0, rx_filter->size);
-
-        /* primary mac needs 1 pmac entry */
-        adapter->pmac_id = kcalloc(adapter->max_pmac_cnt + 1,
-                                   sizeof(*adapter->pmac_id), GFP_KERNEL);
-        if (!adapter->pmac_id)
-                return -ENOMEM;
-
         mutex_init(&adapter->mbox_lock);
         spin_lock_init(&adapter->mcc_lock);
         spin_lock_init(&adapter->mcc_cq_lock);
@@ -3512,14 +3750,14 @@ static int be_stats_init(struct be_adapter *adapter)
 {
         struct be_dma_mem *cmd = &adapter->stats_cmd;
 
-        if (adapter->generation == BE_GEN2) {
+        if (lancer_chip(adapter))
+                cmd->size = sizeof(struct lancer_cmd_req_pport_stats);
+        else if (BE2_chip(adapter))
                 cmd->size = sizeof(struct be_cmd_req_get_stats_v0);
-        } else {
-                if (lancer_chip(adapter))
-                        cmd->size = sizeof(struct lancer_cmd_req_pport_stats);
-                else
-                        cmd->size = sizeof(struct be_cmd_req_get_stats_v1);
-        }
+        else
+                /* BE3 and Skyhawk */
+                cmd->size = sizeof(struct be_cmd_req_get_stats_v1);
+
         cmd->va = dma_alloc_coherent(&adapter->pdev->dev, cmd->size, &cmd->dma,
                                      GFP_KERNEL);
         if (cmd->va == NULL)
@@ -3573,6 +3811,9 @@ u32 be_get_fw_log_level(struct be_adapter *adapter)
         u32 level = 0;
         int j;
 
+        if (lancer_chip(adapter))
+                return 0;
+
         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,
@@ -3598,26 +3839,12 @@ u32 be_get_fw_log_level(struct be_adapter *adapter)
 err:
         return level;
 }
+
 static int be_get_initial_config(struct be_adapter *adapter)
 {
         int status;
         u32 level;
 
-        status = be_cmd_query_fw_cfg(adapter, &adapter->port_num,
-                        &adapter->function_mode, &adapter->function_caps);
-        if (status)
-                return status;
-
-        if (adapter->function_mode & FLEX10_MODE)
-                adapter->max_vlans = BE_NUM_VLANS_SUPPORTED/8;
-        else
-                adapter->max_vlans = BE_NUM_VLANS_SUPPORTED;
-
-        if (be_physfn(adapter))
-                adapter->max_pmac_cnt = BE_UC_PMAC_COUNT;
-        else
-                adapter->max_pmac_cnt = BE_VF_UC_PMAC_COUNT;
-
         status = be_cmd_get_cntl_attributes(adapter);
         if (status)
                 return status;
@@ -3642,55 +3869,6 @@ static int be_get_initial_config(struct be_adapter *adapter)
         return 0;
 }
 
-static int be_dev_type_check(struct be_adapter *adapter)
-{
-        struct pci_dev *pdev = adapter->pdev;
-        u32 sli_intf = 0, if_type;
-
-        switch (pdev->device) {
-        case BE_DEVICE_ID1:
-        case OC_DEVICE_ID1:
-                adapter->generation = BE_GEN2;
-                break;
-        case BE_DEVICE_ID2:
-        case OC_DEVICE_ID2:
-                adapter->generation = BE_GEN3;
-                break;
-        case OC_DEVICE_ID3:
-        case OC_DEVICE_ID4:
-                pci_read_config_dword(pdev, SLI_INTF_REG_OFFSET, &sli_intf);
-                adapter->if_type = (sli_intf & SLI_INTF_IF_TYPE_MASK) >>
-                                                SLI_INTF_IF_TYPE_SHIFT;
-                if_type = (sli_intf & SLI_INTF_IF_TYPE_MASK) >>
-                                                SLI_INTF_IF_TYPE_SHIFT;
-                if (((sli_intf & SLI_INTF_VALID_MASK) != SLI_INTF_VALID) ||
-                        !be_type_2_3(adapter)) {
-                        dev_err(&pdev->dev, "SLI_INTF reg val is not valid\n");
-                        return -EINVAL;
-                }
-                adapter->sli_family = ((sli_intf & SLI_INTF_FAMILY_MASK) >>
-                                         SLI_INTF_FAMILY_SHIFT);
-                adapter->generation = BE_GEN3;
-                break;
-        case OC_DEVICE_ID5:
-                pci_read_config_dword(pdev, SLI_INTF_REG_OFFSET, &sli_intf);
-                if ((sli_intf & SLI_INTF_VALID_MASK) != SLI_INTF_VALID) {
-                        dev_err(&pdev->dev, "SLI_INTF reg val is not valid\n");
-                        return -EINVAL;
-                }
-                adapter->sli_family = ((sli_intf & SLI_INTF_FAMILY_MASK) >>
-                                         SLI_INTF_FAMILY_SHIFT);
-                adapter->generation = BE_GEN3;
-                break;
-        default:
-                adapter->generation = 0;
-        }
-
-        pci_read_config_dword(adapter->pdev, SLI_INTF_REG_OFFSET, &sli_intf);
-        adapter->virtfn = (sli_intf & SLI_INTF_FT_MASK) ? 1 : 0;
-        return 0;
-}
-
 static int lancer_recover_func(struct be_adapter *adapter)
 {
         int status;
@@ -3721,8 +3899,9 @@ static int lancer_recover_func(struct be_adapter *adapter)
                 "Adapter SLIPORT recovery succeeded\n");
         return 0;
 err:
-        dev_err(&adapter->pdev->dev,
-                "Adapter SLIPORT recovery failed\n");
+        if (adapter->eeh_error)
+                dev_err(&adapter->pdev->dev,
+                        "Adapter SLIPORT recovery failed\n");
 
         return status;
 }
@@ -3845,11 +4024,6 @@ static int __devinit be_probe(struct pci_dev *pdev,
         adapter = netdev_priv(netdev);
         adapter->pdev = pdev;
         pci_set_drvdata(pdev, adapter);
-
-        status = be_dev_type_check(adapter);
-        if (status)
-                goto free_netdev;
-
         adapter->netdev = netdev;
         SET_NETDEV_DEV(netdev, &pdev->dev);
 
@@ -4023,9 +4197,6 @@ static void be_shutdown(struct pci_dev *pdev)
 
         netif_device_detach(adapter->netdev);
 
-        if (adapter->wol)
-                be_setup_wol(adapter, true);
-
         be_cmd_reset_function(adapter);
 
         pci_disable_device(pdev);
@@ -4061,9 +4232,13 @@ static pci_ers_result_t be_eeh_err_detected(struct pci_dev *pdev,
 
         /* The error could cause the FW to trigger a flash debug dump.
          * Resetting the card while flash dump is in progress
-         * can cause it not to recover; wait for it to finish
+         * can cause it not to recover; wait for it to finish.
+         * Wait only for first function as it is needed only once per
+         * adapter.
          */
-        ssleep(30);
+        if (pdev->devfn == 0)
+                ssleep(30);
+
         return PCI_ERS_RESULT_NEED_RESET;
 }
 
diff --git a/drivers/net/ethernet/emulex/benet/be_roce.c b/drivers/net/ethernet/emulex/benet/be_roce.c
index deecc44b3617..55d32aa0a093 100644
--- a/drivers/net/ethernet/emulex/benet/be_roce.c
+++ b/drivers/net/ethernet/emulex/benet/be_roce.c
@@ -47,10 +47,7 @@ static void _be_roce_dev_add(struct be_adapter *adapter)
                 dev_info.dpp_unmapped_len = 0;
         }
         dev_info.pdev = adapter->pdev;
-        if (adapter->sli_family == SKYHAWK_SLI_FAMILY)
-                dev_info.db = adapter->db;
-        else
-                dev_info.db = adapter->roce_db.base;
+        dev_info.db = adapter->db;
         dev_info.unmapped_db = adapter->roce_db.io_addr;
         dev_info.db_page_size = adapter->roce_db.size;
         dev_info.db_total_size = adapter->roce_db.total_size;
diff --git a/drivers/net/ethernet/freescale/Kconfig b/drivers/net/ethernet/freescale/Kconfig
index feff51664dcf..5ba6e1cbd346 100644
--- a/drivers/net/ethernet/freescale/Kconfig
+++ b/drivers/net/ethernet/freescale/Kconfig
@@ -92,4 +92,13 @@ config GIANFAR
           This driver supports the Gigabit TSEC on the MPC83xx, MPC85xx,
           and MPC86xx family of chips, and the FEC on the 8540.
 
+config FEC_PTP
+        bool "PTP Hardware Clock (PHC)"
+        depends on FEC && ARCH_MXC
+        select PTP_1588_CLOCK
+        default y if SOC_IMX6Q
+        --help---
+          Say Y here if you want to use PTP Hardware Clock (PHC) in the
+          driver.  Only the basic clock operations have been implemented.
+
 endif # NET_VENDOR_FREESCALE
diff --git a/drivers/net/ethernet/freescale/Makefile b/drivers/net/ethernet/freescale/Makefile
index 3d1839afff65..d4d19b3d00ae 100644
--- a/drivers/net/ethernet/freescale/Makefile
+++ b/drivers/net/ethernet/freescale/Makefile
@@ -3,6 +3,7 @@
 #
 
 obj-$(CONFIG_FEC) += fec.o
+obj-$(CONFIG_FEC_PTP) += fec_ptp.o
 obj-$(CONFIG_FEC_MPC52xx) += fec_mpc52xx.o
 ifeq ($(CONFIG_FEC_MPC52xx_MDIO),y)
         obj-$(CONFIG_FEC_MPC52xx) += fec_mpc52xx_phy.o
diff --git a/drivers/net/ethernet/freescale/fec.c b/drivers/net/ethernet/freescale/fec.c
index fffd20528b5d..2665162ff4e5 100644
--- a/drivers/net/ethernet/freescale/fec.c
+++ b/drivers/net/ethernet/freescale/fec.c
@@ -140,21 +140,6 @@ MODULE_PARM_DESC(macaddr, "FEC Ethernet MAC address");
 #endif
 #endif /* CONFIG_M5272 */
 
-/* The number of Tx and Rx buffers.  These are allocated from the page
- * pool.  The code may assume these are power of two, so it it best
- * to keep them that size.
- * We don't need to allocate pages for the transmitter.  We just use
- * the skbuffer directly.
- */
-#define FEC_ENET_RX_PAGES       8
-#define FEC_ENET_RX_FRSIZE      2048
-#define FEC_ENET_RX_FRPPG       (PAGE_SIZE / FEC_ENET_RX_FRSIZE)
-#define RX_RING_SIZE            (FEC_ENET_RX_FRPPG * FEC_ENET_RX_PAGES)
-#define FEC_ENET_TX_FRSIZE      2048
-#define FEC_ENET_TX_FRPPG       (PAGE_SIZE / FEC_ENET_TX_FRSIZE)
-#define TX_RING_SIZE            16      /* Must be power of two */
-#define TX_RING_MOD_MASK        15      /*   for this to work */
-
 #if (((RX_RING_SIZE + TX_RING_SIZE) * 8) > PAGE_SIZE)
 #error "FEC: descriptor ring size constants too large"
 #endif
@@ -179,9 +164,6 @@ MODULE_PARM_DESC(macaddr, "FEC Ethernet MAC address");
 #define PKT_MINBUF_SIZE         64
 #define PKT_MAXBLR_SIZE         1520
 
-/* This device has up to three irqs on some platforms */
-#define FEC_IRQ_NUM             3
-
 /*
  * The 5270/5271/5280/5282/532x RX control register also contains maximum frame
  * size bits. Other FEC hardware does not, so we need to take that into
@@ -194,61 +176,6 @@ MODULE_PARM_DESC(macaddr, "FEC Ethernet MAC address");
 #define OPT_FRAME_SIZE  0
 #endif
 
-/* The FEC buffer descriptors track the ring buffers.  The rx_bd_base and
- * tx_bd_base always point to the base of the buffer descriptors.  The
- * cur_rx and cur_tx point to the currently available buffer.
- * The dirty_tx tracks the current buffer that is being sent by the
- * controller.  The cur_tx and dirty_tx are equal under both completely
- * empty and completely full conditions.  The empty/ready indicator in
- * the buffer descriptor determines the actual condition.
- */
-struct fec_enet_private {
-        /* Hardware registers of the FEC device */
-        void __iomem *hwp;
-
-        struct net_device *netdev;
-
-        struct clk *clk_ipg;
-        struct clk *clk_ahb;
-
-        /* The saved address of a sent-in-place packet/buffer, for skfree(). */
-        unsigned char *tx_bounce[TX_RING_SIZE];
-        struct  sk_buff* tx_skbuff[TX_RING_SIZE];
-        struct  sk_buff* rx_skbuff[RX_RING_SIZE];
-        ushort  skb_cur;
-        ushort  skb_dirty;
-
-        /* CPM dual port RAM relative addresses */
-        dma_addr_t      bd_dma;
-        /* Address of Rx and Tx buffers */
-        struct bufdesc  *rx_bd_base;
-        struct bufdesc  *tx_bd_base;
-        /* The next free ring entry */
-        struct bufdesc  *cur_rx, *cur_tx;
-        /* The ring entries to be free()ed */
-        struct bufdesc  *dirty_tx;
-
-        uint    tx_full;
-        /* hold while accessing the HW like ringbuffer for tx/rx but not MAC */
-        spinlock_t hw_lock;
-
-        struct  platform_device *pdev;
-
-        int     opened;
-        int     dev_id;
-
-        /* Phylib and MDIO interface */
-        struct  mii_bus *mii_bus;
-        struct  phy_device *phy_dev;
-        int     mii_timeout;
-        uint    phy_speed;
-        phy_interface_t phy_interface;
-        int     link;
-        int     full_duplex;
-        struct  completion mdio_done;
-        int     irq[FEC_IRQ_NUM];
-};
-
 /* FEC MII MMFR bits definition */
 #define FEC_MMFR_ST             (1 << 30)
 #define FEC_MMFR_OP_READ        (2 << 28)
@@ -353,6 +280,17 @@ fec_enet_start_xmit(struct sk_buff *skb, struct net_device *ndev)
                         | BD_ENET_TX_LAST | BD_ENET_TX_TC);
         bdp->cbd_sc = status;
 
+#ifdef CONFIG_FEC_PTP
+        bdp->cbd_bdu = 0;
+        if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP &&
+                        fep->hwts_tx_en)) {
+                        bdp->cbd_esc = (BD_ENET_TX_TS | BD_ENET_TX_INT);
+                        skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
+        } else {
+
+                bdp->cbd_esc = BD_ENET_TX_INT;
+        }
+#endif
         /* Trigger transmission start */
         writel(0, fep->hwp + FEC_X_DES_ACTIVE);
 
@@ -510,10 +448,17 @@ fec_restart(struct net_device *ndev, int duplex)
                 writel(1 << 8, fep->hwp + FEC_X_WMRK);
         }
 
+#ifdef CONFIG_FEC_PTP
+        ecntl |= (1 << 4);
+#endif
+
         /* And last, enable the transmit and receive processing */
         writel(ecntl, fep->hwp + FEC_ECNTRL);
         writel(0, fep->hwp + FEC_R_DES_ACTIVE);
 
+#ifdef CONFIG_FEC_PTP
+        fec_ptp_start_cyclecounter(ndev);
+#endif
         /* Enable interrupts we wish to service */
         writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
 }
@@ -599,6 +544,19 @@ fec_enet_tx(struct net_device *ndev)
                         ndev->stats.tx_packets++;
                 }
 
+#ifdef CONFIG_FEC_PTP
+                if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS)) {
+                        struct skb_shared_hwtstamps shhwtstamps;
+                        unsigned long flags;
+
+                        memset(&shhwtstamps, 0, sizeof(shhwtstamps));
+                        spin_lock_irqsave(&fep->tmreg_lock, flags);
+                        shhwtstamps.hwtstamp = ns_to_ktime(
+                                timecounter_cyc2time(&fep->tc, bdp->ts));
+                        spin_unlock_irqrestore(&fep->tmreg_lock, flags);
+                        skb_tstamp_tx(skb, &shhwtstamps);
+                }
+#endif
                 if (status & BD_ENET_TX_READY)
                         printk("HEY! Enet xmit interrupt and TX_READY.\n");
 
@@ -725,6 +683,21 @@ fec_enet_rx(struct net_device *ndev)
                         skb_put(skb, pkt_len - 4);      /* Make room */
                         skb_copy_to_linear_data(skb, data, pkt_len - 4);
                         skb->protocol = eth_type_trans(skb, ndev);
+#ifdef CONFIG_FEC_PTP
+                        /* Get receive timestamp from the skb */
+                        if (fep->hwts_rx_en) {
+                                struct skb_shared_hwtstamps *shhwtstamps =
+                                                            skb_hwtstamps(skb);
+                                unsigned long flags;
+
+                                memset(shhwtstamps, 0, sizeof(*shhwtstamps));
+
+                                spin_lock_irqsave(&fep->tmreg_lock, flags);
+                                shhwtstamps->hwtstamp = ns_to_ktime(
+                                    timecounter_cyc2time(&fep->tc, bdp->ts));
+                                spin_unlock_irqrestore(&fep->tmreg_lock, flags);
+                        }
+#endif
                         if (!skb_defer_rx_timestamp(skb))
                                 netif_rx(skb);
                 }
@@ -739,6 +712,12 @@ rx_processing_done:
                 status |= BD_ENET_RX_EMPTY;
                 bdp->cbd_sc = status;
 
+#ifdef CONFIG_FEC_PTP
+                bdp->cbd_esc = BD_ENET_RX_INT;
+                bdp->cbd_prot = 0;
+                bdp->cbd_bdu = 0;
+#endif
+
                 /* Update BD pointer to next entry */
                 if (status & BD_ENET_RX_WRAP)
                         bdp = fep->rx_bd_base;
@@ -1178,6 +1157,10 @@ static int fec_enet_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd)
         if (!phydev)
                 return -ENODEV;
 
+#ifdef CONFIG_FEC_PTP
+        if (cmd == SIOCSHWTSTAMP)
+                return fec_ptp_ioctl(ndev, rq, cmd);
+#endif
         return phy_mii_ioctl(phydev, rq, cmd);
 }
 
@@ -1224,6 +1207,9 @@ static int fec_enet_alloc_buffers(struct net_device *ndev)
                 bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, skb->data,
                                 FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);
                 bdp->cbd_sc = BD_ENET_RX_EMPTY;
+#ifdef CONFIG_FEC_PTP
+                bdp->cbd_esc = BD_ENET_RX_INT;
+#endif
                 bdp++;
         }
 
@@ -1237,6 +1223,10 @@ static int fec_enet_alloc_buffers(struct net_device *ndev)
 
                 bdp->cbd_sc = 0;
                 bdp->cbd_bufaddr = 0;
+
+#ifdef CONFIG_FEC_PTP
+                bdp->cbd_esc = BD_ENET_RX_INT;
+#endif
                 bdp++;
         }
 
@@ -1638,9 +1628,19 @@ fec_probe(struct platform_device *pdev)
                 goto failed_clk;
         }
 
+#ifdef CONFIG_FEC_PTP
+        fep->clk_ptp = devm_clk_get(&pdev->dev, "ptp");
+        if (IS_ERR(fep->clk_ptp)) {
+                ret = PTR_ERR(fep->clk_ptp);
+                goto failed_clk;
+        }
+#endif
+
         clk_prepare_enable(fep->clk_ahb);
         clk_prepare_enable(fep->clk_ipg);
-
+#ifdef CONFIG_FEC_PTP
+        clk_prepare_enable(fep->clk_ptp);
+#endif
         reg_phy = devm_regulator_get(&pdev->dev, "phy");
         if (!IS_ERR(reg_phy)) {
                 ret = regulator_enable(reg_phy);
@@ -1668,6 +1668,10 @@ fec_probe(struct platform_device *pdev)
         if (ret)
                 goto failed_register;
 
+#ifdef CONFIG_FEC_PTP
+        fec_ptp_init(ndev, pdev);
+#endif
+
         return 0;
 
 failed_register:
@@ -1677,6 +1681,9 @@ failed_init:
 failed_regulator:
         clk_disable_unprepare(fep->clk_ahb);
         clk_disable_unprepare(fep->clk_ipg);
+#ifdef CONFIG_FEC_PTP
+        clk_disable_unprepare(fep->clk_ptp);
+#endif
 failed_pin:
 failed_clk:
         for (i = 0; i < FEC_IRQ_NUM; i++) {
@@ -1709,6 +1716,12 @@ fec_drv_remove(struct platform_device *pdev)
                 if (irq > 0)
                         free_irq(irq, ndev);
         }
+#ifdef CONFIG_FEC_PTP
+        del_timer_sync(&fep->time_keep);
+        clk_disable_unprepare(fep->clk_ptp);
+        if (fep->ptp_clock)
+                ptp_clock_unregister(fep->ptp_clock);
+#endif
         clk_disable_unprepare(fep->clk_ahb);
         clk_disable_unprepare(fep->clk_ipg);
         iounmap(fep->hwp);
diff --git a/drivers/net/ethernet/freescale/fec.h b/drivers/net/ethernet/freescale/fec.h
index 8408c627b195..c5a3bc1475c7 100644
--- a/drivers/net/ethernet/freescale/fec.h
+++ b/drivers/net/ethernet/freescale/fec.h
@@ -13,6 +13,12 @@
 #define FEC_H
 /****************************************************************************/
 
+#ifdef CONFIG_FEC_PTP
+#include <linux/clocksource.h>
+#include <linux/net_tstamp.h>
+#include <linux/ptp_clock_kernel.h>
+#endif
+
 #if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
     defined(CONFIG_M520x) || defined(CONFIG_M532x) || \
     defined(CONFIG_ARCH_MXC) || defined(CONFIG_SOC_IMX28)
@@ -88,6 +94,13 @@ struct bufdesc {
         unsigned short cbd_datlen;      /* Data length */
         unsigned short cbd_sc;  /* Control and status info */
         unsigned long cbd_bufaddr;      /* Buffer address */
+#ifdef CONFIG_FEC_PTP
+        unsigned long cbd_esc;
+        unsigned long cbd_prot;
+        unsigned long cbd_bdu;
+        unsigned long ts;
+        unsigned short res0[4];
+#endif
 };
 #else
 struct bufdesc {
@@ -147,6 +160,112 @@ struct bufdesc {
 #define BD_ENET_TX_CSL          ((ushort)0x0001)
 #define BD_ENET_TX_STATS        ((ushort)0x03ff)        /* All status bits */
 
+/*enhanced buffer desciptor control/status used by Ethernet transmit*/
+#define BD_ENET_TX_INT          0x40000000
+#define BD_ENET_TX_TS           0x20000000
+
+
+/* This device has up to three irqs on some platforms */
+#define FEC_IRQ_NUM             3
+
+/* The number of Tx and Rx buffers.  These are allocated from the page
+ * pool.  The code may assume these are power of two, so it it best
+ * to keep them that size.
+ * We don't need to allocate pages for the transmitter.  We just use
+ * the skbuffer directly.
+ */
+
+#define FEC_ENET_RX_PAGES       8
+#define FEC_ENET_RX_FRSIZE      2048
+#define FEC_ENET_RX_FRPPG       (PAGE_SIZE / FEC_ENET_RX_FRSIZE)
+#define RX_RING_SIZE            (FEC_ENET_RX_FRPPG * FEC_ENET_RX_PAGES)
+#define FEC_ENET_TX_FRSIZE      2048
+#define FEC_ENET_TX_FRPPG       (PAGE_SIZE / FEC_ENET_TX_FRSIZE)
+#define TX_RING_SIZE            16      /* Must be power of two */
+#define TX_RING_MOD_MASK        15      /*   for this to work */
+
+#define BD_ENET_RX_INT          0x00800000
+#define BD_ENET_RX_PTP          ((ushort)0x0400)
+
+/* The FEC buffer descriptors track the ring buffers.  The rx_bd_base and
+ * tx_bd_base always point to the base of the buffer descriptors.  The
+ * cur_rx and cur_tx point to the currently available buffer.
+ * The dirty_tx tracks the current buffer that is being sent by the
+ * controller.  The cur_tx and dirty_tx are equal under both completely
+ * empty and completely full conditions.  The empty/ready indicator in
+ * the buffer descriptor determines the actual condition.
+ */
+struct fec_enet_private {
+        /* Hardware registers of the FEC device */
+        void __iomem *hwp;
+
+        struct net_device *netdev;
+
+        struct clk *clk_ipg;
+        struct clk *clk_ahb;
+#ifdef CONFIG_FEC_PTP
+        struct clk *clk_ptp;
+#endif
+
+        /* The saved address of a sent-in-place packet/buffer, for skfree(). */
+        unsigned char *tx_bounce[TX_RING_SIZE];
+        struct  sk_buff *tx_skbuff[TX_RING_SIZE];
+        struct  sk_buff *rx_skbuff[RX_RING_SIZE];
+        ushort  skb_cur;
+        ushort  skb_dirty;
+
+        /* CPM dual port RAM relative addresses */
+        dma_addr_t      bd_dma;
+        /* Address of Rx and Tx buffers */
+        struct bufdesc  *rx_bd_base;
+        struct bufdesc  *tx_bd_base;
+        /* The next free ring entry */
+        struct bufdesc  *cur_rx, *cur_tx;
+        /* The ring entries to be free()ed */
+        struct bufdesc  *dirty_tx;
+
+        uint    tx_full;
+        /* hold while accessing the HW like ringbuffer for tx/rx but not MAC */
+        spinlock_t hw_lock;
+
+        struct  platform_device *pdev;
+
+        int     opened;
+        int     dev_id;
+
+        /* Phylib and MDIO interface */
+        struct  mii_bus *mii_bus;
+        struct  phy_device *phy_dev;
+        int     mii_timeout;
+        uint    phy_speed;
+        phy_interface_t phy_interface;
+        int     link;
+        int     full_duplex;
+        struct  completion mdio_done;
+        int     irq[FEC_IRQ_NUM];
+
+#ifdef CONFIG_FEC_PTP
+        struct ptp_clock *ptp_clock;
+        struct ptp_clock_info ptp_caps;
+        unsigned long last_overflow_check;
+        spinlock_t tmreg_lock;
+        struct cyclecounter cc;
+        struct timecounter tc;
+        int rx_hwtstamp_filter;
+        u32 base_incval;
+        u32 cycle_speed;
+        int hwts_rx_en;
+        int hwts_tx_en;
+        struct timer_list time_keep;
+#endif
+
+};
+
+#ifdef CONFIG_FEC_PTP
+void fec_ptp_init(struct net_device *ndev, struct platform_device *pdev);
+void fec_ptp_start_cyclecounter(struct net_device *ndev);
+int fec_ptp_ioctl(struct net_device *ndev, struct ifreq *ifr, int cmd);
+#endif
 
 /****************************************************************************/
 #endif /* FEC_H */
diff --git a/drivers/net/ethernet/freescale/fec_ptp.c b/drivers/net/ethernet/freescale/fec_ptp.c
new file mode 100644
index 000000000000..c40526c78c20
--- /dev/null
+++ b/drivers/net/ethernet/freescale/fec_ptp.c
@@ -0,0 +1,383 @@
+/*
+ * Fast Ethernet Controller (ENET) PTP driver for MX6x.
+ *
+ * Copyright (C) 2012 Freescale Semiconductor, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/workqueue.h>
+#include <linux/bitops.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/clk.h>
+#include <linux/platform_device.h>
+#include <linux/phy.h>
+#include <linux/fec.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
+#include <linux/of_net.h>
+
+#include "fec.h"
+
+/* FEC 1588 register bits */
+#define FEC_T_CTRL_SLAVE                0x00002000
+#define FEC_T_CTRL_CAPTURE              0x00000800
+#define FEC_T_CTRL_RESTART              0x00000200
+#define FEC_T_CTRL_PERIOD_RST           0x00000030
+#define FEC_T_CTRL_PERIOD_EN            0x00000010
+#define FEC_T_CTRL_ENABLE               0x00000001
+
+#define FEC_T_INC_MASK                  0x0000007f
+#define FEC_T_INC_OFFSET                0
+#define FEC_T_INC_CORR_MASK             0x00007f00
+#define FEC_T_INC_CORR_OFFSET           8
+
+#define FEC_ATIME_CTRL          0x400
+#define FEC_ATIME               0x404
+#define FEC_ATIME_EVT_OFFSET    0x408
+#define FEC_ATIME_EVT_PERIOD    0x40c
+#define FEC_ATIME_CORR          0x410
+#define FEC_ATIME_INC           0x414
+#define FEC_TS_TIMESTAMP        0x418
+
+#define FEC_CC_MULT     (1 << 31)
+/**
+ * fec_ptp_read - read raw cycle counter (to be used by time counter)
+ * @cc: the cyclecounter structure
+ *
+ * this function reads the cyclecounter registers and is called by the
+ * cyclecounter structure used to construct a ns counter from the
+ * arbitrary fixed point registers
+ */
+static cycle_t fec_ptp_read(const struct cyclecounter *cc)
+{
+        struct fec_enet_private *fep =
+                container_of(cc, struct fec_enet_private, cc);
+        u32 tempval;
+
+        tempval = readl(fep->hwp + FEC_ATIME_CTRL);
+        tempval |= FEC_T_CTRL_CAPTURE;
+        writel(tempval, fep->hwp + FEC_ATIME_CTRL);
+
+        return readl(fep->hwp + FEC_ATIME);
+}
+
+/**
+ * fec_ptp_start_cyclecounter - create the cycle counter from hw
+ * @ndev: network device
+ *
+ * this function initializes the timecounter and cyclecounter
+ * structures for use in generated a ns counter from the arbitrary
+ * fixed point cycles registers in the hardware.
+ */
+void fec_ptp_start_cyclecounter(struct net_device *ndev)
+{
+        struct fec_enet_private *fep = netdev_priv(ndev);
+        unsigned long flags;
+        int inc;
+
+        inc = 1000000000 / clk_get_rate(fep->clk_ptp);
+
+        /* grab the ptp lock */
+        spin_lock_irqsave(&fep->tmreg_lock, flags);
+
+        /* 1ns counter */
+        writel(inc << FEC_T_INC_OFFSET, fep->hwp + FEC_ATIME_INC);
+
+        /* use free running count */
+        writel(0, fep->hwp + FEC_ATIME_EVT_PERIOD);
+
+        writel(FEC_T_CTRL_ENABLE, fep->hwp + FEC_ATIME_CTRL);
+
+        memset(&fep->cc, 0, sizeof(fep->cc));
+        fep->cc.read = fec_ptp_read;
+        fep->cc.mask = CLOCKSOURCE_MASK(32);
+        fep->cc.shift = 31;
+        fep->cc.mult = FEC_CC_MULT;
+
+        /* reset the ns time counter */
+        timecounter_init(&fep->tc, &fep->cc, ktime_to_ns(ktime_get_real()));
+
+        spin_unlock_irqrestore(&fep->tmreg_lock, flags);
+}
+
+/**
+ * fec_ptp_adjfreq - adjust ptp cycle frequency
+ * @ptp: the ptp clock structure
+ * @ppb: parts per billion adjustment from base
+ *
+ * Adjust the frequency of the ptp cycle counter by the
+ * indicated ppb from the base frequency.
+ *
+ * Because ENET hardware frequency adjust is complex,
+ * using software method to do that.
+ */
+static int fec_ptp_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
+{
+        u64 diff;
+        unsigned long flags;
+        int neg_adj = 0;
+        u32 mult = FEC_CC_MULT;
+
+        struct fec_enet_private *fep =
+            container_of(ptp, struct fec_enet_private, ptp_caps);
+
+        if (ppb < 0) {
+                ppb = -ppb;
+                neg_adj = 1;
+        }
+
+        diff = mult;
+        diff *= ppb;
+        diff = div_u64(diff, 1000000000ULL);
+
+        spin_lock_irqsave(&fep->tmreg_lock, flags);
+        /*
+         * dummy read to set cycle_last in tc to now.
+         * So use adjusted mult to calculate when next call
+         * timercounter_read.
+         */
+        timecounter_read(&fep->tc);
+
+        fep->cc.mult = neg_adj ? mult - diff : mult + diff;
+
+        spin_unlock_irqrestore(&fep->tmreg_lock, flags);
+
+        return 0;
+}
+
+/**
+ * fec_ptp_adjtime
+ * @ptp: the ptp clock structure
+ * @delta: offset to adjust the cycle counter by
+ *
+ * adjust the timer by resetting the timecounter structure.
+ */
+static int fec_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
+{
+        struct fec_enet_private *fep =
+            container_of(ptp, struct fec_enet_private, ptp_caps);
+        unsigned long flags;
+        u64 now;
+
+        spin_lock_irqsave(&fep->tmreg_lock, flags);
+
+        now = timecounter_read(&fep->tc);
+        now += delta;
+
+        /* reset the timecounter */
+        timecounter_init(&fep->tc, &fep->cc, now);
+
+        spin_unlock_irqrestore(&fep->tmreg_lock, flags);
+
+        return 0;
+}
+
+/**
+ * fec_ptp_gettime
+ * @ptp: the ptp clock structure
+ * @ts: timespec structure to hold the current time value
+ *
+ * read the timecounter and return the correct value on ns,
+ * after converting it into a struct timespec.
+ */
+static int fec_ptp_gettime(struct ptp_clock_info *ptp, struct timespec *ts)
+{
+        struct fec_enet_private *adapter =
+            container_of(ptp, struct fec_enet_private, ptp_caps);
+        u64 ns;
+        u32 remainder;
+        unsigned long flags;
+
+        spin_lock_irqsave(&adapter->tmreg_lock, flags);
+        ns = timecounter_read(&adapter->tc);
+        spin_unlock_irqrestore(&adapter->tmreg_lock, flags);
+
+        ts->tv_sec = div_u64_rem(ns, 1000000000ULL, &remainder);
+        ts->tv_nsec = remainder;
+
+        return 0;
+}
+
+/**
+ * fec_ptp_settime
+ * @ptp: the ptp clock structure
+ * @ts: the timespec containing the new time for the cycle counter
+ *
+ * reset the timecounter to use a new base value instead of the kernel
+ * wall timer value.
+ */
+static int fec_ptp_settime(struct ptp_clock_info *ptp,
+                           const struct timespec *ts)
+{
+        struct fec_enet_private *fep =
+            container_of(ptp, struct fec_enet_private, ptp_caps);
+
+        u64 ns;
+        unsigned long flags;
+
+        ns = ts->tv_sec * 1000000000ULL;
+        ns += ts->tv_nsec;
+
+        spin_lock_irqsave(&fep->tmreg_lock, flags);
+        timecounter_init(&fep->tc, &fep->cc, ns);
+        spin_unlock_irqrestore(&fep->tmreg_lock, flags);
+        return 0;
+}
+
+/**
+ * fec_ptp_enable
+ * @ptp: the ptp clock structure
+ * @rq: the requested feature to change
+ * @on: whether to enable or disable the feature
+ *
+ */
+static int fec_ptp_enable(struct ptp_clock_info *ptp,
+                          struct ptp_clock_request *rq, int on)
+{
+        return -EOPNOTSUPP;
+}
+
+/**
+ * fec_ptp_hwtstamp_ioctl - control hardware time stamping
+ * @ndev: pointer to net_device
+ * @ifreq: ioctl data
+ * @cmd: particular ioctl requested
+ */
+int fec_ptp_ioctl(struct net_device *ndev, struct ifreq *ifr, int cmd)
+{
+        struct fec_enet_private *fep = netdev_priv(ndev);
+
+        struct hwtstamp_config config;
+
+        if (copy_from_user(&config, ifr->ifr_data, sizeof(config)))
+                return -EFAULT;
+
+        /* reserved for future extensions */
+        if (config.flags)
+                return -EINVAL;
+
+        switch (config.tx_type) {
+        case HWTSTAMP_TX_OFF:
+                fep->hwts_tx_en = 0;
+                break;
+        case HWTSTAMP_TX_ON:
+                fep->hwts_tx_en = 1;
+                break;
+        default:
+                return -ERANGE;
+        }
+
+        switch (config.rx_filter) {
+        case HWTSTAMP_FILTER_NONE:
+                if (fep->hwts_rx_en)
+                        fep->hwts_rx_en = 0;
+                config.rx_filter = HWTSTAMP_FILTER_NONE;
+                break;
+
+        default:
+                /*
+                 * register RXMTRL must be set in order to do V1 packets,
+                 * therefore it is not possible to time stamp both V1 Sync and
+                 * Delay_Req messages and hardware does not support
+                 * timestamping all packets => return error
+                 */
+                fep->hwts_rx_en = 1;
+                config.rx_filter = HWTSTAMP_FILTER_ALL;
+                break;
+        }
+
+        return copy_to_user(ifr->ifr_data, &config, sizeof(config)) ?
+            -EFAULT : 0;
+}
+
+/**
+ * fec_time_keep - call timecounter_read every second to avoid timer overrun
+ *                 because ENET just support 32bit counter, will timeout in 4s
+ */
+static void fec_time_keep(unsigned long _data)
+{
+        struct fec_enet_private *fep = (struct fec_enet_private *)_data;
+        u64 ns;
+        unsigned long flags;
+
+        spin_lock_irqsave(&fep->tmreg_lock, flags);
+        ns = timecounter_read(&fep->tc);
+        spin_unlock_irqrestore(&fep->tmreg_lock, flags);
+
+        mod_timer(&fep->time_keep, jiffies + HZ);
+}
+
+/**
+ * fec_ptp_init
+ * @ndev: The FEC network adapter
+ *
+ * This function performs the required steps for enabling ptp
+ * support. If ptp support has already been loaded it simply calls the
+ * cyclecounter init routine and exits.
+ */
+
+void fec_ptp_init(struct net_device *ndev, struct platform_device *pdev)
+{
+        struct fec_enet_private *fep = netdev_priv(ndev);
+
+        fep->ptp_caps.owner = THIS_MODULE;
+        snprintf(fep->ptp_caps.name, 16, "fec ptp");
+
+        fep->ptp_caps.max_adj = 250000000;
+        fep->ptp_caps.n_alarm = 0;
+        fep->ptp_caps.n_ext_ts = 0;
+        fep->ptp_caps.n_per_out = 0;
+        fep->ptp_caps.pps = 0;
+        fep->ptp_caps.adjfreq = fec_ptp_adjfreq;
+        fep->ptp_caps.adjtime = fec_ptp_adjtime;
+        fep->ptp_caps.gettime = fec_ptp_gettime;
+        fep->ptp_caps.settime = fec_ptp_settime;
+        fep->ptp_caps.enable = fec_ptp_enable;
+
+        spin_lock_init(&fep->tmreg_lock);
+
+        fec_ptp_start_cyclecounter(ndev);
+
+        init_timer(&fep->time_keep);
+        fep->time_keep.data = (unsigned long)fep;
+        fep->time_keep.function = fec_time_keep;
+        fep->time_keep.expires = jiffies + HZ;
+        add_timer(&fep->time_keep);
+
+        fep->ptp_clock = ptp_clock_register(&fep->ptp_caps, &pdev->dev);
+        if (IS_ERR(fep->ptp_clock)) {
+                fep->ptp_clock = NULL;
+                pr_err("ptp_clock_register failed\n");
+        } else {
+                pr_info("registered PHC device on %s\n", ndev->name);
+        }
+}
diff --git a/drivers/net/ethernet/freescale/gianfar.c b/drivers/net/ethernet/freescale/gianfar.c
index 19ac096cb07b..bffb2edd6858 100644
--- a/drivers/net/ethernet/freescale/gianfar.c
+++ b/drivers/net/ethernet/freescale/gianfar.c
@@ -210,7 +210,7 @@ static int gfar_init_bds(struct net_device *ndev)
                                 skb = gfar_new_skb(ndev);
                                 if (!skb) {
                                         netdev_err(ndev, "Can't allocate RX buffers\n");
-                                        goto err_rxalloc_fail;
+                                        return -ENOMEM;
                                 }
                                 rx_queue->rx_skbuff[j] = skb;
 
@@ -223,10 +223,6 @@ static int gfar_init_bds(struct net_device *ndev)
         }
 
         return 0;
-
-err_rxalloc_fail:
-        free_skb_resources(priv);
-        return -ENOMEM;
 }
 
 static int gfar_alloc_skb_resources(struct net_device *ndev)
@@ -1359,7 +1355,11 @@ static int gfar_restore(struct device *dev)
                 return 0;
         }
 
-        gfar_init_bds(ndev);
+        if (gfar_init_bds(ndev)) {
+                free_skb_resources(priv);
+                return -ENOMEM;
+        }
+
         init_registers(ndev);
         gfar_set_mac_address(ndev);
         gfar_init_mac(ndev);
@@ -1712,6 +1712,7 @@ static void free_skb_tx_queue(struct gfar_priv_tx_q *tx_queue)
                 tx_queue->tx_skbuff[i] = NULL;
         }
         kfree(tx_queue->tx_skbuff);
+        tx_queue->tx_skbuff = NULL;
 }
 
 static void free_skb_rx_queue(struct gfar_priv_rx_q *rx_queue)
@@ -1735,6 +1736,7 @@ static void free_skb_rx_queue(struct gfar_priv_rx_q *rx_queue)
                 rxbdp++;
         }
         kfree(rx_queue->rx_skbuff);
+        rx_queue->rx_skbuff = NULL;
 }
 
 /* If there are any tx skbs or rx skbs still around, free them.
diff --git a/drivers/net/ethernet/ibm/emac/mal.c b/drivers/net/ethernet/ibm/emac/mal.c
index 479e43e2f1ef..84c6b6cf9c14 100644
--- a/drivers/net/ethernet/ibm/emac/mal.c
+++ b/drivers/net/ethernet/ibm/emac/mal.c
@@ -738,13 +738,11 @@ static int __devexit mal_remove(struct platform_device *ofdev)
         /* Synchronize with scheduled polling */
         napi_disable(&mal->napi);
 
-        if (!list_empty(&mal->list)) {
+        if (!list_empty(&mal->list))
                 /* This is *very* bad */
-                printk(KERN_EMERG
+                WARN(1, KERN_EMERG
                        "mal%d: commac list is not empty on remove!\n",
                        mal->index);
-                WARN_ON(1);
-        }
 
         dev_set_drvdata(&ofdev->dev, NULL);
 
diff --git a/drivers/net/ethernet/intel/Kconfig b/drivers/net/ethernet/intel/Kconfig
index 0cafe4fe9406..73d28d51b5d9 100644
--- a/drivers/net/ethernet/intel/Kconfig
+++ b/drivers/net/ethernet/intel/Kconfig
@@ -93,6 +93,7 @@ config E1000E
 config IGB
         tristate "Intel(R) 82575/82576 PCI-Express Gigabit Ethernet support"
         depends on PCI
+        select PTP_1588_CLOCK
         ---help---
           This driver supports Intel(R) 82575/82576 gigabit ethernet family of
           adapters.  For more information on how to identify your adapter, go
@@ -120,19 +121,6 @@ config IGB_DCA
           driver.  DCA is a method for warming the CPU cache before data
           is used, with the intent of lessening the impact of cache misses.
 
-config IGB_PTP
-        bool "PTP Hardware Clock (PHC)"
-        default n
-        depends on IGB && EXPERIMENTAL
-        select PPS
-        select PTP_1588_CLOCK
-        ---help---
-          Say Y here if you want to use PTP Hardware Clock (PHC) in the
-          driver.  Only the basic clock operations have been implemented.
-
-          Every timestamp and clock read operations must consult the
-          overflow counter to form a correct time value.
-
 config IGBVF
         tristate "Intel(R) 82576 Virtual Function Ethernet support"
         depends on PCI
@@ -180,6 +168,7 @@ config IXGBE
         tristate "Intel(R) 10GbE PCI Express adapters support"
         depends on PCI && INET
         select MDIO
+        select PTP_1588_CLOCK
         ---help---
           This driver supports Intel(R) 10GbE PCI Express family of
           adapters.  For more information on how to identify your adapter, go
@@ -222,19 +211,6 @@ config IXGBE_DCB
 
           If unsure, say N.
 
-config IXGBE_PTP
-        bool "PTP Clock Support"
-        default n
-        depends on IXGBE && EXPERIMENTAL
-        select PPS
-        select PTP_1588_CLOCK
-        ---help---
-          Say Y here if you want support for 1588 Timestamping with a
-          PHC device, using the PTP 1588 Clock support. This is
-          required to enable timestamping support for the device.
-
-          If unsure, say N.
-
 config IXGBEVF
         tristate "Intel(R) 82599 Virtual Function Ethernet support"
         depends on PCI_MSI
diff --git a/drivers/net/ethernet/intel/e1000/e1000_hw.c b/drivers/net/ethernet/intel/e1000/e1000_hw.c
index 3d6839528761..8fedd2451538 100644
--- a/drivers/net/ethernet/intel/e1000/e1000_hw.c
+++ b/drivers/net/ethernet/intel/e1000/e1000_hw.c
@@ -107,6 +107,7 @@ u16 e1000_igp_cable_length_table[IGP01E1000_AGC_LENGTH_TABLE_SIZE] = {
 };
 
 static DEFINE_SPINLOCK(e1000_eeprom_lock);
+static DEFINE_SPINLOCK(e1000_phy_lock);
 
 /**
  * e1000_set_phy_type - Set the phy type member in the hw struct.
@@ -2830,19 +2831,25 @@ static u16 e1000_shift_in_mdi_bits(struct e1000_hw *hw)
 s32 e1000_read_phy_reg(struct e1000_hw *hw, u32 reg_addr, u16 *phy_data)
 {
         u32 ret_val;
+        unsigned long flags;
 
         e_dbg("e1000_read_phy_reg");
 
+        spin_lock_irqsave(&e1000_phy_lock, flags);
+
         if ((hw->phy_type == e1000_phy_igp) &&
             (reg_addr > MAX_PHY_MULTI_PAGE_REG)) {
                 ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT,
                                                  (u16) reg_addr);
-                if (ret_val)
+                if (ret_val) {
+                        spin_unlock_irqrestore(&e1000_phy_lock, flags);
                         return ret_val;
+                }
         }
 
         ret_val = e1000_read_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr,
                                         phy_data);
+        spin_unlock_irqrestore(&e1000_phy_lock, flags);
 
         return ret_val;
 }
@@ -2965,19 +2972,25 @@ static s32 e1000_read_phy_reg_ex(struct e1000_hw *hw, u32 reg_addr,
 s32 e1000_write_phy_reg(struct e1000_hw *hw, u32 reg_addr, u16 phy_data)
 {
         u32 ret_val;
+        unsigned long flags;
 
         e_dbg("e1000_write_phy_reg");
 
+        spin_lock_irqsave(&e1000_phy_lock, flags);
+
         if ((hw->phy_type == e1000_phy_igp) &&
             (reg_addr > MAX_PHY_MULTI_PAGE_REG)) {
                 ret_val = e1000_write_phy_reg_ex(hw, IGP01E1000_PHY_PAGE_SELECT,
                                                  (u16) reg_addr);
-                if (ret_val)
+                if (ret_val) {
+                        spin_unlock_irqrestore(&e1000_phy_lock, flags);
                         return ret_val;
+                }
         }
 
         ret_val = e1000_write_phy_reg_ex(hw, MAX_PHY_REG_ADDRESS & reg_addr,
                                          phy_data);
+        spin_unlock_irqrestore(&e1000_phy_lock, flags);
 
         return ret_val;
 }
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index f444eb0b76d8..dadb13be479a 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -5067,6 +5067,17 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
                 return NETDEV_TX_OK;
         }
 
+        /*
+         * The minimum packet size with TCTL.PSP set is 17 bytes so
+         * pad skb in order to meet this minimum size requirement
+         */
+        if (unlikely(skb->len < 17)) {
+                if (skb_pad(skb, 17 - skb->len))
+                        return NETDEV_TX_OK;
+                skb->len = 17;
+                skb_set_tail_pointer(skb, 17);
+        }
+
         mss = skb_shinfo(skb)->gso_size;
         if (mss) {
                 u8 hdr_len;
diff --git a/drivers/net/ethernet/intel/igb/Makefile b/drivers/net/ethernet/intel/igb/Makefile
index 97c197fd4a8e..624476cfa727 100644
--- a/drivers/net/ethernet/intel/igb/Makefile
+++ b/drivers/net/ethernet/intel/igb/Makefile
@@ -34,6 +34,4 @@ obj-$(CONFIG_IGB) += igb.o
 
 igb-objs := igb_main.o igb_ethtool.o e1000_82575.o \
             e1000_mac.o e1000_nvm.o e1000_phy.o e1000_mbx.o \
-            e1000_i210.o
-
-igb-$(CONFIG_IGB_PTP) += igb_ptp.o
+            e1000_i210.o igb_ptp.o
diff --git a/drivers/net/ethernet/intel/igb/e1000_82575.c b/drivers/net/ethernet/intel/igb/e1000_82575.c
index ca4641e2f748..deb05970b9f1 100644
--- a/drivers/net/ethernet/intel/igb/e1000_82575.c
+++ b/drivers/net/ethernet/intel/igb/e1000_82575.c
@@ -319,6 +319,7 @@ static s32 igb_get_invariants_82575(struct e1000_hw *hw)
                 nvm->ops.acquire = igb_acquire_nvm_i210;
                 nvm->ops.release = igb_release_nvm_i210;
                 nvm->ops.read    = igb_read_nvm_srrd_i210;
+                nvm->ops.write   = igb_write_nvm_srwr_i210;
                 nvm->ops.valid_led_default = igb_valid_led_default_i210;
                 break;
         case e1000_i211:
@@ -2233,19 +2234,16 @@ s32 igb_set_eee_i350(struct e1000_hw *hw)
 
         /* enable or disable per user setting */
         if (!(hw->dev_spec._82575.eee_disable)) {
-                ipcnfg |= (E1000_IPCNFG_EEE_1G_AN |
-                        E1000_IPCNFG_EEE_100M_AN);
-                eeer |= (E1000_EEER_TX_LPI_EN |
-                        E1000_EEER_RX_LPI_EN |
+                u32 eee_su = rd32(E1000_EEE_SU);
+
+                ipcnfg |= (E1000_IPCNFG_EEE_1G_AN | E1000_IPCNFG_EEE_100M_AN);
+                eeer |= (E1000_EEER_TX_LPI_EN | E1000_EEER_RX_LPI_EN |
                         E1000_EEER_LPI_FC);
 
-                /* keep the LPI clock running before EEE is enabled */
-                if (hw->mac.type == e1000_i210 || hw->mac.type == e1000_i211) {
-                        u32 eee_su;
-                        eee_su = rd32(E1000_EEE_SU);
-                        eee_su &= ~E1000_EEE_SU_LPI_CLK_STP;
-                        wr32(E1000_EEE_SU, eee_su);
-                }
+                /* This bit should not be set in normal operation. */
+                if (eee_su & E1000_EEE_SU_LPI_CLK_STP)
+                        hw_dbg("LPI Clock Stop Bit should not be set!\n");
+
 
         } else {
                 ipcnfg &= ~(E1000_IPCNFG_EEE_1G_AN |
diff --git a/drivers/net/ethernet/intel/igb/e1000_82575.h b/drivers/net/ethernet/intel/igb/e1000_82575.h
index e85c453f5428..44b76b3b6816 100644
--- a/drivers/net/ethernet/intel/igb/e1000_82575.h
+++ b/drivers/net/ethernet/intel/igb/e1000_82575.h
@@ -172,10 +172,13 @@ struct e1000_adv_tx_context_desc {
 #define E1000_DCA_RXCTRL_DESC_DCA_EN (1 << 5) /* DCA Rx Desc enable */
 #define E1000_DCA_RXCTRL_HEAD_DCA_EN (1 << 6) /* DCA Rx Desc header enable */
 #define E1000_DCA_RXCTRL_DATA_DCA_EN (1 << 7) /* DCA Rx Desc payload enable */
+#define E1000_DCA_RXCTRL_DESC_RRO_EN (1 << 9) /* DCA Rx rd Desc Relax Order */
 
 #define E1000_DCA_TXCTRL_CPUID_MASK 0x0000001F /* Tx CPUID Mask */
 #define E1000_DCA_TXCTRL_DESC_DCA_EN (1 << 5) /* DCA Tx Desc enable */
+#define E1000_DCA_TXCTRL_DESC_RRO_EN (1 << 9) /* Tx rd Desc Relax Order */
 #define E1000_DCA_TXCTRL_TX_WB_RO_EN (1 << 11) /* Tx Desc writeback RO bit */
+#define E1000_DCA_TXCTRL_DATA_RRO_EN (1 << 13) /* Tx rd data Relax Order */
 
 /* Additional DCA related definitions, note change in position of CPUID */
 #define E1000_DCA_TXCTRL_CPUID_MASK_82576 0xFF000000 /* Tx CPUID Mask */
diff --git a/drivers/net/ethernet/intel/igb/e1000_defines.h b/drivers/net/ethernet/intel/igb/e1000_defines.h
index de4b41ec3c40..e647cff9a5e3 100644
--- a/drivers/net/ethernet/intel/igb/e1000_defines.h
+++ b/drivers/net/ethernet/intel/igb/e1000_defines.h
@@ -636,6 +636,7 @@
 /* NVM Word Offsets */
 #define NVM_COMPAT                 0x0003
 #define NVM_ID_LED_SETTINGS        0x0004 /* SERDES output amplitude */
+#define NVM_VERSION                0x0005
 #define NVM_INIT_CONTROL2_REG      0x000F
 #define NVM_INIT_CONTROL3_PORT_B   0x0014
 #define NVM_INIT_CONTROL3_PORT_A   0x0024
@@ -653,6 +654,19 @@
 #define NVM_LED_1_CFG              0x001C
 #define NVM_LED_0_2_CFG            0x001F
 
+/* NVM version defines */
+#define NVM_ETRACK_WORD            0x0042
+#define NVM_COMB_VER_OFF           0x0083
+#define NVM_COMB_VER_PTR           0x003d
+#define NVM_MAJOR_MASK             0xF000
+#define NVM_MINOR_MASK             0x0FF0
+#define NVM_BUILD_MASK             0x000F
+#define NVM_COMB_VER_MASK          0x00FF
+#define NVM_MAJOR_SHIFT                12
+#define NVM_MINOR_SHIFT                 4
+#define NVM_COMB_VER_SHFT               8
+#define NVM_VER_INVALID            0xFFFF
+#define NVM_ETRACK_SHIFT               16
 
 #define E1000_NVM_CFG_DONE_PORT_0  0x040000 /* MNG config cycle done */
 #define E1000_NVM_CFG_DONE_PORT_1  0x080000 /* ...for second port */
diff --git a/drivers/net/ethernet/intel/igb/e1000_i210.c b/drivers/net/ethernet/intel/igb/e1000_i210.c
index 77a5f939bc74..41474298d365 100644
--- a/drivers/net/ethernet/intel/igb/e1000_i210.c
+++ b/drivers/net/ethernet/intel/igb/e1000_i210.c
@@ -423,6 +423,100 @@ s32 igb_read_invm_i211(struct e1000_hw *hw, u16 address, u16 *data)
 }
 
 /**
+ *  igb_read_invm_version - Reads iNVM version and image type
+ *  @hw: pointer to the HW structure
+ *  @invm_ver: version structure for the version read
+ *
+ *  Reads iNVM version and image type.
+ **/
+s32 igb_read_invm_version(struct e1000_hw *hw,
+                          struct e1000_fw_version *invm_ver) {
+        u32 *record = NULL;
+        u32 *next_record = NULL;
+        u32 i = 0;
+        u32 invm_dword = 0;
+        u32 invm_blocks = E1000_INVM_SIZE - (E1000_INVM_ULT_BYTES_SIZE /
+                                             E1000_INVM_RECORD_SIZE_IN_BYTES);
+        u32 buffer[E1000_INVM_SIZE];
+        s32 status = -E1000_ERR_INVM_VALUE_NOT_FOUND;
+        u16 version = 0;
+
+        /* Read iNVM memory */
+        for (i = 0; i < E1000_INVM_SIZE; i++) {
+                invm_dword = rd32(E1000_INVM_DATA_REG(i));
+                buffer[i] = invm_dword;
+        }
+
+        /* Read version number */
+        for (i = 1; i < invm_blocks; i++) {
+                record = &buffer[invm_blocks - i];
+                next_record = &buffer[invm_blocks - i + 1];
+
+                /* Check if we have first version location used */
+                if ((i == 1) && ((*record & E1000_INVM_VER_FIELD_ONE) == 0)) {
+                        version = 0;
+                        status = E1000_SUCCESS;
+                        break;
+                }
+                /* Check if we have second version location used */
+                else if ((i == 1) &&
+                         ((*record & E1000_INVM_VER_FIELD_TWO) == 0)) {
+                        version = (*record & E1000_INVM_VER_FIELD_ONE) >> 3;
+                        status = E1000_SUCCESS;
+                        break;
+                }
+                /* Check if we have odd version location
+                 * used and it is the last one used
+                 */
+                else if ((((*record & E1000_INVM_VER_FIELD_ONE) == 0) &&
+                         ((*record & 0x3) == 0)) || (((*record & 0x3) != 0) &&
+                         (i != 1))) {
+                        version = (*next_record & E1000_INVM_VER_FIELD_TWO)
+                                  >> 13;
+                        status = E1000_SUCCESS;
+                        break;
+                }
+                /* Check if we have even version location
+                 * used and it is the last one used
+                 */
+                else if (((*record & E1000_INVM_VER_FIELD_TWO) == 0) &&
+                         ((*record & 0x3) == 0)) {
+                        version = (*record & E1000_INVM_VER_FIELD_ONE) >> 3;
+                        status = E1000_SUCCESS;
+                        break;
+                }
+        }
+
+        if (status == E1000_SUCCESS) {
+                invm_ver->invm_major = (version & E1000_INVM_MAJOR_MASK)
+                                        >> E1000_INVM_MAJOR_SHIFT;
+                invm_ver->invm_minor = version & E1000_INVM_MINOR_MASK;
+        }
+        /* Read Image Type */
+        for (i = 1; i < invm_blocks; i++) {
+                record = &buffer[invm_blocks - i];
+                next_record = &buffer[invm_blocks - i + 1];
+
+                /* Check if we have image type in first location used */
+                if ((i == 1) && ((*record & E1000_INVM_IMGTYPE_FIELD) == 0)) {
+                        invm_ver->invm_img_type = 0;
+                        status = E1000_SUCCESS;
+                        break;
+                }
+                /* Check if we have image type in first location used */
+                else if ((((*record & 0x3) == 0) &&
+                         ((*record & E1000_INVM_IMGTYPE_FIELD) == 0)) ||
+                         ((((*record & 0x3) != 0) && (i != 1)))) {
+                        invm_ver->invm_img_type =
+                                (*next_record & E1000_INVM_IMGTYPE_FIELD) >> 23;
+                        status = E1000_SUCCESS;
+                        break;
+                }
+        }
+        return status;
+}
+
+/**
  *  igb_validate_nvm_checksum_i210 - Validate EEPROM checksum
  *  @hw: pointer to the HW structure
  *
diff --git a/drivers/net/ethernet/intel/igb/e1000_i210.h b/drivers/net/ethernet/intel/igb/e1000_i210.h
index 5dc2bd3f50bc..974d23584d70 100644
--- a/drivers/net/ethernet/intel/igb/e1000_i210.h
+++ b/drivers/net/ethernet/intel/igb/e1000_i210.h
@@ -43,6 +43,8 @@ extern void igb_release_nvm_i210(struct e1000_hw *hw);
 extern s32 igb_valid_led_default_i210(struct e1000_hw *hw, u16 *data);
 extern s32 igb_read_nvm_i211(struct e1000_hw *hw, u16 offset, u16 words,
                                u16 *data);
+extern s32 igb_read_invm_version(struct e1000_hw *hw,
+                                 struct e1000_fw_version *invm_ver);
 
 #define E1000_STM_OPCODE                0xDB00
 #define E1000_EEPROM_FLASH_SIZE_WORD    0x11
@@ -65,6 +67,15 @@ enum E1000_INVM_STRUCTURE_TYPE {
 
 #define E1000_INVM_RSA_KEY_SHA256_DATA_SIZE_IN_DWORDS   8
 #define E1000_INVM_CSR_AUTOLOAD_DATA_SIZE_IN_DWORDS     1
+#define E1000_INVM_ULT_BYTES_SIZE                       8
+#define E1000_INVM_RECORD_SIZE_IN_BYTES                 4
+#define E1000_INVM_VER_FIELD_ONE                        0x1FF8
+#define E1000_INVM_VER_FIELD_TWO                        0x7FE000
+#define E1000_INVM_IMGTYPE_FIELD                        0x1F800000
+
+#define E1000_INVM_MAJOR_MASK           0x3F0
+#define E1000_INVM_MINOR_MASK           0xF
+#define E1000_INVM_MAJOR_SHIFT          4
 
 #define ID_LED_DEFAULT_I210             ((ID_LED_OFF1_ON2  << 8) | \
                                          (ID_LED_OFF1_OFF2 <<  4) | \
diff --git a/drivers/net/ethernet/intel/igb/e1000_mac.c b/drivers/net/ethernet/intel/igb/e1000_mac.c
index 819c145ac762..7acddfe9e6d5 100644
--- a/drivers/net/ethernet/intel/igb/e1000_mac.c
+++ b/drivers/net/ethernet/intel/igb/e1000_mac.c
@@ -1391,6 +1391,10 @@ s32 igb_validate_mdi_setting(struct e1000_hw *hw)
 {
         s32 ret_val = 0;
 
+        /* All MDI settings are supported on 82580 and newer. */
+        if (hw->mac.type >= e1000_82580)
+                goto out;
+
         if (!hw->mac.autoneg && (hw->phy.mdix == 0 || hw->phy.mdix == 3)) {
                 hw_dbg("Invalid MDI setting detected\n");
                 hw->phy.mdix = 1;
diff --git a/drivers/net/ethernet/intel/igb/e1000_mac.h b/drivers/net/ethernet/intel/igb/e1000_mac.h
index cbddc4e51e30..e2b2c4b9c951 100644
--- a/drivers/net/ethernet/intel/igb/e1000_mac.h
+++ b/drivers/net/ethernet/intel/igb/e1000_mac.h
@@ -33,6 +33,7 @@
 #include "e1000_phy.h"
 #include "e1000_nvm.h"
 #include "e1000_defines.h"
+#include "e1000_i210.h"
 
 /*
  * Functions that should not be called directly from drivers but can be used
diff --git a/drivers/net/ethernet/intel/igb/e1000_nvm.c b/drivers/net/ethernet/intel/igb/e1000_nvm.c
index aa5fcdf3f357..7db3f80bcd57 100644
--- a/drivers/net/ethernet/intel/igb/e1000_nvm.c
+++ b/drivers/net/ethernet/intel/igb/e1000_nvm.c
@@ -710,3 +710,74 @@ s32 igb_update_nvm_checksum(struct e1000_hw *hw)
 out:
         return ret_val;
 }
+
+/**
+ *  igb_get_fw_version - Get firmware version information
+ *  @hw: pointer to the HW structure
+ *  @fw_vers: pointer to output structure
+ *
+ *  unsupported MAC types will return all 0 version structure
+ **/
+void igb_get_fw_version(struct e1000_hw *hw, struct e1000_fw_version *fw_vers)
+{
+        u16 eeprom_verh, eeprom_verl, comb_verh, comb_verl, comb_offset;
+        u16 fw_version;
+
+        memset(fw_vers, 0, sizeof(struct e1000_fw_version));
+
+        switch (hw->mac.type) {
+        case e1000_i211:
+                igb_read_invm_version(hw, fw_vers);
+                return;
+        case e1000_82575:
+        case e1000_82576:
+        case e1000_82580:
+        case e1000_i350:
+        case e1000_i210:
+                break;
+        default:
+                return;
+        }
+        /* basic eeprom version numbers */
+        hw->nvm.ops.read(hw, NVM_VERSION, 1, &fw_version);
+        fw_vers->eep_major = (fw_version & NVM_MAJOR_MASK) >> NVM_MAJOR_SHIFT;
+        fw_vers->eep_minor = (fw_version & NVM_MINOR_MASK);
+
+        /* etrack id */
+        hw->nvm.ops.read(hw, NVM_ETRACK_WORD, 1, &eeprom_verl);
+        hw->nvm.ops.read(hw, (NVM_ETRACK_WORD + 1), 1, &eeprom_verh);
+        fw_vers->etrack_id = (eeprom_verh << NVM_ETRACK_SHIFT) | eeprom_verl;
+
+        switch (hw->mac.type) {
+        case e1000_i210:
+        case e1000_i350:
+                /* find combo image version */
+                hw->nvm.ops.read(hw, NVM_COMB_VER_PTR, 1, &comb_offset);
+                if ((comb_offset != 0x0) && (comb_offset != NVM_VER_INVALID)) {
+
+                        hw->nvm.ops.read(hw, (NVM_COMB_VER_OFF + comb_offset
+                                         + 1), 1, &comb_verh);
+                        hw->nvm.ops.read(hw, (NVM_COMB_VER_OFF + comb_offset),
+                                         1, &comb_verl);
+
+                        /* get Option Rom version if it exists and is valid */
+                        if ((comb_verh && comb_verl) &&
+                            ((comb_verh != NVM_VER_INVALID) &&
+                             (comb_verl != NVM_VER_INVALID))) {
+
+                                fw_vers->or_valid = true;
+                                fw_vers->or_major =
+                                        comb_verl >> NVM_COMB_VER_SHFT;
+                                fw_vers->or_build =
+                                        ((comb_verl << NVM_COMB_VER_SHFT)
+                                        | (comb_verh >> NVM_COMB_VER_SHFT));
+                                fw_vers->or_patch =
+                                        comb_verh & NVM_COMB_VER_MASK;
+                        }
+                }
+                break;
+        default:
+                break;
+        }
+        return;
+}
diff --git a/drivers/net/ethernet/intel/igb/e1000_nvm.h b/drivers/net/ethernet/intel/igb/e1000_nvm.h
index 825b0228cac0..7012d458c6f7 100644
--- a/drivers/net/ethernet/intel/igb/e1000_nvm.h
+++ b/drivers/net/ethernet/intel/igb/e1000_nvm.h
@@ -40,4 +40,20 @@ s32  igb_write_nvm_spi(struct e1000_hw *hw, u16 offset, u16 words, u16 *data);
 s32  igb_validate_nvm_checksum(struct e1000_hw *hw);
 s32  igb_update_nvm_checksum(struct e1000_hw *hw);
 
+struct e1000_fw_version {
+        u32 etrack_id;
+        u16 eep_major;
+        u16 eep_minor;
+
+        u8 invm_major;
+        u8 invm_minor;
+        u8 invm_img_type;
+
+        bool or_valid;
+        u16 or_major;
+        u16 or_build;
+        u16 or_patch;
+};
+void igb_get_fw_version(struct e1000_hw *hw, struct e1000_fw_version *fw_vers);
+
 #endif
diff --git a/drivers/net/ethernet/intel/igb/e1000_phy.c b/drivers/net/ethernet/intel/igb/e1000_phy.c
index 3404bc79f4ca..fe76004aca4e 100644
--- a/drivers/net/ethernet/intel/igb/e1000_phy.c
+++ b/drivers/net/ethernet/intel/igb/e1000_phy.c
@@ -1207,20 +1207,25 @@ s32 igb_phy_force_speed_duplex_m88(struct e1000_hw *hw)
         u16 phy_data;
         bool link;
 
-        /*
-         * Clear Auto-Crossover to force MDI manually.  M88E1000 requires MDI
-         * forced whenever speed and duplex are forced.
-         */
-        ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
-        if (ret_val)
-                goto out;
+        /* I210 and I211 devices support Auto-Crossover in forced operation. */
+        if (phy->type != e1000_phy_i210) {
+                /*
+                 * Clear Auto-Crossover to force MDI manually.  M88E1000
+                 * requires MDI forced whenever speed and duplex are forced.
+                 */
+                ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_CTRL,
+                                            &phy_data);
+                if (ret_val)
+                        goto out;
 
-        phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
-        ret_val = phy->ops.write_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data);
-        if (ret_val)
-                goto out;
+                phy_data &= ~M88E1000_PSCR_AUTO_X_MODE;
+                ret_val = phy->ops.write_reg(hw, M88E1000_PHY_SPEC_CTRL,
+                                             phy_data);
+                if (ret_val)
+                        goto out;
 
-        hw_dbg("M88E1000 PSCR: %X\n", phy_data);
+                hw_dbg("M88E1000 PSCR: %X\n", phy_data);
+        }
 
         ret_val = phy->ops.read_reg(hw, PHY_CONTROL, &phy_data);
         if (ret_val)
@@ -1710,6 +1715,26 @@ s32 igb_get_cable_length_m88_gen2(struct e1000_hw *hw)
 
         switch (hw->phy.id) {
         case I210_I_PHY_ID:
+                /* Get cable length from PHY Cable Diagnostics Control Reg */
+                ret_val = phy->ops.read_reg(hw, (0x7 << GS40G_PAGE_SHIFT) +
+                                            (I347AT4_PCDL + phy->addr),
+                                            &phy_data);
+                if (ret_val)
+                        return ret_val;
+
+                /* Check if the unit of cable length is meters or cm */
+                ret_val = phy->ops.read_reg(hw, (0x7 << GS40G_PAGE_SHIFT) +
+                                            I347AT4_PCDC, &phy_data2);
+                if (ret_val)
+                        return ret_val;
+
+                is_cm = !(phy_data2 & I347AT4_PCDC_CABLE_LENGTH_UNIT);
+
+                /* Populate the phy structure with cable length in meters */
+                phy->min_cable_length = phy_data / (is_cm ? 100 : 1);
+                phy->max_cable_length = phy_data / (is_cm ? 100 : 1);
+                phy->cable_length = phy_data / (is_cm ? 100 : 1);
+                break;
         case I347AT4_E_PHY_ID:
                 /* Remember the original page select and set it to 7 */
                 ret_val = phy->ops.read_reg(hw, I347AT4_PAGE_SELECT,
diff --git a/drivers/net/ethernet/intel/igb/igb.h b/drivers/net/ethernet/intel/igb/igb.h
index 8aad230c0592..796db53954d9 100644
--- a/drivers/net/ethernet/intel/igb/igb.h
+++ b/drivers/net/ethernet/intel/igb/igb.h
@@ -34,11 +34,9 @@
 #include "e1000_mac.h"
 #include "e1000_82575.h"
 
-#ifdef CONFIG_IGB_PTP
 #include <linux/clocksource.h>
 #include <linux/net_tstamp.h>
 #include <linux/ptp_clock_kernel.h>
-#endif /* CONFIG_IGB_PTP */
 #include <linux/bitops.h>
 #include <linux/if_vlan.h>
 
@@ -132,9 +130,10 @@ struct vf_data_storage {
 #define MAXIMUM_ETHERNET_VLAN_SIZE 1522
 
 /* Supported Rx Buffer Sizes */
-#define IGB_RXBUFFER_256   256
-#define IGB_RXBUFFER_16384 16384
-#define IGB_RX_HDR_LEN     IGB_RXBUFFER_256
+#define IGB_RXBUFFER_256        256
+#define IGB_RXBUFFER_2048       2048
+#define IGB_RX_HDR_LEN          IGB_RXBUFFER_256
+#define IGB_RX_BUFSZ            IGB_RXBUFFER_2048
 
 /* How many Tx Descriptors do we need to call netif_wake_queue ? */
 #define IGB_TX_QUEUE_WAKE       16
@@ -174,11 +173,9 @@ struct igb_tx_buffer {
 };
 
 struct igb_rx_buffer {
-        struct sk_buff *skb;
         dma_addr_t dma;
         struct page *page;
-        dma_addr_t page_dma;
-        u32 page_offset;
+        unsigned int page_offset;
 };
 
 struct igb_tx_queue_stats {
@@ -205,22 +202,6 @@ struct igb_ring_container {
         u8 itr;                         /* current ITR setting for ring */
 };
 
-struct igb_q_vector {
-        struct igb_adapter *adapter;    /* backlink */
-        int cpu;                        /* CPU for DCA */
-        u32 eims_value;                 /* EIMS mask value */
-
-        struct igb_ring_container rx, tx;
-
-        struct napi_struct napi;
-
-        u16 itr_val;
-        u8 set_itr;
-        void __iomem *itr_register;
-
-        char name[IFNAMSIZ + 9];
-};
-
 struct igb_ring {
         struct igb_q_vector *q_vector;  /* backlink to q_vector */
         struct net_device *netdev;      /* back pointer to net_device */
@@ -232,15 +213,17 @@ struct igb_ring {
         void *desc;                     /* descriptor ring memory */
         unsigned long flags;            /* ring specific flags */
         void __iomem *tail;             /* pointer to ring tail register */
+        dma_addr_t dma;                 /* phys address of the ring */
+        unsigned int  size;             /* length of desc. ring in bytes */
 
         u16 count;                      /* number of desc. in the ring */
         u8 queue_index;                 /* logical index of the ring*/
         u8 reg_idx;                     /* physical index of the ring */
-        u32 size;                       /* length of desc. ring in bytes */
 
         /* everything past this point are written often */
-        u16 next_to_clean ____cacheline_aligned_in_smp;
+        u16 next_to_clean;
         u16 next_to_use;
+        u16 next_to_alloc;
 
         union {
                 /* TX */
@@ -251,12 +234,30 @@ struct igb_ring {
                 };
                 /* RX */
                 struct {
+                        struct sk_buff *skb;
                         struct igb_rx_queue_stats rx_stats;
                         struct u64_stats_sync rx_syncp;
                 };
         };
-        /* Items past this point are only used during ring alloc / free */
-        dma_addr_t dma;                /* phys address of the ring */
+} ____cacheline_internodealigned_in_smp;
+
+struct igb_q_vector {
+        struct igb_adapter *adapter;    /* backlink */
+        int cpu;                        /* CPU for DCA */
+        u32 eims_value;                 /* EIMS mask value */
+
+        u16 itr_val;
+        u8 set_itr;
+        void __iomem *itr_register;
+
+        struct igb_ring_container rx, tx;
+
+        struct napi_struct napi;
+        struct rcu_head rcu;    /* to avoid race with update stats on free */
+        char name[IFNAMSIZ + 9];
+
+        /* for dynamic allocation of rings associated with this q_vector */
+        struct igb_ring ring[0] ____cacheline_internodealigned_in_smp;
 };
 
 enum e1000_ring_flags_t {
@@ -373,7 +374,6 @@ struct igb_adapter {
         u32 wvbr;
         u32 *shadow_vfta;
 
-#ifdef CONFIG_IGB_PTP
         struct ptp_clock *ptp_clock;
         struct ptp_clock_info ptp_caps;
         struct delayed_work ptp_overflow_work;
@@ -382,7 +382,6 @@ struct igb_adapter {
         spinlock_t tmreg_lock;
         struct cyclecounter cc;
         struct timecounter tc;
-#endif /* CONFIG_IGB_PTP */
 
         char fw_version[32];
 };
@@ -436,18 +435,27 @@ extern bool igb_has_link(struct igb_adapter *adapter);
 extern void igb_set_ethtool_ops(struct net_device *);
 extern void igb_power_up_link(struct igb_adapter *);
 extern void igb_set_fw_version(struct igb_adapter *);
-#ifdef CONFIG_IGB_PTP
 extern void igb_ptp_init(struct igb_adapter *adapter);
 extern void igb_ptp_stop(struct igb_adapter *adapter);
 extern void igb_ptp_reset(struct igb_adapter *adapter);
 extern void igb_ptp_tx_work(struct work_struct *work);
 extern void igb_ptp_tx_hwtstamp(struct igb_adapter *adapter);
-extern void igb_ptp_rx_hwtstamp(struct igb_q_vector *q_vector,
-                                union e1000_adv_rx_desc *rx_desc,
+extern void igb_ptp_rx_rgtstamp(struct igb_q_vector *q_vector,
                                 struct sk_buff *skb);
+extern void igb_ptp_rx_pktstamp(struct igb_q_vector *q_vector,
+                                unsigned char *va,
+                                struct sk_buff *skb);
+static inline void igb_ptp_rx_hwtstamp(struct igb_q_vector *q_vector,
+                                       union e1000_adv_rx_desc *rx_desc,
+                                       struct sk_buff *skb)
+{
+        if (igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TS) &&
+            !igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TSIP))
+                igb_ptp_rx_rgtstamp(q_vector, skb);
+}
+
 extern int igb_ptp_hwtstamp_ioctl(struct net_device *netdev,
                                   struct ifreq *ifr, int cmd);
-#endif /* CONFIG_IGB_PTP */
 
 static inline s32 igb_reset_phy(struct e1000_hw *hw)
 {
diff --git a/drivers/net/ethernet/intel/igb/igb_ethtool.c b/drivers/net/ethernet/intel/igb/igb_ethtool.c
index 2ea012849825..d8b1bee606c0 100644
--- a/drivers/net/ethernet/intel/igb/igb_ethtool.c
+++ b/drivers/net/ethernet/intel/igb/igb_ethtool.c
@@ -37,6 +37,7 @@
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/pm_runtime.h>
+#include <linux/highmem.h>
 
 #include "igb.h"
 
@@ -1685,16 +1686,24 @@ static void igb_create_lbtest_frame(struct sk_buff *skb,
         memset(&skb->data[frame_size + 12], 0xAF, 1);
 }
 
-static int igb_check_lbtest_frame(struct sk_buff *skb, unsigned int frame_size)
+static int igb_check_lbtest_frame(struct igb_rx_buffer *rx_buffer,
+                                  unsigned int frame_size)
 {
-        frame_size /= 2;
-        if (*(skb->data + 3) == 0xFF) {
-                if ((*(skb->data + frame_size + 10) == 0xBE) &&
-                   (*(skb->data + frame_size + 12) == 0xAF)) {
-                        return 0;
-                }
-        }
-        return 13;
+        unsigned char *data;
+        bool match = true;
+
+        frame_size >>= 1;
+
+        data = kmap(rx_buffer->page);
+
+        if (data[3] != 0xFF ||
+            data[frame_size + 10] != 0xBE ||
+            data[frame_size + 12] != 0xAF)
+                match = false;
+
+        kunmap(rx_buffer->page);
+
+        return match;
 }
 
 static int igb_clean_test_rings(struct igb_ring *rx_ring,
@@ -1704,9 +1713,7 @@ static int igb_clean_test_rings(struct igb_ring *rx_ring,
         union e1000_adv_rx_desc *rx_desc;
         struct igb_rx_buffer *rx_buffer_info;
         struct igb_tx_buffer *tx_buffer_info;
-        struct netdev_queue *txq;
         u16 rx_ntc, tx_ntc, count = 0;
-        unsigned int total_bytes = 0, total_packets = 0;
 
         /* initialize next to clean and descriptor values */
         rx_ntc = rx_ring->next_to_clean;
@@ -1717,21 +1724,24 @@ static int igb_clean_test_rings(struct igb_ring *rx_ring,
                 /* check rx buffer */
                 rx_buffer_info = &rx_ring->rx_buffer_info[rx_ntc];
 
-                /* unmap rx buffer, will be remapped by alloc_rx_buffers */
-                dma_unmap_single(rx_ring->dev,
-                                 rx_buffer_info->dma,
-                                 IGB_RX_HDR_LEN,
-                                 DMA_FROM_DEVICE);
-                rx_buffer_info->dma = 0;
+                /* sync Rx buffer for CPU read */
+                dma_sync_single_for_cpu(rx_ring->dev,
+                                        rx_buffer_info->dma,
+                                        IGB_RX_BUFSZ,
+                                        DMA_FROM_DEVICE);
 
                 /* verify contents of skb */
-                if (!igb_check_lbtest_frame(rx_buffer_info->skb, size))
+                if (igb_check_lbtest_frame(rx_buffer_info, size))
                         count++;
 
+                /* sync Rx buffer for device write */
+                dma_sync_single_for_device(rx_ring->dev,
+                                           rx_buffer_info->dma,
+                                           IGB_RX_BUFSZ,
+                                           DMA_FROM_DEVICE);
+
                 /* unmap buffer on tx side */
                 tx_buffer_info = &tx_ring->tx_buffer_info[tx_ntc];
-                total_bytes += tx_buffer_info->bytecount;
-                total_packets += tx_buffer_info->gso_segs;
                 igb_unmap_and_free_tx_resource(tx_ring, tx_buffer_info);
 
                 /* increment rx/tx next to clean counters */
@@ -1746,8 +1756,7 @@ static int igb_clean_test_rings(struct igb_ring *rx_ring,
                 rx_desc = IGB_RX_DESC(rx_ring, rx_ntc);
         }
 
-        txq = netdev_get_tx_queue(tx_ring->netdev, tx_ring->queue_index);
-        netdev_tx_completed_queue(txq, total_packets, total_bytes);
+        netdev_tx_reset_queue(txring_txq(tx_ring));
 
         /* re-map buffers to ring, store next to clean values */
         igb_alloc_rx_buffers(rx_ring, count);
@@ -2301,7 +2310,6 @@ static int igb_get_ts_info(struct net_device *dev,
         struct igb_adapter *adapter = netdev_priv(dev);
 
         switch (adapter->hw.mac.type) {
-#ifdef CONFIG_IGB_PTP
         case e1000_82576:
         case e1000_82580:
         case e1000_i350:
@@ -2337,7 +2345,6 @@ static int igb_get_ts_info(struct net_device *dev,
                                 (1 << HWTSTAMP_FILTER_PTP_V2_EVENT);
 
                 return 0;
-#endif /* CONFIG_IGB_PTP */
         default:
                 return -EOPNOTSUPP;
         }
diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
index e1ceb37ef12e..082ce73dc627 100644
--- a/drivers/net/ethernet/intel/igb/igb_main.c
+++ b/drivers/net/ethernet/intel/igb/igb_main.c
@@ -61,7 +61,7 @@
 
 #define MAJ 4
 #define MIN 0
-#define BUILD 1
+#define BUILD 17
 #define DRV_VERSION __stringify(MAJ) "." __stringify(MIN) "." \
 __stringify(BUILD) "-k"
 char igb_driver_name[] = "igb";
@@ -534,31 +534,27 @@ rx_ring_summary:
 
                         if (staterr & E1000_RXD_STAT_DD) {
                                 /* Descriptor Done */
-                                pr_info("%s[0x%03X]     %016llX %016llX -------"
-                                        "--------- %p%s\n", "RWB", i,
+                                pr_info("%s[0x%03X]     %016llX %016llX ---------------- %s\n",
+                                        "RWB", i,
                                         le64_to_cpu(u0->a),
                                         le64_to_cpu(u0->b),
-                                        buffer_info->skb, next_desc);
+                                        next_desc);
                         } else {
-                                pr_info("%s[0x%03X]     %016llX %016llX %016llX"
-                                        " %p%s\n", "R  ", i,
+                                pr_info("%s[0x%03X]     %016llX %016llX %016llX %s\n",
+                                        "R  ", i,
                                         le64_to_cpu(u0->a),
                                         le64_to_cpu(u0->b),
                                         (u64)buffer_info->dma,
-                                        buffer_info->skb, next_desc);
+                                        next_desc);
 
                                 if (netif_msg_pktdata(adapter) &&
-                                    buffer_info->dma && buffer_info->skb) {
-                                        print_hex_dump(KERN_INFO, "",
-                                                  DUMP_PREFIX_ADDRESS,
-                                                  16, 1, buffer_info->skb->data,
-                                                  IGB_RX_HDR_LEN, true);
+                                    buffer_info->dma && buffer_info->page) {
                                         print_hex_dump(KERN_INFO, "",
                                           DUMP_PREFIX_ADDRESS,
                                           16, 1,
                                           page_address(buffer_info->page) +
                                                       buffer_info->page_offset,
-                                          PAGE_SIZE/2, true);
+                                          IGB_RX_BUFSZ, true);
                                 }
                         }
                 }
@@ -656,80 +652,6 @@ static void igb_cache_ring_register(struct igb_adapter *adapter)
         }
 }
 
-static void igb_free_queues(struct igb_adapter *adapter)
-{
-        int i;
-
-        for (i = 0; i < adapter->num_tx_queues; i++) {
-                kfree(adapter->tx_ring[i]);
-                adapter->tx_ring[i] = NULL;
-        }
-        for (i = 0; i < adapter->num_rx_queues; i++) {
-                kfree(adapter->rx_ring[i]);
-                adapter->rx_ring[i] = NULL;
-        }
-        adapter->num_rx_queues = 0;
-        adapter->num_tx_queues = 0;
-}
-
-/**
- * igb_alloc_queues - Allocate memory for all rings
- * @adapter: board private structure to initialize
- *
- * We allocate one ring per queue at run-time since we don't know the
- * number of queues at compile-time.
- **/
-static int igb_alloc_queues(struct igb_adapter *adapter)
-{
-        struct igb_ring *ring;
-        int i;
-
-        for (i = 0; i < adapter->num_tx_queues; i++) {
-                ring = kzalloc(sizeof(struct igb_ring), GFP_KERNEL);
-                if (!ring)
-                        goto err;
-                ring->count = adapter->tx_ring_count;
-                ring->queue_index = i;
-                ring->dev = &adapter->pdev->dev;
-                ring->netdev = adapter->netdev;
-                /* For 82575, context index must be unique per ring. */
-                if (adapter->hw.mac.type == e1000_82575)
-                        set_bit(IGB_RING_FLAG_TX_CTX_IDX, &ring->flags);
-                adapter->tx_ring[i] = ring;
-        }
-
-        for (i = 0; i < adapter->num_rx_queues; i++) {
-                ring = kzalloc(sizeof(struct igb_ring), GFP_KERNEL);
-                if (!ring)
-                        goto err;
-                ring->count = adapter->rx_ring_count;
-                ring->queue_index = i;
-                ring->dev = &adapter->pdev->dev;
-                ring->netdev = adapter->netdev;
-                /* set flag indicating ring supports SCTP checksum offload */
-                if (adapter->hw.mac.type >= e1000_82576)
-                        set_bit(IGB_RING_FLAG_RX_SCTP_CSUM, &ring->flags);
-
-                /*
-                 * On i350, i210, and i211, loopback VLAN packets
-                 * have the tag byte-swapped.
-                 * */
-                if (adapter->hw.mac.type >= e1000_i350)
-                        set_bit(IGB_RING_FLAG_RX_LB_VLAN_BSWAP, &ring->flags);
-
-                adapter->rx_ring[i] = ring;
-        }
-
-        igb_cache_ring_register(adapter);
-
-        return 0;
-
-err:
-        igb_free_queues(adapter);
-
-        return -ENOMEM;
-}
-
 /**
  *  igb_write_ivar - configure ivar for given MSI-X vector
  *  @hw: pointer to the HW structure
@@ -960,6 +882,35 @@ static void igb_reset_interrupt_capability(struct igb_adapter *adapter)
 }
 
 /**
+ * igb_free_q_vector - Free memory allocated for specific interrupt vector
+ * @adapter: board private structure to initialize
+ * @v_idx: Index of vector to be freed
+ *
+ * This function frees the memory allocated to the q_vector.  In addition if
+ * NAPI is enabled it will delete any references to the NAPI struct prior
+ * to freeing the q_vector.
+ **/
+static void igb_free_q_vector(struct igb_adapter *adapter, int v_idx)
+{
+        struct igb_q_vector *q_vector = adapter->q_vector[v_idx];
+
+        if (q_vector->tx.ring)
+                adapter->tx_ring[q_vector->tx.ring->queue_index] = NULL;
+
+        if (q_vector->rx.ring)
+                adapter->tx_ring[q_vector->rx.ring->queue_index] = NULL;
+
+        adapter->q_vector[v_idx] = NULL;
+        netif_napi_del(&q_vector->napi);
+
+        /*
+         * ixgbe_get_stats64() might access the rings on this vector,
+         * we must wait a grace period before freeing it.
+         */
+        kfree_rcu(q_vector, rcu);
+}
+
+/**
  * igb_free_q_vectors - Free memory allocated for interrupt vectors
  * @adapter: board private structure to initialize
  *
@@ -969,17 +920,14 @@ static void igb_reset_interrupt_capability(struct igb_adapter *adapter)
  **/
 static void igb_free_q_vectors(struct igb_adapter *adapter)
 {
-        int v_idx;
+        int v_idx = adapter->num_q_vectors;
 
-        for (v_idx = 0; v_idx < adapter->num_q_vectors; v_idx++) {
-                struct igb_q_vector *q_vector = adapter->q_vector[v_idx];
-                adapter->q_vector[v_idx] = NULL;
-                if (!q_vector)
-                        continue;
-                netif_napi_del(&q_vector->napi);
-                kfree(q_vector);
-        }
+        adapter->num_tx_queues = 0;
+        adapter->num_rx_queues = 0;
         adapter->num_q_vectors = 0;
+
+        while (v_idx--)
+                igb_free_q_vector(adapter, v_idx);
 }
 
 /**
@@ -990,7 +938,6 @@ static void igb_free_q_vectors(struct igb_adapter *adapter)
  */
 static void igb_clear_interrupt_scheme(struct igb_adapter *adapter)
 {
-        igb_free_queues(adapter);
         igb_free_q_vectors(adapter);
         igb_reset_interrupt_capability(adapter);
 }
@@ -1001,7 +948,7 @@ static void igb_clear_interrupt_scheme(struct igb_adapter *adapter)
  * Attempt to configure interrupts using the best available
  * capabilities of the hardware and kernel.
  **/
-static int igb_set_interrupt_capability(struct igb_adapter *adapter)
+static void igb_set_interrupt_capability(struct igb_adapter *adapter)
 {
         int err;
         int numvecs, i;
@@ -1038,7 +985,7 @@ static int igb_set_interrupt_capability(struct igb_adapter *adapter)
                               adapter->msix_entries,
                               numvecs);
         if (err == 0)
-                goto out;
+                return;
 
         igb_reset_interrupt_capability(adapter);
 
@@ -1068,105 +1015,183 @@ msi_only:
         adapter->num_q_vectors = 1;
         if (!pci_enable_msi(adapter->pdev))
                 adapter->flags |= IGB_FLAG_HAS_MSI;
-out:
-        /* Notify the stack of the (possibly) reduced queue counts. */
-        rtnl_lock();
-        netif_set_real_num_tx_queues(adapter->netdev, adapter->num_tx_queues);
-        err = netif_set_real_num_rx_queues(adapter->netdev,
-                adapter->num_rx_queues);
-        rtnl_unlock();
-        return err;
+}
+
+static void igb_add_ring(struct igb_ring *ring,
+                         struct igb_ring_container *head)
+{
+        head->ring = ring;
+        head->count++;
 }
 
 /**
- * igb_alloc_q_vectors - Allocate memory for interrupt vectors
+ * igb_alloc_q_vector - Allocate memory for a single interrupt vector
  * @adapter: board private structure to initialize
+ * @v_count: q_vectors allocated on adapter, used for ring interleaving
+ * @v_idx: index of vector in adapter struct
+ * @txr_count: total number of Tx rings to allocate
+ * @txr_idx: index of first Tx ring to allocate
+ * @rxr_count: total number of Rx rings to allocate
+ * @rxr_idx: index of first Rx ring to allocate
  *
- * We allocate one q_vector per queue interrupt.  If allocation fails we
- * return -ENOMEM.
+ * We allocate one q_vector.  If allocation fails we return -ENOMEM.
  **/
-static int igb_alloc_q_vectors(struct igb_adapter *adapter)
+static int igb_alloc_q_vector(struct igb_adapter *adapter,
+                              int v_count, int v_idx,
+                              int txr_count, int txr_idx,
+                              int rxr_count, int rxr_idx)
 {
         struct igb_q_vector *q_vector;
-        struct e1000_hw *hw = &adapter->hw;
-        int v_idx;
+        struct igb_ring *ring;
+        int ring_count, size;
 
-        for (v_idx = 0; v_idx < adapter->num_q_vectors; v_idx++) {
-                q_vector = kzalloc(sizeof(struct igb_q_vector),
-                                   GFP_KERNEL);
-                if (!q_vector)
-                        goto err_out;
-                q_vector->adapter = adapter;
-                q_vector->itr_register = hw->hw_addr + E1000_EITR(0);
-                q_vector->itr_val = IGB_START_ITR;
-                netif_napi_add(adapter->netdev, &q_vector->napi, igb_poll, 64);
-                adapter->q_vector[v_idx] = q_vector;
+        /* igb only supports 1 Tx and/or 1 Rx queue per vector */
+        if (txr_count > 1 || rxr_count > 1)
+                return -ENOMEM;
+
+        ring_count = txr_count + rxr_count;
+        size = sizeof(struct igb_q_vector) +
+               (sizeof(struct igb_ring) * ring_count);
+
+        /* allocate q_vector and rings */
+        q_vector = kzalloc(size, GFP_KERNEL);
+        if (!q_vector)
+                return -ENOMEM;
+
+        /* initialize NAPI */
+        netif_napi_add(adapter->netdev, &q_vector->napi,
+                       igb_poll, 64);
+
+        /* tie q_vector and adapter together */
+        adapter->q_vector[v_idx] = q_vector;
+        q_vector->adapter = adapter;
+
+        /* initialize work limits */
+        q_vector->tx.work_limit = adapter->tx_work_limit;
+
+        /* initialize ITR configuration */
+        q_vector->itr_register = adapter->hw.hw_addr + E1000_EITR(0);
+        q_vector->itr_val = IGB_START_ITR;
+
+        /* initialize pointer to rings */
+        ring = q_vector->ring;
+
+        if (txr_count) {
+                /* assign generic ring traits */
+                ring->dev = &adapter->pdev->dev;
+                ring->netdev = adapter->netdev;
+
+                /* configure backlink on ring */
+                ring->q_vector = q_vector;
+
+                /* update q_vector Tx values */
+                igb_add_ring(ring, &q_vector->tx);
+
+                /* For 82575, context index must be unique per ring. */
+                if (adapter->hw.mac.type == e1000_82575)
+                        set_bit(IGB_RING_FLAG_TX_CTX_IDX, &ring->flags);
+
+                /* apply Tx specific ring traits */
+                ring->count = adapter->tx_ring_count;
+                ring->queue_index = txr_idx;
+
+                /* assign ring to adapter */
+                adapter->tx_ring[txr_idx] = ring;
+
+                /* push pointer to next ring */
+                ring++;
         }
 
-        return 0;
+        if (rxr_count) {
+                /* assign generic ring traits */
+                ring->dev = &adapter->pdev->dev;
+                ring->netdev = adapter->netdev;
 
-err_out:
-        igb_free_q_vectors(adapter);
-        return -ENOMEM;
-}
+                /* configure backlink on ring */
+                ring->q_vector = q_vector;
 
-static void igb_map_rx_ring_to_vector(struct igb_adapter *adapter,
-                                      int ring_idx, int v_idx)
-{
-        struct igb_q_vector *q_vector = adapter->q_vector[v_idx];
+                /* update q_vector Rx values */
+                igb_add_ring(ring, &q_vector->rx);
 
-        q_vector->rx.ring = adapter->rx_ring[ring_idx];
-        q_vector->rx.ring->q_vector = q_vector;
-        q_vector->rx.count++;
-        q_vector->itr_val = adapter->rx_itr_setting;
-        if (q_vector->itr_val && q_vector->itr_val <= 3)
-                q_vector->itr_val = IGB_START_ITR;
-}
+                /* set flag indicating ring supports SCTP checksum offload */
+                if (adapter->hw.mac.type >= e1000_82576)
+                        set_bit(IGB_RING_FLAG_RX_SCTP_CSUM, &ring->flags);
 
-static void igb_map_tx_ring_to_vector(struct igb_adapter *adapter,
-                                      int ring_idx, int v_idx)
-{
-        struct igb_q_vector *q_vector = adapter->q_vector[v_idx];
+                /*
+                 * On i350, i210, and i211, loopback VLAN packets
+                 * have the tag byte-swapped.
+                 * */
+                if (adapter->hw.mac.type >= e1000_i350)
+                        set_bit(IGB_RING_FLAG_RX_LB_VLAN_BSWAP, &ring->flags);
 
-        q_vector->tx.ring = adapter->tx_ring[ring_idx];
-        q_vector->tx.ring->q_vector = q_vector;
-        q_vector->tx.count++;
-        q_vector->itr_val = adapter->tx_itr_setting;
-        q_vector->tx.work_limit = adapter->tx_work_limit;
-        if (q_vector->itr_val && q_vector->itr_val <= 3)
-                q_vector->itr_val = IGB_START_ITR;
+                /* apply Rx specific ring traits */
+                ring->count = adapter->rx_ring_count;
+                ring->queue_index = rxr_idx;
+
+                /* assign ring to adapter */
+                adapter->rx_ring[rxr_idx] = ring;
+        }
+
+        return 0;
 }
 
+
 /**
- * igb_map_ring_to_vector - maps allocated queues to vectors
+ * igb_alloc_q_vectors - Allocate memory for interrupt vectors
+ * @adapter: board private structure to initialize
  *
- * This function maps the recently allocated queues to vectors.
+ * We allocate one q_vector per queue interrupt.  If allocation fails we
+ * return -ENOMEM.
  **/
-static int igb_map_ring_to_vector(struct igb_adapter *adapter)
+static int igb_alloc_q_vectors(struct igb_adapter *adapter)
 {
-        int i;
-        int v_idx = 0;
+        int q_vectors = adapter->num_q_vectors;
+        int rxr_remaining = adapter->num_rx_queues;
+        int txr_remaining = adapter->num_tx_queues;
+        int rxr_idx = 0, txr_idx = 0, v_idx = 0;
+        int err;
 
-        if ((adapter->num_q_vectors < adapter->num_rx_queues) ||
-            (adapter->num_q_vectors < adapter->num_tx_queues))
-                return -ENOMEM;
+        if (q_vectors >= (rxr_remaining + txr_remaining)) {
+                for (; rxr_remaining; v_idx++) {
+                        err = igb_alloc_q_vector(adapter, q_vectors, v_idx,
+                                                 0, 0, 1, rxr_idx);
 
-        if (adapter->num_q_vectors >=
-            (adapter->num_rx_queues + adapter->num_tx_queues)) {
-                for (i = 0; i < adapter->num_rx_queues; i++)
-                        igb_map_rx_ring_to_vector(adapter, i, v_idx++);
-                for (i = 0; i < adapter->num_tx_queues; i++)
-                        igb_map_tx_ring_to_vector(adapter, i, v_idx++);
-        } else {
-                for (i = 0; i < adapter->num_rx_queues; i++) {
-                        if (i < adapter->num_tx_queues)
-                                igb_map_tx_ring_to_vector(adapter, i, v_idx);
-                        igb_map_rx_ring_to_vector(adapter, i, v_idx++);
+                        if (err)
+                                goto err_out;
+
+                        /* update counts and index */
+                        rxr_remaining--;
+                        rxr_idx++;
                 }
-                for (; i < adapter->num_tx_queues; i++)
-                        igb_map_tx_ring_to_vector(adapter, i, v_idx++);
         }
+
+        for (; v_idx < q_vectors; v_idx++) {
+                int rqpv = DIV_ROUND_UP(rxr_remaining, q_vectors - v_idx);
+                int tqpv = DIV_ROUND_UP(txr_remaining, q_vectors - v_idx);
+                err = igb_alloc_q_vector(adapter, q_vectors, v_idx,
+                                         tqpv, txr_idx, rqpv, rxr_idx);
+
+                if (err)
+                        goto err_out;
+
+                /* update counts and index */
+                rxr_remaining -= rqpv;
+                txr_remaining -= tqpv;
+                rxr_idx++;
+                txr_idx++;
+        }
+
         return 0;
+
+err_out:
+        adapter->num_tx_queues = 0;
+        adapter->num_rx_queues = 0;
+        adapter->num_q_vectors = 0;
+
+        while (v_idx--)
+                igb_free_q_vector(adapter, v_idx);
+
+        return -ENOMEM;
 }
 
 /**
@@ -1179,9 +1204,7 @@ static int igb_init_interrupt_scheme(struct igb_adapter *adapter)
         struct pci_dev *pdev = adapter->pdev;
         int err;
 
-        err = igb_set_interrupt_capability(adapter);
-        if (err)
-                return err;
+        igb_set_interrupt_capability(adapter);
 
         err = igb_alloc_q_vectors(adapter);
         if (err) {
@@ -1189,24 +1212,10 @@ static int igb_init_interrupt_scheme(struct igb_adapter *adapter)
                 goto err_alloc_q_vectors;
         }
 
-        err = igb_alloc_queues(adapter);
-        if (err) {
-                dev_err(&pdev->dev, "Unable to allocate memory for queues\n");
-                goto err_alloc_queues;
-        }
-
-        err = igb_map_ring_to_vector(adapter);
-        if (err) {
-                dev_err(&pdev->dev, "Invalid q_vector to ring mapping\n");
-                goto err_map_queues;
-        }
-
+        igb_cache_ring_register(adapter);
 
         return 0;
-err_map_queues:
-        igb_free_queues(adapter);
-err_alloc_queues:
-        igb_free_q_vectors(adapter);
+
 err_alloc_q_vectors:
         igb_reset_interrupt_capability(adapter);
         return err;
@@ -1229,11 +1238,11 @@ static int igb_request_irq(struct igb_adapter *adapter)
                 if (!err)
                         goto request_done;
                 /* fall back to MSI */
+                igb_free_all_tx_resources(adapter);
+                igb_free_all_rx_resources(adapter);
                 igb_clear_interrupt_scheme(adapter);
                 if (!pci_enable_msi(pdev))
                         adapter->flags |= IGB_FLAG_HAS_MSI;
-                igb_free_all_tx_resources(adapter);
-                igb_free_all_rx_resources(adapter);
                 adapter->num_tx_queues = 1;
                 adapter->num_rx_queues = 1;
                 adapter->num_q_vectors = 1;
@@ -1243,13 +1252,6 @@ static int igb_request_irq(struct igb_adapter *adapter)
                                 "Unable to allocate memory for vectors\n");
                         goto request_done;
                 }
-                err = igb_alloc_queues(adapter);
-                if (err) {
-                        dev_err(&pdev->dev,
-                                "Unable to allocate memory for queues\n");
-                        igb_free_q_vectors(adapter);
-                        goto request_done;
-                }
                 igb_setup_all_tx_resources(adapter);
                 igb_setup_all_rx_resources(adapter);
         }
@@ -1706,10 +1708,8 @@ void igb_reset(struct igb_adapter *adapter)
         /* Enable h/w to recognize an 802.1Q VLAN Ethernet packet */
         wr32(E1000_VET, ETHERNET_IEEE_VLAN_TYPE);
 
-#ifdef CONFIG_IGB_PTP
         /* Re-enable PTP, where applicable. */
         igb_ptp_reset(adapter);
-#endif /* CONFIG_IGB_PTP */
 
         igb_get_phy_info(hw);
 }
@@ -1783,58 +1783,34 @@ static const struct net_device_ops igb_netdev_ops = {
 void igb_set_fw_version(struct igb_adapter *adapter)
 {
         struct e1000_hw *hw = &adapter->hw;
-        u16 eeprom_verh, eeprom_verl, comb_verh, comb_verl, comb_offset;
-        u16 major, build, patch, fw_version;
-        u32 etrack_id;
-
-        hw->nvm.ops.read(hw, 5, 1, &fw_version);
-        if (adapter->hw.mac.type != e1000_i211) {
-                hw->nvm.ops.read(hw, NVM_ETRACK_WORD, 1, &eeprom_verh);
-                hw->nvm.ops.read(hw, (NVM_ETRACK_WORD + 1), 1, &eeprom_verl);
-                etrack_id = (eeprom_verh << IGB_ETRACK_SHIFT) | eeprom_verl;
-
-                /* combo image version needs to be found */
-                hw->nvm.ops.read(hw, NVM_COMB_VER_PTR, 1, &comb_offset);
-                if ((comb_offset != 0x0) &&
-                    (comb_offset != IGB_NVM_VER_INVALID)) {
-                        hw->nvm.ops.read(hw, (NVM_COMB_VER_OFF + comb_offset
-                                         + 1), 1, &comb_verh);
-                        hw->nvm.ops.read(hw, (NVM_COMB_VER_OFF + comb_offset),
-                                         1, &comb_verl);
-
-                        /* Only display Option Rom if it exists and is valid */
-                        if ((comb_verh && comb_verl) &&
-                            ((comb_verh != IGB_NVM_VER_INVALID) &&
-                             (comb_verl != IGB_NVM_VER_INVALID))) {
-                                major = comb_verl >> IGB_COMB_VER_SHFT;
-                                build = (comb_verl << IGB_COMB_VER_SHFT) |
-                                        (comb_verh >> IGB_COMB_VER_SHFT);
-                                patch = comb_verh & IGB_COMB_VER_MASK;
-                                snprintf(adapter->fw_version,
-                                         sizeof(adapter->fw_version),
-                                         "%d.%d%d, 0x%08x, %d.%d.%d",
-                                         (fw_version & IGB_MAJOR_MASK) >>
-                                         IGB_MAJOR_SHIFT,
-                                         (fw_version & IGB_MINOR_MASK) >>
-                                         IGB_MINOR_SHIFT,
-                                         (fw_version & IGB_BUILD_MASK),
-                                         etrack_id, major, build, patch);
-                                goto out;
-                        }
-                }
-                snprintf(adapter->fw_version, sizeof(adapter->fw_version),
-                         "%d.%d%d, 0x%08x",
-                         (fw_version & IGB_MAJOR_MASK) >> IGB_MAJOR_SHIFT,
-                         (fw_version & IGB_MINOR_MASK) >> IGB_MINOR_SHIFT,
-                         (fw_version & IGB_BUILD_MASK), etrack_id);
-        } else {
+        struct e1000_fw_version fw;
+
+        igb_get_fw_version(hw, &fw);
+
+        switch (hw->mac.type) {
+        case e1000_i211:
                 snprintf(adapter->fw_version, sizeof(adapter->fw_version),
-                         "%d.%d%d",
-                         (fw_version & IGB_MAJOR_MASK) >> IGB_MAJOR_SHIFT,
-                         (fw_version & IGB_MINOR_MASK) >> IGB_MINOR_SHIFT,
-                         (fw_version & IGB_BUILD_MASK));
+                         "%2d.%2d-%d",
+                         fw.invm_major, fw.invm_minor, fw.invm_img_type);
+                break;
+
+        default:
+                /* if option is rom valid, display its version too */
+                if (fw.or_valid) {
+                        snprintf(adapter->fw_version,
+                                 sizeof(adapter->fw_version),
+                                 "%d.%d, 0x%08x, %d.%d.%d",
+                                 fw.eep_major, fw.eep_minor, fw.etrack_id,
+                                 fw.or_major, fw.or_build, fw.or_patch);
+                /* no option rom */
+                } else {
+                        snprintf(adapter->fw_version,
+                                 sizeof(adapter->fw_version),
+                                 "%d.%d, 0x%08x",
+                                 fw.eep_major, fw.eep_minor, fw.etrack_id);
+                }
+                break;
         }
-out:
         return;
 }
 
@@ -2141,10 +2117,8 @@ static int __devinit igb_probe(struct pci_dev *pdev,
 
 #endif
 
-#ifdef CONFIG_IGB_PTP
         /* do hw tstamp init after resetting */
         igb_ptp_init(adapter);
-#endif /* CONFIG_IGB_PTP */
 
         dev_info(&pdev->dev, "Intel(R) Gigabit Ethernet Network Connection\n");
         /* print bus type/speed/width info */
@@ -2219,9 +2193,7 @@ static void __devexit igb_remove(struct pci_dev *pdev)
         struct e1000_hw *hw = &adapter->hw;
 
         pm_runtime_get_noresume(&pdev->dev);
-#ifdef CONFIG_IGB_PTP
         igb_ptp_stop(adapter);
-#endif /* CONFIG_IGB_PTP */
 
         /*
          * The watchdog timer may be rescheduled, so explicitly
@@ -2531,6 +2503,17 @@ static int __igb_open(struct net_device *netdev, bool resuming)
         if (err)
                 goto err_req_irq;
 
+        /* Notify the stack of the actual queue counts. */
+        err = netif_set_real_num_tx_queues(adapter->netdev,
+                                           adapter->num_tx_queues);
+        if (err)
+                goto err_set_queues;
+
+        err = netif_set_real_num_rx_queues(adapter->netdev,
+                                           adapter->num_rx_queues);
+        if (err)
+                goto err_set_queues;
+
         /* From here on the code is the same as igb_up() */
         clear_bit(__IGB_DOWN, &adapter->state);
 
@@ -2560,6 +2543,8 @@ static int __igb_open(struct net_device *netdev, bool resuming)
 
         return 0;
 
+err_set_queues:
+        igb_free_irq(adapter);
 err_req_irq:
         igb_release_hw_control(adapter);
         igb_power_down_link(adapter);
@@ -2637,10 +2622,8 @@ int igb_setup_tx_resources(struct igb_ring *tx_ring)
         tx_ring->size = tx_ring->count * sizeof(union e1000_adv_tx_desc);
         tx_ring->size = ALIGN(tx_ring->size, 4096);
 
-        tx_ring->desc = dma_alloc_coherent(dev,
-                                           tx_ring->size,
-                                           &tx_ring->dma,
-                                           GFP_KERNEL);
+        tx_ring->desc = dma_alloc_coherent(dev, tx_ring->size,
+                                           &tx_ring->dma, GFP_KERNEL);
         if (!tx_ring->desc)
                 goto err;
 
@@ -2777,18 +2760,16 @@ int igb_setup_rx_resources(struct igb_ring *rx_ring)
         if (!rx_ring->rx_buffer_info)
                 goto err;
 
-
         /* Round up to nearest 4K */
         rx_ring->size = rx_ring->count * sizeof(union e1000_adv_rx_desc);
         rx_ring->size = ALIGN(rx_ring->size, 4096);
 
-        rx_ring->desc = dma_alloc_coherent(dev,
-                                           rx_ring->size,
-                                           &rx_ring->dma,
-                                           GFP_KERNEL);
+        rx_ring->desc = dma_alloc_coherent(dev, rx_ring->size,
+                                           &rx_ring->dma, GFP_KERNEL);
         if (!rx_ring->desc)
                 goto err;
 
+        rx_ring->next_to_alloc = 0;
         rx_ring->next_to_clean = 0;
         rx_ring->next_to_use = 0;
 
@@ -3106,16 +3087,10 @@ void igb_configure_rx_ring(struct igb_adapter *adapter,
 
         /* set descriptor configuration */
         srrctl = IGB_RX_HDR_LEN << E1000_SRRCTL_BSIZEHDRSIZE_SHIFT;
-#if (PAGE_SIZE / 2) > IGB_RXBUFFER_16384
-        srrctl |= IGB_RXBUFFER_16384 >> E1000_SRRCTL_BSIZEPKT_SHIFT;
-#else
-        srrctl |= (PAGE_SIZE / 2) >> E1000_SRRCTL_BSIZEPKT_SHIFT;
-#endif
-        srrctl |= E1000_SRRCTL_DESCTYPE_HDR_SPLIT_ALWAYS;
-#ifdef CONFIG_IGB_PTP
+        srrctl |= IGB_RX_BUFSZ >> E1000_SRRCTL_BSIZEPKT_SHIFT;
+        srrctl |= E1000_SRRCTL_DESCTYPE_ADV_ONEBUF;
         if (hw->mac.type >= e1000_82580)
                 srrctl |= E1000_SRRCTL_TIMESTAMP;
-#endif /* CONFIG_IGB_PTP */
         /* Only set Drop Enable if we are supporting multiple queues */
         if (adapter->vfs_allocated_count || adapter->num_rx_queues > 1)
                 srrctl |= E1000_SRRCTL_DROP_EN;
@@ -3305,36 +3280,27 @@ static void igb_clean_rx_ring(struct igb_ring *rx_ring)
         unsigned long size;
         u16 i;
 
+        if (rx_ring->skb)
+                dev_kfree_skb(rx_ring->skb);
+        rx_ring->skb = NULL;
+
         if (!rx_ring->rx_buffer_info)
                 return;
 
         /* Free all the Rx ring sk_buffs */
         for (i = 0; i < rx_ring->count; i++) {
                 struct igb_rx_buffer *buffer_info = &rx_ring->rx_buffer_info[i];
-                if (buffer_info->dma) {
-                        dma_unmap_single(rx_ring->dev,
-                                         buffer_info->dma,
-                                         IGB_RX_HDR_LEN,
-                                         DMA_FROM_DEVICE);
-                        buffer_info->dma = 0;
-                }
 
-                if (buffer_info->skb) {
-                        dev_kfree_skb(buffer_info->skb);
-                        buffer_info->skb = NULL;
-                }
-                if (buffer_info->page_dma) {
-                        dma_unmap_page(rx_ring->dev,
-                                       buffer_info->page_dma,
-                                       PAGE_SIZE / 2,
-                                       DMA_FROM_DEVICE);
-                        buffer_info->page_dma = 0;
-                }
-                if (buffer_info->page) {
-                        put_page(buffer_info->page);
-                        buffer_info->page = NULL;
-                        buffer_info->page_offset = 0;
-                }
+                if (!buffer_info->page)
+                        continue;
+
+                dma_unmap_page(rx_ring->dev,
+                               buffer_info->dma,
+                               PAGE_SIZE,
+                               DMA_FROM_DEVICE);
+                __free_page(buffer_info->page);
+
+                buffer_info->page = NULL;
         }
 
         size = sizeof(struct igb_rx_buffer) * rx_ring->count;
@@ -3343,6 +3309,7 @@ static void igb_clean_rx_ring(struct igb_ring *rx_ring)
         /* Zero out the descriptor ring */
         memset(rx_ring->desc, 0, rx_ring->size);
 
+        rx_ring->next_to_alloc = 0;
         rx_ring->next_to_clean = 0;
         rx_ring->next_to_use = 0;
 }
@@ -4159,11 +4126,9 @@ static __le32 igb_tx_cmd_type(u32 tx_flags)
         if (tx_flags & IGB_TX_FLAGS_VLAN)
                 cmd_type |= cpu_to_le32(E1000_ADVTXD_DCMD_VLE);
 
-#ifdef CONFIG_IGB_PTP
         /* set timestamp bit if present */
         if (unlikely(tx_flags & IGB_TX_FLAGS_TSTAMP))
                 cmd_type |= cpu_to_le32(E1000_ADVTXD_MAC_TSTAMP);
-#endif /* CONFIG_IGB_PTP */
 
         /* set segmentation bits for TSO */
         if (tx_flags & IGB_TX_FLAGS_TSO)
@@ -4372,9 +4337,7 @@ static inline int igb_maybe_stop_tx(struct igb_ring *tx_ring, const u16 size)
 netdev_tx_t igb_xmit_frame_ring(struct sk_buff *skb,
                                 struct igb_ring *tx_ring)
 {
-#ifdef CONFIG_IGB_PTP
         struct igb_adapter *adapter = netdev_priv(tx_ring->netdev);
-#endif /* CONFIG_IGB_PTP */
         struct igb_tx_buffer *first;
         int tso;
         u32 tx_flags = 0;
@@ -4397,7 +4360,6 @@ netdev_tx_t igb_xmit_frame_ring(struct sk_buff *skb,
         first->bytecount = skb->len;
         first->gso_segs = 1;
 
-#ifdef CONFIG_IGB_PTP
         if (unlikely((skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
                      !(adapter->ptp_tx_skb))) {
                 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
@@ -4407,7 +4369,6 @@ netdev_tx_t igb_xmit_frame_ring(struct sk_buff *skb,
                 if (adapter->hw.mac.type == e1000_82576)
                         schedule_work(&adapter->ptp_tx_work);
         }
-#endif /* CONFIG_IGB_PTP */
 
         if (vlan_tx_tag_present(skb)) {
                 tx_flags |= IGB_TX_FLAGS_VLAN;
@@ -4467,10 +4428,11 @@ static netdev_tx_t igb_xmit_frame(struct sk_buff *skb,
          * The minimum packet size with TCTL.PSP set is 17 so pad the skb
          * in order to meet this minimum size requirement.
          */
-        if (skb->len < 17) {
-                if (skb_padto(skb, 17))
+        if (unlikely(skb->len < 17)) {
+                if (skb_pad(skb, 17 - skb->len))
                         return NETDEV_TX_OK;
                 skb->len = 17;
+                skb_set_tail_pointer(skb, 17);
         }
 
         return igb_xmit_frame_ring(skb, igb_tx_queue_mapping(adapter, skb));
@@ -4800,7 +4762,6 @@ static irqreturn_t igb_msix_other(int irq, void *data)
                         mod_timer(&adapter->watchdog_timer, jiffies + 1);
         }
 
-#ifdef CONFIG_IGB_PTP
         if (icr & E1000_ICR_TS) {
                 u32 tsicr = rd32(E1000_TSICR);
 
@@ -4811,7 +4772,6 @@ static irqreturn_t igb_msix_other(int irq, void *data)
                         schedule_work(&adapter->ptp_tx_work);
                 }
         }
-#endif /* CONFIG_IGB_PTP */
 
         wr32(E1000_EIMS, adapter->eims_other);
 
@@ -4851,45 +4811,63 @@ static irqreturn_t igb_msix_ring(int irq, void *data)
 }
 
 #ifdef CONFIG_IGB_DCA
+static void igb_update_tx_dca(struct igb_adapter *adapter,
+                              struct igb_ring *tx_ring,
+                              int cpu)
+{
+        struct e1000_hw *hw = &adapter->hw;
+        u32 txctrl = dca3_get_tag(tx_ring->dev, cpu);
+
+        if (hw->mac.type != e1000_82575)
+                txctrl <<= E1000_DCA_TXCTRL_CPUID_SHIFT;
+
+        /*
+         * We can enable relaxed ordering for reads, but not writes when
+         * DCA is enabled.  This is due to a known issue in some chipsets
+         * which will cause the DCA tag to be cleared.
+         */
+        txctrl |= E1000_DCA_TXCTRL_DESC_RRO_EN |
+                  E1000_DCA_TXCTRL_DATA_RRO_EN |
+                  E1000_DCA_TXCTRL_DESC_DCA_EN;
+
+        wr32(E1000_DCA_TXCTRL(tx_ring->reg_idx), txctrl);
+}
+
+static void igb_update_rx_dca(struct igb_adapter *adapter,
+                              struct igb_ring *rx_ring,
+                              int cpu)
+{
+        struct e1000_hw *hw = &adapter->hw;
+        u32 rxctrl = dca3_get_tag(&adapter->pdev->dev, cpu);
+
+        if (hw->mac.type != e1000_82575)
+                rxctrl <<= E1000_DCA_RXCTRL_CPUID_SHIFT;
+
+        /*
+         * We can enable relaxed ordering for reads, but not writes when
+         * DCA is enabled.  This is due to a known issue in some chipsets
+         * which will cause the DCA tag to be cleared.
+         */
+        rxctrl |= E1000_DCA_RXCTRL_DESC_RRO_EN |
+                  E1000_DCA_RXCTRL_DESC_DCA_EN;
+
+        wr32(E1000_DCA_RXCTRL(rx_ring->reg_idx), rxctrl);
+}
+
 static void igb_update_dca(struct igb_q_vector *q_vector)
 {
         struct igb_adapter *adapter = q_vector->adapter;
-        struct e1000_hw *hw = &adapter->hw;
         int cpu = get_cpu();
 
         if (q_vector->cpu == cpu)
                 goto out_no_update;
 
-        if (q_vector->tx.ring) {
-                int q = q_vector->tx.ring->reg_idx;
-                u32 dca_txctrl = rd32(E1000_DCA_TXCTRL(q));
-                if (hw->mac.type == e1000_82575) {
-                        dca_txctrl &= ~E1000_DCA_TXCTRL_CPUID_MASK;
-                        dca_txctrl |= dca3_get_tag(&adapter->pdev->dev, cpu);
-                } else {
-                        dca_txctrl &= ~E1000_DCA_TXCTRL_CPUID_MASK_82576;
-                        dca_txctrl |= dca3_get_tag(&adapter->pdev->dev, cpu) <<
-                                      E1000_DCA_TXCTRL_CPUID_SHIFT;
-                }
-                dca_txctrl |= E1000_DCA_TXCTRL_DESC_DCA_EN;
-                wr32(E1000_DCA_TXCTRL(q), dca_txctrl);
-        }
-        if (q_vector->rx.ring) {
-                int q = q_vector->rx.ring->reg_idx;
-                u32 dca_rxctrl = rd32(E1000_DCA_RXCTRL(q));
-                if (hw->mac.type == e1000_82575) {
-                        dca_rxctrl &= ~E1000_DCA_RXCTRL_CPUID_MASK;
-                        dca_rxctrl |= dca3_get_tag(&adapter->pdev->dev, cpu);
-                } else {
-                        dca_rxctrl &= ~E1000_DCA_RXCTRL_CPUID_MASK_82576;
-                        dca_rxctrl |= dca3_get_tag(&adapter->pdev->dev, cpu) <<
-                                      E1000_DCA_RXCTRL_CPUID_SHIFT;
-                }
-                dca_rxctrl |= E1000_DCA_RXCTRL_DESC_DCA_EN;
-                dca_rxctrl |= E1000_DCA_RXCTRL_HEAD_DCA_EN;
-                dca_rxctrl |= E1000_DCA_RXCTRL_DATA_DCA_EN;
-                wr32(E1000_DCA_RXCTRL(q), dca_rxctrl);
-        }
+        if (q_vector->tx.ring)
+                igb_update_tx_dca(adapter, q_vector->tx.ring, cpu);
+
+        if (q_vector->rx.ring)
+                igb_update_rx_dca(adapter, q_vector->rx.ring, cpu);
+
         q_vector->cpu = cpu;
 out_no_update:
         put_cpu();
@@ -5545,7 +5523,6 @@ static irqreturn_t igb_intr_msi(int irq, void *data)
                         mod_timer(&adapter->watchdog_timer, jiffies + 1);
         }
 
-#ifdef CONFIG_IGB_PTP
         if (icr & E1000_ICR_TS) {
                 u32 tsicr = rd32(E1000_TSICR);
 
@@ -5556,7 +5533,6 @@ static irqreturn_t igb_intr_msi(int irq, void *data)
                         schedule_work(&adapter->ptp_tx_work);
                 }
         }
-#endif /* CONFIG_IGB_PTP */
 
         napi_schedule(&q_vector->napi);
 
@@ -5599,7 +5575,6 @@ static irqreturn_t igb_intr(int irq, void *data)
                         mod_timer(&adapter->watchdog_timer, jiffies + 1);
         }
 
-#ifdef CONFIG_IGB_PTP
         if (icr & E1000_ICR_TS) {
                 u32 tsicr = rd32(E1000_TSICR);
 
@@ -5610,7 +5585,6 @@ static irqreturn_t igb_intr(int irq, void *data)
                         schedule_work(&adapter->ptp_tx_work);
                 }
         }
-#endif /* CONFIG_IGB_PTP */
 
         napi_schedule(&q_vector->napi);
 
@@ -5840,6 +5814,181 @@ static bool igb_clean_tx_irq(struct igb_q_vector *q_vector)
         return !!budget;
 }
 
+/**
+ * igb_reuse_rx_page - page flip buffer and store it back on the ring
+ * @rx_ring: rx descriptor ring to store buffers on
+ * @old_buff: donor buffer to have page reused
+ *
+ * Synchronizes page for reuse by the adapter
+ **/
+static void igb_reuse_rx_page(struct igb_ring *rx_ring,
+                              struct igb_rx_buffer *old_buff)
+{
+        struct igb_rx_buffer *new_buff;
+        u16 nta = rx_ring->next_to_alloc;
+
+        new_buff = &rx_ring->rx_buffer_info[nta];
+
+        /* update, and store next to alloc */
+        nta++;
+        rx_ring->next_to_alloc = (nta < rx_ring->count) ? nta : 0;
+
+        /* transfer page from old buffer to new buffer */
+        memcpy(new_buff, old_buff, sizeof(struct igb_rx_buffer));
+
+        /* sync the buffer for use by the device */
+        dma_sync_single_range_for_device(rx_ring->dev, old_buff->dma,
+                                         old_buff->page_offset,
+                                         IGB_RX_BUFSZ,
+                                         DMA_FROM_DEVICE);
+}
+
+/**
+ * igb_add_rx_frag - Add contents of Rx buffer to sk_buff
+ * @rx_ring: rx descriptor ring to transact packets on
+ * @rx_buffer: buffer containing page to add
+ * @rx_desc: descriptor containing length of buffer written by hardware
+ * @skb: sk_buff to place the data into
+ *
+ * This function will add the data contained in rx_buffer->page to the skb.
+ * This is done either through a direct copy if the data in the buffer is
+ * less than the skb header size, otherwise it will just attach the page as
+ * a frag to the skb.
+ *
+ * The function will then update the page offset if necessary and return
+ * true if the buffer can be reused by the adapter.
+ **/
+static bool igb_add_rx_frag(struct igb_ring *rx_ring,
+                            struct igb_rx_buffer *rx_buffer,
+                            union e1000_adv_rx_desc *rx_desc,
+                            struct sk_buff *skb)
+{
+        struct page *page = rx_buffer->page;
+        unsigned int size = le16_to_cpu(rx_desc->wb.upper.length);
+
+        if ((size <= IGB_RX_HDR_LEN) && !skb_is_nonlinear(skb)) {
+                unsigned char *va = page_address(page) + rx_buffer->page_offset;
+
+                if (igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TSIP)) {
+                        igb_ptp_rx_pktstamp(rx_ring->q_vector, va, skb);
+                        va += IGB_TS_HDR_LEN;
+                        size -= IGB_TS_HDR_LEN;
+                }
+
+                memcpy(__skb_put(skb, size), va, ALIGN(size, sizeof(long)));
+
+                /* we can reuse buffer as-is, just make sure it is local */
+                if (likely(page_to_nid(page) == numa_node_id()))
+                        return true;
+
+                /* this page cannot be reused so discard it */
+                put_page(page);
+                return false;
+        }
+
+        skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, page,
+                        rx_buffer->page_offset, size, IGB_RX_BUFSZ);
+
+        /* avoid re-using remote pages */
+        if (unlikely(page_to_nid(page) != numa_node_id()))
+                return false;
+
+#if (PAGE_SIZE < 8192)
+        /* if we are only owner of page we can reuse it */
+        if (unlikely(page_count(page) != 1))
+                return false;
+
+        /* flip page offset to other buffer */
+        rx_buffer->page_offset ^= IGB_RX_BUFSZ;
+
+        /*
+         * since we are the only owner of the page and we need to
+         * increment it, just set the value to 2 in order to avoid
+         * an unnecessary locked operation
+         */
+        atomic_set(&page->_count, 2);
+#else
+        /* move offset up to the next cache line */
+        rx_buffer->page_offset += SKB_DATA_ALIGN(size);
+
+        if (rx_buffer->page_offset > (PAGE_SIZE - IGB_RX_BUFSZ))
+                return false;
+
+        /* bump ref count on page before it is given to the stack */
+        get_page(page);
+#endif
+
+        return true;
+}
+
+static struct sk_buff *igb_fetch_rx_buffer(struct igb_ring *rx_ring,
+                                           union e1000_adv_rx_desc *rx_desc,
+                                           struct sk_buff *skb)
+{
+        struct igb_rx_buffer *rx_buffer;
+        struct page *page;
+
+        rx_buffer = &rx_ring->rx_buffer_info[rx_ring->next_to_clean];
+
+        /*
+         * This memory barrier is needed to keep us from reading
+         * any other fields out of the rx_desc until we know the
+         * RXD_STAT_DD bit is set
+         */
+        rmb();
+
+        page = rx_buffer->page;
+        prefetchw(page);
+
+        if (likely(!skb)) {
+                void *page_addr = page_address(page) +
+                                  rx_buffer->page_offset;
+
+                /* prefetch first cache line of first page */
+                prefetch(page_addr);
+#if L1_CACHE_BYTES < 128
+                prefetch(page_addr + L1_CACHE_BYTES);
+#endif
+
+                /* allocate a skb to store the frags */
+                skb = netdev_alloc_skb_ip_align(rx_ring->netdev,
+                                                IGB_RX_HDR_LEN);
+                if (unlikely(!skb)) {
+                        rx_ring->rx_stats.alloc_failed++;
+                        return NULL;
+                }
+
+                /*
+                 * we will be copying header into skb->data in
+                 * pskb_may_pull so it is in our interest to prefetch
+                 * it now to avoid a possible cache miss
+                 */
+                prefetchw(skb->data);
+        }
+
+        /* we are reusing so sync this buffer for CPU use */
+        dma_sync_single_range_for_cpu(rx_ring->dev,
+                                      rx_buffer->dma,
+                                      rx_buffer->page_offset,
+                                      IGB_RX_BUFSZ,
+                                      DMA_FROM_DEVICE);
+
+        /* pull page into skb */
+        if (igb_add_rx_frag(rx_ring, rx_buffer, rx_desc, skb)) {
+                /* hand second half of page back to the ring */
+                igb_reuse_rx_page(rx_ring, rx_buffer);
+        } else {
+                /* we are not reusing the buffer so unmap it */
+                dma_unmap_page(rx_ring->dev, rx_buffer->dma,
+                               PAGE_SIZE, DMA_FROM_DEVICE);
+        }
+
+        /* clear contents of rx_buffer */
+        rx_buffer->page = NULL;
+
+        return skb;
+}
+
 static inline void igb_rx_checksum(struct igb_ring *ring,
                                    union e1000_adv_rx_desc *rx_desc,
                                    struct sk_buff *skb)
@@ -5889,224 +6038,386 @@ static inline void igb_rx_hash(struct igb_ring *ring,
                 skb->rxhash = le32_to_cpu(rx_desc->wb.lower.hi_dword.rss);
 }
 
-static void igb_rx_vlan(struct igb_ring *ring,
-                        union e1000_adv_rx_desc *rx_desc,
-                        struct sk_buff *skb)
+/**
+ * igb_is_non_eop - process handling of non-EOP buffers
+ * @rx_ring: Rx ring being processed
+ * @rx_desc: Rx descriptor for current buffer
+ * @skb: current socket buffer containing buffer in progress
+ *
+ * This function updates next to clean.  If the buffer is an EOP buffer
+ * this function exits returning false, otherwise it will place the
+ * sk_buff in the next buffer to be chained and return true indicating
+ * that this is in fact a non-EOP buffer.
+ **/
+static bool igb_is_non_eop(struct igb_ring *rx_ring,
+                           union e1000_adv_rx_desc *rx_desc)
 {
-        if (igb_test_staterr(rx_desc, E1000_RXD_STAT_VP)) {
-                u16 vid;
-                if (igb_test_staterr(rx_desc, E1000_RXDEXT_STATERR_LB) &&
-                    test_bit(IGB_RING_FLAG_RX_LB_VLAN_BSWAP, &ring->flags))
-                        vid = be16_to_cpu(rx_desc->wb.upper.vlan);
-                else
-                        vid = le16_to_cpu(rx_desc->wb.upper.vlan);
+        u32 ntc = rx_ring->next_to_clean + 1;
 
-                __vlan_hwaccel_put_tag(skb, vid);
-        }
+        /* fetch, update, and store next to clean */
+        ntc = (ntc < rx_ring->count) ? ntc : 0;
+        rx_ring->next_to_clean = ntc;
+
+        prefetch(IGB_RX_DESC(rx_ring, ntc));
+
+        if (likely(igb_test_staterr(rx_desc, E1000_RXD_STAT_EOP)))
+                return false;
+
+        return true;
 }
 
-static inline u16 igb_get_hlen(union e1000_adv_rx_desc *rx_desc)
-{
-        /* HW will not DMA in data larger than the given buffer, even if it
-         * parses the (NFS, of course) header to be larger.  In that case, it
-         * fills the header buffer and spills the rest into the page.
+/**
+ * igb_get_headlen - determine size of header for LRO/GRO
+ * @data: pointer to the start of the headers
+ * @max_len: total length of section to find headers in
+ *
+ * This function is meant to determine the length of headers that will
+ * be recognized by hardware for LRO, and GRO offloads.  The main
+ * motivation of doing this is to only perform one pull for IPv4 TCP
+ * packets so that we can do basic things like calculating the gso_size
+ * based on the average data per packet.
+ **/
+static unsigned int igb_get_headlen(unsigned char *data,
+                                    unsigned int max_len)
+{
+        union {
+                unsigned char *network;
+                /* l2 headers */
+                struct ethhdr *eth;
+                struct vlan_hdr *vlan;
+                /* l3 headers */
+                struct iphdr *ipv4;
+                struct ipv6hdr *ipv6;
+        } hdr;
+        __be16 protocol;
+        u8 nexthdr = 0; /* default to not TCP */
+        u8 hlen;
+
+        /* this should never happen, but better safe than sorry */
+        if (max_len < ETH_HLEN)
+                return max_len;
+
+        /* initialize network frame pointer */
+        hdr.network = data;
+
+        /* set first protocol and move network header forward */
+        protocol = hdr.eth->h_proto;
+        hdr.network += ETH_HLEN;
+
+        /* handle any vlan tag if present */
+        if (protocol == __constant_htons(ETH_P_8021Q)) {
+                if ((hdr.network - data) > (max_len - VLAN_HLEN))
+                        return max_len;
+
+                protocol = hdr.vlan->h_vlan_encapsulated_proto;
+                hdr.network += VLAN_HLEN;
+        }
+
+        /* handle L3 protocols */
+        if (protocol == __constant_htons(ETH_P_IP)) {
+                if ((hdr.network - data) > (max_len - sizeof(struct iphdr)))
+                        return max_len;
+
+                /* access ihl as a u8 to avoid unaligned access on ia64 */
+                hlen = (hdr.network[0] & 0x0F) << 2;
+
+                /* verify hlen meets minimum size requirements */
+                if (hlen < sizeof(struct iphdr))
+                        return hdr.network - data;
+
+                /* record next protocol */
+                nexthdr = hdr.ipv4->protocol;
+                hdr.network += hlen;
+        } else if (protocol == __constant_htons(ETH_P_IPV6)) {
+                if ((hdr.network - data) > (max_len - sizeof(struct ipv6hdr)))
+                        return max_len;
+
+                /* record next protocol */
+                nexthdr = hdr.ipv6->nexthdr;
+                hdr.network += sizeof(struct ipv6hdr);
+        } else {
+                return hdr.network - data;
+        }
+
+        /* finally sort out TCP */
+        if (nexthdr == IPPROTO_TCP) {
+                if ((hdr.network - data) > (max_len - sizeof(struct tcphdr)))
+                        return max_len;
+
+                /* access doff as a u8 to avoid unaligned access on ia64 */
+                hlen = (hdr.network[12] & 0xF0) >> 2;
+
+                /* verify hlen meets minimum size requirements */
+                if (hlen < sizeof(struct tcphdr))
+                        return hdr.network - data;
+
+                hdr.network += hlen;
+        } else if (nexthdr == IPPROTO_UDP) {
+                if ((hdr.network - data) > (max_len - sizeof(struct udphdr)))
+                        return max_len;
+
+                hdr.network += sizeof(struct udphdr);
+        }
+
+        /*
+         * If everything has gone correctly hdr.network should be the
+         * data section of the packet and will be the end of the header.
+         * If not then it probably represents the end of the last recognized
+         * header.
          */
-        u16 hlen = (le16_to_cpu(rx_desc->wb.lower.lo_dword.hdr_info) &
-                   E1000_RXDADV_HDRBUFLEN_MASK) >> E1000_RXDADV_HDRBUFLEN_SHIFT;
-        if (hlen > IGB_RX_HDR_LEN)
-                hlen = IGB_RX_HDR_LEN;
-        return hlen;
+        if ((hdr.network - data) < max_len)
+                return hdr.network - data;
+        else
+                return max_len;
 }
 
-static bool igb_clean_rx_irq(struct igb_q_vector *q_vector, int budget)
+/**
+ * igb_pull_tail - igb specific version of skb_pull_tail
+ * @rx_ring: rx descriptor ring packet is being transacted on
+ * @rx_desc: pointer to the EOP Rx descriptor
+ * @skb: pointer to current skb being adjusted
+ *
+ * This function is an igb specific version of __pskb_pull_tail.  The
+ * main difference between this version and the original function is that
+ * this function can make several assumptions about the state of things
+ * that allow for significant optimizations versus the standard function.
+ * As a result we can do things like drop a frag and maintain an accurate
+ * truesize for the skb.
+ */
+static void igb_pull_tail(struct igb_ring *rx_ring,
+                          union e1000_adv_rx_desc *rx_desc,
+                          struct sk_buff *skb)
 {
-        struct igb_ring *rx_ring = q_vector->rx.ring;
-        union e1000_adv_rx_desc *rx_desc;
-        const int current_node = numa_node_id();
-        unsigned int total_bytes = 0, total_packets = 0;
-        u16 cleaned_count = igb_desc_unused(rx_ring);
-        u16 i = rx_ring->next_to_clean;
+        struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[0];
+        unsigned char *va;
+        unsigned int pull_len;
 
-        rx_desc = IGB_RX_DESC(rx_ring, i);
+        /*
+         * it is valid to use page_address instead of kmap since we are
+         * working with pages allocated out of the lomem pool per
+         * alloc_page(GFP_ATOMIC)
+         */
+        va = skb_frag_address(frag);
 
-        while (igb_test_staterr(rx_desc, E1000_RXD_STAT_DD)) {
-                struct igb_rx_buffer *buffer_info = &rx_ring->rx_buffer_info[i];
-                struct sk_buff *skb = buffer_info->skb;
-                union e1000_adv_rx_desc *next_rxd;
+        if (igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TSIP)) {
+                /* retrieve timestamp from buffer */
+                igb_ptp_rx_pktstamp(rx_ring->q_vector, va, skb);
 
-                buffer_info->skb = NULL;
-                prefetch(skb->data);
+                /* update pointers to remove timestamp header */
+                skb_frag_size_sub(frag, IGB_TS_HDR_LEN);
+                frag->page_offset += IGB_TS_HDR_LEN;
+                skb->data_len -= IGB_TS_HDR_LEN;
+                skb->len -= IGB_TS_HDR_LEN;
 
-                i++;
-                if (i == rx_ring->count)
-                        i = 0;
+                /* move va to start of packet data */
+                va += IGB_TS_HDR_LEN;
+        }
+
+        /*
+         * we need the header to contain the greater of either ETH_HLEN or
+         * 60 bytes if the skb->len is less than 60 for skb_pad.
+         */
+        pull_len = igb_get_headlen(va, IGB_RX_HDR_LEN);
 
-                next_rxd = IGB_RX_DESC(rx_ring, i);
-                prefetch(next_rxd);
+        /* align pull length to size of long to optimize memcpy performance */
+        skb_copy_to_linear_data(skb, va, ALIGN(pull_len, sizeof(long)));
 
-                /*
-                 * This memory barrier is needed to keep us from reading
-                 * any other fields out of the rx_desc until we know the
-                 * RXD_STAT_DD bit is set
-                 */
-                rmb();
+        /* update all of the pointers */
+        skb_frag_size_sub(frag, pull_len);
+        frag->page_offset += pull_len;
+        skb->data_len -= pull_len;
+        skb->tail += pull_len;
+}
 
-                if (!skb_is_nonlinear(skb)) {
-                        __skb_put(skb, igb_get_hlen(rx_desc));
-                        dma_unmap_single(rx_ring->dev, buffer_info->dma,
-                                         IGB_RX_HDR_LEN,
-                                         DMA_FROM_DEVICE);
-                        buffer_info->dma = 0;
+/**
+ * igb_cleanup_headers - Correct corrupted or empty headers
+ * @rx_ring: rx descriptor ring packet is being transacted on
+ * @rx_desc: pointer to the EOP Rx descriptor
+ * @skb: pointer to current skb being fixed
+ *
+ * Address the case where we are pulling data in on pages only
+ * and as such no data is present in the skb header.
+ *
+ * In addition if skb is not at least 60 bytes we need to pad it so that
+ * it is large enough to qualify as a valid Ethernet frame.
+ *
+ * Returns true if an error was encountered and skb was freed.
+ **/
+static bool igb_cleanup_headers(struct igb_ring *rx_ring,
+                                union e1000_adv_rx_desc *rx_desc,
+                                struct sk_buff *skb)
+{
+
+        if (unlikely((igb_test_staterr(rx_desc,
+                                       E1000_RXDEXT_ERR_FRAME_ERR_MASK)))) {
+                struct net_device *netdev = rx_ring->netdev;
+                if (!(netdev->features & NETIF_F_RXALL)) {
+                        dev_kfree_skb_any(skb);
+                        return true;
                 }
+        }
 
-                if (rx_desc->wb.upper.length) {
-                        u16 length = le16_to_cpu(rx_desc->wb.upper.length);
+        /* place header in linear portion of buffer */
+        if (skb_is_nonlinear(skb))
+                igb_pull_tail(rx_ring, rx_desc, skb);
 
-                        skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags,
-                                                buffer_info->page,
-                                                buffer_info->page_offset,
-                                                length);
+        /* if skb_pad returns an error the skb was freed */
+        if (unlikely(skb->len < 60)) {
+                int pad_len = 60 - skb->len;
 
-                        skb->len += length;
-                        skb->data_len += length;
-                        skb->truesize += PAGE_SIZE / 2;
+                if (skb_pad(skb, pad_len))
+                        return true;
+                __skb_put(skb, pad_len);
+        }
 
-                        if ((page_count(buffer_info->page) != 1) ||
-                            (page_to_nid(buffer_info->page) != current_node))
-                                buffer_info->page = NULL;
-                        else
-                                get_page(buffer_info->page);
+        return false;
+}
 
-                        dma_unmap_page(rx_ring->dev, buffer_info->page_dma,
-                                       PAGE_SIZE / 2, DMA_FROM_DEVICE);
-                        buffer_info->page_dma = 0;
-                }
+/**
+ * igb_process_skb_fields - Populate skb header fields from Rx descriptor
+ * @rx_ring: rx descriptor ring packet is being transacted on
+ * @rx_desc: pointer to the EOP Rx descriptor
+ * @skb: pointer to current skb being populated
+ *
+ * This function checks the ring, descriptor, and packet information in
+ * order to populate the hash, checksum, VLAN, timestamp, protocol, and
+ * other fields within the skb.
+ **/
+static void igb_process_skb_fields(struct igb_ring *rx_ring,
+                                   union e1000_adv_rx_desc *rx_desc,
+                                   struct sk_buff *skb)
+{
+        struct net_device *dev = rx_ring->netdev;
 
-                if (!igb_test_staterr(rx_desc, E1000_RXD_STAT_EOP)) {
-                        struct igb_rx_buffer *next_buffer;
-                        next_buffer = &rx_ring->rx_buffer_info[i];
-                        buffer_info->skb = next_buffer->skb;
-                        buffer_info->dma = next_buffer->dma;
-                        next_buffer->skb = skb;
-                        next_buffer->dma = 0;
-                        goto next_desc;
-                }
+        igb_rx_hash(rx_ring, rx_desc, skb);
 
-                if (unlikely((igb_test_staterr(rx_desc,
-                                               E1000_RXDEXT_ERR_FRAME_ERR_MASK))
-                             && !(rx_ring->netdev->features & NETIF_F_RXALL))) {
-                        dev_kfree_skb_any(skb);
-                        goto next_desc;
-                }
+        igb_rx_checksum(rx_ring, rx_desc, skb);
 
-#ifdef CONFIG_IGB_PTP
-                igb_ptp_rx_hwtstamp(q_vector, rx_desc, skb);
-#endif /* CONFIG_IGB_PTP */
-                igb_rx_hash(rx_ring, rx_desc, skb);
-                igb_rx_checksum(rx_ring, rx_desc, skb);
-                igb_rx_vlan(rx_ring, rx_desc, skb);
+        igb_ptp_rx_hwtstamp(rx_ring->q_vector, rx_desc, skb);
 
-                total_bytes += skb->len;
-                total_packets++;
+        if ((dev->features & NETIF_F_HW_VLAN_RX) &&
+            igb_test_staterr(rx_desc, E1000_RXD_STAT_VP)) {
+                u16 vid;
+                if (igb_test_staterr(rx_desc, E1000_RXDEXT_STATERR_LB) &&
+                    test_bit(IGB_RING_FLAG_RX_LB_VLAN_BSWAP, &rx_ring->flags))
+                        vid = be16_to_cpu(rx_desc->wb.upper.vlan);
+                else
+                        vid = le16_to_cpu(rx_desc->wb.upper.vlan);
 
-                skb->protocol = eth_type_trans(skb, rx_ring->netdev);
+                __vlan_hwaccel_put_tag(skb, vid);
+        }
 
-                napi_gro_receive(&q_vector->napi, skb);
+        skb_record_rx_queue(skb, rx_ring->queue_index);
 
-                budget--;
-next_desc:
-                if (!budget)
-                        break;
+        skb->protocol = eth_type_trans(skb, rx_ring->netdev);
+}
+
+static bool igb_clean_rx_irq(struct igb_q_vector *q_vector, const int budget)
+{
+        struct igb_ring *rx_ring = q_vector->rx.ring;
+        struct sk_buff *skb = rx_ring->skb;
+        unsigned int total_bytes = 0, total_packets = 0;
+        u16 cleaned_count = igb_desc_unused(rx_ring);
+
+        do {
+                union e1000_adv_rx_desc *rx_desc;
 
-                cleaned_count++;
                 /* return some buffers to hardware, one at a time is too slow */
                 if (cleaned_count >= IGB_RX_BUFFER_WRITE) {
                         igb_alloc_rx_buffers(rx_ring, cleaned_count);
                         cleaned_count = 0;
                 }
 
-                /* use prefetched values */
-                rx_desc = next_rxd;
-        }
+                rx_desc = IGB_RX_DESC(rx_ring, rx_ring->next_to_clean);
 
-        rx_ring->next_to_clean = i;
-        u64_stats_update_begin(&rx_ring->rx_syncp);
-        rx_ring->rx_stats.packets += total_packets;
-        rx_ring->rx_stats.bytes += total_bytes;
-        u64_stats_update_end(&rx_ring->rx_syncp);
-        q_vector->rx.total_packets += total_packets;
-        q_vector->rx.total_bytes += total_bytes;
+                if (!igb_test_staterr(rx_desc, E1000_RXD_STAT_DD))
+                        break;
 
-        if (cleaned_count)
-                igb_alloc_rx_buffers(rx_ring, cleaned_count);
+                /* retrieve a buffer from the ring */
+                skb = igb_fetch_rx_buffer(rx_ring, rx_desc, skb);
 
-        return !!budget;
-}
+                /* exit if we failed to retrieve a buffer */
+                if (!skb)
+                        break;
 
-static bool igb_alloc_mapped_skb(struct igb_ring *rx_ring,
-                                 struct igb_rx_buffer *bi)
-{
-        struct sk_buff *skb = bi->skb;
-        dma_addr_t dma = bi->dma;
+                cleaned_count++;
 
-        if (dma)
-                return true;
+                /* fetch next buffer in frame if non-eop */
+                if (igb_is_non_eop(rx_ring, rx_desc))
+                        continue;
 
-        if (likely(!skb)) {
-                skb = netdev_alloc_skb_ip_align(rx_ring->netdev,
-                                                IGB_RX_HDR_LEN);
-                bi->skb = skb;
-                if (!skb) {
-                        rx_ring->rx_stats.alloc_failed++;
-                        return false;
+                /* verify the packet layout is correct */
+                if (igb_cleanup_headers(rx_ring, rx_desc, skb)) {
+                        skb = NULL;
+                        continue;
                 }
 
-                /* initialize skb for ring */
-                skb_record_rx_queue(skb, rx_ring->queue_index);
-        }
+                /* probably a little skewed due to removing CRC */
+                total_bytes += skb->len;
 
-        dma = dma_map_single(rx_ring->dev, skb->data,
-                             IGB_RX_HDR_LEN, DMA_FROM_DEVICE);
+                /* populate checksum, timestamp, VLAN, and protocol */
+                igb_process_skb_fields(rx_ring, rx_desc, skb);
 
-        if (dma_mapping_error(rx_ring->dev, dma)) {
-                rx_ring->rx_stats.alloc_failed++;
-                return false;
-        }
+                napi_gro_receive(&q_vector->napi, skb);
 
-        bi->dma = dma;
-        return true;
+                /* reset skb pointer */
+                skb = NULL;
+
+                /* update budget accounting */
+                total_packets++;
+        } while (likely(total_packets < budget));
+
+        /* place incomplete frames back on ring for completion */
+        rx_ring->skb = skb;
+
+        u64_stats_update_begin(&rx_ring->rx_syncp);
+        rx_ring->rx_stats.packets += total_packets;
+        rx_ring->rx_stats.bytes += total_bytes;
+        u64_stats_update_end(&rx_ring->rx_syncp);
+        q_vector->rx.total_packets += total_packets;
+        q_vector->rx.total_bytes += total_bytes;
+
+        if (cleaned_count)
+                igb_alloc_rx_buffers(rx_ring, cleaned_count);
+
+        return (total_packets < budget);
 }
 
 static bool igb_alloc_mapped_page(struct igb_ring *rx_ring,
                                   struct igb_rx_buffer *bi)
 {
         struct page *page = bi->page;
-        dma_addr_t page_dma = bi->page_dma;
-        unsigned int page_offset = bi->page_offset ^ (PAGE_SIZE / 2);
+        dma_addr_t dma;
 
-        if (page_dma)
+        /* since we are recycling buffers we should seldom need to alloc */
+        if (likely(page))
                 return true;
 
-        if (!page) {
-                page = __skb_alloc_page(GFP_ATOMIC, bi->skb);
-                bi->page = page;
-                if (unlikely(!page)) {
-                        rx_ring->rx_stats.alloc_failed++;
-                        return false;
-                }
+        /* alloc new page for storage */
+        page = __skb_alloc_page(GFP_ATOMIC | __GFP_COLD, NULL);
+        if (unlikely(!page)) {
+                rx_ring->rx_stats.alloc_failed++;
+                return false;
         }
 
-        page_dma = dma_map_page(rx_ring->dev, page,
-                                page_offset, PAGE_SIZE / 2,
-                                DMA_FROM_DEVICE);
+        /* map page for use */
+        dma = dma_map_page(rx_ring->dev, page, 0, PAGE_SIZE, DMA_FROM_DEVICE);
+
+        /*
+         * if mapping failed free memory back to system since
+         * there isn't much point in holding memory we can't use
+         */
+        if (dma_mapping_error(rx_ring->dev, dma)) {
+                __free_page(page);
 
-        if (dma_mapping_error(rx_ring->dev, page_dma)) {
                 rx_ring->rx_stats.alloc_failed++;
                 return false;
         }
 
-        bi->page_dma = page_dma;
-        bi->page_offset = page_offset;
+        bi->dma = dma;
+        bi->page = page;
+        bi->page_offset = 0;
+
         return true;
 }
 
@@ -6120,22 +6431,23 @@ void igb_alloc_rx_buffers(struct igb_ring *rx_ring, u16 cleaned_count)
         struct igb_rx_buffer *bi;
         u16 i = rx_ring->next_to_use;
 
+        /* nothing to do */
+        if (!cleaned_count)
+                return;
+
         rx_desc = IGB_RX_DESC(rx_ring, i);
         bi = &rx_ring->rx_buffer_info[i];
         i -= rx_ring->count;
 
-        while (cleaned_count--) {
-                if (!igb_alloc_mapped_skb(rx_ring, bi))
-                        break;
-
-                /* Refresh the desc even if buffer_addrs didn't change
-                 * because each write-back erases this info. */
-                rx_desc->read.hdr_addr = cpu_to_le64(bi->dma);
-
+        do {
                 if (!igb_alloc_mapped_page(rx_ring, bi))
                         break;
 
-                rx_desc->read.pkt_addr = cpu_to_le64(bi->page_dma);
+                /*
+                 * Refresh the desc even if buffer_addrs didn't change
+                 * because each write-back erases this info.
+                 */
+                rx_desc->read.pkt_addr = cpu_to_le64(bi->dma + bi->page_offset);
 
                 rx_desc++;
                 bi++;
@@ -6148,17 +6460,25 @@ void igb_alloc_rx_buffers(struct igb_ring *rx_ring, u16 cleaned_count)
 
                 /* clear the hdr_addr for the next_to_use descriptor */
                 rx_desc->read.hdr_addr = 0;
-        }
+
+                cleaned_count--;
+        } while (cleaned_count);
 
         i += rx_ring->count;
 
         if (rx_ring->next_to_use != i) {
+                /* record the next descriptor to use */
                 rx_ring->next_to_use = i;
 
-                /* Force memory writes to complete before letting h/w
+                /* update next to alloc since we have filled the ring */
+                rx_ring->next_to_alloc = i;
+
+                /*
+                 * Force memory writes to complete before letting h/w
                  * know there are new descriptors to fetch.  (Only
                  * applicable for weak-ordered memory model archs,
-                 * such as IA-64). */
+                 * such as IA-64).
+                 */
                 wmb();
                 writel(i, rx_ring->tail);
         }
@@ -6207,10 +6527,8 @@ static int igb_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
         case SIOCGMIIREG:
         case SIOCSMIIREG:
                 return igb_mii_ioctl(netdev, ifr, cmd);
-#ifdef CONFIG_IGB_PTP
         case SIOCSHWTSTAMP:
                 return igb_ptp_hwtstamp_ioctl(netdev, ifr, cmd);
-#endif /* CONFIG_IGB_PTP */
         default:
                 return -EOPNOTSUPP;
         }
@@ -6492,7 +6810,9 @@ static int igb_resume(struct device *dev)
         wr32(E1000_WUS, ~0);
 
         if (netdev->flags & IFF_UP) {
+                rtnl_lock();
                 err = __igb_open(netdev, true);
+                rtnl_unlock();
                 if (err)
                         return err;
         }
diff --git a/drivers/net/ethernet/intel/igb/igb_ptp.c b/drivers/net/ethernet/intel/igb/igb_ptp.c
index ee21445157a3..aa10f69f9f16 100644
--- a/drivers/net/ethernet/intel/igb/igb_ptp.c
+++ b/drivers/net/ethernet/intel/igb/igb_ptp.c
@@ -441,18 +441,46 @@ void igb_ptp_tx_hwtstamp(struct igb_adapter *adapter)
         adapter->ptp_tx_skb = NULL;
 }
 
-void igb_ptp_rx_hwtstamp(struct igb_q_vector *q_vector,
-                         union e1000_adv_rx_desc *rx_desc,
+/**
+ * igb_ptp_rx_pktstamp - retrieve Rx per packet timestamp
+ * @q_vector: Pointer to interrupt specific structure
+ * @va: Pointer to address containing Rx buffer
+ * @skb: Buffer containing timestamp and packet
+ *
+ * This function is meant to retrieve a timestamp from the first buffer of an
+ * incoming frame.  The value is stored in little endian format starting on
+ * byte 8.
+ */
+void igb_ptp_rx_pktstamp(struct igb_q_vector *q_vector,
+                         unsigned char *va,
+                         struct sk_buff *skb)
+{
+        __le64 *regval = (__le64 *)va;
+
+        /*
+         * The timestamp is recorded in little endian format.
+         * DWORD: 0        1        2        3
+         * Field: Reserved Reserved SYSTIML  SYSTIMH
+         */
+        igb_ptp_systim_to_hwtstamp(q_vector->adapter, skb_hwtstamps(skb),
+                                   le64_to_cpu(regval[1]));
+}
+
+/**
+ * igb_ptp_rx_rgtstamp - retrieve Rx timestamp stored in register
+ * @q_vector: Pointer to interrupt specific structure
+ * @skb: Buffer containing timestamp and packet
+ *
+ * This function is meant to retrieve a timestamp from the internal registers
+ * of the adapter and store it in the skb.
+ */
+void igb_ptp_rx_rgtstamp(struct igb_q_vector *q_vector,
                          struct sk_buff *skb)
 {
         struct igb_adapter *adapter = q_vector->adapter;
         struct e1000_hw *hw = &adapter->hw;
         u64 regval;
 
-        if (!igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TSIP |
-                                       E1000_RXDADV_STAT_TS))
-                return;
-
         /*
          * If this bit is set, then the RX registers contain the time stamp. No
          * other packet will be time stamped until we read these registers, so
@@ -464,18 +492,11 @@ void igb_ptp_rx_hwtstamp(struct igb_q_vector *q_vector,
          * If nothing went wrong, then it should have a shared tx_flags that we
          * can turn into a skb_shared_hwtstamps.
          */
-        if (igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TSIP)) {
-                u32 *stamp = (u32 *)skb->data;
-                regval = le32_to_cpu(*(stamp + 2));
-                regval |= (u64)le32_to_cpu(*(stamp + 3)) << 32;
-                skb_pull(skb, IGB_TS_HDR_LEN);
-        } else {
-                if (!(rd32(E1000_TSYNCRXCTL) & E1000_TSYNCRXCTL_VALID))
-                        return;
+        if (!(rd32(E1000_TSYNCRXCTL) & E1000_TSYNCRXCTL_VALID))
+                return;
 
-                regval = rd32(E1000_RXSTMPL);
-                regval |= (u64)rd32(E1000_RXSTMPH) << 32;
-        }
+        regval = rd32(E1000_RXSTMPL);
+        regval |= (u64)rd32(E1000_RXSTMPH) << 32;
 
         igb_ptp_systim_to_hwtstamp(adapter, skb_hwtstamps(skb), regval);
 }
diff --git a/drivers/net/ethernet/intel/igbvf/netdev.c b/drivers/net/ethernet/intel/igbvf/netdev.c
index 0ac11f527a84..4051ec404613 100644
--- a/drivers/net/ethernet/intel/igbvf/netdev.c
+++ b/drivers/net/ethernet/intel/igbvf/netdev.c
@@ -184,6 +184,13 @@ static void igbvf_alloc_rx_buffers(struct igbvf_ring *rx_ring,
                                              buffer_info->page_offset,
                                              PAGE_SIZE / 2,
                                              DMA_FROM_DEVICE);
+                        if (dma_mapping_error(&pdev->dev,
+                                              buffer_info->page_dma)) {
+                                __free_page(buffer_info->page);
+                                buffer_info->page = NULL;
+                                dev_err(&pdev->dev, "RX DMA map failed\n");
+                                break;
+                        }
                 }
 
                 if (!buffer_info->skb) {
@@ -197,6 +204,12 @@ static void igbvf_alloc_rx_buffers(struct igbvf_ring *rx_ring,
                         buffer_info->dma = dma_map_single(&pdev->dev, skb->data,
                                                           bufsz,
                                                           DMA_FROM_DEVICE);
+                        if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
+                                dev_kfree_skb(buffer_info->skb);
+                                buffer_info->skb = NULL;
+                                dev_err(&pdev->dev, "RX DMA map failed\n");
+                                goto no_buffers;
+                        }
                 }
                 /* Refresh the desc even if buffer_addrs didn't change because
                  * each write-back erases this info. */
diff --git a/drivers/net/ethernet/intel/ixgbe/Makefile b/drivers/net/ethernet/intel/ixgbe/Makefile
index 89f40e51fc13..f3a632bf8d96 100644
--- a/drivers/net/ethernet/intel/ixgbe/Makefile
+++ b/drivers/net/ethernet/intel/ixgbe/Makefile
@@ -34,11 +34,10 @@ obj-$(CONFIG_IXGBE) += ixgbe.o
 
 ixgbe-objs := ixgbe_main.o ixgbe_common.o ixgbe_ethtool.o ixgbe_debugfs.o\
               ixgbe_82599.o ixgbe_82598.o ixgbe_phy.o ixgbe_sriov.o \
-              ixgbe_mbx.o ixgbe_x540.o ixgbe_lib.o
+              ixgbe_mbx.o ixgbe_x540.o ixgbe_lib.o ixgbe_ptp.o
 
 ixgbe-$(CONFIG_IXGBE_DCB) +=  ixgbe_dcb.o ixgbe_dcb_82598.o \
                               ixgbe_dcb_82599.o ixgbe_dcb_nl.o
 
-ixgbe-$(CONFIG_IXGBE_PTP) += ixgbe_ptp.o
 ixgbe-$(CONFIG_IXGBE_HWMON) += ixgbe_sysfs.o
 ixgbe-$(CONFIG_FCOE:m=y) += ixgbe_fcoe.o
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe.h b/drivers/net/ethernet/intel/ixgbe/ixgbe.h
index 30efc9f0f47a..7ff4c4fdcb0d 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe.h
@@ -36,11 +36,9 @@
 #include <linux/aer.h>
 #include <linux/if_vlan.h>
 
-#ifdef CONFIG_IXGBE_PTP
 #include <linux/clocksource.h>
 #include <linux/net_tstamp.h>
 #include <linux/ptp_clock_kernel.h>
-#endif /* CONFIG_IXGBE_PTP */
 
 #include "ixgbe_type.h"
 #include "ixgbe_common.h"
@@ -135,6 +133,7 @@ struct vf_data_storage {
         u16 tx_rate;
         u16 vlan_count;
         u8 spoofchk_enabled;
+        unsigned int vf_api;
 };
 
 struct vf_macvlans {
@@ -482,7 +481,7 @@ struct ixgbe_adapter {
 #define IXGBE_FLAG2_FDIR_REQUIRES_REINIT        (u32)(1 << 7)
 #define IXGBE_FLAG2_RSS_FIELD_IPV4_UDP          (u32)(1 << 8)
 #define IXGBE_FLAG2_RSS_FIELD_IPV6_UDP          (u32)(1 << 9)
-#define IXGBE_FLAG2_OVERFLOW_CHECK_ENABLED      (u32)(1 << 10)
+#define IXGBE_FLAG2_PTP_ENABLED                 (u32)(1 << 10)
 #define IXGBE_FLAG2_PTP_PPS_ENABLED             (u32)(1 << 11)
 
         /* Tx fast path data */
@@ -571,7 +570,6 @@ struct ixgbe_adapter {
         u32 interrupt_event;
         u32 led_reg;
 
-#ifdef CONFIG_IXGBE_PTP
         struct ptp_clock *ptp_clock;
         struct ptp_clock_info ptp_caps;
         unsigned long last_overflow_check;
@@ -580,8 +578,6 @@ struct ixgbe_adapter {
         struct timecounter tc;
         int rx_hwtstamp_filter;
         u32 base_incval;
-        u32 cycle_speed;
-#endif /* CONFIG_IXGBE_PTP */
 
         /* SR-IOV */
         DECLARE_BITMAP(active_vfs, IXGBE_MAX_VF_FUNCTIONS);
@@ -600,6 +596,8 @@ struct ixgbe_adapter {
 #ifdef CONFIG_DEBUG_FS
         struct dentry *ixgbe_dbg_adapter;
 #endif /*CONFIG_DEBUG_FS*/
+
+        u8 default_up;
 };
 
 struct ixgbe_fdir_filter {
@@ -691,6 +689,7 @@ extern s32 ixgbe_fdir_erase_perfect_filter_82599(struct ixgbe_hw *hw,
                                                  u16 soft_id);
 extern void ixgbe_atr_compute_perfect_hash_82599(union ixgbe_atr_input *input,
                                                  union ixgbe_atr_input *mask);
+extern bool ixgbe_verify_lesm_fw_enabled_82599(struct ixgbe_hw *hw);
 extern void ixgbe_set_rx_mode(struct net_device *netdev);
 #ifdef CONFIG_IXGBE_DCB
 extern void ixgbe_set_rx_drop_en(struct ixgbe_adapter *adapter);
@@ -739,7 +738,6 @@ static inline struct netdev_queue *txring_txq(const struct ixgbe_ring *ring)
         return netdev_get_tx_queue(ring->netdev, ring->queue_index);
 }
 
-#ifdef CONFIG_IXGBE_PTP
 extern void ixgbe_ptp_init(struct ixgbe_adapter *adapter);
 extern void ixgbe_ptp_stop(struct ixgbe_adapter *adapter);
 extern void ixgbe_ptp_overflow_check(struct ixgbe_adapter *adapter);
@@ -751,7 +749,7 @@ extern void ixgbe_ptp_rx_hwtstamp(struct ixgbe_q_vector *q_vector,
 extern int ixgbe_ptp_hwtstamp_ioctl(struct ixgbe_adapter *adapter,
                                     struct ifreq *ifr, int cmd);
 extern void ixgbe_ptp_start_cyclecounter(struct ixgbe_adapter *adapter);
+extern void ixgbe_ptp_reset(struct ixgbe_adapter *adapter);
 extern void ixgbe_ptp_check_pps_event(struct ixgbe_adapter *adapter, u32 eicr);
-#endif /* CONFIG_IXGBE_PTP */
 
 #endif /* _IXGBE_H_ */
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_82599.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_82599.c
index 1077cb2b38db..e75f5a4a2a6d 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_82599.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_82599.c
@@ -62,7 +62,6 @@ static s32 ixgbe_setup_copper_link_82599(struct ixgbe_hw *hw,
                                          bool autoneg,
                                          bool autoneg_wait_to_complete);
 static s32 ixgbe_verify_fw_version_82599(struct ixgbe_hw *hw);
-static bool ixgbe_verify_lesm_fw_enabled_82599(struct ixgbe_hw *hw);
 
 static void ixgbe_init_mac_link_ops_82599(struct ixgbe_hw *hw)
 {
@@ -99,9 +98,8 @@ static void ixgbe_init_mac_link_ops_82599(struct ixgbe_hw *hw)
 static s32 ixgbe_setup_sfp_modules_82599(struct ixgbe_hw *hw)
 {
         s32 ret_val = 0;
-        u32 reg_anlp1 = 0;
-        u32 i = 0;
         u16 list_offset, data_offset, data_value;
+        bool got_lock = false;
 
         if (hw->phy.sfp_type != ixgbe_sfp_type_unknown) {
                 ixgbe_init_mac_link_ops_82599(hw);
@@ -137,28 +135,36 @@ static s32 ixgbe_setup_sfp_modules_82599(struct ixgbe_hw *hw)
                 usleep_range(hw->eeprom.semaphore_delay * 1000,
                              hw->eeprom.semaphore_delay * 2000);
 
-                /* Now restart DSP by setting Restart_AN and clearing LMS */
-                IXGBE_WRITE_REG(hw, IXGBE_AUTOC, ((IXGBE_READ_REG(hw,
-                                IXGBE_AUTOC) & ~IXGBE_AUTOC_LMS_MASK) |
-                                IXGBE_AUTOC_AN_RESTART));
-
-                /* Wait for AN to leave state 0 */
-                for (i = 0; i < 10; i++) {
-                        usleep_range(4000, 8000);
-                        reg_anlp1 = IXGBE_READ_REG(hw, IXGBE_ANLP1);
-                        if (reg_anlp1 & IXGBE_ANLP1_AN_STATE_MASK)
-                                break;
+                /* Need SW/FW semaphore around AUTOC writes if LESM on,
+                 * likewise reset_pipeline requires lock as it also writes
+                 * AUTOC.
+                 */
+                if (ixgbe_verify_lesm_fw_enabled_82599(hw)) {
+                        ret_val = hw->mac.ops.acquire_swfw_sync(hw,
+                                                        IXGBE_GSSR_MAC_CSR_SM);
+                        if (ret_val)
+                                goto setup_sfp_out;
+
+                        got_lock = true;
+                }
+
+                /* Restart DSP and set SFI mode */
+                IXGBE_WRITE_REG(hw, IXGBE_AUTOC, (IXGBE_READ_REG(hw,
+                                IXGBE_AUTOC) | IXGBE_AUTOC_LMS_10G_SERIAL));
+
+                ret_val = ixgbe_reset_pipeline_82599(hw);
+
+                if (got_lock) {
+                        hw->mac.ops.release_swfw_sync(hw,
+                                                      IXGBE_GSSR_MAC_CSR_SM);
+                        got_lock = false;
                 }
-                if (!(reg_anlp1 & IXGBE_ANLP1_AN_STATE_MASK)) {
-                        hw_dbg(hw, "sfp module setup not complete\n");
+
+                if (ret_val) {
+                        hw_dbg(hw, " sfp module setup not complete\n");
                         ret_val = IXGBE_ERR_SFP_SETUP_NOT_COMPLETE;
                         goto setup_sfp_out;
                 }
-
-                /* Restart DSP by setting Restart_AN and return to SFI mode */
-                IXGBE_WRITE_REG(hw, IXGBE_AUTOC, (IXGBE_READ_REG(hw,
-                                IXGBE_AUTOC) | IXGBE_AUTOC_LMS_10G_SERIAL |
-                                IXGBE_AUTOC_AN_RESTART));
         }
 
 setup_sfp_out:
@@ -394,14 +400,26 @@ static s32 ixgbe_start_mac_link_82599(struct ixgbe_hw *hw,
         u32 links_reg;
         u32 i;
         s32 status = 0;
+        bool got_lock = false;
+
+        if (ixgbe_verify_lesm_fw_enabled_82599(hw)) {
+                status = hw->mac.ops.acquire_swfw_sync(hw,
+                                                IXGBE_GSSR_MAC_CSR_SM);
+                if (status)
+                        goto out;
+
+                got_lock = true;
+        }
 
         /* Restart link */
-        autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC);
-        autoc_reg |= IXGBE_AUTOC_AN_RESTART;
-        IXGBE_WRITE_REG(hw, IXGBE_AUTOC, autoc_reg);
+        ixgbe_reset_pipeline_82599(hw);
+
+        if (got_lock)
+                hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_MAC_CSR_SM);
 
         /* Only poll for autoneg to complete if specified to do so */
         if (autoneg_wait_to_complete) {
+                autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC);
                 if ((autoc_reg & IXGBE_AUTOC_LMS_MASK) ==
                      IXGBE_AUTOC_LMS_KX4_KX_KR ||
                     (autoc_reg & IXGBE_AUTOC_LMS_MASK) ==
@@ -425,6 +443,7 @@ static s32 ixgbe_start_mac_link_82599(struct ixgbe_hw *hw,
         /* Add delay to filter out noises during initial link setup */
         msleep(50);
 
+out:
         return status;
 }
 
@@ -779,6 +798,7 @@ static s32 ixgbe_setup_mac_link_82599(struct ixgbe_hw *hw,
         u32 links_reg;
         u32 i;
         ixgbe_link_speed link_capabilities = IXGBE_LINK_SPEED_UNKNOWN;
+        bool got_lock = false;
 
         /* Check to see if speed passed in is supported. */
         status = hw->mac.ops.get_link_capabilities(hw, &link_capabilities,
@@ -836,9 +856,26 @@ static s32 ixgbe_setup_mac_link_82599(struct ixgbe_hw *hw,
         }
 
         if (autoc != start_autoc) {
+                /* Need SW/FW semaphore around AUTOC writes if LESM is on,
+                 * likewise reset_pipeline requires us to hold this lock as
+                 * it also writes to AUTOC.
+                 */
+                if (ixgbe_verify_lesm_fw_enabled_82599(hw)) {
+                        status = hw->mac.ops.acquire_swfw_sync(hw,
+                                                        IXGBE_GSSR_MAC_CSR_SM);
+                        if (status != 0)
+                                goto out;
+
+                        got_lock = true;
+                }
+
                 /* Restart link */
-                autoc |= IXGBE_AUTOC_AN_RESTART;
                 IXGBE_WRITE_REG(hw, IXGBE_AUTOC, autoc);
+                ixgbe_reset_pipeline_82599(hw);
+
+                if (got_lock)
+                        hw->mac.ops.release_swfw_sync(hw,
+                                                      IXGBE_GSSR_MAC_CSR_SM);
 
                 /* Only poll for autoneg to complete if specified to do so */
                 if (autoneg_wait_to_complete) {
@@ -994,9 +1031,28 @@ mac_reset_top:
                 hw->mac.orig_autoc2 = autoc2;
                 hw->mac.orig_link_settings_stored = true;
         } else {
-                if (autoc != hw->mac.orig_autoc)
-                        IXGBE_WRITE_REG(hw, IXGBE_AUTOC, (hw->mac.orig_autoc |
-                                        IXGBE_AUTOC_AN_RESTART));
+                if (autoc != hw->mac.orig_autoc) {
+                        /* Need SW/FW semaphore around AUTOC writes if LESM is
+                         * on, likewise reset_pipeline requires us to hold
+                         * this lock as it also writes to AUTOC.
+                         */
+                        bool got_lock = false;
+                        if (ixgbe_verify_lesm_fw_enabled_82599(hw)) {
+                                status = hw->mac.ops.acquire_swfw_sync(hw,
+                                                        IXGBE_GSSR_MAC_CSR_SM);
+                                if (status)
+                                        goto reset_hw_out;
+
+                                got_lock = true;
+                        }
+
+                        IXGBE_WRITE_REG(hw, IXGBE_AUTOC, hw->mac.orig_autoc);
+                        ixgbe_reset_pipeline_82599(hw);
+
+                        if (got_lock)
+                                hw->mac.ops.release_swfw_sync(hw,
+                                                        IXGBE_GSSR_MAC_CSR_SM);
+                }
 
                 if ((autoc2 & IXGBE_AUTOC2_UPPER_MASK) !=
                     (hw->mac.orig_autoc2 & IXGBE_AUTOC2_UPPER_MASK)) {
@@ -1983,7 +2039,7 @@ fw_version_out:
  *  Returns true if the LESM FW module is present and enabled. Otherwise
  *  returns false. Smart Speed must be disabled if LESM FW module is enabled.
  **/
-static bool ixgbe_verify_lesm_fw_enabled_82599(struct ixgbe_hw *hw)
+bool ixgbe_verify_lesm_fw_enabled_82599(struct ixgbe_hw *hw)
 {
         bool lesm_enabled = false;
         u16 fw_offset, fw_lesm_param_offset, fw_lesm_state;
@@ -2080,6 +2136,50 @@ static s32 ixgbe_read_eeprom_82599(struct ixgbe_hw *hw,
         return ret_val;
 }
 
+/**
+ * ixgbe_reset_pipeline_82599 - perform pipeline reset
+ *
+ * @hw: pointer to hardware structure
+ *
+ * Reset pipeline by asserting Restart_AN together with LMS change to ensure
+ * full pipeline reset.  Note - We must hold the SW/FW semaphore before writing
+ * to AUTOC, so this function assumes the semaphore is held.
+ **/
+s32 ixgbe_reset_pipeline_82599(struct ixgbe_hw *hw)
+{
+        s32 i, autoc_reg, ret_val;
+        s32 anlp1_reg = 0;
+
+        autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC);
+        autoc_reg |= IXGBE_AUTOC_AN_RESTART;
+
+        /* Write AUTOC register with toggled LMS[2] bit and Restart_AN */
+        IXGBE_WRITE_REG(hw, IXGBE_AUTOC, autoc_reg ^ IXGBE_AUTOC_LMS_1G_AN);
+
+        /* Wait for AN to leave state 0 */
+        for (i = 0; i < 10; i++) {
+                usleep_range(4000, 8000);
+                anlp1_reg = IXGBE_READ_REG(hw, IXGBE_ANLP1);
+                if (anlp1_reg & IXGBE_ANLP1_AN_STATE_MASK)
+                        break;
+        }
+
+        if (!(anlp1_reg & IXGBE_ANLP1_AN_STATE_MASK)) {
+                hw_dbg(hw, "auto negotiation not completed\n");
+                ret_val = IXGBE_ERR_RESET_FAILED;
+                goto reset_pipeline_out;
+        }
+
+        ret_val = 0;
+
+reset_pipeline_out:
+        /* Write AUTOC register with original LMS field and Restart_AN */
+        IXGBE_WRITE_REG(hw, IXGBE_AUTOC, autoc_reg);
+        IXGBE_WRITE_FLUSH(hw);
+
+        return ret_val;
+}
+
 static struct ixgbe_mac_operations mac_ops_82599 = {
         .init_hw                = &ixgbe_init_hw_generic,
         .reset_hw               = &ixgbe_reset_hw_82599,
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_common.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_common.c
index dbf37e4a45fd..8f285edb5094 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_common.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_common.c
@@ -90,6 +90,7 @@ static s32 ixgbe_setup_fc(struct ixgbe_hw *hw)
         s32 ret_val = 0;
         u32 reg = 0, reg_bp = 0;
         u16 reg_cu = 0;
+        bool got_lock = false;
 
         /*
          * Validate the requested mode.  Strict IEEE mode does not allow
@@ -210,8 +211,29 @@ static s32 ixgbe_setup_fc(struct ixgbe_hw *hw)
          *
          */
         if (hw->phy.media_type == ixgbe_media_type_backplane) {
-                reg_bp |= IXGBE_AUTOC_AN_RESTART;
+                /* Need the SW/FW semaphore around AUTOC writes if 82599 and
+                 * LESM is on, likewise reset_pipeline requries the lock as
+                 * it also writes AUTOC.
+                 */
+                if ((hw->mac.type == ixgbe_mac_82599EB) &&
+                    ixgbe_verify_lesm_fw_enabled_82599(hw)) {
+                        ret_val = hw->mac.ops.acquire_swfw_sync(hw,
+                                                        IXGBE_GSSR_MAC_CSR_SM);
+                        if (ret_val)
+                                goto out;
+
+                        got_lock = true;
+                }
+
                 IXGBE_WRITE_REG(hw, IXGBE_AUTOC, reg_bp);
+
+                if (hw->mac.type == ixgbe_mac_82599EB)
+                        ixgbe_reset_pipeline_82599(hw);
+
+                if (got_lock)
+                        hw->mac.ops.release_swfw_sync(hw,
+                                                      IXGBE_GSSR_MAC_CSR_SM);
+
         } else if ((hw->phy.media_type == ixgbe_media_type_copper) &&
                     (ixgbe_device_supports_autoneg_fc(hw) == 0)) {
                 hw->phy.ops.write_reg(hw, MDIO_AN_ADVERTISE,
@@ -1778,8 +1800,7 @@ s32 ixgbe_validate_mac_addr(u8 *mac_addr)
         else if (IXGBE_IS_BROADCAST(mac_addr))
                 status = IXGBE_ERR_INVALID_MAC_ADDR;
         /* Reject the zero address */
-        else if (mac_addr[0] == 0 && mac_addr[1] == 0 && mac_addr[2] == 0 &&
-                 mac_addr[3] == 0 && mac_addr[4] == 0 && mac_addr[5] == 0)
+        else if (is_zero_ether_addr(mac_addr))
                 status = IXGBE_ERR_INVALID_MAC_ADDR;
 
         return status;
@@ -2617,6 +2638,7 @@ s32 ixgbe_blink_led_start_generic(struct ixgbe_hw *hw, u32 index)
         bool link_up = false;
         u32 autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC);
         u32 led_reg = IXGBE_READ_REG(hw, IXGBE_LEDCTL);
+        s32 ret_val = 0;
 
         /*
          * Link must be up to auto-blink the LEDs;
@@ -2625,10 +2647,28 @@ s32 ixgbe_blink_led_start_generic(struct ixgbe_hw *hw, u32 index)
         hw->mac.ops.check_link(hw, &speed, &link_up, false);
 
         if (!link_up) {
+                /* Need the SW/FW semaphore around AUTOC writes if 82599 and
+                 * LESM is on.
+                 */
+                bool got_lock = false;
+
+                if ((hw->mac.type == ixgbe_mac_82599EB) &&
+                    ixgbe_verify_lesm_fw_enabled_82599(hw)) {
+                        ret_val = hw->mac.ops.acquire_swfw_sync(hw,
+                                                        IXGBE_GSSR_MAC_CSR_SM);
+                        if (ret_val)
+                                goto out;
+
+                        got_lock = true;
+                }
                 autoc_reg |= IXGBE_AUTOC_AN_RESTART;
                 autoc_reg |= IXGBE_AUTOC_FLU;
                 IXGBE_WRITE_REG(hw, IXGBE_AUTOC, autoc_reg);
                 IXGBE_WRITE_FLUSH(hw);
+
+                if (got_lock)
+                        hw->mac.ops.release_swfw_sync(hw,
+                                                      IXGBE_GSSR_MAC_CSR_SM);
                 usleep_range(10000, 20000);
         }
 
@@ -2637,7 +2677,8 @@ s32 ixgbe_blink_led_start_generic(struct ixgbe_hw *hw, u32 index)
         IXGBE_WRITE_REG(hw, IXGBE_LEDCTL, led_reg);
         IXGBE_WRITE_FLUSH(hw);
 
-        return 0;
+out:
+        return ret_val;
 }
 
 /**
@@ -2649,18 +2690,40 @@ s32 ixgbe_blink_led_stop_generic(struct ixgbe_hw *hw, u32 index)
 {
         u32 autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC);
         u32 led_reg = IXGBE_READ_REG(hw, IXGBE_LEDCTL);
+        s32 ret_val = 0;
+        bool got_lock = false;
+
+        /* Need the SW/FW semaphore around AUTOC writes if 82599 and
+         * LESM is on.
+         */
+        if ((hw->mac.type == ixgbe_mac_82599EB) &&
+            ixgbe_verify_lesm_fw_enabled_82599(hw)) {
+                ret_val = hw->mac.ops.acquire_swfw_sync(hw,
+                                                IXGBE_GSSR_MAC_CSR_SM);
+                if (ret_val)
+                        goto out;
+
+                got_lock = true;
+        }
 
         autoc_reg &= ~IXGBE_AUTOC_FLU;
         autoc_reg |= IXGBE_AUTOC_AN_RESTART;
         IXGBE_WRITE_REG(hw, IXGBE_AUTOC, autoc_reg);
 
+        if (hw->mac.type == ixgbe_mac_82599EB)
+                ixgbe_reset_pipeline_82599(hw);
+
+        if (got_lock)
+                hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_MAC_CSR_SM);
+
         led_reg &= ~IXGBE_LED_MODE_MASK(index);
         led_reg &= ~IXGBE_LED_BLINK(index);
         led_reg |= IXGBE_LED_LINK_ACTIVE << IXGBE_LED_MODE_SHIFT(index);
         IXGBE_WRITE_REG(hw, IXGBE_LEDCTL, led_reg);
         IXGBE_WRITE_FLUSH(hw);
 
-        return 0;
+out:
+        return ret_val;
 }
 
 /**
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_common.h b/drivers/net/ethernet/intel/ixgbe/ixgbe_common.h
index d813d1188c36..587db4728072 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_common.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_common.h
@@ -107,6 +107,7 @@ void ixgbe_clear_tx_pending(struct ixgbe_hw *hw);
 
 void ixgbe_set_rxpba_generic(struct ixgbe_hw *hw, int num_pb,
                              u32 headroom, int strategy);
+s32 ixgbe_reset_pipeline_82599(struct ixgbe_hw *hw);
 
 #define IXGBE_I2C_THERMAL_SENSOR_ADDR   0xF8
 #define IXGBE_EMC_INTERNAL_DATA         0x00
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c
index 116f0e901bee..a545728e100c 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c
@@ -887,24 +887,23 @@ static int ixgbe_set_ringparam(struct net_device *netdev,
                                struct ethtool_ringparam *ring)
 {
         struct ixgbe_adapter *adapter = netdev_priv(netdev);
-        struct ixgbe_ring *temp_tx_ring, *temp_rx_ring;
+        struct ixgbe_ring *temp_ring;
         int i, err = 0;
         u32 new_rx_count, new_tx_count;
-        bool need_update = false;
 
         if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
                 return -EINVAL;
 
-        new_rx_count = max_t(u32, ring->rx_pending, IXGBE_MIN_RXD);
-        new_rx_count = min_t(u32, new_rx_count, IXGBE_MAX_RXD);
-        new_rx_count = ALIGN(new_rx_count, IXGBE_REQ_RX_DESCRIPTOR_MULTIPLE);
-
-        new_tx_count = max_t(u32, ring->tx_pending, IXGBE_MIN_TXD);
-        new_tx_count = min_t(u32, new_tx_count, IXGBE_MAX_TXD);
+        new_tx_count = clamp_t(u32, ring->tx_pending,
+                               IXGBE_MIN_TXD, IXGBE_MAX_TXD);
         new_tx_count = ALIGN(new_tx_count, IXGBE_REQ_TX_DESCRIPTOR_MULTIPLE);
 
-        if ((new_tx_count == adapter->tx_ring[0]->count) &&
-            (new_rx_count == adapter->rx_ring[0]->count)) {
+        new_rx_count = clamp_t(u32, ring->rx_pending,
+                               IXGBE_MIN_RXD, IXGBE_MAX_RXD);
+        new_rx_count = ALIGN(new_rx_count, IXGBE_REQ_RX_DESCRIPTOR_MULTIPLE);
+
+        if ((new_tx_count == adapter->tx_ring_count) &&
+            (new_rx_count == adapter->rx_ring_count)) {
                 /* nothing to do */
                 return 0;
         }
@@ -922,81 +921,80 @@ static int ixgbe_set_ringparam(struct net_device *netdev,
                 goto clear_reset;
         }
 
-        temp_tx_ring = vmalloc(adapter->num_tx_queues * sizeof(struct ixgbe_ring));
-        if (!temp_tx_ring) {
+        /* allocate temporary buffer to store rings in */
+        i = max_t(int, adapter->num_tx_queues, adapter->num_rx_queues);
+        temp_ring = vmalloc(i * sizeof(struct ixgbe_ring));
+
+        if (!temp_ring) {
                 err = -ENOMEM;
                 goto clear_reset;
         }
 
+        ixgbe_down(adapter);
+
+        /*
+         * Setup new Tx resources and free the old Tx resources in that order.
+         * We can then assign the new resources to the rings via a memcpy.
+         * The advantage to this approach is that we are guaranteed to still
+         * have resources even in the case of an allocation failure.
+         */
         if (new_tx_count != adapter->tx_ring_count) {
                 for (i = 0; i < adapter->num_tx_queues; i++) {
-                        memcpy(&temp_tx_ring[i], adapter->tx_ring[i],
+                        memcpy(&temp_ring[i], adapter->tx_ring[i],
                                sizeof(struct ixgbe_ring));
-                        temp_tx_ring[i].count = new_tx_count;
-                        err = ixgbe_setup_tx_resources(&temp_tx_ring[i]);
+
+                        temp_ring[i].count = new_tx_count;
+                        err = ixgbe_setup_tx_resources(&temp_ring[i]);
                         if (err) {
                                 while (i) {
                                         i--;
-                                        ixgbe_free_tx_resources(&temp_tx_ring[i]);
+                                        ixgbe_free_tx_resources(&temp_ring[i]);
                                 }
-                                goto clear_reset;
+                                goto err_setup;
                         }
                 }
-                need_update = true;
-        }
 
-        temp_rx_ring = vmalloc(adapter->num_rx_queues * sizeof(struct ixgbe_ring));
-        if (!temp_rx_ring) {
-                err = -ENOMEM;
-                goto err_setup;
+                for (i = 0; i < adapter->num_tx_queues; i++) {
+                        ixgbe_free_tx_resources(adapter->tx_ring[i]);
+
+                        memcpy(adapter->tx_ring[i], &temp_ring[i],
+                               sizeof(struct ixgbe_ring));
+                }
+
+                adapter->tx_ring_count = new_tx_count;
         }
 
+        /* Repeat the process for the Rx rings if needed */
         if (new_rx_count != adapter->rx_ring_count) {
                 for (i = 0; i < adapter->num_rx_queues; i++) {
-                        memcpy(&temp_rx_ring[i], adapter->rx_ring[i],
+                        memcpy(&temp_ring[i], adapter->rx_ring[i],
                                sizeof(struct ixgbe_ring));
-                        temp_rx_ring[i].count = new_rx_count;
-                        err = ixgbe_setup_rx_resources(&temp_rx_ring[i]);
+
+                        temp_ring[i].count = new_rx_count;
+                        err = ixgbe_setup_rx_resources(&temp_ring[i]);
                         if (err) {
                                 while (i) {
                                         i--;
-                                        ixgbe_free_rx_resources(&temp_rx_ring[i]);
+                                        ixgbe_free_rx_resources(&temp_ring[i]);
                                 }
                                 goto err_setup;
                         }
+
                 }
-                need_update = true;
-        }
 
-        /* if rings need to be updated, here's the place to do it in one shot */
-        if (need_update) {
-                ixgbe_down(adapter);
+                for (i = 0; i < adapter->num_rx_queues; i++) {
+                        ixgbe_free_rx_resources(adapter->rx_ring[i]);
 
-                /* tx */
-                if (new_tx_count != adapter->tx_ring_count) {
-                        for (i = 0; i < adapter->num_tx_queues; i++) {
-                                ixgbe_free_tx_resources(adapter->tx_ring[i]);
-                                memcpy(adapter->tx_ring[i], &temp_tx_ring[i],
-                                       sizeof(struct ixgbe_ring));
-                        }
-                        adapter->tx_ring_count = new_tx_count;
+                        memcpy(adapter->rx_ring[i], &temp_ring[i],
+                               sizeof(struct ixgbe_ring));
                 }
 
-                /* rx */
-                if (new_rx_count != adapter->rx_ring_count) {
-                        for (i = 0; i < adapter->num_rx_queues; i++) {
-                                ixgbe_free_rx_resources(adapter->rx_ring[i]);
-                                memcpy(adapter->rx_ring[i], &temp_rx_ring[i],
-                                       sizeof(struct ixgbe_ring));
-                        }
-                        adapter->rx_ring_count = new_rx_count;
-                }
-                ixgbe_up(adapter);
+                adapter->rx_ring_count = new_rx_count;
         }
 
-        vfree(temp_rx_ring);
 err_setup:
-        vfree(temp_tx_ring);
+        ixgbe_up(adapter);
+        vfree(temp_ring);
 clear_reset:
         clear_bit(__IXGBE_RESETTING, &adapter->state);
         return err;
@@ -2669,7 +2667,6 @@ static int ixgbe_get_ts_info(struct net_device *dev,
         struct ixgbe_adapter *adapter = netdev_priv(dev);
 
         switch (adapter->hw.mac.type) {
-#ifdef CONFIG_IXGBE_PTP
         case ixgbe_mac_X540:
         case ixgbe_mac_82599EB:
                 info->so_timestamping =
@@ -2695,7 +2692,6 @@ static int ixgbe_get_ts_info(struct net_device *dev,
                         (1 << HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ) |
                         (1 << HWTSTAMP_FILTER_PTP_V2_EVENT);
                 break;
-#endif /* CONFIG_IXGBE_PTP */
         default:
                 return ethtool_op_get_ts_info(dev, info);
                 break;
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c
index ae73ef14fdf3..252850d9a3e0 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c
@@ -800,6 +800,10 @@ int ixgbe_fcoe_enable(struct net_device *netdev)
                 return -EINVAL;
 
         e_info(drv, "Enabling FCoE offload features.\n");
+
+        if (adapter->flags & IXGBE_FLAG_SRIOV_ENABLED)
+                e_warn(probe, "Enabling FCoE on PF will disable legacy VFs\n");
+
         if (netif_running(netdev))
                 netdev->netdev_ops->ndo_stop(netdev);
 
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c
index 17ecbcedd548..8c74f739011d 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c
@@ -802,10 +802,13 @@ static int ixgbe_alloc_q_vector(struct ixgbe_adapter *adapter,
         /* setup affinity mask and node */
         if (cpu != -1)
                 cpumask_set_cpu(cpu, &q_vector->affinity_mask);
-        else
-                cpumask_copy(&q_vector->affinity_mask, cpu_online_mask);
         q_vector->numa_node = node;
 
+#ifdef CONFIG_IXGBE_DCA
+        /* initialize CPU for DCA */
+        q_vector->cpu = -1;
+
+#endif
         /* initialize NAPI */
         netif_napi_add(adapter->netdev, &q_vector->napi,
                        ixgbe_poll, 64);
@@ -821,6 +824,21 @@ static int ixgbe_alloc_q_vector(struct ixgbe_adapter *adapter,
         /* initialize pointer to rings */
         ring = q_vector->ring;
 
+        /* intialize ITR */
+        if (txr_count && !rxr_count) {
+                /* tx only vector */
+                if (adapter->tx_itr_setting == 1)
+                        q_vector->itr = IXGBE_10K_ITR;
+                else
+                        q_vector->itr = adapter->tx_itr_setting;
+        } else {
+                /* rx or rx/tx vector */
+                if (adapter->rx_itr_setting == 1)
+                        q_vector->itr = IXGBE_20K_ITR;
+                else
+                        q_vector->itr = adapter->rx_itr_setting;
+        }
+
         while (txr_count) {
                 /* assign generic ring traits */
                 ring->dev = &adapter->pdev->dev;
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
index fa3d552e1f4a..690535a0322f 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
@@ -44,6 +44,7 @@
 #include <linux/ethtool.h>
 #include <linux/if.h>
 #include <linux/if_vlan.h>
+#include <linux/if_bridge.h>
 #include <linux/prefetch.h>
 #include <scsi/fc/fc_fcoe.h>
 
@@ -355,13 +356,37 @@ static void ixgbe_dump(struct ixgbe_adapter *adapter)
 
         /* Transmit Descriptor Formats
          *
-         * Advanced Transmit Descriptor
+         * 82598 Advanced Transmit Descriptor
          *   +--------------------------------------------------------------+
          * 0 |         Buffer Address [63:0]                                |
          *   +--------------------------------------------------------------+
-         * 8 |  PAYLEN  | PORTS  | IDX | STA | DCMD  |DTYP |  RSV |  DTALEN |
+         * 8 |  PAYLEN  | POPTS  | IDX | STA | DCMD  |DTYP |  RSV |  DTALEN |
          *   +--------------------------------------------------------------+
          *   63       46 45    40 39 36 35 32 31   24 23 20 19              0
+         *
+         * 82598 Advanced Transmit Descriptor (Write-Back Format)
+         *   +--------------------------------------------------------------+
+         * 0 |                          RSV [63:0]                          |
+         *   +--------------------------------------------------------------+
+         * 8 |            RSV           |  STA  |          NXTSEQ           |
+         *   +--------------------------------------------------------------+
+         *   63                       36 35   32 31                         0
+         *
+         * 82599+ Advanced Transmit Descriptor
+         *   +--------------------------------------------------------------+
+         * 0 |         Buffer Address [63:0]                                |
+         *   +--------------------------------------------------------------+
+         * 8 |PAYLEN  |POPTS|CC|IDX  |STA  |DCMD  |DTYP |MAC  |RSV  |DTALEN |
+         *   +--------------------------------------------------------------+
+         *   63     46 45 40 39 38 36 35 32 31  24 23 20 19 18 17 16 15     0
+         *
+         * 82599+ Advanced Transmit Descriptor (Write-Back Format)
+         *   +--------------------------------------------------------------+
+         * 0 |                          RSV [63:0]                          |
+         *   +--------------------------------------------------------------+
+         * 8 |            RSV           |  STA  |           RSV             |
+         *   +--------------------------------------------------------------+
+         *   63                       36 35   32 31                         0
          */
 
         for (n = 0; n < adapter->num_tx_queues; n++) {
@@ -422,7 +447,9 @@ rx_ring_summary:
 
         dev_info(&adapter->pdev->dev, "RX Rings Dump\n");
 
-        /* Advanced Receive Descriptor (Read) Format
+        /* Receive Descriptor Formats
+         *
+         * 82598 Advanced Receive Descriptor (Read) Format
          *    63                                           1        0
          *    +-----------------------------------------------------+
          *  0 |       Packet Buffer Address [63:1]           |A0/NSE|
@@ -431,17 +458,40 @@ rx_ring_summary:
          *    +-----------------------------------------------------+
          *
          *
-         * Advanced Receive Descriptor (Write-Back) Format
+         * 82598 Advanced Receive Descriptor (Write-Back) Format
          *
          *   63       48 47    32 31  30      21 20 16 15   4 3     0
          *   +------------------------------------------------------+
-         * 0 | Packet     IP     |SPH| HDR_LEN   | RSV|Packet|  RSS |
-         *   | Checksum   Ident  |   |           |    | Type | Type |
+         * 0 |       RSS Hash /  |SPH| HDR_LEN  | RSV |Packet|  RSS |
+         *   | Packet   | IP     |   |          |     | Type | Type |
+         *   | Checksum | Ident  |   |          |     |      |      |
          *   +------------------------------------------------------+
          * 8 | VLAN Tag | Length | Extended Error | Extended Status |
          *   +------------------------------------------------------+
          *   63       48 47    32 31            20 19               0
+         *
+         * 82599+ Advanced Receive Descriptor (Read) Format
+         *    63                                           1        0
+         *    +-----------------------------------------------------+
+         *  0 |       Packet Buffer Address [63:1]           |A0/NSE|
+         *    +----------------------------------------------+------+
+         *  8 |       Header Buffer Address [63:1]           |  DD  |
+         *    +-----------------------------------------------------+
+         *
+         *
+         * 82599+ Advanced Receive Descriptor (Write-Back) Format
+         *
+         *   63       48 47    32 31  30      21 20 17 16   4 3     0
+         *   +------------------------------------------------------+
+         * 0 |RSS / Frag Checksum|SPH| HDR_LEN  |RSC- |Packet|  RSS |
+         *   |/ RTT / PCoE_PARAM |   |          | CNT | Type | Type |
+         *   |/ Flow Dir Flt ID  |   |          |     |      |      |
+         *   +------------------------------------------------------+
+         * 8 | VLAN Tag | Length |Extended Error| Xtnd Status/NEXTP |
+         *   +------------------------------------------------------+
+         *   63       48 47    32 31          20 19                 0
          */
+
         for (n = 0; n < adapter->num_rx_queues; n++) {
                 rx_ring = adapter->rx_ring[n];
                 pr_info("------------------------------------\n");
@@ -791,10 +841,8 @@ static bool ixgbe_clean_tx_irq(struct ixgbe_q_vector *q_vector,
                 total_bytes += tx_buffer->bytecount;
                 total_packets += tx_buffer->gso_segs;
 
-#ifdef CONFIG_IXGBE_PTP
                 if (unlikely(tx_buffer->tx_flags & IXGBE_TX_FLAGS_TSTAMP))
                         ixgbe_ptp_tx_hwtstamp(q_vector, tx_buffer->skb);
-#endif
 
                 /* free the skb */
                 dev_kfree_skb_any(tx_buffer->skb);
@@ -1244,6 +1292,7 @@ static unsigned int ixgbe_get_headlen(unsigned char *data,
                 struct vlan_hdr *vlan;
                 /* l3 headers */
                 struct iphdr *ipv4;
+                struct ipv6hdr *ipv6;
         } hdr;
         __be16 protocol;
         u8 nexthdr = 0; /* default to not TCP */
@@ -1284,6 +1333,13 @@ static unsigned int ixgbe_get_headlen(unsigned char *data,
                 /* record next protocol */
                 nexthdr = hdr.ipv4->protocol;
                 hdr.network += hlen;
+        } else if (protocol == __constant_htons(ETH_P_IPV6)) {
+                if ((hdr.network - data) > (max_len - sizeof(struct ipv6hdr)))
+                        return max_len;
+
+                /* record next protocol */
+                nexthdr = hdr.ipv6->nexthdr;
+                hdr.network += sizeof(struct ipv6hdr);
 #ifdef IXGBE_FCOE
         } else if (protocol == __constant_htons(ETH_P_FCOE)) {
                 if ((hdr.network - data) > (max_len - FCOE_HEADER_LEN))
@@ -1294,7 +1350,7 @@ static unsigned int ixgbe_get_headlen(unsigned char *data,
                 return hdr.network - data;
         }
 
-        /* finally sort out TCP */
+        /* finally sort out TCP/UDP */
         if (nexthdr == IPPROTO_TCP) {
                 if ((hdr.network - data) > (max_len - sizeof(struct tcphdr)))
                         return max_len;
@@ -1307,6 +1363,11 @@ static unsigned int ixgbe_get_headlen(unsigned char *data,
                         return hdr.network - data;
 
                 hdr.network += hlen;
+        } else if (nexthdr == IPPROTO_UDP) {
+                if ((hdr.network - data) > (max_len - sizeof(struct udphdr)))
+                        return max_len;
+
+                hdr.network += sizeof(struct udphdr);
         }
 
         /*
@@ -1369,9 +1430,7 @@ static void ixgbe_process_skb_fields(struct ixgbe_ring *rx_ring,
 
         ixgbe_rx_checksum(rx_ring, rx_desc, skb);
 
-#ifdef CONFIG_IXGBE_PTP
         ixgbe_ptp_rx_hwtstamp(rx_ring->q_vector, rx_desc, skb);
-#endif
 
         if ((dev->features & NETIF_F_HW_VLAN_RX) &&
             ixgbe_test_staterr(rx_desc, IXGBE_RXD_STAT_VP)) {
@@ -1781,7 +1840,7 @@ dma_sync:
  **/
 static bool ixgbe_clean_rx_irq(struct ixgbe_q_vector *q_vector,
                                struct ixgbe_ring *rx_ring,
-                               int budget)
+                               const int budget)
 {
         unsigned int total_rx_bytes = 0, total_rx_packets = 0;
 #ifdef IXGBE_FCOE
@@ -1832,7 +1891,6 @@ static bool ixgbe_clean_rx_irq(struct ixgbe_q_vector *q_vector,
 
                 /* probably a little skewed due to removing CRC */
                 total_rx_bytes += skb->len;
-                total_rx_packets++;
 
                 /* populate checksum, timestamp, VLAN, and protocol */
                 ixgbe_process_skb_fields(rx_ring, rx_desc, skb);
@@ -1865,8 +1923,8 @@ static bool ixgbe_clean_rx_irq(struct ixgbe_q_vector *q_vector,
                 ixgbe_rx_skb(q_vector, skb);
 
                 /* update budget accounting */
-                budget--;
-        } while (likely(budget));
+                total_rx_packets++;
+        } while (likely(total_rx_packets < budget));
 
         u64_stats_update_begin(&rx_ring->syncp);
         rx_ring->stats.packets += total_rx_packets;
@@ -1878,7 +1936,7 @@ static bool ixgbe_clean_rx_irq(struct ixgbe_q_vector *q_vector,
         if (cleaned_count)
                 ixgbe_alloc_rx_buffers(rx_ring, cleaned_count);
 
-        return !!budget;
+        return (total_rx_packets < budget);
 }
 
 /**
@@ -1914,20 +1972,6 @@ static void ixgbe_configure_msix(struct ixgbe_adapter *adapter)
                 ixgbe_for_each_ring(ring, q_vector->tx)
                         ixgbe_set_ivar(adapter, 1, ring->reg_idx, v_idx);
 
-                if (q_vector->tx.ring && !q_vector->rx.ring) {
-                        /* tx only vector */
-                        if (adapter->tx_itr_setting == 1)
-                                q_vector->itr = IXGBE_10K_ITR;
-                        else
-                                q_vector->itr = adapter->tx_itr_setting;
-                } else {
-                        /* rx or rx/tx vector */
-                        if (adapter->rx_itr_setting == 1)
-                                q_vector->itr = IXGBE_20K_ITR;
-                        else
-                                q_vector->itr = adapter->rx_itr_setting;
-                }
-
                 ixgbe_write_eitr(q_vector);
         }
 
@@ -2324,10 +2368,8 @@ static inline void ixgbe_irq_enable(struct ixgbe_adapter *adapter, bool queues,
                 break;
         }
 
-#ifdef CONFIG_IXGBE_PTP
         if (adapter->hw.mac.type == ixgbe_mac_X540)
                 mask |= IXGBE_EIMS_TIMESYNC;
-#endif
 
         if ((adapter->flags & IXGBE_FLAG_FDIR_HASH_CAPABLE) &&
             !(adapter->flags2 & IXGBE_FLAG2_FDIR_REQUIRES_REINIT))
@@ -2393,10 +2435,8 @@ static irqreturn_t ixgbe_msix_other(int irq, void *data)
 
         ixgbe_check_fan_failure(adapter, eicr);
 
-#ifdef CONFIG_IXGBE_PTP
         if (unlikely(eicr & IXGBE_EICR_TIMESYNC))
                 ixgbe_ptp_check_pps_event(adapter, eicr);
-#endif
 
         /* re-enable the original interrupt state, no lsc, no queues */
         if (!test_bit(__IXGBE_DOWN, &adapter->state))
@@ -2588,10 +2628,8 @@ static irqreturn_t ixgbe_intr(int irq, void *data)
         }
 
         ixgbe_check_fan_failure(adapter, eicr);
-#ifdef CONFIG_IXGBE_PTP
         if (unlikely(eicr & IXGBE_EICR_TIMESYNC))
                 ixgbe_ptp_check_pps_event(adapter, eicr);
-#endif
 
         /* would disable interrupts here but EIAM disabled it */
         napi_schedule(&q_vector->napi);
@@ -2699,12 +2737,6 @@ static void ixgbe_configure_msi_and_legacy(struct ixgbe_adapter *adapter)
 {
         struct ixgbe_q_vector *q_vector = adapter->q_vector[0];
 
-        /* rx/tx vector */
-        if (adapter->rx_itr_setting == 1)
-                q_vector->itr = IXGBE_20K_ITR;
-        else
-                q_vector->itr = adapter->rx_itr_setting;
-
         ixgbe_write_eitr(q_vector);
 
         ixgbe_set_ivar(adapter, 0, 0, 0);
@@ -3211,7 +3243,6 @@ static void ixgbe_configure_virtualization(struct ixgbe_adapter *adapter)
         IXGBE_WRITE_REG(hw, IXGBE_VFRE(reg_offset ^ 1), reg_offset - 1);
         IXGBE_WRITE_REG(hw, IXGBE_VFTE(reg_offset), (~0) << vf_shift);
         IXGBE_WRITE_REG(hw, IXGBE_VFTE(reg_offset ^ 1), reg_offset - 1);
-        IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, IXGBE_PFDTXGSWC_VT_LBEN);
 
         /* Map PF MAC address in RAR Entry 0 to first pool following VFs */
         hw->mac.ops.set_vmdq(hw, 0, VMDQ_P(0));
@@ -3234,8 +3265,6 @@ static void ixgbe_configure_virtualization(struct ixgbe_adapter *adapter)
 
         IXGBE_WRITE_REG(hw, IXGBE_GCR_EXT, gcr_ext);
 
-        /* enable Tx loopback for VF/PF communication */
-        IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, IXGBE_PFDTXGSWC_VT_LBEN);
 
         /* Enable MAC Anti-Spoofing */
         hw->mac.ops.set_mac_anti_spoofing(hw, (adapter->num_vfs != 0),
@@ -3263,6 +3292,11 @@ static void ixgbe_set_rx_buffer_len(struct ixgbe_adapter *adapter)
                 max_frame = IXGBE_FCOE_JUMBO_FRAME_SIZE;
 
 #endif /* IXGBE_FCOE */
+
+        /* adjust max frame to be at least the size of a standard frame */
+        if (max_frame < (ETH_FRAME_LEN + ETH_FCS_LEN))
+                max_frame = (ETH_FRAME_LEN + ETH_FCS_LEN);
+
         mhadd = IXGBE_READ_REG(hw, IXGBE_MHADD);
         if (max_frame != (mhadd >> IXGBE_MHADD_MFS_SHIFT)) {
                 mhadd &= ~IXGBE_MHADD_MFS_MASK;
@@ -3271,9 +3305,6 @@ static void ixgbe_set_rx_buffer_len(struct ixgbe_adapter *adapter)
                 IXGBE_WRITE_REG(hw, IXGBE_MHADD, mhadd);
         }
 
-        /* MHADD will allow an extra 4 bytes past for vlan tagged frames */
-        max_frame += VLAN_HLEN;
-
         hlreg0 = IXGBE_READ_REG(hw, IXGBE_HLREG0);
         /* set jumbo enable since MHADD.MFS is keeping size locked at max_frame */
         hlreg0 |= IXGBE_HLREG0_JUMBOEN;
@@ -4072,11 +4103,8 @@ static void ixgbe_up_complete(struct ixgbe_adapter *adapter)
         else
                 ixgbe_configure_msi_and_legacy(adapter);
 
-        /* enable the optics for both mult-speed fiber and 82599 SFP+ fiber */
-        if (hw->mac.ops.enable_tx_laser &&
-            ((hw->phy.multispeed_fiber) ||
-             ((hw->mac.ops.get_media_type(hw) == ixgbe_media_type_fiber) &&
-              (hw->mac.type == ixgbe_mac_82599EB))))
+        /* enable the optics for 82599 SFP+ fiber */
+        if (hw->mac.ops.enable_tx_laser)
                 hw->mac.ops.enable_tx_laser(hw);
 
         clear_bit(__IXGBE_DOWN, &adapter->state);
@@ -4192,6 +4220,9 @@ void ixgbe_reset(struct ixgbe_adapter *adapter)
         /* update SAN MAC vmdq pool selection */
         if (hw->mac.san_mac_rar_index)
                 hw->mac.ops.set_vmdq_san_mac(hw, VMDQ_P(0));
+
+        if (adapter->flags2 & IXGBE_FLAG2_PTP_ENABLED)
+                ixgbe_ptp_reset(adapter);
 }
 
 /**
@@ -4393,11 +4424,8 @@ void ixgbe_down(struct ixgbe_adapter *adapter)
         if (!pci_channel_offline(adapter->pdev))
                 ixgbe_reset(adapter);
 
-        /* power down the optics for multispeed fiber and 82599 SFP+ fiber */
-        if (hw->mac.ops.disable_tx_laser &&
-            ((hw->phy.multispeed_fiber) ||
-             ((hw->mac.ops.get_media_type(hw) == ixgbe_media_type_fiber) &&
-              (hw->mac.type == ixgbe_mac_82599EB))))
+        /* power down the optics for 82599 SFP+ fiber */
+        if (hw->mac.ops.disable_tx_laser)
                 hw->mac.ops.disable_tx_laser(hw);
 
         ixgbe_clean_all_tx_rings(adapter);
@@ -4828,14 +4856,14 @@ static int ixgbe_change_mtu(struct net_device *netdev, int new_mtu)
                 return -EINVAL;
 
         /*
-         * For 82599EB we cannot allow PF to change MTU greater than 1500
-         * in SR-IOV mode as it may cause buffer overruns in guest VFs that
-         * don't allocate and chain buffers correctly.
+         * For 82599EB we cannot allow legacy VFs to enable their receive
+         * paths when MTU greater than 1500 is configured.  So display a
+         * warning that legacy VFs will be disabled.
          */
         if ((adapter->flags & IXGBE_FLAG_SRIOV_ENABLED) &&
             (adapter->hw.mac.type == ixgbe_mac_82599EB) &&
             (max_frame > MAXIMUM_ETHERNET_VLAN_SIZE))
-                        return -EINVAL;
+                e_warn(probe, "Setting MTU > 1500 will disable legacy VFs\n");
 
         e_info(probe, "changing MTU from %d to %d\n", netdev->mtu, new_mtu);
 
@@ -4901,6 +4929,8 @@ static int ixgbe_open(struct net_device *netdev)
         if (err)
                 goto err_set_queues;
 
+        ixgbe_ptp_init(adapter);
+
         ixgbe_up_complete(adapter);
 
         return 0;
@@ -4932,6 +4962,8 @@ static int ixgbe_close(struct net_device *netdev)
 {
         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 
+        ixgbe_ptp_stop(adapter);
+
         ixgbe_down(adapter);
         ixgbe_free_irq(adapter);
 
@@ -5022,14 +5054,8 @@ static int __ixgbe_shutdown(struct pci_dev *pdev, bool *enable_wake)
         if (wufc) {
                 ixgbe_set_rx_mode(netdev);
 
-                /*
-                 * enable the optics for both mult-speed fiber and
-                 * 82599 SFP+ fiber as we can WoL.
-                 */
-                if (hw->mac.ops.enable_tx_laser &&
-                    (hw->phy.multispeed_fiber ||
-                    (hw->mac.ops.get_media_type(hw) == ixgbe_media_type_fiber &&
-                     hw->mac.type == ixgbe_mac_82599EB)))
+                /* enable the optics for 82599 SFP+ fiber as we can WoL */
+                if (hw->mac.ops.enable_tx_laser)
                         hw->mac.ops.enable_tx_laser(hw);
 
                 /* turn on all-multi mode if wake on multicast is enabled */
@@ -5442,6 +5468,23 @@ static void ixgbe_watchdog_update_link(struct ixgbe_adapter *adapter)
         adapter->link_speed = link_speed;
 }
 
+static void ixgbe_update_default_up(struct ixgbe_adapter *adapter)
+{
+#ifdef CONFIG_IXGBE_DCB
+        struct net_device *netdev = adapter->netdev;
+        struct dcb_app app = {
+                              .selector = IEEE_8021QAZ_APP_SEL_ETHERTYPE,
+                              .protocol = 0,
+                             };
+        u8 up = 0;
+
+        if (adapter->dcbx_cap & DCB_CAP_DCBX_VER_IEEE)
+                up = dcb_ieee_getapp_mask(netdev, &app);
+
+        adapter->default_up = (up > 1) ? (ffs(up) - 1) : 0;
+#endif
+}
+
 /**
  * ixgbe_watchdog_link_is_up - update netif_carrier status and
  *                             print link up message
@@ -5482,9 +5525,8 @@ static void ixgbe_watchdog_link_is_up(struct ixgbe_adapter *adapter)
                 break;
         }
 
-#ifdef CONFIG_IXGBE_PTP
-        ixgbe_ptp_start_cyclecounter(adapter);
-#endif
+        if (adapter->flags2 & IXGBE_FLAG2_PTP_ENABLED)
+                ixgbe_ptp_start_cyclecounter(adapter);
 
         e_info(drv, "NIC Link is Up %s, Flow Control: %s\n",
                (link_speed == IXGBE_LINK_SPEED_10GB_FULL ?
@@ -5501,6 +5543,9 @@ static void ixgbe_watchdog_link_is_up(struct ixgbe_adapter *adapter)
         netif_carrier_on(netdev);
         ixgbe_check_vf_rate_limit(adapter);
 
+        /* update the default user priority for VFs */
+        ixgbe_update_default_up(adapter);
+
         /* ping all the active vfs to let them know link has changed */
         ixgbe_ping_all_vfs(adapter);
 }
@@ -5526,9 +5571,8 @@ static void ixgbe_watchdog_link_is_down(struct ixgbe_adapter *adapter)
         if (ixgbe_is_sfp(hw) && hw->mac.type == ixgbe_mac_82598EB)
                 adapter->flags2 |= IXGBE_FLAG2_SEARCH_FOR_SFP;
 
-#ifdef CONFIG_IXGBE_PTP
-        ixgbe_ptp_start_cyclecounter(adapter);
-#endif
+        if (adapter->flags2 & IXGBE_FLAG2_PTP_ENABLED)
+                ixgbe_ptp_start_cyclecounter(adapter);
 
         e_info(drv, "NIC Link is Down\n");
         netif_carrier_off(netdev);
@@ -5833,9 +5877,7 @@ static void ixgbe_service_task(struct work_struct *work)
         ixgbe_watchdog_subtask(adapter);
         ixgbe_fdir_reinit_subtask(adapter);
         ixgbe_check_hang_subtask(adapter);
-#ifdef CONFIG_IXGBE_PTP
         ixgbe_ptp_overflow_check(adapter);
-#endif
 
         ixgbe_service_event_complete(adapter);
 }
@@ -5988,10 +6030,8 @@ static __le32 ixgbe_tx_cmd_type(u32 tx_flags)
         if (tx_flags & IXGBE_TX_FLAGS_HW_VLAN)
                 cmd_type |= cpu_to_le32(IXGBE_ADVTXD_DCMD_VLE);
 
-#ifdef CONFIG_IXGBE_PTP
         if (tx_flags & IXGBE_TX_FLAGS_TSTAMP)
                 cmd_type |= cpu_to_le32(IXGBE_ADVTXD_MAC_TSTAMP);
-#endif
 
         /* set segmentation enable bits for TSO/FSO */
 #ifdef IXGBE_FCOE
@@ -6393,12 +6433,10 @@ netdev_tx_t ixgbe_xmit_frame_ring(struct sk_buff *skb,
 
         skb_tx_timestamp(skb);
 
-#ifdef CONFIG_IXGBE_PTP
         if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)) {
                 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
                 tx_flags |= IXGBE_TX_FLAGS_TSTAMP;
         }
-#endif
 
 #ifdef CONFIG_PCI_IOV
         /*
@@ -6485,6 +6523,7 @@ static netdev_tx_t ixgbe_xmit_frame(struct sk_buff *skb,
                 if (skb_pad(skb, 17 - skb->len))
                         return NETDEV_TX_OK;
                 skb->len = 17;
+                skb_set_tail_pointer(skb, 17);
         }
 
         tx_ring = adapter->tx_ring[skb->queue_mapping];
@@ -6547,10 +6586,8 @@ static int ixgbe_ioctl(struct net_device *netdev, struct ifreq *req, int cmd)
         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 
         switch (cmd) {
-#ifdef CONFIG_IXGBE_PTP
         case SIOCSHWTSTAMP:
                 return ixgbe_ptp_hwtstamp_ioctl(adapter, req, cmd);
-#endif
         default:
                 return mdio_mii_ioctl(&adapter->hw.phy.mdio, if_mii(req), cmd);
         }
@@ -6916,7 +6953,7 @@ static int ixgbe_ndo_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
                 return -EINVAL;
         }
 
-        if (is_unicast_ether_addr(addr)) {
+        if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr)) {
                 u32 rar_uc_entries = IXGBE_MAX_PF_MACVLANS;
 
                 if (netdev_uc_count(dev) < rar_uc_entries)
@@ -6974,6 +7011,59 @@ static int ixgbe_ndo_fdb_dump(struct sk_buff *skb,
         return idx;
 }
 
+static int ixgbe_ndo_bridge_setlink(struct net_device *dev,
+                                    struct nlmsghdr *nlh)
+{
+        struct ixgbe_adapter *adapter = netdev_priv(dev);
+        struct nlattr *attr, *br_spec;
+        int rem;
+
+        if (!(adapter->flags & IXGBE_FLAG_SRIOV_ENABLED))
+                return -EOPNOTSUPP;
+
+        br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
+
+        nla_for_each_nested(attr, br_spec, rem) {
+                __u16 mode;
+                u32 reg = 0;
+
+                if (nla_type(attr) != IFLA_BRIDGE_MODE)
+                        continue;
+
+                mode = nla_get_u16(attr);
+                if (mode == BRIDGE_MODE_VEPA)
+                        reg = 0;
+                else if (mode == BRIDGE_MODE_VEB)
+                        reg = IXGBE_PFDTXGSWC_VT_LBEN;
+                else
+                        return -EINVAL;
+
+                IXGBE_WRITE_REG(&adapter->hw, IXGBE_PFDTXGSWC, reg);
+
+                e_info(drv, "enabling bridge mode: %s\n",
+                        mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB");
+        }
+
+        return 0;
+}
+
+static int ixgbe_ndo_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
+                                    struct net_device *dev)
+{
+        struct ixgbe_adapter *adapter = netdev_priv(dev);
+        u16 mode;
+
+        if (!(adapter->flags & IXGBE_FLAG_SRIOV_ENABLED))
+                return 0;
+
+        if (IXGBE_READ_REG(&adapter->hw, IXGBE_PFDTXGSWC) & 1)
+                mode = BRIDGE_MODE_VEB;
+        else
+                mode = BRIDGE_MODE_VEPA;
+
+        return ndo_dflt_bridge_getlink(skb, pid, seq, dev, mode);
+}
+
 static const struct net_device_ops ixgbe_netdev_ops = {
         .ndo_open               = ixgbe_open,
         .ndo_stop               = ixgbe_close,
@@ -7013,6 +7103,8 @@ static const struct net_device_ops ixgbe_netdev_ops = {
         .ndo_fdb_add            = ixgbe_ndo_fdb_add,
         .ndo_fdb_del            = ixgbe_ndo_fdb_del,
         .ndo_fdb_dump           = ixgbe_ndo_fdb_dump,
+        .ndo_bridge_setlink     = ixgbe_ndo_bridge_setlink,
+        .ndo_bridge_getlink     = ixgbe_ndo_bridge_getlink,
 };
 
 /**
@@ -7042,6 +7134,7 @@ int ixgbe_wol_supported(struct ixgbe_adapter *adapter, u16 device_id,
                                 break;
                 case IXGBE_SUBDEV_ID_82599_SFP:
                 case IXGBE_SUBDEV_ID_82599_RNDC:
+                case IXGBE_SUBDEV_ID_82599_ECNA_DP:
                         is_wol_supported = 1;
                         break;
                 }
@@ -7364,10 +7457,6 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
 
         device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
 
-#ifdef CONFIG_IXGBE_PTP
-        ixgbe_ptp_init(adapter);
-#endif /* CONFIG_IXGBE_PTP*/
-
         /* save off EEPROM version number */
         hw->eeprom.ops.read(hw, 0x2e, &adapter->eeprom_verh);
         hw->eeprom.ops.read(hw, 0x2d, &adapter->eeprom_verl);
@@ -7420,11 +7509,8 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
         if (err)
                 goto err_register;
 
-        /* power down the optics for multispeed fiber and 82599 SFP+ fiber */
-        if (hw->mac.ops.disable_tx_laser &&
-            ((hw->phy.multispeed_fiber) ||
-             ((hw->mac.ops.get_media_type(hw) == ixgbe_media_type_fiber) &&
-              (hw->mac.type == ixgbe_mac_82599EB))))
+        /* power down the optics for 82599 SFP+ fiber */
+        if (hw->mac.ops.disable_tx_laser)
                 hw->mac.ops.disable_tx_laser(hw);
 
         /* carrier off reporting is important to ethtool even BEFORE open */
@@ -7505,9 +7591,6 @@ static void __devexit ixgbe_remove(struct pci_dev *pdev)
         set_bit(__IXGBE_DOWN, &adapter->state);
         cancel_work_sync(&adapter->service_task);
 
-#ifdef CONFIG_IXGBE_PTP
-        ixgbe_ptp_stop(adapter);
-#endif
 
 #ifdef CONFIG_IXGBE_DCA
         if (adapter->flags & IXGBE_FLAG_DCA_ENABLED) {
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_mbx.h b/drivers/net/ethernet/intel/ixgbe/ixgbe_mbx.h
index 310bdd961075..42dd65e6ac97 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_mbx.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_mbx.h
@@ -62,12 +62,39 @@
 /* bits 23:16 are used for exra info for certain messages */
 #define IXGBE_VT_MSGINFO_MASK     (0xFF << IXGBE_VT_MSGINFO_SHIFT)
 
+/* definitions to support mailbox API version negotiation */
+
+/*
+ * Each element denotes a version of the API; existing numbers may not
+ * change; any additions must go at the end
+ */
+enum ixgbe_pfvf_api_rev {
+        ixgbe_mbox_api_10,      /* API version 1.0, linux/freebsd VF driver */
+        ixgbe_mbox_api_20,      /* API version 2.0, solaris Phase1 VF driver */
+        ixgbe_mbox_api_11,      /* API version 1.1, linux/freebsd VF driver */
+        /* This value should always be last */
+        ixgbe_mbox_api_unknown, /* indicates that API version is not known */
+};
+
+/* mailbox API, legacy requests */
 #define IXGBE_VF_RESET            0x01 /* VF requests reset */
 #define IXGBE_VF_SET_MAC_ADDR     0x02 /* VF requests PF to set MAC addr */
 #define IXGBE_VF_SET_MULTICAST    0x03 /* VF requests PF to set MC addr */
 #define IXGBE_VF_SET_VLAN         0x04 /* VF requests PF to set VLAN */
-#define IXGBE_VF_SET_LPE          0x05 /* VF requests PF to set VMOLR.LPE */
-#define IXGBE_VF_SET_MACVLAN      0x06 /* VF requests PF for unicast filter */
+
+/* mailbox API, version 1.0 VF requests */
+#define IXGBE_VF_SET_LPE        0x05 /* VF requests PF to set VMOLR.LPE */
+#define IXGBE_VF_SET_MACVLAN    0x06 /* VF requests PF for unicast filter */
+#define IXGBE_VF_API_NEGOTIATE  0x08 /* negotiate API version */
+
+/* mailbox API, version 1.1 VF requests */
+#define IXGBE_VF_GET_QUEUES     0x09 /* get queue configuration */
+
+/* GET_QUEUES return data indices within the mailbox */
+#define IXGBE_VF_TX_QUEUES      1       /* number of Tx queues supported */
+#define IXGBE_VF_RX_QUEUES      2       /* number of Rx queues supported */
+#define IXGBE_VF_TRANS_VLAN     3       /* Indication of port vlan */
+#define IXGBE_VF_DEF_QUEUE      4       /* Default queue offset */
 
 /* length of permanent address message returned from PF */
 #define IXGBE_VF_PERMADDR_MSG_LEN 4
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c
index d9291316ee9f..01d99af0b9ba 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c
@@ -387,6 +387,15 @@ void ixgbe_ptp_check_pps_event(struct ixgbe_adapter *adapter, u32 eicr)
         struct ixgbe_hw *hw = &adapter->hw;
         struct ptp_clock_event event;
 
+        event.type = PTP_CLOCK_PPS;
+
+        /* this check is necessary in case the interrupt was enabled via some
+         * alternative means (ex. debug_fs). Better to check here than
+         * everywhere that calls this function.
+         */
+        if (!adapter->ptp_clock)
+                return;
+
         switch (hw->mac.type) {
         case ixgbe_mac_X540:
                 ptp_clock_event(adapter->ptp_clock, &event);
@@ -411,7 +420,7 @@ void ixgbe_ptp_overflow_check(struct ixgbe_adapter *adapter)
         unsigned long elapsed_jiffies = adapter->last_overflow_check - jiffies;
         struct timespec ts;
 
-        if ((adapter->flags2 & IXGBE_FLAG2_OVERFLOW_CHECK_ENABLED) &&
+        if ((adapter->flags2 & IXGBE_FLAG2_PTP_ENABLED) &&
             (elapsed_jiffies >= IXGBE_OVERFLOW_PERIOD)) {
                 ixgbe_ptp_gettime(&adapter->ptp_caps, &ts);
                 adapter->last_overflow_check = jiffies;
@@ -554,12 +563,14 @@ void ixgbe_ptp_rx_hwtstamp(struct ixgbe_q_vector *q_vector,
         adapter = q_vector->adapter;
         hw = &adapter->hw;
 
+        if (likely(!ixgbe_ptp_match(skb, adapter->rx_hwtstamp_filter)))
+                return;
+
         tsyncrxctl = IXGBE_READ_REG(hw, IXGBE_TSYNCRXCTL);
 
         /* Check if we have a valid timestamp and make sure the skb should
          * have been timestamped */
-        if (likely(!(tsyncrxctl & IXGBE_TSYNCRXCTL_VALID) ||
-                   !ixgbe_ptp_match(skb, adapter->rx_hwtstamp_filter)))
+        if (!(tsyncrxctl & IXGBE_TSYNCRXCTL_VALID))
                 return;
 
         /*
@@ -759,58 +770,20 @@ int ixgbe_ptp_hwtstamp_ioctl(struct ixgbe_adapter *adapter,
  * ixgbe_ptp_start_cyclecounter - create the cycle counter from hw
  * @adapter: pointer to the adapter structure
  *
- * this function initializes the timecounter and cyclecounter
- * structures for use in generated a ns counter from the arbitrary
- * fixed point cycles registers in the hardware.
- *
- * A change in link speed impacts the frequency of the DMA clock on
- * the device, which is used to generate the cycle counter
- * registers. Therefor this function is called whenever the link speed
- * changes.
- *
- * This function also turns on the SDP pin for clock out feature (X540
- * only), because this is where the shift is first calculated.
+ * This function should be called to set the proper values for the TIMINCA
+ * register and tell the cyclecounter structure what the tick rate of SYSTIME
+ * is. It does not directly modify SYSTIME registers or the timecounter
+ * structure. It should be called whenever a new TIMINCA value is necessary,
+ * such as during initialization or when the link speed changes.
  */
 void ixgbe_ptp_start_cyclecounter(struct ixgbe_adapter *adapter)
 {
         struct ixgbe_hw *hw = &adapter->hw;
         u32 incval = 0;
-        u32 timinca = 0;
         u32 shift = 0;
-        u32 cycle_speed;
         unsigned long flags;
 
         /**
-         * Determine what speed we need to set the cyclecounter
-         * for. It should be different for 100Mb, 1Gb, and 10Gb. Treat
-         * unknown speeds as 10Gb. (Hence why we can't just copy the
-         * link_speed.
-         */
-        switch (adapter->link_speed) {
-        case IXGBE_LINK_SPEED_100_FULL:
-        case IXGBE_LINK_SPEED_1GB_FULL:
-        case IXGBE_LINK_SPEED_10GB_FULL:
-                cycle_speed = adapter->link_speed;
-                break;
-        default:
-                /* cycle speed should be 10Gb when there is no link */
-                cycle_speed = IXGBE_LINK_SPEED_10GB_FULL;
-                break;
-        }
-
-        /*
-         * grab the current TIMINCA value from the register so that it can be
-         * double checked. If the register value has been cleared, it must be
-         * reset to the correct value for generating a cyclecounter. If
-         * TIMINCA is zero, the SYSTIME registers do not increment at all.
-         */
-        timinca = IXGBE_READ_REG(hw, IXGBE_TIMINCA);
-
-        /* Bail if the cycle speed didn't change and TIMINCA is non-zero */
-        if (adapter->cycle_speed == cycle_speed && timinca)
-                return;
-
-        /**
          * Scale the NIC cycle counter by a large factor so that
          * relatively small corrections to the frequency can be added
          * or subtracted. The drawbacks of a large factor include
@@ -819,8 +792,12 @@ void ixgbe_ptp_start_cyclecounter(struct ixgbe_adapter *adapter)
          * to nanoseconds using only a multiplier and a right-shift,
          * and (c) the value must fit within the timinca register space
          * => math based on internal DMA clock rate and available bits
+         *
+         * Note that when there is no link, internal DMA clock is same as when
+         * link speed is 10Gb. Set the registers correctly even when link is
+         * down to preserve the clock setting
          */
-        switch (cycle_speed) {
+        switch (adapter->link_speed) {
         case IXGBE_LINK_SPEED_100_FULL:
                 incval = IXGBE_INCVAL_100;
                 shift = IXGBE_INCVAL_SHIFT_100;
@@ -830,6 +807,7 @@ void ixgbe_ptp_start_cyclecounter(struct ixgbe_adapter *adapter)
                 shift = IXGBE_INCVAL_SHIFT_1GB;
                 break;
         case IXGBE_LINK_SPEED_10GB_FULL:
+        default:
                 incval = IXGBE_INCVAL_10GB;
                 shift = IXGBE_INCVAL_SHIFT_10GB;
                 break;
@@ -857,18 +835,11 @@ void ixgbe_ptp_start_cyclecounter(struct ixgbe_adapter *adapter)
                 return;
         }
 
-        /* reset the system time registers */
-        IXGBE_WRITE_REG(hw, IXGBE_SYSTIML, 0x00000000);
-        IXGBE_WRITE_REG(hw, IXGBE_SYSTIMH, 0x00000000);
-        IXGBE_WRITE_FLUSH(hw);
-
-        /* store the new cycle speed */
-        adapter->cycle_speed = cycle_speed;
-
+        /* update the base incval used to calculate frequency adjustment */
         ACCESS_ONCE(adapter->base_incval) = incval;
         smp_mb();
 
-        /* grab the ptp lock */
+        /* need lock to prevent incorrect read while modifying cyclecounter */
         spin_lock_irqsave(&adapter->tmreg_lock, flags);
 
         memset(&adapter->cc, 0, sizeof(adapter->cc));
@@ -877,6 +848,31 @@ void ixgbe_ptp_start_cyclecounter(struct ixgbe_adapter *adapter)
         adapter->cc.shift = shift;
         adapter->cc.mult = 1;
 
+        spin_unlock_irqrestore(&adapter->tmreg_lock, flags);
+}
+
+/**
+ * ixgbe_ptp_reset
+ * @adapter: the ixgbe private board structure
+ *
+ * When the MAC resets, all timesync features are reset. This function should be
+ * called to re-enable the PTP clock structure. It will re-init the timecounter
+ * structure based on the kernel time as well as setup the cycle counter data.
+ */
+void ixgbe_ptp_reset(struct ixgbe_adapter *adapter)
+{
+        struct ixgbe_hw *hw = &adapter->hw;
+        unsigned long flags;
+
+        /* set SYSTIME registers to 0 just in case */
+        IXGBE_WRITE_REG(hw, IXGBE_SYSTIML, 0x00000000);
+        IXGBE_WRITE_REG(hw, IXGBE_SYSTIMH, 0x00000000);
+        IXGBE_WRITE_FLUSH(hw);
+
+        ixgbe_ptp_start_cyclecounter(adapter);
+
+        spin_lock_irqsave(&adapter->tmreg_lock, flags);
+
         /* reset the ns time counter */
         timecounter_init(&adapter->tc, &adapter->cc,
                          ktime_to_ns(ktime_get_real()));
@@ -904,7 +900,7 @@ void ixgbe_ptp_init(struct ixgbe_adapter *adapter)
 
         switch (adapter->hw.mac.type) {
         case ixgbe_mac_X540:
-                snprintf(adapter->ptp_caps.name, 16, "%pm", netdev->dev_addr);
+                snprintf(adapter->ptp_caps.name, 16, "%s", netdev->name);
                 adapter->ptp_caps.owner = THIS_MODULE;
                 adapter->ptp_caps.max_adj = 250000000;
                 adapter->ptp_caps.n_alarm = 0;
@@ -918,7 +914,7 @@ void ixgbe_ptp_init(struct ixgbe_adapter *adapter)
                 adapter->ptp_caps.enable = ixgbe_ptp_enable;
                 break;
         case ixgbe_mac_82599EB:
-                snprintf(adapter->ptp_caps.name, 16, "%pm", netdev->dev_addr);
+                snprintf(adapter->ptp_caps.name, 16, "%s", netdev->name);
                 adapter->ptp_caps.owner = THIS_MODULE;
                 adapter->ptp_caps.max_adj = 250000000;
                 adapter->ptp_caps.n_alarm = 0;
@@ -942,11 +938,6 @@ void ixgbe_ptp_init(struct ixgbe_adapter *adapter)
 
         spin_lock_init(&adapter->tmreg_lock);
 
-        ixgbe_ptp_start_cyclecounter(adapter);
-
-        /* (Re)start the overflow check */
-        adapter->flags2 |= IXGBE_FLAG2_OVERFLOW_CHECK_ENABLED;
-
         adapter->ptp_clock = ptp_clock_register(&adapter->ptp_caps,
                                                 &adapter->pdev->dev);
         if (IS_ERR(adapter->ptp_clock)) {
@@ -955,6 +946,11 @@ void ixgbe_ptp_init(struct ixgbe_adapter *adapter)
         } else
                 e_dev_info("registered PHC device on %s\n", netdev->name);
 
+        ixgbe_ptp_reset(adapter);
+
+        /* set the flag that PTP has been enabled */
+        adapter->flags2 |= IXGBE_FLAG2_PTP_ENABLED;
+
         return;
 }
 
@@ -967,7 +963,7 @@ void ixgbe_ptp_init(struct ixgbe_adapter *adapter)
 void ixgbe_ptp_stop(struct ixgbe_adapter *adapter)
 {
         /* stop the overflow check task */
-        adapter->flags2 &= ~(IXGBE_FLAG2_OVERFLOW_CHECK_ENABLED |
+        adapter->flags2 &= ~(IXGBE_FLAG2_PTP_ENABLED |
                              IXGBE_FLAG2_PTP_PPS_ENABLED);
 
         ixgbe_ptp_setup_sdp(adapter);
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c
index dce48bf64d96..4993642d1ce1 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c
@@ -117,6 +117,9 @@ void ixgbe_enable_sriov(struct ixgbe_adapter *adapter,
                 }
         }
 
+        /* Initialize default switching mode VEB */
+        IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, IXGBE_PFDTXGSWC_VT_LBEN);
+
         /* If call to enable VFs succeeded then allocate memory
          * for per VF control structures.
          */
@@ -150,16 +153,6 @@ void ixgbe_enable_sriov(struct ixgbe_adapter *adapter,
                 adapter->flags2 &= ~(IXGBE_FLAG2_RSC_CAPABLE |
                                      IXGBE_FLAG2_RSC_ENABLED);
 
-#ifdef IXGBE_FCOE
-                /*
-                 * When SR-IOV is enabled 82599 cannot support jumbo frames
-                 * so we must disable FCoE because we cannot support FCoE MTU.
-                 */
-                if (adapter->hw.mac.type == ixgbe_mac_82599EB)
-                        adapter->flags &= ~(IXGBE_FLAG_FCOE_ENABLED |
-                                            IXGBE_FLAG_FCOE_CAPABLE);
-#endif
-
                 /* enable spoof checking for all VFs */
                 for (i = 0; i < adapter->num_vfs; i++)
                         adapter->vfinfo[i].spoofchk_enabled = true;
@@ -265,8 +258,11 @@ void ixgbe_disable_sriov(struct ixgbe_adapter *adapter)
 }
 
 static int ixgbe_set_vf_multicasts(struct ixgbe_adapter *adapter,
-                                   int entries, u16 *hash_list, u32 vf)
+                                   u32 *msgbuf, u32 vf)
 {
+        int entries = (msgbuf[0] & IXGBE_VT_MSGINFO_MASK)
+                       >> IXGBE_VT_MSGINFO_SHIFT;
+        u16 *hash_list = (u16 *)&msgbuf[1];
         struct vf_data_storage *vfinfo = &adapter->vfinfo[vf];
         struct ixgbe_hw *hw = &adapter->hw;
         int i;
@@ -353,31 +349,89 @@ static int ixgbe_set_vf_vlan(struct ixgbe_adapter *adapter, int add, int vid,
         return adapter->hw.mac.ops.set_vfta(&adapter->hw, vid, vf, (bool)add);
 }
 
-static void ixgbe_set_vf_lpe(struct ixgbe_adapter *adapter, u32 *msgbuf)
+static s32 ixgbe_set_vf_lpe(struct ixgbe_adapter *adapter, u32 *msgbuf, u32 vf)
 {
         struct ixgbe_hw *hw = &adapter->hw;
-        int new_mtu = msgbuf[1];
+        int max_frame = msgbuf[1];
         u32 max_frs;
-        int max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN;
 
-        /* Only X540 supports jumbo frames in IOV mode */
-        if (adapter->hw.mac.type != ixgbe_mac_X540)
-                return;
+        /*
+         * For 82599EB we have to keep all PFs and VFs operating with
+         * the same max_frame value in order to avoid sending an oversize
+         * frame to a VF.  In order to guarantee this is handled correctly
+         * for all cases we have several special exceptions to take into
+         * account before we can enable the VF for receive
+         */
+        if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
+                struct net_device *dev = adapter->netdev;
+                int pf_max_frame = dev->mtu + ETH_HLEN;
+                u32 reg_offset, vf_shift, vfre;
+                s32 err = 0;
+
+#ifdef CONFIG_FCOE
+                if (dev->features & NETIF_F_FCOE_MTU)
+                        pf_max_frame = max_t(int, pf_max_frame,
+                                             IXGBE_FCOE_JUMBO_FRAME_SIZE);
+
+#endif /* CONFIG_FCOE */
+                switch (adapter->vfinfo[vf].vf_api) {
+                case ixgbe_mbox_api_11:
+                        /*
+                         * Version 1.1 supports jumbo frames on VFs if PF has
+                         * jumbo frames enabled which means legacy VFs are
+                         * disabled
+                         */
+                        if (pf_max_frame > ETH_FRAME_LEN)
+                                break;
+                default:
+                        /*
+                         * If the PF or VF are running w/ jumbo frames enabled
+                         * we need to shut down the VF Rx path as we cannot
+                         * support jumbo frames on legacy VFs
+                         */
+                        if ((pf_max_frame > ETH_FRAME_LEN) ||
+                            (max_frame > (ETH_FRAME_LEN + ETH_FCS_LEN)))
+                                err = -EINVAL;
+                        break;
+                }
+
+                /* determine VF receive enable location */
+                vf_shift = vf % 32;
+                reg_offset = vf / 32;
+
+                /* enable or disable receive depending on error */
+                vfre = IXGBE_READ_REG(hw, IXGBE_VFRE(reg_offset));
+                if (err)
+                        vfre &= ~(1 << vf_shift);
+                else
+                        vfre |= 1 << vf_shift;
+                IXGBE_WRITE_REG(hw, IXGBE_VFRE(reg_offset), vfre);
+
+                if (err) {
+                        e_err(drv, "VF max_frame %d out of range\n", max_frame);
+                        return err;
+                }
+        }
 
         /* MTU < 68 is an error and causes problems on some kernels */
-        if ((new_mtu < 68) || (max_frame > IXGBE_MAX_JUMBO_FRAME_SIZE)) {
-                e_err(drv, "VF mtu %d out of range\n", new_mtu);
-                return;
+        if (max_frame > IXGBE_MAX_JUMBO_FRAME_SIZE) {
+                e_err(drv, "VF max_frame %d out of range\n", max_frame);
+                return -EINVAL;
         }
 
-        max_frs = (IXGBE_READ_REG(hw, IXGBE_MAXFRS) &
-                   IXGBE_MHADD_MFS_MASK) >> IXGBE_MHADD_MFS_SHIFT;
-        if (max_frs < new_mtu) {
-                max_frs = new_mtu << IXGBE_MHADD_MFS_SHIFT;
+        /* pull current max frame size from hardware */
+        max_frs = IXGBE_READ_REG(hw, IXGBE_MAXFRS);
+        max_frs &= IXGBE_MHADD_MFS_MASK;
+        max_frs >>= IXGBE_MHADD_MFS_SHIFT;
+
+        if (max_frs < max_frame) {
+                max_frs = max_frame << IXGBE_MHADD_MFS_SHIFT;
                 IXGBE_WRITE_REG(hw, IXGBE_MAXFRS, max_frs);
         }
 
-        e_info(hw, "VF requests change max MTU to %d\n", new_mtu);
+        e_info(hw, "VF requests change max MTU to %d\n", max_frame);
+
+        return 0;
 }
 
 static void ixgbe_set_vmolr(struct ixgbe_hw *hw, u32 vf, bool aupe)
@@ -392,35 +446,47 @@ static void ixgbe_set_vmolr(struct ixgbe_hw *hw, u32 vf, bool aupe)
         IXGBE_WRITE_REG(hw, IXGBE_VMOLR(vf), vmolr);
 }
 
-static void ixgbe_set_vmvir(struct ixgbe_adapter *adapter, u32 vid, u32 vf)
+static void ixgbe_set_vmvir(struct ixgbe_adapter *adapter,
+                            u16 vid, u16 qos, u32 vf)
 {
         struct ixgbe_hw *hw = &adapter->hw;
+        u32 vmvir = vid | (qos << VLAN_PRIO_SHIFT) | IXGBE_VMVIR_VLANA_DEFAULT;
 
-        if (vid)
-                IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf),
-                                (vid | IXGBE_VMVIR_VLANA_DEFAULT));
-        else
-                IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf), 0);
+        IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf), vmvir);
 }
 
+static void ixgbe_clear_vmvir(struct ixgbe_adapter *adapter, u32 vf)
+{
+        struct ixgbe_hw *hw = &adapter->hw;
+
+        IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf), 0);
+}
 static inline void ixgbe_vf_reset_event(struct ixgbe_adapter *adapter, u32 vf)
 {
         struct ixgbe_hw *hw = &adapter->hw;
+        struct vf_data_storage *vfinfo = &adapter->vfinfo[vf];
         int rar_entry = hw->mac.num_rar_entries - (vf + 1);
+        u8 num_tcs = netdev_get_num_tc(adapter->netdev);
+
+        /* add PF assigned VLAN or VLAN 0 */
+        ixgbe_set_vf_vlan(adapter, true, vfinfo->pf_vlan, vf);
 
         /* reset offloads to defaults */
-        if (adapter->vfinfo[vf].pf_vlan) {
-                ixgbe_set_vf_vlan(adapter, true,
-                                  adapter->vfinfo[vf].pf_vlan, vf);
-                ixgbe_set_vmvir(adapter,
-                                (adapter->vfinfo[vf].pf_vlan |
-                                 (adapter->vfinfo[vf].pf_qos <<
-                                  VLAN_PRIO_SHIFT)), vf);
-                ixgbe_set_vmolr(hw, vf, false);
+        ixgbe_set_vmolr(hw, vf, !vfinfo->pf_vlan);
+
+        /* set outgoing tags for VFs */
+        if (!vfinfo->pf_vlan && !vfinfo->pf_qos && !num_tcs) {
+                ixgbe_clear_vmvir(adapter, vf);
         } else {
-                ixgbe_set_vf_vlan(adapter, true, 0, vf);
-                ixgbe_set_vmvir(adapter, 0, vf);
-                ixgbe_set_vmolr(hw, vf, true);
+                if (vfinfo->pf_qos || !num_tcs)
+                        ixgbe_set_vmvir(adapter, vfinfo->pf_vlan,
+                                        vfinfo->pf_qos, vf);
+                else
+                        ixgbe_set_vmvir(adapter, vfinfo->pf_vlan,
+                                        adapter->default_up, vf);
+
+                if (vfinfo->spoofchk_enabled)
+                        hw->mac.ops.set_vlan_anti_spoofing(hw, true, vf);
         }
 
         /* reset multicast table array for vf */
@@ -430,6 +496,9 @@ static inline void ixgbe_vf_reset_event(struct ixgbe_adapter *adapter, u32 vf)
         ixgbe_set_rx_mode(adapter->netdev);
 
         hw->mac.ops.clear_rar(hw, rar_entry);
+
+        /* reset VF api back to unknown */
+        adapter->vfinfo[vf].vf_api = ixgbe_mbox_api_10;
 }
 
 static int ixgbe_set_vf_mac(struct ixgbe_adapter *adapter,
@@ -521,30 +590,221 @@ int ixgbe_vf_configuration(struct pci_dev *pdev, unsigned int event_mask)
         return 0;
 }
 
-static inline void ixgbe_vf_reset_msg(struct ixgbe_adapter *adapter, u32 vf)
+static int ixgbe_vf_reset_msg(struct ixgbe_adapter *adapter, u32 vf)
 {
         struct ixgbe_hw *hw = &adapter->hw;
-        u32 reg;
+        unsigned char *vf_mac = adapter->vfinfo[vf].vf_mac_addresses;
+        u32 reg, msgbuf[4];
         u32 reg_offset, vf_shift;
+        u8 *addr = (u8 *)(&msgbuf[1]);
+
+        e_info(probe, "VF Reset msg received from vf %d\n", vf);
+
+        /* reset the filters for the device */
+        ixgbe_vf_reset_event(adapter, vf);
+
+        /* set vf mac address */
+        ixgbe_set_vf_mac(adapter, vf, vf_mac);
 
         vf_shift = vf % 32;
         reg_offset = vf / 32;
 
-        /* enable transmit and receive for vf */
+        /* enable transmit for vf */
         reg = IXGBE_READ_REG(hw, IXGBE_VFTE(reg_offset));
-        reg |= (reg | (1 << vf_shift));
+        reg |= 1 << vf_shift;
         IXGBE_WRITE_REG(hw, IXGBE_VFTE(reg_offset), reg);
 
+        /* enable receive for vf */
         reg = IXGBE_READ_REG(hw, IXGBE_VFRE(reg_offset));
-        reg |= (reg | (1 << vf_shift));
+        reg |= 1 << vf_shift;
+        /*
+         * The 82599 cannot support a mix of jumbo and non-jumbo PF/VFs.
+         * For more info take a look at ixgbe_set_vf_lpe
+         */
+        if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
+                struct net_device *dev = adapter->netdev;
+                int pf_max_frame = dev->mtu + ETH_HLEN;
+
+#ifdef CONFIG_FCOE
+                if (dev->features & NETIF_F_FCOE_MTU)
+                        pf_max_frame = max_t(int, pf_max_frame,
+                                             IXGBE_FCOE_JUMBO_FRAME_SIZE);
+
+#endif /* CONFIG_FCOE */
+                if (pf_max_frame > ETH_FRAME_LEN)
+                        reg &= ~(1 << vf_shift);
+        }
         IXGBE_WRITE_REG(hw, IXGBE_VFRE(reg_offset), reg);
 
+        /* enable VF mailbox for further messages */
+        adapter->vfinfo[vf].clear_to_send = true;
+
         /* Enable counting of spoofed packets in the SSVPC register */
         reg = IXGBE_READ_REG(hw, IXGBE_VMECM(reg_offset));
         reg |= (1 << vf_shift);
         IXGBE_WRITE_REG(hw, IXGBE_VMECM(reg_offset), reg);
 
-        ixgbe_vf_reset_event(adapter, vf);
+        /* reply to reset with ack and vf mac address */
+        msgbuf[0] = IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_ACK;
+        memcpy(addr, vf_mac, ETH_ALEN);
+
+        /*
+         * Piggyback the multicast filter type so VF can compute the
+         * correct vectors
+         */
+        msgbuf[3] = hw->mac.mc_filter_type;
+        ixgbe_write_mbx(hw, msgbuf, IXGBE_VF_PERMADDR_MSG_LEN, vf);
+
+        return 0;
+}
+
+static int ixgbe_set_vf_mac_addr(struct ixgbe_adapter *adapter,
+                                 u32 *msgbuf, u32 vf)
+{
+        u8 *new_mac = ((u8 *)(&msgbuf[1]));
+
+        if (!is_valid_ether_addr(new_mac)) {
+                e_warn(drv, "VF %d attempted to set invalid mac\n", vf);
+                return -1;
+        }
+
+        if (adapter->vfinfo[vf].pf_set_mac &&
+            memcmp(adapter->vfinfo[vf].vf_mac_addresses, new_mac,
+                   ETH_ALEN)) {
+                e_warn(drv,
+                       "VF %d attempted to override administratively set MAC address\n"
+                       "Reload the VF driver to resume operations\n",
+                       vf);
+                return -1;
+        }
+
+        return ixgbe_set_vf_mac(adapter, vf, new_mac) < 0;
+}
+
+static int ixgbe_set_vf_vlan_msg(struct ixgbe_adapter *adapter,
+                                 u32 *msgbuf, u32 vf)
+{
+        struct ixgbe_hw *hw = &adapter->hw;
+        int add = (msgbuf[0] & IXGBE_VT_MSGINFO_MASK) >> IXGBE_VT_MSGINFO_SHIFT;
+        int vid = (msgbuf[1] & IXGBE_VLVF_VLANID_MASK);
+        int err;
+        u8 tcs = netdev_get_num_tc(adapter->netdev);
+
+        if (adapter->vfinfo[vf].pf_vlan || tcs) {
+                e_warn(drv,
+                       "VF %d attempted to override administratively set VLAN configuration\n"
+                       "Reload the VF driver to resume operations\n",
+                       vf);
+                return -1;
+        }
+
+        if (add)
+                adapter->vfinfo[vf].vlan_count++;
+        else if (adapter->vfinfo[vf].vlan_count)
+                adapter->vfinfo[vf].vlan_count--;
+
+        err = ixgbe_set_vf_vlan(adapter, add, vid, vf);
+        if (!err && adapter->vfinfo[vf].spoofchk_enabled)
+                hw->mac.ops.set_vlan_anti_spoofing(hw, true, vf);
+
+        return err;
+}
+
+static int ixgbe_set_vf_macvlan_msg(struct ixgbe_adapter *adapter,
+                                    u32 *msgbuf, u32 vf)
+{
+        u8 *new_mac = ((u8 *)(&msgbuf[1]));
+        int index = (msgbuf[0] & IXGBE_VT_MSGINFO_MASK) >>
+                    IXGBE_VT_MSGINFO_SHIFT;
+        int err;
+
+        if (adapter->vfinfo[vf].pf_set_mac && index > 0) {
+                e_warn(drv,
+                       "VF %d requested MACVLAN filter but is administratively denied\n",
+                       vf);
+                return -1;
+        }
+
+        /* An non-zero index indicates the VF is setting a filter */
+        if (index) {
+                if (!is_valid_ether_addr(new_mac)) {
+                        e_warn(drv, "VF %d attempted to set invalid mac\n", vf);
+                        return -1;
+                }
+
+                /*
+                 * If the VF is allowed to set MAC filters then turn off
+                 * anti-spoofing to avoid false positives.
+                 */
+                if (adapter->vfinfo[vf].spoofchk_enabled)
+                        ixgbe_ndo_set_vf_spoofchk(adapter->netdev, vf, false);
+        }
+
+        err = ixgbe_set_vf_macvlan(adapter, vf, index, new_mac);
+        if (err == -ENOSPC)
+                e_warn(drv,
+                       "VF %d has requested a MACVLAN filter but there is no space for it\n",
+                       vf);
+
+        return err < 0;
+}
+
+static int ixgbe_negotiate_vf_api(struct ixgbe_adapter *adapter,
+                                  u32 *msgbuf, u32 vf)
+{
+        int api = msgbuf[1];
+
+        switch (api) {
+        case ixgbe_mbox_api_10:
+        case ixgbe_mbox_api_11:
+                adapter->vfinfo[vf].vf_api = api;
+                return 0;
+        default:
+                break;
+        }
+
+        e_info(drv, "VF %d requested invalid api version %u\n", vf, api);
+
+        return -1;
+}
+
+static int ixgbe_get_vf_queues(struct ixgbe_adapter *adapter,
+                               u32 *msgbuf, u32 vf)
+{
+        struct net_device *dev = adapter->netdev;
+        struct ixgbe_ring_feature *vmdq = &adapter->ring_feature[RING_F_VMDQ];
+        unsigned int default_tc = 0;
+        u8 num_tcs = netdev_get_num_tc(dev);
+
+        /* verify the PF is supporting the correct APIs */
+        switch (adapter->vfinfo[vf].vf_api) {
+        case ixgbe_mbox_api_20:
+        case ixgbe_mbox_api_11:
+                break;
+        default:
+                return -1;
+        }
+
+        /* only allow 1 Tx queue for bandwidth limiting */
+        msgbuf[IXGBE_VF_TX_QUEUES] = __ALIGN_MASK(1, ~vmdq->mask);
+        msgbuf[IXGBE_VF_RX_QUEUES] = __ALIGN_MASK(1, ~vmdq->mask);
+
+        /* if TCs > 1 determine which TC belongs to default user priority */
+        if (num_tcs > 1)
+                default_tc = netdev_get_prio_tc_map(dev, adapter->default_up);
+
+        /* notify VF of need for VLAN tag stripping, and correct queue */
+        if (num_tcs)
+                msgbuf[IXGBE_VF_TRANS_VLAN] = num_tcs;
+        else if (adapter->vfinfo[vf].pf_vlan || adapter->vfinfo[vf].pf_qos)
+                msgbuf[IXGBE_VF_TRANS_VLAN] = 1;
+        else
+                msgbuf[IXGBE_VF_TRANS_VLAN] = 0;
+
+        /* notify VF of default queue */
+        msgbuf[IXGBE_VF_DEF_QUEUE] = default_tc;
+
+        return 0;
 }
 
 static int ixgbe_rcv_msg_from_vf(struct ixgbe_adapter *adapter, u32 vf)
@@ -553,10 +813,6 @@ static int ixgbe_rcv_msg_from_vf(struct ixgbe_adapter *adapter, u32 vf)
         u32 msgbuf[IXGBE_VFMAILBOX_SIZE];
         struct ixgbe_hw *hw = &adapter->hw;
         s32 retval;
-        int entries;
-        u16 *hash_list;
-        int add, vid, index;
-        u8 *new_mac;
 
         retval = ixgbe_read_mbx(hw, msgbuf, mbx_size, vf);
 
@@ -572,39 +828,13 @@ static int ixgbe_rcv_msg_from_vf(struct ixgbe_adapter *adapter, u32 vf)
         /* flush the ack before we write any messages back */
         IXGBE_WRITE_FLUSH(hw);
 
+        if (msgbuf[0] == IXGBE_VF_RESET)
+                return ixgbe_vf_reset_msg(adapter, vf);
+
         /*
          * until the vf completes a virtual function reset it should not be
          * allowed to start any configuration.
          */
-
-        if (msgbuf[0] == IXGBE_VF_RESET) {
-                unsigned char *vf_mac = adapter->vfinfo[vf].vf_mac_addresses;
-                new_mac = (u8 *)(&msgbuf[1]);
-                e_info(probe, "VF Reset msg received from vf %d\n", vf);
-                adapter->vfinfo[vf].clear_to_send = false;
-                ixgbe_vf_reset_msg(adapter, vf);
-                adapter->vfinfo[vf].clear_to_send = true;
-
-                if (is_valid_ether_addr(new_mac) &&
-                    !adapter->vfinfo[vf].pf_set_mac)
-                        ixgbe_set_vf_mac(adapter, vf, vf_mac);
-                else
-                        ixgbe_set_vf_mac(adapter,
-                                 vf, adapter->vfinfo[vf].vf_mac_addresses);
-
-                /* reply to reset with ack and vf mac address */
-                msgbuf[0] = IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_ACK;
-                memcpy(new_mac, vf_mac, ETH_ALEN);
-                /*
-                 * Piggyback the multicast filter type so VF can compute the
-                 * correct vectors
-                 */
-                msgbuf[3] = hw->mac.mc_filter_type;
-                ixgbe_write_mbx(hw, msgbuf, IXGBE_VF_PERMADDR_MSG_LEN, vf);
-
-                return retval;
-        }
-
         if (!adapter->vfinfo[vf].clear_to_send) {
                 msgbuf[0] |= IXGBE_VT_MSGTYPE_NACK;
                 ixgbe_write_mbx(hw, msgbuf, 1, vf);
@@ -613,70 +843,25 @@ static int ixgbe_rcv_msg_from_vf(struct ixgbe_adapter *adapter, u32 vf)
 
         switch ((msgbuf[0] & 0xFFFF)) {
         case IXGBE_VF_SET_MAC_ADDR:
-                new_mac = ((u8 *)(&msgbuf[1]));
-                if (is_valid_ether_addr(new_mac) &&
-                    !adapter->vfinfo[vf].pf_set_mac) {
-                        ixgbe_set_vf_mac(adapter, vf, new_mac);
-                } else if (memcmp(adapter->vfinfo[vf].vf_mac_addresses,
-                                  new_mac, ETH_ALEN)) {
-                        e_warn(drv, "VF %d attempted to override "
-                               "administratively set MAC address\nReload "
-                               "the VF driver to resume operations\n", vf);
-                        retval = -1;
-                }
+                retval = ixgbe_set_vf_mac_addr(adapter, msgbuf, vf);
                 break;
         case IXGBE_VF_SET_MULTICAST:
-                entries = (msgbuf[0] & IXGBE_VT_MSGINFO_MASK)
-                          >> IXGBE_VT_MSGINFO_SHIFT;
-                hash_list = (u16 *)&msgbuf[1];
-                retval = ixgbe_set_vf_multicasts(adapter, entries,
-                                                 hash_list, vf);
-                break;
-        case IXGBE_VF_SET_LPE:
-                ixgbe_set_vf_lpe(adapter, msgbuf);
+                retval = ixgbe_set_vf_multicasts(adapter, msgbuf, vf);
                 break;
         case IXGBE_VF_SET_VLAN:
-                add = (msgbuf[0] & IXGBE_VT_MSGINFO_MASK)
-                      >> IXGBE_VT_MSGINFO_SHIFT;
-                vid = (msgbuf[1] & IXGBE_VLVF_VLANID_MASK);
-                if (adapter->vfinfo[vf].pf_vlan) {
-                        e_warn(drv, "VF %d attempted to override "
-                               "administratively set VLAN configuration\n"
-                               "Reload the VF driver to resume operations\n",
-                               vf);
-                        retval = -1;
-                } else {
-                        if (add)
-                                adapter->vfinfo[vf].vlan_count++;
-                        else if (adapter->vfinfo[vf].vlan_count)
-                                adapter->vfinfo[vf].vlan_count--;
-                        retval = ixgbe_set_vf_vlan(adapter, add, vid, vf);
-                        if (!retval && adapter->vfinfo[vf].spoofchk_enabled)
-                                hw->mac.ops.set_vlan_anti_spoofing(hw, true, vf);
-                }
+                retval = ixgbe_set_vf_vlan_msg(adapter, msgbuf, vf);
+                break;
+        case IXGBE_VF_SET_LPE:
+                retval = ixgbe_set_vf_lpe(adapter, msgbuf, vf);
                 break;
         case IXGBE_VF_SET_MACVLAN:
-                index = (msgbuf[0] & IXGBE_VT_MSGINFO_MASK) >>
-                        IXGBE_VT_MSGINFO_SHIFT;
-                if (adapter->vfinfo[vf].pf_set_mac && index > 0) {
-                        e_warn(drv, "VF %d requested MACVLAN filter but is "
-                                    "administratively denied\n", vf);
-                        retval = -1;
-                        break;
-                }
-                /*
-                 * If the VF is allowed to set MAC filters then turn off
-                 * anti-spoofing to avoid false positives.  An index
-                 * greater than 0 will indicate the VF is setting a
-                 * macvlan MAC filter.
-                 */
-                if (index > 0 && adapter->vfinfo[vf].spoofchk_enabled)
-                        ixgbe_ndo_set_vf_spoofchk(adapter->netdev, vf, false);
-                retval = ixgbe_set_vf_macvlan(adapter, vf, index,
-                                              (unsigned char *)(&msgbuf[1]));
-                if (retval == -ENOSPC)
-                        e_warn(drv, "VF %d has requested a MACVLAN filter "
-                                    "but there is no space for it\n", vf);
+                retval = ixgbe_set_vf_macvlan_msg(adapter, msgbuf, vf);
+                break;
+        case IXGBE_VF_API_NEGOTIATE:
+                retval = ixgbe_negotiate_vf_api(adapter, msgbuf, vf);
+                break;
+        case IXGBE_VF_GET_QUEUES:
+                retval = ixgbe_get_vf_queues(adapter, msgbuf, vf);
                 break;
         default:
                 e_err(drv, "Unhandled Msg %8.8x\n", msgbuf[0]);
@@ -692,7 +877,7 @@ static int ixgbe_rcv_msg_from_vf(struct ixgbe_adapter *adapter, u32 vf)
 
         msgbuf[0] |= IXGBE_VT_MSGTYPE_CTS;
 
-        ixgbe_write_mbx(hw, msgbuf, 1, vf);
+        ixgbe_write_mbx(hw, msgbuf, mbx_size, vf);
 
         return retval;
 }
@@ -783,7 +968,7 @@ int ixgbe_ndo_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos)
                 err = ixgbe_set_vf_vlan(adapter, true, vlan, vf);
                 if (err)
                         goto out;
-                ixgbe_set_vmvir(adapter, vlan | (qos << VLAN_PRIO_SHIFT), vf);
+                ixgbe_set_vmvir(adapter, vlan, qos, vf);
                 ixgbe_set_vmolr(hw, vf, false);
                 if (adapter->vfinfo[vf].spoofchk_enabled)
                         hw->mac.ops.set_vlan_anti_spoofing(hw, true, vf);
@@ -803,7 +988,7 @@ int ixgbe_ndo_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos)
         } else {
                 err = ixgbe_set_vf_vlan(adapter, false,
                                         adapter->vfinfo[vf].pf_vlan, vf);
-                ixgbe_set_vmvir(adapter, vlan, vf);
+                ixgbe_clear_vmvir(adapter, vf);
                 ixgbe_set_vmolr(hw, vf, true);
                 hw->mac.ops.set_vlan_anti_spoofing(hw, false, vf);
                 if (adapter->vfinfo[vf].vlan_count)
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_type.h b/drivers/net/ethernet/intel/ixgbe/ixgbe_type.h
index 0722f3368092..21915e20399a 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_type.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_type.h
@@ -56,6 +56,7 @@
 #define IXGBE_SUBDEV_ID_82599_SFP        0x11A9
 #define IXGBE_SUBDEV_ID_82599_RNDC       0x1F72
 #define IXGBE_SUBDEV_ID_82599_560FLR     0x17D0
+#define IXGBE_SUBDEV_ID_82599_ECNA_DP    0x0470
 #define IXGBE_DEV_ID_82599_SFP_EM        0x1507
 #define IXGBE_DEV_ID_82599_SFP_SF2       0x154D
 #define IXGBE_DEV_ID_82599EN_SFP         0x1557
diff --git a/drivers/net/ethernet/intel/ixgbevf/defines.h b/drivers/net/ethernet/intel/ixgbevf/defines.h
index da17ccf5c09d..3147795bd135 100644
--- a/drivers/net/ethernet/intel/ixgbevf/defines.h
+++ b/drivers/net/ethernet/intel/ixgbevf/defines.h
@@ -33,8 +33,11 @@
 #define IXGBE_DEV_ID_X540_VF            0x1515
 
 #define IXGBE_VF_IRQ_CLEAR_MASK         7
-#define IXGBE_VF_MAX_TX_QUEUES          1
-#define IXGBE_VF_MAX_RX_QUEUES          1
+#define IXGBE_VF_MAX_TX_QUEUES          8
+#define IXGBE_VF_MAX_RX_QUEUES          8
+
+/* DCB define */
+#define IXGBE_VF_MAX_TRAFFIC_CLASS      8
 
 /* Link speed */
 typedef u32 ixgbe_link_speed;
diff --git a/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h b/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h
index 4a9c9c285685..2323ccd211c0 100644
--- a/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h
+++ b/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h
@@ -89,8 +89,8 @@ struct ixgbevf_ring {
 /* How many Rx Buffers do we bundle into one write to the hardware ? */
 #define IXGBEVF_RX_BUFFER_WRITE 16      /* Must be power of 2 */
 
-#define MAX_RX_QUEUES 1
-#define MAX_TX_QUEUES 1
+#define MAX_RX_QUEUES IXGBE_VF_MAX_RX_QUEUES
+#define MAX_TX_QUEUES IXGBE_VF_MAX_TX_QUEUES
 
 #define IXGBEVF_DEFAULT_TXD   1024
 #define IXGBEVF_DEFAULT_RXD   512
diff --git a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
index de1ad506665d..f3d3947ae962 100644
--- a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
+++ b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
@@ -58,7 +58,7 @@ const char ixgbevf_driver_name[] = "ixgbevf";
 static const char ixgbevf_driver_string[] =
         "Intel(R) 10 Gigabit PCI Express Virtual Function Network Driver";
 
-#define DRV_VERSION "2.6.0-k"
+#define DRV_VERSION "2.7.12-k"
 const char ixgbevf_driver_version[] = DRV_VERSION;
 static char ixgbevf_copyright[] =
         "Copyright (c) 2009 - 2012 Intel Corporation.";
@@ -99,6 +99,7 @@ MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
 
 /* forward decls */
 static void ixgbevf_set_itr(struct ixgbevf_q_vector *q_vector);
+static void ixgbevf_free_all_rx_resources(struct ixgbevf_adapter *adapter);
 
 static inline void ixgbevf_release_rx_desc(struct ixgbe_hw *hw,
                                            struct ixgbevf_ring *rx_ring,
@@ -358,6 +359,12 @@ static void ixgbevf_alloc_rx_buffers(struct ixgbevf_adapter *adapter,
                         bi->dma = dma_map_single(&pdev->dev, skb->data,
                                                  rx_ring->rx_buf_len,
                                                  DMA_FROM_DEVICE);
+                        if (dma_mapping_error(&pdev->dev, bi->dma)) {
+                                dev_kfree_skb(skb);
+                                bi->skb = NULL;
+                                dev_err(&pdev->dev, "RX DMA map failed\n");
+                                break;
+                        }
                 }
                 rx_desc->read.pkt_addr = cpu_to_le64(bi->dma);
 
@@ -471,6 +478,16 @@ static bool ixgbevf_clean_rx_irq(struct ixgbevf_q_vector *q_vector,
                 }
                 skb->protocol = eth_type_trans(skb, rx_ring->netdev);
 
+                /* Workaround hardware that can't do proper VEPA multicast
+                 * source pruning.
+                 */
+                if ((skb->pkt_type & (PACKET_BROADCAST | PACKET_MULTICAST)) &&
+                    !(compare_ether_addr(adapter->netdev->dev_addr,
+                                        eth_hdr(skb)->h_source))) {
+                        dev_kfree_skb_irq(skb);
+                        goto next_desc;
+                }
+
                 ixgbevf_receive_skb(q_vector, skb, staterr, rx_desc);
 
 next_desc:
@@ -1131,12 +1148,12 @@ static int ixgbevf_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
         if (!hw->mac.ops.set_vfta)
                 return -EOPNOTSUPP;
 
-        spin_lock(&adapter->mbx_lock);
+        spin_lock_bh(&adapter->mbx_lock);
 
         /* add VID to filter table */
         err = hw->mac.ops.set_vfta(hw, vid, 0, true);
 
-        spin_unlock(&adapter->mbx_lock);
+        spin_unlock_bh(&adapter->mbx_lock);
 
         /* translate error return types so error makes sense */
         if (err == IXGBE_ERR_MBX)
@@ -1156,13 +1173,13 @@ static int ixgbevf_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
         struct ixgbe_hw *hw = &adapter->hw;
         int err = -EOPNOTSUPP;
 
-        spin_lock(&adapter->mbx_lock);
+        spin_lock_bh(&adapter->mbx_lock);
 
         /* remove VID from filter table */
         if (hw->mac.ops.set_vfta)
                 err = hw->mac.ops.set_vfta(hw, vid, 0, false);
 
-        spin_unlock(&adapter->mbx_lock);
+        spin_unlock_bh(&adapter->mbx_lock);
 
         clear_bit(vid, adapter->active_vlans);
 
@@ -1218,7 +1235,7 @@ static void ixgbevf_set_rx_mode(struct net_device *netdev)
         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
         struct ixgbe_hw *hw = &adapter->hw;
 
-        spin_lock(&adapter->mbx_lock);
+        spin_lock_bh(&adapter->mbx_lock);
 
         /* reprogram multicast list */
         if (hw->mac.ops.update_mc_addr_list)
@@ -1226,7 +1243,7 @@ static void ixgbevf_set_rx_mode(struct net_device *netdev)
 
         ixgbevf_write_uc_addr_list(netdev);
 
-        spin_unlock(&adapter->mbx_lock);
+        spin_unlock_bh(&adapter->mbx_lock);
 }
 
 static void ixgbevf_napi_enable_all(struct ixgbevf_adapter *adapter)
@@ -1335,11 +1352,12 @@ static void ixgbevf_init_last_counter_stats(struct ixgbevf_adapter *adapter)
 static void ixgbevf_negotiate_api(struct ixgbevf_adapter *adapter)
 {
         struct ixgbe_hw *hw = &adapter->hw;
-        int api[] = { ixgbe_mbox_api_10,
+        int api[] = { ixgbe_mbox_api_11,
+                      ixgbe_mbox_api_10,
                       ixgbe_mbox_api_unknown };
         int err = 0, idx = 0;
 
-        spin_lock(&adapter->mbx_lock);
+        spin_lock_bh(&adapter->mbx_lock);
 
         while (api[idx] != ixgbe_mbox_api_unknown) {
                 err = ixgbevf_negotiate_api_version(hw, api[idx]);
@@ -1348,7 +1366,7 @@ static void ixgbevf_negotiate_api(struct ixgbevf_adapter *adapter)
                 idx++;
         }
 
-        spin_unlock(&adapter->mbx_lock);
+        spin_unlock_bh(&adapter->mbx_lock);
 }
 
 static void ixgbevf_up_complete(struct ixgbevf_adapter *adapter)
@@ -1389,7 +1407,7 @@ static void ixgbevf_up_complete(struct ixgbevf_adapter *adapter)
 
         ixgbevf_configure_msix(adapter);
 
-        spin_lock(&adapter->mbx_lock);
+        spin_lock_bh(&adapter->mbx_lock);
 
         if (hw->mac.ops.set_rar) {
                 if (is_valid_ether_addr(hw->mac.addr))
@@ -1398,7 +1416,7 @@ static void ixgbevf_up_complete(struct ixgbevf_adapter *adapter)
                         hw->mac.ops.set_rar(hw, 0, hw->mac.perm_addr, 0);
         }
 
-        spin_unlock(&adapter->mbx_lock);
+        spin_unlock_bh(&adapter->mbx_lock);
 
         clear_bit(__IXGBEVF_DOWN, &adapter->state);
         ixgbevf_napi_enable_all(adapter);
@@ -1413,12 +1431,87 @@ static void ixgbevf_up_complete(struct ixgbevf_adapter *adapter)
         mod_timer(&adapter->watchdog_timer, jiffies);
 }
 
+static int ixgbevf_reset_queues(struct ixgbevf_adapter *adapter)
+{
+        struct ixgbe_hw *hw = &adapter->hw;
+        struct ixgbevf_ring *rx_ring;
+        unsigned int def_q = 0;
+        unsigned int num_tcs = 0;
+        unsigned int num_rx_queues = 1;
+        int err, i;
+
+        spin_lock_bh(&adapter->mbx_lock);
+
+        /* fetch queue configuration from the PF */
+        err = ixgbevf_get_queues(hw, &num_tcs, &def_q);
+
+        spin_unlock_bh(&adapter->mbx_lock);
+
+        if (err)
+                return err;
+
+        if (num_tcs > 1) {
+                /* update default Tx ring register index */
+                adapter->tx_ring[0].reg_idx = def_q;
+
+                /* we need as many queues as traffic classes */
+                num_rx_queues = num_tcs;
+        }
+
+        /* nothing to do if we have the correct number of queues */
+        if (adapter->num_rx_queues == num_rx_queues)
+                return 0;
+
+        /* allocate new rings */
+        rx_ring = kcalloc(num_rx_queues,
+                          sizeof(struct ixgbevf_ring), GFP_KERNEL);
+        if (!rx_ring)
+                return -ENOMEM;
+
+        /* setup ring fields */
+        for (i = 0; i < num_rx_queues; i++) {
+                rx_ring[i].count = adapter->rx_ring_count;
+                rx_ring[i].queue_index = i;
+                rx_ring[i].reg_idx = i;
+                rx_ring[i].dev = &adapter->pdev->dev;
+                rx_ring[i].netdev = adapter->netdev;
+
+                /* allocate resources on the ring */
+                err = ixgbevf_setup_rx_resources(adapter, &rx_ring[i]);
+                if (err) {
+                        while (i) {
+                                i--;
+                                ixgbevf_free_rx_resources(adapter, &rx_ring[i]);
+                        }
+                        kfree(rx_ring);
+                        return err;
+                }
+        }
+
+        /* free the existing rings and queues */
+        ixgbevf_free_all_rx_resources(adapter);
+        adapter->num_rx_queues = 0;
+        kfree(adapter->rx_ring);
+
+        /* move new rings into position on the adapter struct */
+        adapter->rx_ring = rx_ring;
+        adapter->num_rx_queues = num_rx_queues;
+
+        /* reset ring to vector mapping */
+        ixgbevf_reset_q_vectors(adapter);
+        ixgbevf_map_rings_to_vectors(adapter);
+
+        return 0;
+}
+
 void ixgbevf_up(struct ixgbevf_adapter *adapter)
 {
         struct ixgbe_hw *hw = &adapter->hw;
 
         ixgbevf_negotiate_api(adapter);
 
+        ixgbevf_reset_queues(adapter);
+
         ixgbevf_configure(adapter);
 
         ixgbevf_up_complete(adapter);
@@ -1611,14 +1704,14 @@ void ixgbevf_reset(struct ixgbevf_adapter *adapter)
         struct ixgbe_hw *hw = &adapter->hw;
         struct net_device *netdev = adapter->netdev;
 
-        spin_lock(&adapter->mbx_lock);
+        spin_lock_bh(&adapter->mbx_lock);
 
         if (hw->mac.ops.reset_hw(hw))
                 hw_dbg(hw, "PF still resetting\n");
         else
                 hw->mac.ops.init_hw(hw);
 
-        spin_unlock(&adapter->mbx_lock);
+        spin_unlock_bh(&adapter->mbx_lock);
 
         if (is_valid_ether_addr(adapter->hw.mac.addr)) {
                 memcpy(netdev->dev_addr, adapter->hw.mac.addr,
@@ -1717,6 +1810,7 @@ static int ixgbevf_alloc_queues(struct ixgbevf_adapter *adapter)
         for (i = 0; i < adapter->num_tx_queues; i++) {
                 adapter->tx_ring[i].count = adapter->tx_ring_count;
                 adapter->tx_ring[i].queue_index = i;
+                /* reg_idx may be remapped later by DCB config */
                 adapter->tx_ring[i].reg_idx = i;
                 adapter->tx_ring[i].dev = &adapter->pdev->dev;
                 adapter->tx_ring[i].netdev = adapter->netdev;
@@ -1834,18 +1928,13 @@ err_out:
  **/
 static void ixgbevf_free_q_vectors(struct ixgbevf_adapter *adapter)
 {
-        int q_idx, num_q_vectors;
-        int napi_vectors;
-
-        num_q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
-        napi_vectors = adapter->num_rx_queues;
+        int q_idx, num_q_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
 
         for (q_idx = 0; q_idx < num_q_vectors; q_idx++) {
                 struct ixgbevf_q_vector *q_vector = adapter->q_vector[q_idx];
 
                 adapter->q_vector[q_idx] = NULL;
-                if (q_idx < napi_vectors)
-                        netif_napi_del(&q_vector->napi);
+                netif_napi_del(&q_vector->napi);
                 kfree(q_vector);
         }
 }
@@ -1950,8 +2039,11 @@ static int __devinit ixgbevf_sw_init(struct ixgbevf_adapter *adapter)
         hw->subsystem_device_id = pdev->subsystem_device;
 
         hw->mbx.ops.init_params(hw);
-        hw->mac.max_tx_queues = MAX_TX_QUEUES;
-        hw->mac.max_rx_queues = MAX_RX_QUEUES;
+
+        /* assume legacy case in which PF would only give VF 2 queues */
+        hw->mac.max_tx_queues = 2;
+        hw->mac.max_rx_queues = 2;
+
         err = hw->mac.ops.reset_hw(hw);
         if (err) {
                 dev_info(&pdev->dev,
@@ -2113,12 +2205,12 @@ static void ixgbevf_watchdog_task(struct work_struct *work)
         if (hw->mac.ops.check_link) {
                 s32 need_reset;
 
-                spin_lock(&adapter->mbx_lock);
+                spin_lock_bh(&adapter->mbx_lock);
 
                 need_reset = hw->mac.ops.check_link(hw, &link_speed,
                                                     &link_up, false);
 
-                spin_unlock(&adapter->mbx_lock);
+                spin_unlock_bh(&adapter->mbx_lock);
 
                 if (need_reset) {
                         adapter->link_up = link_up;
@@ -2377,6 +2469,63 @@ static void ixgbevf_free_all_rx_resources(struct ixgbevf_adapter *adapter)
                                                   &adapter->rx_ring[i]);
 }
 
+static int ixgbevf_setup_queues(struct ixgbevf_adapter *adapter)
+{
+        struct ixgbe_hw *hw = &adapter->hw;
+        struct ixgbevf_ring *rx_ring;
+        unsigned int def_q = 0;
+        unsigned int num_tcs = 0;
+        unsigned int num_rx_queues = 1;
+        int err, i;
+
+        spin_lock_bh(&adapter->mbx_lock);
+
+        /* fetch queue configuration from the PF */
+        err = ixgbevf_get_queues(hw, &num_tcs, &def_q);
+
+        spin_unlock_bh(&adapter->mbx_lock);
+
+        if (err)
+                return err;
+
+        if (num_tcs > 1) {
+                /* update default Tx ring register index */
+                adapter->tx_ring[0].reg_idx = def_q;
+
+                /* we need as many queues as traffic classes */
+                num_rx_queues = num_tcs;
+        }
+
+        /* nothing to do if we have the correct number of queues */
+        if (adapter->num_rx_queues == num_rx_queues)
+                return 0;
+
+        /* allocate new rings */
+        rx_ring = kcalloc(num_rx_queues,
+                          sizeof(struct ixgbevf_ring), GFP_KERNEL);
+        if (!rx_ring)
+                return -ENOMEM;
+
+        /* setup ring fields */
+        for (i = 0; i < num_rx_queues; i++) {
+                rx_ring[i].count = adapter->rx_ring_count;
+                rx_ring[i].queue_index = i;
+                rx_ring[i].reg_idx = i;
+                rx_ring[i].dev = &adapter->pdev->dev;
+                rx_ring[i].netdev = adapter->netdev;
+        }
+
+        /* free the existing ring and queues */
+        adapter->num_rx_queues = 0;
+        kfree(adapter->rx_ring);
+
+        /* move new rings into position on the adapter struct */
+        adapter->rx_ring = rx_ring;
+        adapter->num_rx_queues = num_rx_queues;
+
+        return 0;
+}
+
 /**
  * ixgbevf_open - Called when a network interface is made active
  * @netdev: network interface device structure
@@ -2413,6 +2562,11 @@ static int ixgbevf_open(struct net_device *netdev)
 
         ixgbevf_negotiate_api(adapter);
 
+        /* setup queue reg_idx and Rx queue count */
+        err = ixgbevf_setup_queues(adapter);
+        if (err)
+                goto err_setup_queues;
+
         /* allocate transmit descriptors */
         err = ixgbevf_setup_all_tx_resources(adapter);
         if (err)
@@ -2451,6 +2605,7 @@ err_setup_rx:
         ixgbevf_free_all_rx_resources(adapter);
 err_setup_tx:
         ixgbevf_free_all_tx_resources(adapter);
+err_setup_queues:
         ixgbevf_reset(adapter);
 
 err_setup_reset:
@@ -2678,10 +2833,10 @@ static int ixgbevf_tx_map(struct ixgbevf_ring *tx_ring,
                         tx_buffer_info->dma =
                                 skb_frag_dma_map(tx_ring->dev, frag,
                                                  offset, size, DMA_TO_DEVICE);
-                        tx_buffer_info->mapped_as_page = true;
                         if (dma_mapping_error(tx_ring->dev,
                                               tx_buffer_info->dma))
                                 goto dma_error;
+                        tx_buffer_info->mapped_as_page = true;
                         tx_buffer_info->next_to_watch = i;
 
                         len -= size;
@@ -2823,6 +2978,11 @@ static int ixgbevf_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
 #if PAGE_SIZE > IXGBE_MAX_DATA_PER_TXD
         unsigned short f;
 #endif
+        u8 *dst_mac = skb_header_pointer(skb, 0, 0, NULL);
+        if (!dst_mac || is_link_local_ether_addr(dst_mac)) {
+                dev_kfree_skb(skb);
+                return NETDEV_TX_OK;
+        }
 
         tx_ring = &adapter->tx_ring[r_idx];
 
@@ -2902,12 +3062,12 @@ static int ixgbevf_set_mac(struct net_device *netdev, void *p)
         memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
         memcpy(hw->mac.addr, addr->sa_data, netdev->addr_len);
 
-        spin_lock(&adapter->mbx_lock);
+        spin_lock_bh(&adapter->mbx_lock);
 
         if (hw->mac.ops.set_rar)
                 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0);
 
-        spin_unlock(&adapter->mbx_lock);
+        spin_unlock_bh(&adapter->mbx_lock);
 
         return 0;
 }
@@ -2925,8 +3085,15 @@ static int ixgbevf_change_mtu(struct net_device *netdev, int new_mtu)
         int max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN;
         int max_possible_frame = MAXIMUM_ETHERNET_VLAN_SIZE;
 
-        if (adapter->hw.mac.type == ixgbe_mac_X540_vf)
+        switch (adapter->hw.api_version) {
+        case ixgbe_mbox_api_11:
                 max_possible_frame = IXGBE_MAX_JUMBO_FRAME_SIZE;
+                break;
+        default:
+                if (adapter->hw.mac.type == ixgbe_mac_X540_vf)
+                        max_possible_frame = IXGBE_MAX_JUMBO_FRAME_SIZE;
+                break;
+        }
 
         /* MTU < 68 is an error and causes problems on some kernels */
         if ((new_mtu < 68) || (max_frame > max_possible_frame))
diff --git a/drivers/net/ethernet/intel/ixgbevf/mbx.h b/drivers/net/ethernet/intel/ixgbevf/mbx.h
index 946ce86f337f..0bc30058ff82 100644
--- a/drivers/net/ethernet/intel/ixgbevf/mbx.h
+++ b/drivers/net/ethernet/intel/ixgbevf/mbx.h
@@ -85,6 +85,7 @@
 enum ixgbe_pfvf_api_rev {
         ixgbe_mbox_api_10,      /* API version 1.0, linux/freebsd VF driver */
         ixgbe_mbox_api_20,      /* API version 2.0, solaris Phase1 VF driver */
+        ixgbe_mbox_api_11,      /* API version 1.1, linux/freebsd VF driver */
         /* This value should always be last */
         ixgbe_mbox_api_unknown, /* indicates that API version is not known */
 };
@@ -100,6 +101,15 @@ enum ixgbe_pfvf_api_rev {
 #define IXGBE_VF_SET_MACVLAN    0x06 /* VF requests PF for unicast filter */
 #define IXGBE_VF_API_NEGOTIATE  0x08 /* negotiate API version */
 
+/* mailbox API, version 1.1 VF requests */
+#define IXGBE_VF_GET_QUEUE      0x09 /* get queue configuration */
+
+/* GET_QUEUES return data indices within the mailbox */
+#define IXGBE_VF_TX_QUEUES      1       /* number of Tx queues supported */
+#define IXGBE_VF_RX_QUEUES      2       /* number of Rx queues supported */
+#define IXGBE_VF_TRANS_VLAN     3       /* Indication of port vlan */
+#define IXGBE_VF_DEF_QUEUE      4       /* Default queue offset */
+
 /* length of permanent address message returned from PF */
 #define IXGBE_VF_PERMADDR_MSG_LEN 4
 /* word in permanent address message with the current multicast type */
diff --git a/drivers/net/ethernet/intel/ixgbevf/vf.c b/drivers/net/ethernet/intel/ixgbevf/vf.c
index 0c7447e6fcc8..0c94557b53df 100644
--- a/drivers/net/ethernet/intel/ixgbevf/vf.c
+++ b/drivers/net/ethernet/intel/ixgbevf/vf.c
@@ -331,6 +331,9 @@ static s32 ixgbevf_update_mc_addr_list_vf(struct ixgbe_hw *hw,
         netdev_for_each_mc_addr(ha, netdev) {
                 if (i == cnt)
                         break;
+                if (is_link_local_ether_addr(ha->addr))
+                        continue;
+
                 vector_list[i++] = ixgbevf_mta_vector(hw, ha->addr);
         }
 
@@ -513,6 +516,64 @@ int ixgbevf_negotiate_api_version(struct ixgbe_hw *hw, int api)
         return err;
 }
 
+int ixgbevf_get_queues(struct ixgbe_hw *hw, unsigned int *num_tcs,
+                       unsigned int *default_tc)
+{
+        int err;
+        u32 msg[5];
+
+        /* do nothing if API doesn't support ixgbevf_get_queues */
+        switch (hw->api_version) {
+        case ixgbe_mbox_api_11:
+                break;
+        default:
+                return 0;
+        }
+
+        /* Fetch queue configuration from the PF */
+        msg[0] = IXGBE_VF_GET_QUEUE;
+        msg[1] = msg[2] = msg[3] = msg[4] = 0;
+        err = hw->mbx.ops.write_posted(hw, msg, 5);
+
+        if (!err)
+                err = hw->mbx.ops.read_posted(hw, msg, 5);
+
+        if (!err) {
+                msg[0] &= ~IXGBE_VT_MSGTYPE_CTS;
+
+                /*
+                 * if we we didn't get an ACK there must have been
+                 * some sort of mailbox error so we should treat it
+                 * as such
+                 */
+                if (msg[0] != (IXGBE_VF_GET_QUEUE | IXGBE_VT_MSGTYPE_ACK))
+                        return IXGBE_ERR_MBX;
+
+                /* record and validate values from message */
+                hw->mac.max_tx_queues = msg[IXGBE_VF_TX_QUEUES];
+                if (hw->mac.max_tx_queues == 0 ||
+                    hw->mac.max_tx_queues > IXGBE_VF_MAX_TX_QUEUES)
+                        hw->mac.max_tx_queues = IXGBE_VF_MAX_TX_QUEUES;
+
+                hw->mac.max_rx_queues = msg[IXGBE_VF_RX_QUEUES];
+                if (hw->mac.max_rx_queues == 0 ||
+                    hw->mac.max_rx_queues > IXGBE_VF_MAX_RX_QUEUES)
+                        hw->mac.max_rx_queues = IXGBE_VF_MAX_RX_QUEUES;
+
+                *num_tcs = msg[IXGBE_VF_TRANS_VLAN];
+                /* in case of unknown state assume we cannot tag frames */
+                if (*num_tcs > hw->mac.max_rx_queues)
+                        *num_tcs = 1;
+
+                *default_tc = msg[IXGBE_VF_DEF_QUEUE];
+                /* default to queue 0 on out-of-bounds queue number */
+                if (*default_tc >= hw->mac.max_tx_queues)
+                        *default_tc = 0;
+        }
+
+        return err;
+}
+
 static const struct ixgbe_mac_operations ixgbevf_mac_ops = {
         .init_hw             = ixgbevf_init_hw_vf,
         .reset_hw            = ixgbevf_reset_hw_vf,
diff --git a/drivers/net/ethernet/intel/ixgbevf/vf.h b/drivers/net/ethernet/intel/ixgbevf/vf.h
index 47f11a584d8c..7b1f502d1716 100644
--- a/drivers/net/ethernet/intel/ixgbevf/vf.h
+++ b/drivers/net/ethernet/intel/ixgbevf/vf.h
@@ -174,5 +174,7 @@ struct ixgbevf_info {
 
 void ixgbevf_rlpml_set_vf(struct ixgbe_hw *hw, u16 max_size);
 int ixgbevf_negotiate_api_version(struct ixgbe_hw *hw, int api);
+int ixgbevf_get_queues(struct ixgbe_hw *hw, unsigned int *num_tcs,
+                       unsigned int *default_tc);
 #endif /* __IXGBE_VF_H__ */
 
diff --git a/drivers/net/ethernet/marvell/pxa168_eth.c b/drivers/net/ethernet/marvell/pxa168_eth.c
index 59489722e898..10d678d3dd01 100644
--- a/drivers/net/ethernet/marvell/pxa168_eth.c
+++ b/drivers/net/ethernet/marvell/pxa168_eth.c
@@ -1131,7 +1131,7 @@ static int pxa168_eth_open(struct net_device *dev)
         err = request_irq(dev->irq, pxa168_eth_int_handler,
                           IRQF_DISABLED, dev->name, dev);
         if (err) {
-                dev_printk(KERN_ERR, &dev->dev, "can't assign irq\n");
+                dev_err(&dev->dev, "can't assign irq\n");
                 return -EAGAIN;
         }
         pep->rx_resource_err = 0;
@@ -1201,9 +1201,8 @@ static int pxa168_eth_change_mtu(struct net_device *dev, int mtu)
          */
         pxa168_eth_stop(dev);
         if (pxa168_eth_open(dev)) {
-                dev_printk(KERN_ERR, &dev->dev,
-                           "fatal error on re-opening device after "
-                           "MTU change\n");
+                dev_err(&dev->dev,
+                        "fatal error on re-opening device after MTU change\n");
         }
 
         return 0;
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c
index edd9cb8d3e1d..2b23ca21b320 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c
@@ -870,7 +870,7 @@ static void mlx4_en_set_default_moderation(struct mlx4_en_priv *priv)
         /* If we haven't received a specific coalescing setting
          * (module param), we set the moderation parameters as follows:
          * - moder_cnt is set to the number of mtu sized packets to
-         *   satisfy our coelsing target.
+         *   satisfy our coalescing target.
          * - moder_time is set to a fixed value.
          */
         priv->rx_frames = MLX4_EN_RX_COAL_TARGET;
diff --git a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
index 9d27e42264e2..8a5e70d68894 100644
--- a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
+++ b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
@@ -126,7 +126,7 @@ enum {
 #define MLX4_EN_RX_COAL_TIME    0x10
 
 #define MLX4_EN_TX_COAL_PKTS    16
-#define MLX4_EN_TX_COAL_TIME    0x80
+#define MLX4_EN_TX_COAL_TIME    0x10
 
 #define MLX4_EN_RX_RATE_LOW             400000
 #define MLX4_EN_RX_COAL_TIME_LOW        0
diff --git a/drivers/net/ethernet/micrel/ksz884x.c b/drivers/net/ethernet/micrel/ksz884x.c
index e558edd1cb6c..e4ba868e232c 100644
--- a/drivers/net/ethernet/micrel/ksz884x.c
+++ b/drivers/net/ethernet/micrel/ksz884x.c
@@ -7251,18 +7251,7 @@ static struct pci_driver pci_device_driver = {
         .remove         = pcidev_exit
 };
 
-static int __init ksz884x_init_module(void)
-{
-        return pci_register_driver(&pci_device_driver);
-}
-
-static void __exit ksz884x_cleanup_module(void)
-{
-        pci_unregister_driver(&pci_device_driver);
-}
-
-module_init(ksz884x_init_module);
-module_exit(ksz884x_cleanup_module);
+module_pci_driver(pci_device_driver);
 
 MODULE_DESCRIPTION("KSZ8841/2 PCI network driver");
 MODULE_AUTHOR("Tristram Ha <Tristram.Ha@micrel.com>");
diff --git a/drivers/net/ethernet/neterion/s2io.c b/drivers/net/ethernet/neterion/s2io.c
index de50547c187d..c98decb19ce8 100644
--- a/drivers/net/ethernet/neterion/s2io.c
+++ b/drivers/net/ethernet/neterion/s2io.c
@@ -8239,7 +8239,8 @@ static int __init s2io_starter(void)
 
 /**
  * s2io_closer - Cleanup routine for the driver
- * Description: This function is the cleanup routine for the driver. It unregist * ers the driver.
+ * Description: This function is the cleanup routine for the driver. It
+ * unregisters the driver.
  */
 
 static __exit void s2io_closer(void)
diff --git a/drivers/net/ethernet/oki-semi/pch_gbe/Kconfig b/drivers/net/ethernet/oki-semi/pch_gbe/Kconfig
index 5296cc8d3cba..00bc4fc968c7 100644
--- a/drivers/net/ethernet/oki-semi/pch_gbe/Kconfig
+++ b/drivers/net/ethernet/oki-semi/pch_gbe/Kconfig
@@ -20,19 +20,3 @@ config PCH_GBE
           purpose use.
           ML7223/ML7831 is companion chip for Intel Atom E6xx series.
           ML7223/ML7831 is completely compatible for Intel EG20T PCH.
-
-if PCH_GBE
-
-config PCH_PTP
-        bool "PCH PTP clock support"
-        default n
-        depends on EXPERIMENTAL
-        select PPS
-        select PTP_1588_CLOCK
-        select PTP_1588_CLOCK_PCH
-        ---help---
-          Say Y here if you want to use Precision Time Protocol (PTP) in the
-          driver. PTP is a method to precisely synchronize distributed clocks
-          over Ethernet networks.
-
-endif # PCH_GBE
diff --git a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe.h b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe.h
index b07311eaa693..7fb7e178c74e 100644
--- a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe.h
+++ b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe.h
@@ -649,7 +649,6 @@ extern void pch_gbe_free_tx_resources(struct pch_gbe_adapter *adapter,
 extern void pch_gbe_free_rx_resources(struct pch_gbe_adapter *adapter,
                                        struct pch_gbe_rx_ring *rx_ring);
 extern void pch_gbe_update_stats(struct pch_gbe_adapter *adapter);
-#ifdef CONFIG_PCH_PTP
 extern u32 pch_ch_control_read(struct pci_dev *pdev);
 extern void pch_ch_control_write(struct pci_dev *pdev, u32 val);
 extern u32 pch_ch_event_read(struct pci_dev *pdev);
@@ -659,7 +658,6 @@ extern u32 pch_src_uuid_hi_read(struct pci_dev *pdev);
 extern u64 pch_rx_snap_read(struct pci_dev *pdev);
 extern u64 pch_tx_snap_read(struct pci_dev *pdev);
 extern int pch_set_station_address(u8 *addr, struct pci_dev *pdev);
-#endif
 
 /* pch_gbe_param.c */
 extern void pch_gbe_check_options(struct pch_gbe_adapter *adapter);
diff --git a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
index 4c4fe5b1a29a..39ab4d09faaa 100644
--- a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
+++ b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
@@ -21,10 +21,8 @@
 #include "pch_gbe.h"
 #include "pch_gbe_api.h"
 #include <linux/module.h>
-#ifdef CONFIG_PCH_PTP
 #include <linux/net_tstamp.h>
 #include <linux/ptp_classify.h>
-#endif
 
 #define DRV_VERSION     "1.01"
 const char pch_driver_version[] = DRV_VERSION;
@@ -98,7 +96,6 @@ const char pch_driver_version[] = DRV_VERSION;
 
 #define PCH_GBE_INT_DISABLE_ALL         0
 
-#ifdef CONFIG_PCH_PTP
 /* Macros for ieee1588 */
 /* 0x40 Time Synchronization Channel Control Register Bits */
 #define MASTER_MODE   (1<<0)
@@ -113,7 +110,6 @@ const char pch_driver_version[] = DRV_VERSION;
 
 #define PTP_L4_MULTICAST_SA "01:00:5e:00:01:81"
 #define PTP_L2_MULTICAST_SA "01:1b:19:00:00:00"
-#endif
 
 static unsigned int copybreak __read_mostly = PCH_GBE_COPYBREAK_DEFAULT;
 
@@ -122,7 +118,6 @@ static void pch_gbe_mdio_write(struct net_device *netdev, int addr, int reg,
                                int data);
 static void pch_gbe_set_multi(struct net_device *netdev);
 
-#ifdef CONFIG_PCH_PTP
 static struct sock_filter ptp_filter[] = {
         PTP_FILTER
 };
@@ -291,7 +286,6 @@ static int hwtstamp_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
 
         return copy_to_user(ifr->ifr_data, &cfg, sizeof(cfg)) ? -EFAULT : 0;
 }
-#endif
 
 inline void pch_gbe_mac_load_mac_addr(struct pch_gbe_hw *hw)
 {
@@ -1244,9 +1238,7 @@ static void pch_gbe_tx_queue(struct pch_gbe_adapter *adapter,
                   (int)sizeof(struct pch_gbe_tx_desc) * ring_num,
                   &hw->reg->TX_DSC_SW_P);
 
-#ifdef CONFIG_PCH_PTP
         pch_tx_timestamp(adapter, skb);
-#endif
 
         dev_kfree_skb_any(skb);
 }
@@ -1730,9 +1722,7 @@ pch_gbe_clean_rx(struct pch_gbe_adapter *adapter,
                         /* Write meta date of skb */
                         skb_put(skb, length);
 
-#ifdef CONFIG_PCH_PTP
                         pch_rx_timestamp(adapter, skb);
-#endif
 
                         skb->protocol = eth_type_trans(skb, netdev);
                         if (tcp_ip_status & PCH_GBE_RXD_ACC_STAT_TCPIPOK)
@@ -2334,10 +2324,8 @@ static int pch_gbe_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
 
         pr_debug("cmd : 0x%04x\n", cmd);
 
-#ifdef CONFIG_PCH_PTP
         if (cmd == SIOCSHWTSTAMP)
                 return hwtstamp_ioctl(netdev, ifr, cmd);
-#endif
 
         return generic_mii_ioctl(&adapter->mii, if_mii(ifr), cmd, NULL);
 }
@@ -2623,14 +2611,12 @@ static int pch_gbe_probe(struct pci_dev *pdev,
                 goto err_free_netdev;
         }
 
-#ifdef CONFIG_PCH_PTP
         adapter->ptp_pdev = pci_get_bus_and_slot(adapter->pdev->bus->number,
                                                PCI_DEVFN(12, 4));
         if (ptp_filter_init(ptp_filter, ARRAY_SIZE(ptp_filter))) {
                 pr_err("Bad ptp filter\n");
                 return -EINVAL;
         }
-#endif
 
         netdev->netdev_ops = &pch_gbe_netdev_ops;
         netdev->watchdog_timeo = PCH_GBE_WATCHDOG_PERIOD;
diff --git a/drivers/net/ethernet/qlogic/netxen/netxen_nic_ethtool.c b/drivers/net/ethernet/qlogic/netxen/netxen_nic_ethtool.c
index 10468e7932dd..4ca2c196c98a 100644
--- a/drivers/net/ethernet/qlogic/netxen/netxen_nic_ethtool.c
+++ b/drivers/net/ethernet/qlogic/netxen/netxen_nic_ethtool.c
@@ -218,7 +218,7 @@ skip:
                         check_sfp_module = netif_running(dev) &&
                                 adapter->has_link_events;
                 } else {
-                        ecmd->supported |= (SUPPORTED_TP |SUPPORTED_Autoneg);
+                        ecmd->supported |= (SUPPORTED_TP | SUPPORTED_Autoneg);
                         ecmd->advertising |=
                                 (ADVERTISED_TP | ADVERTISED_Autoneg);
                         ecmd->port = PORT_TP;
@@ -381,7 +381,7 @@ static u32 netxen_nic_test_link(struct net_device *dev)
 
 static int
 netxen_nic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
-                      u8 * bytes)
+                      u8 *bytes)
 {
         struct netxen_adapter *adapter = netdev_priv(dev);
         int offset;
@@ -488,6 +488,8 @@ netxen_nic_get_pauseparam(struct net_device *dev,
         __u32 val;
         int port = adapter->physical_port;
 
+        pause->autoneg = 0;
+
         if (adapter->ahw.port_type == NETXEN_NIC_GBE) {
                 if ((port < 0) || (port >= NETXEN_NIU_MAX_GBE_PORTS))
                         return;
@@ -496,19 +498,19 @@ netxen_nic_get_pauseparam(struct net_device *dev,
                 pause->rx_pause = netxen_gb_get_rx_flowctl(val);
                 val = NXRD32(adapter, NETXEN_NIU_GB_PAUSE_CTL);
                 switch (port) {
-                        case 0:
-                                pause->tx_pause = !(netxen_gb_get_gb0_mask(val));
-                                break;
-                        case 1:
-                                pause->tx_pause = !(netxen_gb_get_gb1_mask(val));
-                                break;
-                        case 2:
-                                pause->tx_pause = !(netxen_gb_get_gb2_mask(val));
-                                break;
-                        case 3:
-                        default:
-                                pause->tx_pause = !(netxen_gb_get_gb3_mask(val));
-                                break;
+                case 0:
+                        pause->tx_pause = !(netxen_gb_get_gb0_mask(val));
+                        break;
+                case 1:
+                        pause->tx_pause = !(netxen_gb_get_gb1_mask(val));
+                        break;
+                case 2:
+                        pause->tx_pause = !(netxen_gb_get_gb2_mask(val));
+                        break;
+                case 3:
+                default:
+                        pause->tx_pause = !(netxen_gb_get_gb3_mask(val));
+                        break;
                 }
         } else if (adapter->ahw.port_type == NETXEN_NIC_XGBE) {
                 if ((port < 0) || (port >= NETXEN_NIU_MAX_XG_PORTS))
@@ -532,6 +534,11 @@ netxen_nic_set_pauseparam(struct net_device *dev,
         struct netxen_adapter *adapter = netdev_priv(dev);
         __u32 val;
         int port = adapter->physical_port;
+
+        /* not supported */
+        if (pause->autoneg)
+                return -EINVAL;
+
         /* read mode */
         if (adapter->ahw.port_type == NETXEN_NIC_GBE) {
                 if ((port < 0) || (port >= NETXEN_NIU_MAX_GBE_PORTS))
@@ -549,31 +556,31 @@ netxen_nic_set_pauseparam(struct net_device *dev,
                 /* set autoneg */
                 val = NXRD32(adapter, NETXEN_NIU_GB_PAUSE_CTL);
                 switch (port) {
-                        case 0:
-                                if (pause->tx_pause)
-                                        netxen_gb_unset_gb0_mask(val);
-                                else
-                                        netxen_gb_set_gb0_mask(val);
-                                break;
-                        case 1:
-                                if (pause->tx_pause)
-                                        netxen_gb_unset_gb1_mask(val);
-                                else
-                                        netxen_gb_set_gb1_mask(val);
-                                break;
-                        case 2:
-                                if (pause->tx_pause)
-                                        netxen_gb_unset_gb2_mask(val);
-                                else
-                                        netxen_gb_set_gb2_mask(val);
-                                break;
-                        case 3:
-                        default:
-                                if (pause->tx_pause)
-                                        netxen_gb_unset_gb3_mask(val);
-                                else
-                                        netxen_gb_set_gb3_mask(val);
-                                break;
+                case 0:
+                        if (pause->tx_pause)
+                                netxen_gb_unset_gb0_mask(val);
+                        else
+                                netxen_gb_set_gb0_mask(val);
+                        break;
+                case 1:
+                        if (pause->tx_pause)
+                                netxen_gb_unset_gb1_mask(val);
+                        else
+                                netxen_gb_set_gb1_mask(val);
+                        break;
+                case 2:
+                        if (pause->tx_pause)
+                                netxen_gb_unset_gb2_mask(val);
+                        else
+                                netxen_gb_set_gb2_mask(val);
+                        break;
+                case 3:
+                default:
+                        if (pause->tx_pause)
+                                netxen_gb_unset_gb3_mask(val);
+                        else
+                                netxen_gb_set_gb3_mask(val);
+                        break;
                 }
                 NXWR32(adapter, NETXEN_NIU_GB_PAUSE_CTL, val);
         } else if (adapter->ahw.port_type == NETXEN_NIC_XGBE) {
@@ -636,7 +643,7 @@ static int netxen_get_sset_count(struct net_device *dev, int sset)
 
 static void
 netxen_nic_diag_test(struct net_device *dev, struct ethtool_test *eth_test,
-                     u64 * data)
+                     u64 *data)
 {
         memset(data, 0, sizeof(uint64_t) * NETXEN_NIC_TEST_LEN);
         if ((data[0] = netxen_nic_reg_test(dev)))
@@ -647,7 +654,7 @@ netxen_nic_diag_test(struct net_device *dev, struct ethtool_test *eth_test,
 }
 
 static void
-netxen_nic_get_strings(struct net_device *dev, u32 stringset, u8 * data)
+netxen_nic_get_strings(struct net_device *dev, u32 stringset, u8 *data)
 {
         int index;
 
@@ -668,7 +675,7 @@ netxen_nic_get_strings(struct net_device *dev, u32 stringset, u8 * data)
 
 static void
 netxen_nic_get_ethtool_stats(struct net_device *dev,
-                             struct ethtool_stats *stats, u64 * data)
+                             struct ethtool_stats *stats, u64 *data)
 {
         struct netxen_adapter *adapter = netdev_priv(dev);
         int index;
diff --git a/drivers/net/ethernet/qlogic/qla3xxx.c b/drivers/net/ethernet/qlogic/qla3xxx.c
index 6407d0d77e81..12d1f2470d5c 100644
--- a/drivers/net/ethernet/qlogic/qla3xxx.c
+++ b/drivers/net/ethernet/qlogic/qla3xxx.c
@@ -1920,7 +1920,6 @@ static void ql_process_mac_tx_intr(struct ql3_adapter *qdev,
 {
         struct ql_tx_buf_cb *tx_cb;
         int i;
-        int retval = 0;
 
         if (mac_rsp->flags & OB_MAC_IOCB_RSP_S) {
                 netdev_warn(qdev->ndev,
@@ -1935,7 +1934,6 @@ static void ql_process_mac_tx_intr(struct ql3_adapter *qdev,
                            "Frame too short to be legal, frame not sent\n");
 
                 qdev->ndev->stats.tx_errors++;
-                retval = -EIO;
                 goto frame_not_sent;
         }
 
@@ -1944,7 +1942,6 @@ static void ql_process_mac_tx_intr(struct ql3_adapter *qdev,
                            mac_rsp->transaction_id);
 
                 qdev->ndev->stats.tx_errors++;
-                retval = -EIO;
                 goto invalid_seg_count;
         }
 
@@ -3958,15 +3955,4 @@ static struct pci_driver ql3xxx_driver = {
         .remove = __devexit_p(ql3xxx_remove),
 };
 
-static int __init ql3xxx_init_module(void)
-{
-        return pci_register_driver(&ql3xxx_driver);
-}
-
-static void __exit ql3xxx_exit(void)
-{
-        pci_unregister_driver(&ql3xxx_driver);
-}
-
-module_init(ql3xxx_init_module);
-module_exit(ql3xxx_exit);
+module_pci_driver(ql3xxx_driver);
diff --git a/drivers/net/ethernet/qlogic/qlge/qlge_dbg.c b/drivers/net/ethernet/qlogic/qlge/qlge_dbg.c
index 58185b604b72..10093f0c4c0f 100644
--- a/drivers/net/ethernet/qlogic/qlge/qlge_dbg.c
+++ b/drivers/net/ethernet/qlogic/qlge/qlge_dbg.c
@@ -86,7 +86,7 @@ exit:
 }
 
 /* Read out the SERDES registers */
-static int ql_read_serdes_reg(struct ql_adapter *qdev, u32 reg, u32 * data)
+static int ql_read_serdes_reg(struct ql_adapter *qdev, u32 reg, u32 *data)
 {
         int status;
 
@@ -364,7 +364,7 @@ exit:
 /* Read the 400 xgmac control/statistics registers
  * skipping unused locations.
  */
-static int ql_get_xgmac_regs(struct ql_adapter *qdev, u32 * buf,
+static int ql_get_xgmac_regs(struct ql_adapter *qdev, u32 *buf,
                                         unsigned int other_function)
 {
         int status = 0;
@@ -405,7 +405,7 @@ static int ql_get_xgmac_regs(struct ql_adapter *qdev, u32 * buf,
         return status;
 }
 
-static int ql_get_ets_regs(struct ql_adapter *qdev, u32 * buf)
+static int ql_get_ets_regs(struct ql_adapter *qdev, u32 *buf)
 {
         int status = 0;
         int i;
@@ -423,7 +423,7 @@ static int ql_get_ets_regs(struct ql_adapter *qdev, u32 * buf)
         return status;
 }
 
-static void ql_get_intr_states(struct ql_adapter *qdev, u32 * buf)
+static void ql_get_intr_states(struct ql_adapter *qdev, u32 *buf)
 {
         int i;
 
@@ -434,7 +434,7 @@ static void ql_get_intr_states(struct ql_adapter *qdev, u32 * buf)
         }
 }
 
-static int ql_get_cam_entries(struct ql_adapter *qdev, u32 * buf)
+static int ql_get_cam_entries(struct ql_adapter *qdev, u32 *buf)
 {
         int i, status;
         u32 value[3];
@@ -471,7 +471,7 @@ err:
         return status;
 }
 
-static int ql_get_routing_entries(struct ql_adapter *qdev, u32 * buf)
+static int ql_get_routing_entries(struct ql_adapter *qdev, u32 *buf)
 {
         int status;
         u32 value, i;
@@ -496,7 +496,7 @@ err:
 }
 
 /* Read the MPI Processor shadow registers */
-static int ql_get_mpi_shadow_regs(struct ql_adapter *qdev, u32 * buf)
+static int ql_get_mpi_shadow_regs(struct ql_adapter *qdev, u32 *buf)
 {
         u32 i;
         int status;
@@ -515,7 +515,7 @@ end:
 }
 
 /* Read the MPI Processor core registers */
-static int ql_get_mpi_regs(struct ql_adapter *qdev, u32 * buf,
+static int ql_get_mpi_regs(struct ql_adapter *qdev, u32 *buf,
                                 u32 offset, u32 count)
 {
         int i, status = 0;
diff --git a/drivers/net/ethernet/realtek/atp.c b/drivers/net/ethernet/realtek/atp.c
index e02f04d7f3ad..9f2d416de750 100644
--- a/drivers/net/ethernet/realtek/atp.c
+++ b/drivers/net/ethernet/realtek/atp.c
@@ -175,8 +175,7 @@ struct net_local {
     unsigned int tx_unit_busy:1;
     unsigned char re_tx,        /* Number of packet retransmissions. */
                 addr_mode,              /* Current Rx filter e.g. promiscuous, etc. */
-                pac_cnt_in_tx_buf,
-                chip_type;
+                pac_cnt_in_tx_buf;
 };
 
 /* This code, written by wwc@super.org, resets the adapter every
@@ -339,7 +338,6 @@ static int __init atp_probe1(long ioaddr)
         write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
 
         lp = netdev_priv(dev);
-        lp->chip_type = RTL8002;
         lp->addr_mode = CMR2h_Normal;
         spin_lock_init(&lp->lock);
 
@@ -852,7 +850,7 @@ net_close(struct net_device *dev)
  *      Set or clear the multicast filter for this adapter.
  */
 
-static void set_rx_mode_8002(struct net_device *dev)
+static void set_rx_mode(struct net_device *dev)
 {
         struct net_local *lp = netdev_priv(dev);
         long ioaddr = dev->base_addr;
@@ -864,58 +862,6 @@ static void set_rx_mode_8002(struct net_device *dev)
         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 }
 
-static void set_rx_mode_8012(struct net_device *dev)
-{
-        struct net_local *lp = netdev_priv(dev);
-        long ioaddr = dev->base_addr;
-        unsigned char new_mode, mc_filter[8]; /* Multicast hash filter */
-        int i;
-
-        if (dev->flags & IFF_PROMISC) {                 /* Set promiscuous. */
-                new_mode = CMR2h_PROMISC;
-        } else if ((netdev_mc_count(dev) > 1000) ||
-                   (dev->flags & IFF_ALLMULTI)) {
-                /* Too many to filter perfectly -- accept all multicasts. */
-                memset(mc_filter, 0xff, sizeof(mc_filter));
-                new_mode = CMR2h_Normal;
-        } else {
-                struct netdev_hw_addr *ha;
-
-                memset(mc_filter, 0, sizeof(mc_filter));
-                netdev_for_each_mc_addr(ha, dev) {
-                        int filterbit = ether_crc_le(ETH_ALEN, ha->addr) & 0x3f;
-                        mc_filter[filterbit >> 5] |= 1 << (filterbit & 31);
-                }
-                new_mode = CMR2h_Normal;
-        }
-        lp->addr_mode = new_mode;
-    write_reg(ioaddr, CMR2, CMR2_IRQOUT | 0x04); /* Switch to page 1. */
-    for (i = 0; i < 8; i++)
-                write_reg_byte(ioaddr, i, mc_filter[i]);
-        if (net_debug > 2 || 1) {
-                lp->addr_mode = 1;
-                printk(KERN_DEBUG "%s: Mode %d, setting multicast filter to",
-                           dev->name, lp->addr_mode);
-                for (i = 0; i < 8; i++)
-                        printk(" %2.2x", mc_filter[i]);
-                printk(".\n");
-        }
-
-        write_reg_high(ioaddr, CMR2, lp->addr_mode);
-    write_reg(ioaddr, CMR2, CMR2_IRQOUT); /* Switch back to page 0 */
-}
-
-static void set_rx_mode(struct net_device *dev)
-{
-        struct net_local *lp = netdev_priv(dev);
-
-        if (lp->chip_type == RTL8002)
-                return set_rx_mode_8002(dev);
-        else
-                return set_rx_mode_8012(dev);
-}
-
-
 static int __init atp_init_module(void) {
         if (debug)                                      /* Emit version even if no cards detected. */
                 printk(KERN_INFO "%s", version);
diff --git a/drivers/net/ethernet/realtek/atp.h b/drivers/net/ethernet/realtek/atp.h
index 0edc642c2c2f..040b13739947 100644
--- a/drivers/net/ethernet/realtek/atp.h
+++ b/drivers/net/ethernet/realtek/atp.h
@@ -16,8 +16,6 @@ struct rx_header {
 #define PAR_STATUS      1
 #define PAR_CONTROL 2
 
-enum chip_type { RTL8002, RTL8012 };
-
 #define Ctrl_LNibRead   0x08    /* LP_PSELECP */
 #define Ctrl_HNibRead   0
 #define Ctrl_LNibWrite  0x08    /* LP_PSELECP */
diff --git a/drivers/net/ethernet/realtek/r8169.c b/drivers/net/ethernet/realtek/r8169.c
index 927aa33d4349..50a55fb10368 100644
--- a/drivers/net/ethernet/realtek/r8169.c
+++ b/drivers/net/ethernet/realtek/r8169.c
@@ -78,7 +78,6 @@ static const int multicast_filter_limit = 32;
 
 #define MAX_READ_REQUEST_SHIFT  12
 #define TX_DMA_BURST    7       /* Maximum PCI burst, '7' is unlimited */
-#define SafeMtu         0x1c20  /* ... actually life sucks beyond ~7k */
 #define InterFrameGap   0x03    /* 3 means InterFrameGap = the shortest one */
 
 #define R8169_REGS_SIZE         256
@@ -456,6 +455,7 @@ enum rtl8168_registers {
 #define PWM_EN                          (1 << 22)
 #define RXDV_GATED_EN                   (1 << 19)
 #define EARLY_TALLY_EN                  (1 << 16)
+#define FORCE_CLK                       (1 << 15) /* force clock request */
 };
 
 enum rtl_register_content {
@@ -519,6 +519,7 @@ enum rtl_register_content {
         PMEnable        = (1 << 0),     /* Power Management Enable */
 
         /* Config2 register p. 25 */
+        ClkReqEn        = (1 << 7),     /* Clock Request Enable */
         MSIEnable       = (1 << 5),     /* 8169 only. Reserved in the 8168. */
         PCI_Clock_66MHz = 0x01,
         PCI_Clock_33MHz = 0x00,
@@ -539,6 +540,7 @@ enum rtl_register_content {
         Spi_en          = (1 << 3),
         LanWake         = (1 << 1),     /* LanWake enable/disable */
         PMEStatus       = (1 << 0),     /* PME status can be reset by PCI RST# */
+        ASPM_en         = (1 << 0),     /* ASPM enable */
 
         /* TBICSR p.28 */
         TBIReset        = 0x80000000,
@@ -687,6 +689,7 @@ enum features {
         RTL_FEATURE_WOL         = (1 << 0),
         RTL_FEATURE_MSI         = (1 << 1),
         RTL_FEATURE_GMII        = (1 << 2),
+        RTL_FEATURE_FW_LOADED   = (1 << 3),
 };
 
 struct rtl8169_counters {
@@ -2394,8 +2397,10 @@ static void rtl_apply_firmware(struct rtl8169_private *tp)
         struct rtl_fw *rtl_fw = tp->rtl_fw;
 
         /* TODO: release firmware once rtl_phy_write_fw signals failures. */
-        if (!IS_ERR_OR_NULL(rtl_fw))
+        if (!IS_ERR_OR_NULL(rtl_fw)) {
                 rtl_phy_write_fw(tp, rtl_fw);
+                tp->features |= RTL_FEATURE_FW_LOADED;
+        }
 }
 
 static void rtl_apply_firmware_cond(struct rtl8169_private *tp, u8 reg, u16 val)
@@ -2406,6 +2411,31 @@ static void rtl_apply_firmware_cond(struct rtl8169_private *tp, u8 reg, u16 val)
                 rtl_apply_firmware(tp);
 }
 
+static void r810x_aldps_disable(struct rtl8169_private *tp)
+{
+        rtl_writephy(tp, 0x1f, 0x0000);
+        rtl_writephy(tp, 0x18, 0x0310);
+        msleep(100);
+}
+
+static void r810x_aldps_enable(struct rtl8169_private *tp)
+{
+        if (!(tp->features & RTL_FEATURE_FW_LOADED))
+                return;
+
+        rtl_writephy(tp, 0x1f, 0x0000);
+        rtl_writephy(tp, 0x18, 0x8310);
+}
+
+static void r8168_aldps_enable_1(struct rtl8169_private *tp)
+{
+        if (!(tp->features & RTL_FEATURE_FW_LOADED))
+                return;
+
+        rtl_writephy(tp, 0x1f, 0x0000);
+        rtl_w1w0_phy(tp, 0x15, 0x1000, 0x0000);
+}
+
 static void rtl8169s_hw_phy_config(struct rtl8169_private *tp)
 {
         static const struct phy_reg phy_reg_init[] = {
@@ -3178,6 +3208,8 @@ static void rtl8168e_2_hw_phy_config(struct rtl8169_private *tp)
         rtl_w1w0_phy(tp, 0x19, 0x0000, 0x0001);
         rtl_w1w0_phy(tp, 0x10, 0x0000, 0x0400);
         rtl_writephy(tp, 0x1f, 0x0000);
+
+        r8168_aldps_enable_1(tp);
 }
 
 static void rtl8168f_hw_phy_config(struct rtl8169_private *tp)
@@ -3250,6 +3282,8 @@ static void rtl8168f_1_hw_phy_config(struct rtl8169_private *tp)
         rtl_writephy(tp, 0x05, 0x8b85);
         rtl_w1w0_phy(tp, 0x06, 0x4000, 0x0000);
         rtl_writephy(tp, 0x1f, 0x0000);
+
+        r8168_aldps_enable_1(tp);
 }
 
 static void rtl8168f_2_hw_phy_config(struct rtl8169_private *tp)
@@ -3257,6 +3291,8 @@ static void rtl8168f_2_hw_phy_config(struct rtl8169_private *tp)
         rtl_apply_firmware(tp);
 
         rtl8168f_hw_phy_config(tp);
+
+        r8168_aldps_enable_1(tp);
 }
 
 static void rtl8411_hw_phy_config(struct rtl8169_private *tp)
@@ -3354,6 +3390,8 @@ static void rtl8411_hw_phy_config(struct rtl8169_private *tp)
         rtl_w1w0_phy(tp, 0x19, 0x0000, 0x0001);
         rtl_w1w0_phy(tp, 0x10, 0x0000, 0x0400);
         rtl_writephy(tp, 0x1f, 0x0000);
+
+        r8168_aldps_enable_1(tp);
 }
 
 static void rtl8168g_1_hw_phy_config(struct rtl8169_private *tp)
@@ -3439,21 +3477,19 @@ static void rtl8105e_hw_phy_config(struct rtl8169_private *tp)
         };
 
         /* Disable ALDPS before ram code */
-        rtl_writephy(tp, 0x1f, 0x0000);
-        rtl_writephy(tp, 0x18, 0x0310);
-        msleep(100);
+        r810x_aldps_disable(tp);
 
         rtl_apply_firmware(tp);
 
         rtl_writephy_batch(tp, phy_reg_init, ARRAY_SIZE(phy_reg_init));
+
+        r810x_aldps_enable(tp);
 }
 
 static void rtl8402_hw_phy_config(struct rtl8169_private *tp)
 {
         /* Disable ALDPS before setting firmware */
-        rtl_writephy(tp, 0x1f, 0x0000);
-        rtl_writephy(tp, 0x18, 0x0310);
-        msleep(20);
+        r810x_aldps_disable(tp);
 
         rtl_apply_firmware(tp);
 
@@ -3463,6 +3499,8 @@ static void rtl8402_hw_phy_config(struct rtl8169_private *tp)
         rtl_writephy(tp, 0x10, 0x401f);
         rtl_writephy(tp, 0x19, 0x7030);
         rtl_writephy(tp, 0x1f, 0x0000);
+
+        r810x_aldps_enable(tp);
 }
 
 static void rtl8106e_hw_phy_config(struct rtl8169_private *tp)
@@ -3475,9 +3513,7 @@ static void rtl8106e_hw_phy_config(struct rtl8169_private *tp)
         };
 
         /* Disable ALDPS before ram code */
-        rtl_writephy(tp, 0x1f, 0x0000);
-        rtl_writephy(tp, 0x18, 0x0310);
-        msleep(100);
+        r810x_aldps_disable(tp);
 
         rtl_apply_firmware(tp);
 
@@ -3485,6 +3521,8 @@ static void rtl8106e_hw_phy_config(struct rtl8169_private *tp)
         rtl_writephy_batch(tp, phy_reg_init, ARRAY_SIZE(phy_reg_init));
 
         rtl_eri_write(tp, 0x1d0, ERIAR_MASK_0011, 0x0000, ERIAR_EXGMAC);
+
+        r810x_aldps_enable(tp);
 }
 
 static void rtl_hw_phy_config(struct net_device *dev)
@@ -5015,8 +5053,6 @@ static void rtl_hw_start_8168e_2(struct rtl8169_private *tp)
 
         RTL_W8(MaxTxPacketSize, EarlySize);
 
-        rtl_disable_clock_request(pdev);
-
         RTL_W32(TxConfig, RTL_R32(TxConfig) | TXCFG_AUTO_FIFO);
         RTL_W8(MCU, RTL_R8(MCU) & ~NOW_IS_OOB);
 
@@ -5025,7 +5061,8 @@ static void rtl_hw_start_8168e_2(struct rtl8169_private *tp)
 
         RTL_W8(DLLPR, RTL_R8(DLLPR) | PFM_EN);
         RTL_W32(MISC, RTL_R32(MISC) | PWM_EN);
-        RTL_W8(Config5, RTL_R8(Config5) & ~Spi_en);
+        RTL_W8(Config5, (RTL_R8(Config5) & ~Spi_en) | ASPM_en);
+        RTL_W8(Config2, RTL_R8(Config2) | ClkReqEn);
 }
 
 static void rtl_hw_start_8168f(struct rtl8169_private *tp)
@@ -5050,13 +5087,12 @@ static void rtl_hw_start_8168f(struct rtl8169_private *tp)
 
         RTL_W8(MaxTxPacketSize, EarlySize);
 
-        rtl_disable_clock_request(pdev);
-
         RTL_W32(TxConfig, RTL_R32(TxConfig) | TXCFG_AUTO_FIFO);
         RTL_W8(MCU, RTL_R8(MCU) & ~NOW_IS_OOB);
         RTL_W8(DLLPR, RTL_R8(DLLPR) | PFM_EN);
-        RTL_W32(MISC, RTL_R32(MISC) | PWM_EN);
-        RTL_W8(Config5, RTL_R8(Config5) & ~Spi_en);
+        RTL_W32(MISC, RTL_R32(MISC) | PWM_EN | FORCE_CLK);
+        RTL_W8(Config5, (RTL_R8(Config5) & ~Spi_en) | ASPM_en);
+        RTL_W8(Config2, RTL_R8(Config2) | ClkReqEn);
 }
 
 static void rtl_hw_start_8168f_1(struct rtl8169_private *tp)
@@ -5113,8 +5149,10 @@ static void rtl_hw_start_8168g_1(struct rtl8169_private *tp)
         rtl_w1w0_eri(tp, 0xdc, ERIAR_MASK_0001, 0x01, 0x00, ERIAR_EXGMAC);
 
         RTL_W8(ChipCmd, CmdTxEnb | CmdRxEnb);
-        RTL_W32(MISC, RTL_R32(MISC) & ~RXDV_GATED_EN);
+        RTL_W32(MISC, (RTL_R32(MISC) | FORCE_CLK) & ~RXDV_GATED_EN);
         RTL_W8(MaxTxPacketSize, EarlySize);
+        RTL_W8(Config5, RTL_R8(Config5) | ASPM_en);
+        RTL_W8(Config2, RTL_R8(Config2) | ClkReqEn);
 
         rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000, ERIAR_EXGMAC);
         rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000, ERIAR_EXGMAC);
@@ -5330,6 +5368,9 @@ static void rtl_hw_start_8105e_1(struct rtl8169_private *tp)
 
         RTL_W8(MCU, RTL_R8(MCU) | EN_NDP | EN_OOB_RESET);
         RTL_W8(DLLPR, RTL_R8(DLLPR) | PFM_EN);
+        RTL_W8(Config5, RTL_R8(Config5) | ASPM_en);
+        RTL_W8(Config2, RTL_R8(Config2) | ClkReqEn);
+        RTL_W32(MISC, RTL_R32(MISC) | FORCE_CLK);
 
         rtl_ephy_init(tp, e_info_8105e_1, ARRAY_SIZE(e_info_8105e_1));
 }
@@ -5355,6 +5396,9 @@ static void rtl_hw_start_8402(struct rtl8169_private *tp)
 
         RTL_W32(TxConfig, RTL_R32(TxConfig) | TXCFG_AUTO_FIFO);
         RTL_W8(MCU, RTL_R8(MCU) & ~NOW_IS_OOB);
+        RTL_W8(Config5, RTL_R8(Config5) | ASPM_en);
+        RTL_W8(Config2, RTL_R8(Config2) | ClkReqEn);
+        RTL_W32(MISC, RTL_R32(MISC) | FORCE_CLK);
 
         rtl_ephy_init(tp, e_info_8402, ARRAY_SIZE(e_info_8402));
 
@@ -5376,7 +5420,10 @@ static void rtl_hw_start_8106(struct rtl8169_private *tp)
         /* Force LAN exit from ASPM if Rx/Tx are not idle */
         RTL_W32(FuncEvent, RTL_R32(FuncEvent) | 0x002800);
 
-        RTL_W32(MISC, (RTL_R32(MISC) | DISABLE_LAN_EN) & ~EARLY_TALLY_EN);
+        RTL_W32(MISC,
+                (RTL_R32(MISC) | DISABLE_LAN_EN | FORCE_CLK) & ~EARLY_TALLY_EN);
+        RTL_W8(Config5, RTL_R8(Config5) | ASPM_en);
+        RTL_W8(Config2, RTL_R8(Config2) | ClkReqEn);
         RTL_W8(MCU, RTL_R8(MCU) | EN_NDP | EN_OOB_RESET);
         RTL_W8(DLLPR, RTL_R8(DLLPR) & ~PFM_EN);
 }
@@ -6992,15 +7039,4 @@ static struct pci_driver rtl8169_pci_driver = {
         .driver.pm      = RTL8169_PM_OPS,
 };
 
-static int __init rtl8169_init_module(void)
-{
-        return pci_register_driver(&rtl8169_pci_driver);
-}
-
-static void __exit rtl8169_cleanup_module(void)
-{
-        pci_unregister_driver(&rtl8169_pci_driver);
-}
-
-module_init(rtl8169_init_module);
-module_exit(rtl8169_cleanup_module);
+module_pci_driver(rtl8169_pci_driver);
diff --git a/drivers/net/ethernet/renesas/sh_eth.c b/drivers/net/ethernet/renesas/sh_eth.c
index c8bfea0524dd..3d705862bd7d 100644
--- a/drivers/net/ethernet/renesas/sh_eth.c
+++ b/drivers/net/ethernet/renesas/sh_eth.c
@@ -2286,7 +2286,7 @@ static int sh_mdio_init(struct net_device *ndev, int id,
         for (i = 0; i < PHY_MAX_ADDR; i++)
                 mdp->mii_bus->irq[i] = PHY_POLL;
 
-        /* regist mdio bus */
+        /* register mdio bus */
         ret = mdiobus_register(mdp->mii_bus);
         if (ret)
                 goto out_free_irq;
diff --git a/drivers/net/ethernet/sfc/Kconfig b/drivers/net/ethernet/sfc/Kconfig
index 25906c1d1b15..3ab2c4289a47 100644
--- a/drivers/net/ethernet/sfc/Kconfig
+++ b/drivers/net/ethernet/sfc/Kconfig
@@ -5,6 +5,7 @@ config SFC
         select CRC32
         select I2C
         select I2C_ALGOBIT
+        select PTP_1588_CLOCK
         ---help---
           This driver supports 10-gigabit Ethernet cards based on
           the Solarflare SFC4000 and SFC9000-family controllers.
@@ -34,10 +35,3 @@ config SFC_SRIOV
           This enables support for the SFC9000 I/O Virtualization
           features, allowing accelerated network performance in
           virtualized environments.
-config SFC_PTP
-        bool "Solarflare SFC9000-family PTP support"
-        depends on SFC && PTP_1588_CLOCK && !(SFC=y && PTP_1588_CLOCK=m)
-        default y
-        ---help---
-          This enables support for the Precision Time Protocol (PTP)
-          on SFC9000-family NICs
diff --git a/drivers/net/ethernet/sfc/Makefile b/drivers/net/ethernet/sfc/Makefile
index e11f2ecf69d9..945bf06e69ef 100644
--- a/drivers/net/ethernet/sfc/Makefile
+++ b/drivers/net/ethernet/sfc/Makefile
@@ -2,9 +2,8 @@ sfc-y			+= efx.o nic.o falcon.o siena.o tx.o rx.o filter.o \
                            falcon_xmac.o mcdi_mac.o \
                            selftest.o ethtool.o qt202x_phy.o mdio_10g.o \
                            tenxpress.o txc43128_phy.o falcon_boards.o \
-                           mcdi.o mcdi_phy.o mcdi_mon.o
+                           mcdi.o mcdi_phy.o mcdi_mon.o ptp.o
 sfc-$(CONFIG_SFC_MTD)   += mtd.o
 sfc-$(CONFIG_SFC_SRIOV) += siena_sriov.o
-sfc-$(CONFIG_SFC_PTP)   += ptp.o
 
 obj-$(CONFIG_SFC)       += sfc.o
diff --git a/drivers/net/ethernet/sfc/net_driver.h b/drivers/net/ethernet/sfc/net_driver.h
index 576a31091165..2487f582ab04 100644
--- a/drivers/net/ethernet/sfc/net_driver.h
+++ b/drivers/net/ethernet/sfc/net_driver.h
@@ -868,9 +868,7 @@ struct efx_nic {
         struct work_struct peer_work;
 #endif
 
-#ifdef CONFIG_SFC_PTP
         struct efx_ptp_data *ptp_data;
-#endif
 
         /* The following fields may be written more often */
 
diff --git a/drivers/net/ethernet/sfc/nic.h b/drivers/net/ethernet/sfc/nic.h
index 438cef11f727..7a9647a3c565 100644
--- a/drivers/net/ethernet/sfc/nic.h
+++ b/drivers/net/ethernet/sfc/nic.h
@@ -252,7 +252,6 @@ extern int efx_sriov_set_vf_spoofchk(struct net_device *net_dev, int vf,
                                      bool spoofchk);
 
 struct ethtool_ts_info;
-#ifdef CONFIG_SFC_PTP
 extern void efx_ptp_probe(struct efx_nic *efx);
 extern int efx_ptp_ioctl(struct efx_nic *efx, struct ifreq *ifr, int cmd);
 extern int efx_ptp_get_ts_info(struct net_device *net_dev,
@@ -260,31 +259,6 @@ extern int efx_ptp_get_ts_info(struct net_device *net_dev,
 extern bool efx_ptp_is_ptp_tx(struct efx_nic *efx, struct sk_buff *skb);
 extern int efx_ptp_tx(struct efx_nic *efx, struct sk_buff *skb);
 extern void efx_ptp_event(struct efx_nic *efx, efx_qword_t *ev);
-#else
-static inline void efx_ptp_probe(struct efx_nic *efx) {}
-static inline int efx_ptp_ioctl(struct efx_nic *efx, struct ifreq *ifr, int cmd)
-{
-        return -EOPNOTSUPP;
-}
-static inline int efx_ptp_get_ts_info(struct net_device *net_dev,
-                                      struct ethtool_ts_info *ts_info)
-{
-        ts_info->so_timestamping = (SOF_TIMESTAMPING_SOFTWARE |
-                                    SOF_TIMESTAMPING_RX_SOFTWARE);
-        ts_info->phc_index = -1;
-
-        return 0;
-}
-static inline bool efx_ptp_is_ptp_tx(struct efx_nic *efx, struct sk_buff *skb)
-{
-        return false;
-}
-static inline int efx_ptp_tx(struct efx_nic *efx, struct sk_buff *skb)
-{
-        return NETDEV_TX_OK;
-}
-static inline void efx_ptp_event(struct efx_nic *efx, efx_qword_t *ev) {}
-#endif
 
 extern const struct efx_nic_type falcon_a1_nic_type;
 extern const struct efx_nic_type falcon_b0_nic_type;
diff --git a/drivers/net/ethernet/ti/Kconfig b/drivers/net/ethernet/ti/Kconfig
index 2c41894d5472..48fcb5e3bd3d 100644
--- a/drivers/net/ethernet/ti/Kconfig
+++ b/drivers/net/ethernet/ti/Kconfig
@@ -60,6 +60,14 @@ config TI_CPSW
           To compile this driver as a module, choose M here: the module
           will be called cpsw.
 
+config TI_CPTS
+        boolean "TI Common Platform Time Sync (CPTS) Support"
+        select PTP_1588_CLOCK
+        ---help---
+          This driver supports the Common Platform Time Sync unit of
+          the CPSW Ethernet Switch. The unit can time stamp PTP UDP/IPv4
+          and Layer 2 packets, and the driver offers a PTP Hardware Clock.
+
 config TLAN
         tristate "TI ThunderLAN support"
         depends on (PCI || EISA)
diff --git a/drivers/net/ethernet/ti/Makefile b/drivers/net/ethernet/ti/Makefile
index 91bd8bba78ff..c65148e8aa1d 100644
--- a/drivers/net/ethernet/ti/Makefile
+++ b/drivers/net/ethernet/ti/Makefile
@@ -8,4 +8,4 @@ obj-$(CONFIG_TI_DAVINCI_EMAC) += davinci_emac.o
 obj-$(CONFIG_TI_DAVINCI_MDIO) += davinci_mdio.o
 obj-$(CONFIG_TI_DAVINCI_CPDMA) += davinci_cpdma.o
 obj-$(CONFIG_TI_CPSW) += ti_cpsw.o
-ti_cpsw-y := cpsw_ale.o cpsw.o
+ti_cpsw-y := cpsw_ale.o cpsw.o cpts.o
diff --git a/drivers/net/ethernet/ti/cpsw.c b/drivers/net/ethernet/ti/cpsw.c
index df55e2403746..7654a62ab75e 100644
--- a/drivers/net/ethernet/ti/cpsw.c
+++ b/drivers/net/ethernet/ti/cpsw.c
@@ -24,6 +24,7 @@
 #include <linux/if_ether.h>
 #include <linux/etherdevice.h>
 #include <linux/netdevice.h>
+#include <linux/net_tstamp.h>
 #include <linux/phy.h>
 #include <linux/workqueue.h>
 #include <linux/delay.h>
@@ -35,6 +36,7 @@
 #include <linux/platform_data/cpsw.h>
 
 #include "cpsw_ale.h"
+#include "cpts.h"
 #include "davinci_cpdma.h"
 
 #define CPSW_DEBUG      (NETIF_MSG_HW           | NETIF_MSG_WOL         | \
@@ -70,10 +72,14 @@ do {								\
                 dev_notice(priv->dev, format, ## __VA_ARGS__);  \
 } while (0)
 
+#define ALE_ALL_PORTS           0x7
+
 #define CPSW_MAJOR_VERSION(reg)         (reg >> 8 & 0x7)
 #define CPSW_MINOR_VERSION(reg)         (reg & 0xff)
 #define CPSW_RTL_VERSION(reg)           ((reg >> 11) & 0x1f)
 
+#define CPSW_VERSION_1          0x19010a
+#define CPSW_VERSION_2          0x19010c
 #define CPDMA_RXTHRESH          0x0c0
 #define CPDMA_RXFREE            0x0e0
 #define CPDMA_TXHDP             0x00
@@ -129,7 +135,7 @@ static int rx_packet_max = CPSW_MAX_PACKET_SIZE;
 module_param(rx_packet_max, int, 0);
 MODULE_PARM_DESC(rx_packet_max, "maximum receive packet size (bytes)");
 
-struct cpsw_ss_regs {
+struct cpsw_wr_regs {
         u32     id_ver;
         u32     soft_reset;
         u32     control;
@@ -140,26 +146,98 @@ struct cpsw_ss_regs {
         u32     misc_en;
 };
 
-struct cpsw_regs {
+struct cpsw_ss_regs {
         u32     id_ver;
         u32     control;
         u32     soft_reset;
         u32     stat_port_en;
         u32     ptype;
+        u32     soft_idle;
+        u32     thru_rate;
+        u32     gap_thresh;
+        u32     tx_start_wds;
+        u32     flow_control;
+        u32     vlan_ltype;
+        u32     ts_ltype;
+        u32     dlr_ltype;
 };
 
-struct cpsw_slave_regs {
-        u32     max_blks;
-        u32     blk_cnt;
-        u32     flow_thresh;
-        u32     port_vlan;
-        u32     tx_pri_map;
-        u32     ts_ctl;
-        u32     ts_seq_ltype;
-        u32     ts_vlan;
-        u32     sa_lo;
-        u32     sa_hi;
-};
+/* CPSW_PORT_V1 */
+#define CPSW1_MAX_BLKS      0x00 /* Maximum FIFO Blocks */
+#define CPSW1_BLK_CNT       0x04 /* FIFO Block Usage Count (Read Only) */
+#define CPSW1_TX_IN_CTL     0x08 /* Transmit FIFO Control */
+#define CPSW1_PORT_VLAN     0x0c /* VLAN Register */
+#define CPSW1_TX_PRI_MAP    0x10 /* Tx Header Priority to Switch Pri Mapping */
+#define CPSW1_TS_CTL        0x14 /* Time Sync Control */
+#define CPSW1_TS_SEQ_LTYPE  0x18 /* Time Sync Sequence ID Offset and Msg Type */
+#define CPSW1_TS_VLAN       0x1c /* Time Sync VLAN1 and VLAN2 */
+
+/* CPSW_PORT_V2 */
+#define CPSW2_CONTROL       0x00 /* Control Register */
+#define CPSW2_MAX_BLKS      0x08 /* Maximum FIFO Blocks */
+#define CPSW2_BLK_CNT       0x0c /* FIFO Block Usage Count (Read Only) */
+#define CPSW2_TX_IN_CTL     0x10 /* Transmit FIFO Control */
+#define CPSW2_PORT_VLAN     0x14 /* VLAN Register */
+#define CPSW2_TX_PRI_MAP    0x18 /* Tx Header Priority to Switch Pri Mapping */
+#define CPSW2_TS_SEQ_MTYPE  0x1c /* Time Sync Sequence ID Offset and Msg Type */
+
+/* CPSW_PORT_V1 and V2 */
+#define SA_LO               0x20 /* CPGMAC_SL Source Address Low */
+#define SA_HI               0x24 /* CPGMAC_SL Source Address High */
+#define SEND_PERCENT        0x28 /* Transmit Queue Send Percentages */
+
+/* CPSW_PORT_V2 only */
+#define RX_DSCP_PRI_MAP0    0x30 /* Rx DSCP Priority to Rx Packet Mapping */
+#define RX_DSCP_PRI_MAP1    0x34 /* Rx DSCP Priority to Rx Packet Mapping */
+#define RX_DSCP_PRI_MAP2    0x38 /* Rx DSCP Priority to Rx Packet Mapping */
+#define RX_DSCP_PRI_MAP3    0x3c /* Rx DSCP Priority to Rx Packet Mapping */
+#define RX_DSCP_PRI_MAP4    0x40 /* Rx DSCP Priority to Rx Packet Mapping */
+#define RX_DSCP_PRI_MAP5    0x44 /* Rx DSCP Priority to Rx Packet Mapping */
+#define RX_DSCP_PRI_MAP6    0x48 /* Rx DSCP Priority to Rx Packet Mapping */
+#define RX_DSCP_PRI_MAP7    0x4c /* Rx DSCP Priority to Rx Packet Mapping */
+
+/* Bit definitions for the CPSW2_CONTROL register */
+#define PASS_PRI_TAGGED     (1<<24) /* Pass Priority Tagged */
+#define VLAN_LTYPE2_EN      (1<<21) /* VLAN LTYPE 2 enable */
+#define VLAN_LTYPE1_EN      (1<<20) /* VLAN LTYPE 1 enable */
+#define DSCP_PRI_EN         (1<<16) /* DSCP Priority Enable */
+#define TS_320              (1<<14) /* Time Sync Dest Port 320 enable */
+#define TS_319              (1<<13) /* Time Sync Dest Port 319 enable */
+#define TS_132              (1<<12) /* Time Sync Dest IP Addr 132 enable */
+#define TS_131              (1<<11) /* Time Sync Dest IP Addr 131 enable */
+#define TS_130              (1<<10) /* Time Sync Dest IP Addr 130 enable */
+#define TS_129              (1<<9)  /* Time Sync Dest IP Addr 129 enable */
+#define TS_BIT8             (1<<8)  /* ts_ttl_nonzero? */
+#define TS_ANNEX_D_EN       (1<<4)  /* Time Sync Annex D enable */
+#define TS_LTYPE2_EN        (1<<3)  /* Time Sync LTYPE 2 enable */
+#define TS_LTYPE1_EN        (1<<2)  /* Time Sync LTYPE 1 enable */
+#define TS_TX_EN            (1<<1)  /* Time Sync Transmit Enable */
+#define TS_RX_EN            (1<<0)  /* Time Sync Receive Enable */
+
+#define CTRL_TS_BITS \
+        (TS_320 | TS_319 | TS_132 | TS_131 | TS_130 | TS_129 | TS_BIT8 | \
+         TS_ANNEX_D_EN | TS_LTYPE1_EN)
+
+#define CTRL_ALL_TS_MASK (CTRL_TS_BITS | TS_TX_EN | TS_RX_EN)
+#define CTRL_TX_TS_BITS  (CTRL_TS_BITS | TS_TX_EN)
+#define CTRL_RX_TS_BITS  (CTRL_TS_BITS | TS_RX_EN)
+
+/* Bit definitions for the CPSW2_TS_SEQ_MTYPE register */
+#define TS_SEQ_ID_OFFSET_SHIFT   (16)    /* Time Sync Sequence ID Offset */
+#define TS_SEQ_ID_OFFSET_MASK    (0x3f)
+#define TS_MSG_TYPE_EN_SHIFT     (0)     /* Time Sync Message Type Enable */
+#define TS_MSG_TYPE_EN_MASK      (0xffff)
+
+/* The PTP event messages - Sync, Delay_Req, Pdelay_Req, and Pdelay_Resp. */
+#define EVENT_MSG_BITS ((1<<0) | (1<<1) | (1<<2) | (1<<3))
+
+/* Bit definitions for the CPSW1_TS_CTL register */
+#define CPSW_V1_TS_RX_EN                BIT(0)
+#define CPSW_V1_TS_TX_EN                BIT(4)
+#define CPSW_V1_MSG_TYPE_OFS            16
+
+/* Bit definitions for the CPSW1_TS_SEQ_LTYPE register */
+#define CPSW_V1_SEQ_ID_OFS_SHIFT        16
 
 struct cpsw_host_regs {
         u32     max_blks;
@@ -185,7 +263,7 @@ struct cpsw_sliver_regs {
 };
 
 struct cpsw_slave {
-        struct cpsw_slave_regs __iomem  *regs;
+        void __iomem                    *regs;
         struct cpsw_sliver_regs __iomem *sliver;
         int                             slave_num;
         u32                             mac_control;
@@ -193,19 +271,30 @@ struct cpsw_slave {
         struct phy_device               *phy;
 };
 
+static inline u32 slave_read(struct cpsw_slave *slave, u32 offset)
+{
+        return __raw_readl(slave->regs + offset);
+}
+
+static inline void slave_write(struct cpsw_slave *slave, u32 val, u32 offset)
+{
+        __raw_writel(val, slave->regs + offset);
+}
+
 struct cpsw_priv {
         spinlock_t                      lock;
         struct platform_device          *pdev;
         struct net_device               *ndev;
         struct resource                 *cpsw_res;
-        struct resource                 *cpsw_ss_res;
+        struct resource                 *cpsw_wr_res;
         struct napi_struct              napi;
         struct device                   *dev;
         struct cpsw_platform_data       data;
-        struct cpsw_regs __iomem        *regs;
-        struct cpsw_ss_regs __iomem     *ss_regs;
+        struct cpsw_ss_regs __iomem     *regs;
+        struct cpsw_wr_regs __iomem     *wr_regs;
         struct cpsw_host_regs __iomem   *host_port_regs;
         u32                             msg_enable;
+        u32                             version;
         struct net_device_stats         stats;
         int                             rx_packet_max;
         int                             host_port;
@@ -218,6 +307,7 @@ struct cpsw_priv {
         /* snapshot of IRQ numbers */
         u32 irqs_table[4];
         u32 num_irqs;
+        struct cpts cpts;
 };
 
 #define napi_to_priv(napi)      container_of(napi, struct cpsw_priv, napi)
@@ -228,10 +318,34 @@ struct cpsw_priv {
                         (func)((priv)->slaves + idx, ##arg);    \
         } while (0)
 
+static void cpsw_ndo_set_rx_mode(struct net_device *ndev)
+{
+        struct cpsw_priv *priv = netdev_priv(ndev);
+
+        if (ndev->flags & IFF_PROMISC) {
+                /* Enable promiscuous mode */
+                dev_err(priv->dev, "Ignoring Promiscuous mode\n");
+                return;
+        }
+
+        /* Clear all mcast from ALE */
+        cpsw_ale_flush_multicast(priv->ale, ALE_ALL_PORTS << priv->host_port);
+
+        if (!netdev_mc_empty(ndev)) {
+                struct netdev_hw_addr *ha;
+
+                /* program multicast address list into ALE register */
+                netdev_for_each_mc_addr(ha, ndev) {
+                        cpsw_ale_add_mcast(priv->ale, (u8 *)ha->addr,
+                                ALE_ALL_PORTS << priv->host_port, 0, 0);
+                }
+        }
+}
+
 static void cpsw_intr_enable(struct cpsw_priv *priv)
 {
-        __raw_writel(0xFF, &priv->ss_regs->tx_en);
-        __raw_writel(0xFF, &priv->ss_regs->rx_en);
+        __raw_writel(0xFF, &priv->wr_regs->tx_en);
+        __raw_writel(0xFF, &priv->wr_regs->rx_en);
 
         cpdma_ctlr_int_ctrl(priv->dma, true);
         return;
@@ -239,8 +353,8 @@ static void cpsw_intr_enable(struct cpsw_priv *priv)
 
 static void cpsw_intr_disable(struct cpsw_priv *priv)
 {
-        __raw_writel(0, &priv->ss_regs->tx_en);
-        __raw_writel(0, &priv->ss_regs->rx_en);
+        __raw_writel(0, &priv->wr_regs->tx_en);
+        __raw_writel(0, &priv->wr_regs->rx_en);
 
         cpdma_ctlr_int_ctrl(priv->dma, false);
         return;
@@ -254,6 +368,7 @@ void cpsw_tx_handler(void *token, int len, int status)
 
         if (unlikely(netif_queue_stopped(ndev)))
                 netif_start_queue(ndev);
+        cpts_tx_timestamp(&priv->cpts, skb);
         priv->stats.tx_packets++;
         priv->stats.tx_bytes += len;
         dev_kfree_skb_any(skb);
@@ -274,6 +389,7 @@ void cpsw_rx_handler(void *token, int len, int status)
         }
         if (likely(status >= 0)) {
                 skb_put(skb, len);
+                cpts_rx_timestamp(&priv->cpts, skb);
                 skb->protocol = eth_type_trans(skb, ndev);
                 netif_receive_skb(skb);
                 priv->stats.rx_bytes += len;
@@ -359,8 +475,8 @@ static inline void soft_reset(const char *module, void __iomem *reg)
 static void cpsw_set_slave_mac(struct cpsw_slave *slave,
                                struct cpsw_priv *priv)
 {
-        __raw_writel(mac_hi(priv->mac_addr), &slave->regs->sa_hi);
-        __raw_writel(mac_lo(priv->mac_addr), &slave->regs->sa_lo);
+        slave_write(slave, mac_hi(priv->mac_addr), SA_HI);
+        slave_write(slave, mac_lo(priv->mac_addr), SA_LO);
 }
 
 static void _cpsw_adjust_link(struct cpsw_slave *slave,
@@ -446,7 +562,15 @@ static void cpsw_slave_open(struct cpsw_slave *slave, struct cpsw_priv *priv)
 
         /* setup priority mapping */
         __raw_writel(RX_PRIORITY_MAPPING, &slave->sliver->rx_pri_map);
-        __raw_writel(TX_PRIORITY_MAPPING, &slave->regs->tx_pri_map);
+
+        switch (priv->version) {
+        case CPSW_VERSION_1:
+                slave_write(slave, TX_PRIORITY_MAPPING, CPSW1_TX_PRI_MAP);
+                break;
+        case CPSW_VERSION_2:
+                slave_write(slave, TX_PRIORITY_MAPPING, CPSW2_TX_PRI_MAP);
+                break;
+        }
 
         /* setup max packet size, and mac address */
         __raw_writel(priv->rx_packet_max, &slave->sliver->rx_maxlen);
@@ -506,6 +630,7 @@ static int cpsw_ndo_open(struct net_device *ndev)
         pm_runtime_get_sync(&priv->pdev->dev);
 
         reg = __raw_readl(&priv->regs->id_ver);
+        priv->version = reg;
 
         dev_info(priv->dev, "initializing cpsw version %d.%d (%d)\n",
                  CPSW_MAJOR_VERSION(reg), CPSW_MINOR_VERSION(reg),
@@ -592,6 +717,11 @@ static netdev_tx_t cpsw_ndo_start_xmit(struct sk_buff *skb,
                 return NETDEV_TX_OK;
         }
 
+        if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP && priv->cpts.tx_enable)
+                skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
+
+        skb_tx_timestamp(skb);
+
         ret = cpdma_chan_submit(priv->txch, skb, skb->data,
                                 skb->len, GFP_KERNEL);
         if (unlikely(ret != 0)) {
@@ -629,6 +759,130 @@ static void cpsw_ndo_change_rx_flags(struct net_device *ndev, int flags)
                 dev_err(&ndev->dev, "multicast traffic cannot be filtered!\n");
 }
 
+#ifdef CONFIG_TI_CPTS
+
+static void cpsw_hwtstamp_v1(struct cpsw_priv *priv)
+{
+        struct cpsw_slave *slave = &priv->slaves[priv->data.cpts_active_slave];
+        u32 ts_en, seq_id;
+
+        if (!priv->cpts.tx_enable && !priv->cpts.rx_enable) {
+                slave_write(slave, 0, CPSW1_TS_CTL);
+                return;
+        }
+
+        seq_id = (30 << CPSW_V1_SEQ_ID_OFS_SHIFT) | ETH_P_1588;
+        ts_en = EVENT_MSG_BITS << CPSW_V1_MSG_TYPE_OFS;
+
+        if (priv->cpts.tx_enable)
+                ts_en |= CPSW_V1_TS_TX_EN;
+
+        if (priv->cpts.rx_enable)
+                ts_en |= CPSW_V1_TS_RX_EN;
+
+        slave_write(slave, ts_en, CPSW1_TS_CTL);
+        slave_write(slave, seq_id, CPSW1_TS_SEQ_LTYPE);
+}
+
+static void cpsw_hwtstamp_v2(struct cpsw_priv *priv)
+{
+        struct cpsw_slave *slave = &priv->slaves[priv->data.cpts_active_slave];
+        u32 ctrl, mtype;
+
+        ctrl = slave_read(slave, CPSW2_CONTROL);
+        ctrl &= ~CTRL_ALL_TS_MASK;
+
+        if (priv->cpts.tx_enable)
+                ctrl |= CTRL_TX_TS_BITS;
+
+        if (priv->cpts.rx_enable)
+                ctrl |= CTRL_RX_TS_BITS;
+
+        mtype = (30 << TS_SEQ_ID_OFFSET_SHIFT) | EVENT_MSG_BITS;
+
+        slave_write(slave, mtype, CPSW2_TS_SEQ_MTYPE);
+        slave_write(slave, ctrl, CPSW2_CONTROL);
+        __raw_writel(ETH_P_1588, &priv->regs->ts_ltype);
+}
+
+static int cpsw_hwtstamp_ioctl(struct cpsw_priv *priv, struct ifreq *ifr)
+{
+        struct cpts *cpts = &priv->cpts;
+        struct hwtstamp_config cfg;
+
+        if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg)))
+                return -EFAULT;
+
+        /* reserved for future extensions */
+        if (cfg.flags)
+                return -EINVAL;
+
+        switch (cfg.tx_type) {
+        case HWTSTAMP_TX_OFF:
+                cpts->tx_enable = 0;
+                break;
+        case HWTSTAMP_TX_ON:
+                cpts->tx_enable = 1;
+                break;
+        default:
+                return -ERANGE;
+        }
+
+        switch (cfg.rx_filter) {
+        case HWTSTAMP_FILTER_NONE:
+                cpts->rx_enable = 0;
+                break;
+        case HWTSTAMP_FILTER_ALL:
+        case HWTSTAMP_FILTER_PTP_V1_L4_EVENT:
+        case HWTSTAMP_FILTER_PTP_V1_L4_SYNC:
+        case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ:
+                return -ERANGE;
+        case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
+        case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
+        case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
+        case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
+        case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
+        case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
+        case HWTSTAMP_FILTER_PTP_V2_EVENT:
+        case HWTSTAMP_FILTER_PTP_V2_SYNC:
+        case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
+                cpts->rx_enable = 1;
+                cfg.rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT;
+                break;
+        default:
+                return -ERANGE;
+        }
+
+        switch (priv->version) {
+        case CPSW_VERSION_1:
+                cpsw_hwtstamp_v1(priv);
+                break;
+        case CPSW_VERSION_2:
+                cpsw_hwtstamp_v2(priv);
+                break;
+        default:
+                return -ENOTSUPP;
+        }
+
+        return copy_to_user(ifr->ifr_data, &cfg, sizeof(cfg)) ? -EFAULT : 0;
+}
+
+#endif /*CONFIG_TI_CPTS*/
+
+static int cpsw_ndo_ioctl(struct net_device *dev, struct ifreq *req, int cmd)
+{
+        struct cpsw_priv *priv = netdev_priv(dev);
+
+        if (!netif_running(dev))
+                return -EINVAL;
+
+#ifdef CONFIG_TI_CPTS
+        if (cmd == SIOCSHWTSTAMP)
+                return cpsw_hwtstamp_ioctl(priv, req);
+#endif
+        return -ENOTSUPP;
+}
+
 static void cpsw_ndo_tx_timeout(struct net_device *ndev)
 {
         struct cpsw_priv *priv = netdev_priv(ndev);
@@ -669,10 +923,12 @@ static const struct net_device_ops cpsw_netdev_ops = {
         .ndo_stop               = cpsw_ndo_stop,
         .ndo_start_xmit         = cpsw_ndo_start_xmit,
         .ndo_change_rx_flags    = cpsw_ndo_change_rx_flags,
+        .ndo_do_ioctl           = cpsw_ndo_ioctl,
         .ndo_validate_addr      = eth_validate_addr,
         .ndo_change_mtu         = eth_change_mtu,
         .ndo_tx_timeout         = cpsw_ndo_tx_timeout,
         .ndo_get_stats          = cpsw_ndo_get_stats,
+        .ndo_set_rx_mode        = cpsw_ndo_set_rx_mode,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = cpsw_ndo_poll_controller,
 #endif
@@ -699,11 +955,44 @@ static void cpsw_set_msglevel(struct net_device *ndev, u32 value)
         priv->msg_enable = value;
 }
 
+static int cpsw_get_ts_info(struct net_device *ndev,
+                            struct ethtool_ts_info *info)
+{
+#ifdef CONFIG_TI_CPTS
+        struct cpsw_priv *priv = netdev_priv(ndev);
+
+        info->so_timestamping =
+                SOF_TIMESTAMPING_TX_HARDWARE |
+                SOF_TIMESTAMPING_TX_SOFTWARE |
+                SOF_TIMESTAMPING_RX_HARDWARE |
+                SOF_TIMESTAMPING_RX_SOFTWARE |
+                SOF_TIMESTAMPING_SOFTWARE |
+                SOF_TIMESTAMPING_RAW_HARDWARE;
+        info->phc_index = priv->cpts.phc_index;
+        info->tx_types =
+                (1 << HWTSTAMP_TX_OFF) |
+                (1 << HWTSTAMP_TX_ON);
+        info->rx_filters =
+                (1 << HWTSTAMP_FILTER_NONE) |
+                (1 << HWTSTAMP_FILTER_PTP_V2_EVENT);
+#else
+        info->so_timestamping =
+                SOF_TIMESTAMPING_TX_SOFTWARE |
+                SOF_TIMESTAMPING_RX_SOFTWARE |
+                SOF_TIMESTAMPING_SOFTWARE;
+        info->phc_index = -1;
+        info->tx_types = 0;
+        info->rx_filters = 0;
+#endif
+        return 0;
+}
+
 static const struct ethtool_ops cpsw_ethtool_ops = {
         .get_drvinfo    = cpsw_get_drvinfo,
         .get_msglevel   = cpsw_get_msglevel,
         .set_msglevel   = cpsw_set_msglevel,
         .get_link       = ethtool_op_get_link,
+        .get_ts_info    = cpsw_get_ts_info,
 };
 
 static void cpsw_slave_init(struct cpsw_slave *slave, struct cpsw_priv *priv)
@@ -734,6 +1023,27 @@ static int cpsw_probe_dt(struct cpsw_platform_data *data,
         }
         data->slaves = prop;
 
+        if (of_property_read_u32(node, "cpts_active_slave", &prop)) {
+                pr_err("Missing cpts_active_slave property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->cpts_active_slave = prop;
+
+        if (of_property_read_u32(node, "cpts_clock_mult", &prop)) {
+                pr_err("Missing cpts_clock_mult property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->cpts_clock_mult = prop;
+
+        if (of_property_read_u32(node, "cpts_clock_shift", &prop)) {
+                pr_err("Missing cpts_clock_shift property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->cpts_clock_shift = prop;
+
         data->slave_data = kzalloc(sizeof(struct cpsw_slave_data) *
                                    data->slaves, GFP_KERNEL);
         if (!data->slave_data) {
@@ -799,6 +1109,13 @@ static int cpsw_probe_dt(struct cpsw_platform_data *data,
         }
         data->hw_stats_reg_ofs = prop;
 
+        if (of_property_read_u32(node, "cpts_reg_ofs", &prop)) {
+                pr_err("Missing cpts_reg_ofs property in the DT.\n");
+                ret = -EINVAL;
+                goto error_ret;
+        }
+        data->cpts_reg_ofs = prop;
+
         if (of_property_read_u32(node, "bd_ram_ofs", &prop)) {
                 pr_err("Missing bd_ram_ofs property in the DT.\n");
                 ret = -EINVAL;
@@ -935,14 +1252,12 @@ static int __devinit cpsw_probe(struct platform_device *pdev)
                 ret = -ENOENT;
                 goto clean_clk_ret;
         }
-
         if (!request_mem_region(priv->cpsw_res->start,
                                 resource_size(priv->cpsw_res), ndev->name)) {
                 dev_err(priv->dev, "failed request i/o region\n");
                 ret = -ENXIO;
                 goto clean_clk_ret;
         }
-
         regs = ioremap(priv->cpsw_res->start, resource_size(priv->cpsw_res));
         if (!regs) {
                 dev_err(priv->dev, "unable to map i/o region\n");
@@ -951,28 +1266,27 @@ static int __devinit cpsw_probe(struct platform_device *pdev)
         priv->regs = regs;
         priv->host_port = data->host_port_num;
         priv->host_port_regs = regs + data->host_port_reg_ofs;
+        priv->cpts.reg = regs + data->cpts_reg_ofs;
 
-        priv->cpsw_ss_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-        if (!priv->cpsw_ss_res) {
+        priv->cpsw_wr_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (!priv->cpsw_wr_res) {
                 dev_err(priv->dev, "error getting i/o resource\n");
                 ret = -ENOENT;
-                goto clean_clk_ret;
+                goto clean_iomap_ret;
         }
-
-        if (!request_mem_region(priv->cpsw_ss_res->start,
-                        resource_size(priv->cpsw_ss_res), ndev->name)) {
+        if (!request_mem_region(priv->cpsw_wr_res->start,
+                        resource_size(priv->cpsw_wr_res), ndev->name)) {
                 dev_err(priv->dev, "failed request i/o region\n");
                 ret = -ENXIO;
-                goto clean_clk_ret;
+                goto clean_iomap_ret;
         }
-
-        regs = ioremap(priv->cpsw_ss_res->start,
-                                resource_size(priv->cpsw_ss_res));
+        regs = ioremap(priv->cpsw_wr_res->start,
+                                resource_size(priv->cpsw_wr_res));
         if (!regs) {
                 dev_err(priv->dev, "unable to map i/o region\n");
-                goto clean_cpsw_ss_iores_ret;
+                goto clean_cpsw_wr_iores_ret;
         }
-        priv->ss_regs = regs;
+        priv->wr_regs = regs;
 
         for_each_slave(priv, cpsw_slave_init, priv);
 
@@ -1008,7 +1322,7 @@ static int __devinit cpsw_probe(struct platform_device *pdev)
         if (!priv->dma) {
                 dev_err(priv->dev, "error initializing dma\n");
                 ret = -ENOMEM;
-                goto clean_iomap_ret;
+                goto clean_wr_iomap_ret;
         }
 
         priv->txch = cpdma_chan_create(priv->dma, tx_chan_num(0),
@@ -1072,6 +1386,10 @@ static int __devinit cpsw_probe(struct platform_device *pdev)
                 goto clean_irq_ret;
         }
 
+        if (cpts_register(&pdev->dev, &priv->cpts,
+                          data->cpts_clock_mult, data->cpts_clock_shift))
+                dev_err(priv->dev, "error registering cpts device\n");
+
         cpsw_notice(priv, probe, "initialized device (regs %x, irq %d)\n",
                   priv->cpsw_res->start, ndev->irq);
 
@@ -1085,11 +1403,13 @@ clean_dma_ret:
         cpdma_chan_destroy(priv->txch);
         cpdma_chan_destroy(priv->rxch);
         cpdma_ctlr_destroy(priv->dma);
+clean_wr_iomap_ret:
+        iounmap(priv->wr_regs);
+clean_cpsw_wr_iores_ret:
+        release_mem_region(priv->cpsw_wr_res->start,
+                           resource_size(priv->cpsw_wr_res));
 clean_iomap_ret:
         iounmap(priv->regs);
-clean_cpsw_ss_iores_ret:
-        release_mem_region(priv->cpsw_ss_res->start,
-                           resource_size(priv->cpsw_ss_res));
 clean_cpsw_iores_ret:
         release_mem_region(priv->cpsw_res->start,
                            resource_size(priv->cpsw_res));
@@ -1111,6 +1431,7 @@ static int __devexit cpsw_remove(struct platform_device *pdev)
         pr_info("removing device");
         platform_set_drvdata(pdev, NULL);
 
+        cpts_unregister(&priv->cpts);
         free_irq(ndev->irq, priv);
         cpsw_ale_destroy(priv->ale);
         cpdma_chan_destroy(priv->txch);
@@ -1119,8 +1440,9 @@ static int __devexit cpsw_remove(struct platform_device *pdev)
         iounmap(priv->regs);
         release_mem_region(priv->cpsw_res->start,
                            resource_size(priv->cpsw_res));
-        release_mem_region(priv->cpsw_ss_res->start,
-                           resource_size(priv->cpsw_ss_res));
+        iounmap(priv->wr_regs);
+        release_mem_region(priv->cpsw_wr_res->start,
+                           resource_size(priv->cpsw_wr_res));
         pm_runtime_disable(&pdev->dev);
         clk_put(priv->clk);
         kfree(priv->slaves);
diff --git a/drivers/net/ethernet/ti/cpsw_ale.c b/drivers/net/ethernet/ti/cpsw_ale.c
index ca0d48a7e508..0e9ccc2cf91f 100644
--- a/drivers/net/ethernet/ti/cpsw_ale.c
+++ b/drivers/net/ethernet/ti/cpsw_ale.c
@@ -20,6 +20,7 @@
 #include <linux/io.h>
 #include <linux/stat.h>
 #include <linux/sysfs.h>
+#include <linux/etherdevice.h>
 
 #include "cpsw_ale.h"
 
@@ -211,10 +212,34 @@ static void cpsw_ale_flush_mcast(struct cpsw_ale *ale, u32 *ale_entry,
         mask &= ~port_mask;
 
         /* free if only remaining port is host port */
-        if (mask == BIT(ale->params.ale_ports))
-                cpsw_ale_set_entry_type(ale_entry, ALE_TYPE_FREE);
-        else
+        if (mask)
                 cpsw_ale_set_port_mask(ale_entry, mask);
+        else
+                cpsw_ale_set_entry_type(ale_entry, ALE_TYPE_FREE);
+}
+
+int cpsw_ale_flush_multicast(struct cpsw_ale *ale, int port_mask)
+{
+        u32 ale_entry[ALE_ENTRY_WORDS];
+        int ret, idx;
+
+        for (idx = 0; idx < ale->params.ale_entries; idx++) {
+                cpsw_ale_read(ale, idx, ale_entry);
+                ret = cpsw_ale_get_entry_type(ale_entry);
+                if (ret != ALE_TYPE_ADDR && ret != ALE_TYPE_VLAN_ADDR)
+                        continue;
+
+                if (cpsw_ale_get_mcast(ale_entry)) {
+                        u8 addr[6];
+
+                        cpsw_ale_get_addr(ale_entry, addr);
+                        if (!is_broadcast_ether_addr(addr))
+                                cpsw_ale_flush_mcast(ale, ale_entry, port_mask);
+                }
+
+                cpsw_ale_write(ale, idx, ale_entry);
+        }
+        return 0;
 }
 
 static void cpsw_ale_flush_ucast(struct cpsw_ale *ale, u32 *ale_entry,
diff --git a/drivers/net/ethernet/ti/cpsw_ale.h b/drivers/net/ethernet/ti/cpsw_ale.h
index a95b37beb02d..2bd09cbce522 100644
--- a/drivers/net/ethernet/ti/cpsw_ale.h
+++ b/drivers/net/ethernet/ti/cpsw_ale.h
@@ -80,6 +80,7 @@ void cpsw_ale_stop(struct cpsw_ale *ale);
 
 int cpsw_ale_set_ageout(struct cpsw_ale *ale, int ageout);
 int cpsw_ale_flush(struct cpsw_ale *ale, int port_mask);
+int cpsw_ale_flush_multicast(struct cpsw_ale *ale, int port_mask);
 int cpsw_ale_add_ucast(struct cpsw_ale *ale, u8 *addr, int port, int flags);
 int cpsw_ale_del_ucast(struct cpsw_ale *ale, u8 *addr, int port);
 int cpsw_ale_add_mcast(struct cpsw_ale *ale, u8 *addr, int port_mask,
diff --git a/drivers/net/ethernet/ti/cpts.c b/drivers/net/ethernet/ti/cpts.c
new file mode 100644
index 000000000000..337766738eca
--- /dev/null
+++ b/drivers/net/ethernet/ti/cpts.c
@@ -0,0 +1,427 @@
+/*
+ * TI Common Platform Time Sync
+ *
+ * Copyright (C) 2012 Richard Cochran <richardcochran@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <linux/err.h>
+#include <linux/if.h>
+#include <linux/hrtimer.h>
+#include <linux/module.h>
+#include <linux/net_tstamp.h>
+#include <linux/ptp_classify.h>
+#include <linux/time.h>
+#include <linux/uaccess.h>
+#include <linux/workqueue.h>
+
+#include <plat/clock.h>
+
+#include "cpts.h"
+
+#ifdef CONFIG_TI_CPTS
+
+static struct sock_filter ptp_filter[] = {
+        PTP_FILTER
+};
+
+#define cpts_read32(c, r)       __raw_readl(&c->reg->r)
+#define cpts_write32(c, v, r)   __raw_writel(v, &c->reg->r)
+
+static int event_expired(struct cpts_event *event)
+{
+        return time_after(jiffies, event->tmo);
+}
+
+static int event_type(struct cpts_event *event)
+{
+        return (event->high >> EVENT_TYPE_SHIFT) & EVENT_TYPE_MASK;
+}
+
+static int cpts_fifo_pop(struct cpts *cpts, u32 *high, u32 *low)
+{
+        u32 r = cpts_read32(cpts, intstat_raw);
+
+        if (r & TS_PEND_RAW) {
+                *high = cpts_read32(cpts, event_high);
+                *low  = cpts_read32(cpts, event_low);
+                cpts_write32(cpts, EVENT_POP, event_pop);
+                return 0;
+        }
+        return -1;
+}
+
+/*
+ * Returns zero if matching event type was found.
+ */
+static int cpts_fifo_read(struct cpts *cpts, int match)
+{
+        int i, type = -1;
+        u32 hi, lo;
+        struct cpts_event *event;
+
+        for (i = 0; i < CPTS_FIFO_DEPTH; i++) {
+                if (cpts_fifo_pop(cpts, &hi, &lo))
+                        break;
+                if (list_empty(&cpts->pool)) {
+                        pr_err("cpts: event pool is empty\n");
+                        return -1;
+                }
+                event = list_first_entry(&cpts->pool, struct cpts_event, list);
+                event->tmo = jiffies + 2;
+                event->high = hi;
+                event->low = lo;
+                type = event_type(event);
+                switch (type) {
+                case CPTS_EV_PUSH:
+                case CPTS_EV_RX:
+                case CPTS_EV_TX:
+                        list_del_init(&event->list);
+                        list_add_tail(&event->list, &cpts->events);
+                        break;
+                case CPTS_EV_ROLL:
+                case CPTS_EV_HALF:
+                case CPTS_EV_HW:
+                        break;
+                default:
+                        pr_err("cpts: unkown event type\n");
+                        break;
+                }
+                if (type == match)
+                        break;
+        }
+        return type == match ? 0 : -1;
+}
+
+static cycle_t cpts_systim_read(const struct cyclecounter *cc)
+{
+        u64 val = 0;
+        struct cpts_event *event;
+        struct list_head *this, *next;
+        struct cpts *cpts = container_of(cc, struct cpts, cc);
+
+        cpts_write32(cpts, TS_PUSH, ts_push);
+        if (cpts_fifo_read(cpts, CPTS_EV_PUSH))
+                pr_err("cpts: unable to obtain a time stamp\n");
+
+        list_for_each_safe(this, next, &cpts->events) {
+                event = list_entry(this, struct cpts_event, list);
+                if (event_type(event) == CPTS_EV_PUSH) {
+                        list_del_init(&event->list);
+                        list_add(&event->list, &cpts->pool);
+                        val = event->low;
+                        break;
+                }
+        }
+
+        return val;
+}
+
+/* PTP clock operations */
+
+static int cpts_ptp_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
+{
+        u64 adj;
+        u32 diff, mult;
+        int neg_adj = 0;
+        unsigned long flags;
+        struct cpts *cpts = container_of(ptp, struct cpts, info);
+
+        if (ppb < 0) {
+                neg_adj = 1;
+                ppb = -ppb;
+        }
+        mult = cpts->cc_mult;
+        adj = mult;
+        adj *= ppb;
+        diff = div_u64(adj, 1000000000ULL);
+
+        spin_lock_irqsave(&cpts->lock, flags);
+
+        timecounter_read(&cpts->tc);
+
+        cpts->cc.mult = neg_adj ? mult - diff : mult + diff;
+
+        spin_unlock_irqrestore(&cpts->lock, flags);
+
+        return 0;
+}
+
+static int cpts_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
+{
+        s64 now;
+        unsigned long flags;
+        struct cpts *cpts = container_of(ptp, struct cpts, info);
+
+        spin_lock_irqsave(&cpts->lock, flags);
+        now = timecounter_read(&cpts->tc);
+        now += delta;
+        timecounter_init(&cpts->tc, &cpts->cc, now);
+        spin_unlock_irqrestore(&cpts->lock, flags);
+
+        return 0;
+}
+
+static int cpts_ptp_gettime(struct ptp_clock_info *ptp, struct timespec *ts)
+{
+        u64 ns;
+        u32 remainder;
+        unsigned long flags;
+        struct cpts *cpts = container_of(ptp, struct cpts, info);
+
+        spin_lock_irqsave(&cpts->lock, flags);
+        ns = timecounter_read(&cpts->tc);
+        spin_unlock_irqrestore(&cpts->lock, flags);
+
+        ts->tv_sec = div_u64_rem(ns, 1000000000, &remainder);
+        ts->tv_nsec = remainder;
+
+        return 0;
+}
+
+static int cpts_ptp_settime(struct ptp_clock_info *ptp,
+                            const struct timespec *ts)
+{
+        u64 ns;
+        unsigned long flags;
+        struct cpts *cpts = container_of(ptp, struct cpts, info);
+
+        ns = ts->tv_sec * 1000000000ULL;
+        ns += ts->tv_nsec;
+
+        spin_lock_irqsave(&cpts->lock, flags);
+        timecounter_init(&cpts->tc, &cpts->cc, ns);
+        spin_unlock_irqrestore(&cpts->lock, flags);
+
+        return 0;
+}
+
+static int cpts_ptp_enable(struct ptp_clock_info *ptp,
+                           struct ptp_clock_request *rq, int on)
+{
+        return -EOPNOTSUPP;
+}
+
+static struct ptp_clock_info cpts_info = {
+        .owner          = THIS_MODULE,
+        .name           = "CTPS timer",
+        .max_adj        = 1000000,
+        .n_ext_ts       = 0,
+        .pps            = 0,
+        .adjfreq        = cpts_ptp_adjfreq,
+        .adjtime        = cpts_ptp_adjtime,
+        .gettime        = cpts_ptp_gettime,
+        .settime        = cpts_ptp_settime,
+        .enable         = cpts_ptp_enable,
+};
+
+static void cpts_overflow_check(struct work_struct *work)
+{
+        struct timespec ts;
+        struct cpts *cpts = container_of(work, struct cpts, overflow_work.work);
+
+        cpts_write32(cpts, CPTS_EN, control);
+        cpts_write32(cpts, TS_PEND_EN, int_enable);
+        cpts_ptp_gettime(&cpts->info, &ts);
+        pr_debug("cpts overflow check at %ld.%09lu\n", ts.tv_sec, ts.tv_nsec);
+        schedule_delayed_work(&cpts->overflow_work, CPTS_OVERFLOW_PERIOD);
+}
+
+#define CPTS_REF_CLOCK_NAME "cpsw_cpts_rft_clk"
+
+static void cpts_clk_init(struct cpts *cpts)
+{
+        cpts->refclk = clk_get(NULL, CPTS_REF_CLOCK_NAME);
+        if (IS_ERR(cpts->refclk)) {
+                pr_err("Failed to clk_get %s\n", CPTS_REF_CLOCK_NAME);
+                cpts->refclk = NULL;
+                return;
+        }
+        clk_enable(cpts->refclk);
+        cpts->freq = cpts->refclk->recalc(cpts->refclk);
+}
+
+static void cpts_clk_release(struct cpts *cpts)
+{
+        clk_disable(cpts->refclk);
+        clk_put(cpts->refclk);
+}
+
+static int cpts_match(struct sk_buff *skb, unsigned int ptp_class,
+                      u16 ts_seqid, u8 ts_msgtype)
+{
+        u16 *seqid;
+        unsigned int offset;
+        u8 *msgtype, *data = skb->data;
+
+        switch (ptp_class) {
+        case PTP_CLASS_V1_IPV4:
+        case PTP_CLASS_V2_IPV4:
+                offset = ETH_HLEN + IPV4_HLEN(data) + UDP_HLEN;
+                break;
+        case PTP_CLASS_V1_IPV6:
+        case PTP_CLASS_V2_IPV6:
+                offset = OFF_PTP6;
+                break;
+        case PTP_CLASS_V2_L2:
+                offset = ETH_HLEN;
+                break;
+        case PTP_CLASS_V2_VLAN:
+                offset = ETH_HLEN + VLAN_HLEN;
+                break;
+        default:
+                return 0;
+        }
+
+        if (skb->len + ETH_HLEN < offset + OFF_PTP_SEQUENCE_ID + sizeof(*seqid))
+                return 0;
+
+        if (unlikely(ptp_class & PTP_CLASS_V1))
+                msgtype = data + offset + OFF_PTP_CONTROL;
+        else
+                msgtype = data + offset;
+
+        seqid = (u16 *)(data + offset + OFF_PTP_SEQUENCE_ID);
+
+        return (ts_msgtype == (*msgtype & 0xf) && ts_seqid == ntohs(*seqid));
+}
+
+static u64 cpts_find_ts(struct cpts *cpts, struct sk_buff *skb, int ev_type)
+{
+        u64 ns = 0;
+        struct cpts_event *event;
+        struct list_head *this, *next;
+        unsigned int class = sk_run_filter(skb, ptp_filter);
+        unsigned long flags;
+        u16 seqid;
+        u8 mtype;
+
+        if (class == PTP_CLASS_NONE)
+                return 0;
+
+        spin_lock_irqsave(&cpts->lock, flags);
+        cpts_fifo_read(cpts, CPTS_EV_PUSH);
+        list_for_each_safe(this, next, &cpts->events) {
+                event = list_entry(this, struct cpts_event, list);
+                if (event_expired(event)) {
+                        list_del_init(&event->list);
+                        list_add(&event->list, &cpts->pool);
+                        continue;
+                }
+                mtype = (event->high >> MESSAGE_TYPE_SHIFT) & MESSAGE_TYPE_MASK;
+                seqid = (event->high >> SEQUENCE_ID_SHIFT) & SEQUENCE_ID_MASK;
+                if (ev_type == event_type(event) &&
+                    cpts_match(skb, class, seqid, mtype)) {
+                        ns = timecounter_cyc2time(&cpts->tc, event->low);
+                        list_del_init(&event->list);
+                        list_add(&event->list, &cpts->pool);
+                        break;
+                }
+        }
+        spin_unlock_irqrestore(&cpts->lock, flags);
+
+        return ns;
+}
+
+void cpts_rx_timestamp(struct cpts *cpts, struct sk_buff *skb)
+{
+        u64 ns;
+        struct skb_shared_hwtstamps *ssh;
+
+        if (!cpts->rx_enable)
+                return;
+        ns = cpts_find_ts(cpts, skb, CPTS_EV_RX);
+        if (!ns)
+                return;
+        ssh = skb_hwtstamps(skb);
+        memset(ssh, 0, sizeof(*ssh));
+        ssh->hwtstamp = ns_to_ktime(ns);
+}
+
+void cpts_tx_timestamp(struct cpts *cpts, struct sk_buff *skb)
+{
+        u64 ns;
+        struct skb_shared_hwtstamps ssh;
+
+        if (!(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS))
+                return;
+        ns = cpts_find_ts(cpts, skb, CPTS_EV_TX);
+        if (!ns)
+                return;
+        memset(&ssh, 0, sizeof(ssh));
+        ssh.hwtstamp = ns_to_ktime(ns);
+        skb_tstamp_tx(skb, &ssh);
+}
+
+#endif /*CONFIG_TI_CPTS*/
+
+int cpts_register(struct device *dev, struct cpts *cpts,
+                  u32 mult, u32 shift)
+{
+#ifdef CONFIG_TI_CPTS
+        int err, i;
+        unsigned long flags;
+
+        if (ptp_filter_init(ptp_filter, ARRAY_SIZE(ptp_filter))) {
+                pr_err("cpts: bad ptp filter\n");
+                return -EINVAL;
+        }
+        cpts->info = cpts_info;
+        cpts->clock = ptp_clock_register(&cpts->info, dev);
+        if (IS_ERR(cpts->clock)) {
+                err = PTR_ERR(cpts->clock);
+                cpts->clock = NULL;
+                return err;
+        }
+        spin_lock_init(&cpts->lock);
+
+        cpts->cc.read = cpts_systim_read;
+        cpts->cc.mask = CLOCKSOURCE_MASK(32);
+        cpts->cc_mult = mult;
+        cpts->cc.mult = mult;
+        cpts->cc.shift = shift;
+
+        INIT_LIST_HEAD(&cpts->events);
+        INIT_LIST_HEAD(&cpts->pool);
+        for (i = 0; i < CPTS_MAX_EVENTS; i++)
+                list_add(&cpts->pool_data[i].list, &cpts->pool);
+
+        cpts_clk_init(cpts);
+        cpts_write32(cpts, CPTS_EN, control);
+        cpts_write32(cpts, TS_PEND_EN, int_enable);
+
+        spin_lock_irqsave(&cpts->lock, flags);
+        timecounter_init(&cpts->tc, &cpts->cc, ktime_to_ns(ktime_get_real()));
+        spin_unlock_irqrestore(&cpts->lock, flags);
+
+        INIT_DELAYED_WORK(&cpts->overflow_work, cpts_overflow_check);
+        schedule_delayed_work(&cpts->overflow_work, CPTS_OVERFLOW_PERIOD);
+
+        cpts->phc_index = ptp_clock_index(cpts->clock);
+#endif
+        return 0;
+}
+
+void cpts_unregister(struct cpts *cpts)
+{
+#ifdef CONFIG_TI_CPTS
+        if (cpts->clock) {
+                ptp_clock_unregister(cpts->clock);
+                cancel_delayed_work_sync(&cpts->overflow_work);
+        }
+        if (cpts->refclk)
+                cpts_clk_release(cpts);
+#endif
+}
diff --git a/drivers/net/ethernet/ti/cpts.h b/drivers/net/ethernet/ti/cpts.h
new file mode 100644
index 000000000000..e1bba3a496b2
--- /dev/null
+++ b/drivers/net/ethernet/ti/cpts.h
@@ -0,0 +1,146 @@
+/*
+ * TI Common Platform Time Sync
+ *
+ * Copyright (C) 2012 Richard Cochran <richardcochran@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef _TI_CPTS_H_
+#define _TI_CPTS_H_
+
+#include <linux/clk.h>
+#include <linux/clkdev.h>
+#include <linux/clocksource.h>
+#include <linux/device.h>
+#include <linux/list.h>
+#include <linux/ptp_clock_kernel.h>
+#include <linux/skbuff.h>
+
+struct cpsw_cpts {
+        u32 idver;                /* Identification and version */
+        u32 control;              /* Time sync control */
+        u32 res1;
+        u32 ts_push;              /* Time stamp event push */
+        u32 ts_load_val;          /* Time stamp load value */
+        u32 ts_load_en;           /* Time stamp load enable */
+        u32 res2[2];
+        u32 intstat_raw;          /* Time sync interrupt status raw */
+        u32 intstat_masked;       /* Time sync interrupt status masked */
+        u32 int_enable;           /* Time sync interrupt enable */
+        u32 res3;
+        u32 event_pop;            /* Event interrupt pop */
+        u32 event_low;            /* 32 Bit Event Time Stamp */
+        u32 event_high;           /* Event Type Fields */
+};
+
+/* Bit definitions for the IDVER register */
+#define TX_IDENT_SHIFT       (16)    /* TX Identification Value */
+#define TX_IDENT_MASK        (0xffff)
+#define RTL_VER_SHIFT        (11)    /* RTL Version Value */
+#define RTL_VER_MASK         (0x1f)
+#define MAJOR_VER_SHIFT      (8)     /* Major Version Value */
+#define MAJOR_VER_MASK       (0x7)
+#define MINOR_VER_SHIFT      (0)     /* Minor Version Value */
+#define MINOR_VER_MASK       (0xff)
+
+/* Bit definitions for the CONTROL register */
+#define HW4_TS_PUSH_EN       (1<<11) /* Hardware push 4 enable */
+#define HW3_TS_PUSH_EN       (1<<10) /* Hardware push 3 enable */
+#define HW2_TS_PUSH_EN       (1<<9)  /* Hardware push 2 enable */
+#define HW1_TS_PUSH_EN       (1<<8)  /* Hardware push 1 enable */
+#define INT_TEST             (1<<1)  /* Interrupt Test */
+#define CPTS_EN              (1<<0)  /* Time Sync Enable */
+
+/*
+ * Definitions for the single bit resisters:
+ * TS_PUSH TS_LOAD_EN  INTSTAT_RAW INTSTAT_MASKED INT_ENABLE EVENT_POP
+ */
+#define TS_PUSH             (1<<0)  /* Time stamp event push */
+#define TS_LOAD_EN          (1<<0)  /* Time Stamp Load */
+#define TS_PEND_RAW         (1<<0)  /* int read (before enable) */
+#define TS_PEND             (1<<0)  /* masked interrupt read (after enable) */
+#define TS_PEND_EN          (1<<0)  /* masked interrupt enable */
+#define EVENT_POP           (1<<0)  /* writing discards one event */
+
+/* Bit definitions for the EVENT_HIGH register */
+#define PORT_NUMBER_SHIFT    (24)    /* Indicates Ethernet port or HW pin */
+#define PORT_NUMBER_MASK     (0x1f)
+#define EVENT_TYPE_SHIFT     (20)    /* Time sync event type */
+#define EVENT_TYPE_MASK      (0xf)
+#define MESSAGE_TYPE_SHIFT   (16)    /* PTP message type */
+#define MESSAGE_TYPE_MASK    (0xf)
+#define SEQUENCE_ID_SHIFT    (0)     /* PTP message sequence ID */
+#define SEQUENCE_ID_MASK     (0xffff)
+
+enum {
+        CPTS_EV_PUSH, /* Time Stamp Push Event */
+        CPTS_EV_ROLL, /* Time Stamp Rollover Event */
+        CPTS_EV_HALF, /* Time Stamp Half Rollover Event */
+        CPTS_EV_HW,   /* Hardware Time Stamp Push Event */
+        CPTS_EV_RX,   /* Ethernet Receive Event */
+        CPTS_EV_TX,   /* Ethernet Transmit Event */
+};
+
+/* This covers any input clock up to about 500 MHz. */
+#define CPTS_OVERFLOW_PERIOD (HZ * 8)
+
+#define CPTS_FIFO_DEPTH 16
+#define CPTS_MAX_EVENTS 32
+
+struct cpts_event {
+        struct list_head list;
+        unsigned long tmo;
+        u32 high;
+        u32 low;
+};
+
+struct cpts {
+        struct cpsw_cpts __iomem *reg;
+        int tx_enable;
+        int rx_enable;
+#ifdef CONFIG_TI_CPTS
+        struct ptp_clock_info info;
+        struct ptp_clock *clock;
+        spinlock_t lock; /* protects time registers */
+        u32 cc_mult; /* for the nominal frequency */
+        struct cyclecounter cc;
+        struct timecounter tc;
+        struct delayed_work overflow_work;
+        int phc_index;
+        struct clk *refclk;
+        unsigned long freq;
+        struct list_head events;
+        struct list_head pool;
+        struct cpts_event pool_data[CPTS_MAX_EVENTS];
+#endif
+};
+
+#ifdef CONFIG_TI_CPTS
+extern void cpts_rx_timestamp(struct cpts *cpts, struct sk_buff *skb);
+extern void cpts_tx_timestamp(struct cpts *cpts, struct sk_buff *skb);
+#else
+static inline void cpts_rx_timestamp(struct cpts *cpts, struct sk_buff *skb)
+{
+}
+static inline void cpts_tx_timestamp(struct cpts *cpts, struct sk_buff *skb)
+{
+}
+#endif
+
+extern int cpts_register(struct device *dev, struct cpts *cpts,
+                         u32 mult, u32 shift);
+extern void cpts_unregister(struct cpts *cpts);
+
+#endif