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

Pull networking fixes from David Miller:

 1) Provide device string properly for USB i2400m wimax devices, also
    don't OOPS when providing firmware string.  From Phil Sutter.

 2) Add support for sh_eth SH7734 chips, from Nobuhiro Iwamatsu.

 3) Add another device ID to USB zaurus driver, from Guan Xin.

 4) Loop index start in pool vector iterator is wrong causing MAC to not
    get configured in bnx2x driver, fix from Dmitry Kravkov.

 5) EQL driver assumes HZ=100, fix from Eric Dumazet.

 6) Now that skb_add_rx_frag() can specify the truesize increment
    separately, do so in f_phonet and cdc_phonet, also from Eric
    Dumazet.

 7) virtio_net accidently uses net_ratelimit() not only on the kernel
    warning but also the statistic bump, fix from Rick Jones.

 8) ip_route_input_mc() uses fixed init_net namespace, oops, use
    dev_net(dev) instead.  Fix from Benjamin LaHaise.

 9) dev_forward_skb() needs to clear the incoming interface index of the
    SKB so that it looks like a new incoming packet, also from Benjamin
    LaHaise.

10) iwlwifi mistakenly initializes a channel entry as 2GHZ instead of
    5GHZ, fix from Stanislav Yakovlev.

11) Missing kmalloc() return value checks in orinoco, from Santosh
    Nayak.

12) ath9k doesn't check for HT capabilities in the right way, it is
    checking ht_supported instead of the ATH9K_HW_CAP_HT flag.  Fix from
    Sujith Manoharan.

13) Fix x86 BPF JIT emission of 16-bit immediate field of AND
    instructions, from Feiran Zhuang.

14) Avoid infinite loop in GARP code when registering sysfs entries.
    From David Ward.

15) rose protocol uses memcpy instead of memcmp in a device address
    comparison, oops.  Fix from Daniel Borkmann.

16) Fix build of lpc_eth due to dev_hw_addr_rancom() interface being
    renamed to eth_hw_addr_random().  From Roland Stigge.

17) Make ipv6 RTM_GETROUTE interpret RTA_IIF attribute the same way
    that ipv4 does.  Fix from Shmulik Ladkani.

18) via-rhine has an inverted bit test, causing suspend/resume
    regressions.  Fix from Andreas Mohr.

19) RIONET assumes 4K page size, fix from Akinobu Mita.

20) Initialization of imask register in sky2 is buggy, because bits are
    "or'd" into an uninitialized local variable.  Fix from Lino
    Sanfilippo.

21) Fix FCOE checksum offload handling, from Yi Zou.

22) Fix VLAN processing regression in e1000, from Jiri Pirko.

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (52 commits)
  sky2: dont overwrite settings for PHY Quick link
  tg3: Fix 5717 serdes powerdown problem
  net: usb: cdc_eem: fix mtu
  net: sh_eth: fix endian check for architecture independent
  usb/rtl8150 : Remove duplicated definitions
  rionet: fix page allocation order of rionet_active
  via-rhine: fix wait-bit inversion.
  ipv6: Fix RTM_GETROUTE's interpretation of RTA_IIF to be consistent with ipv4
  net: lpc_eth: Fix rename of dev_hw_addr_random
  net/netfilter/nfnetlink_acct.c: use linux/atomic.h
  rose_dev: fix memcpy-bug in rose_set_mac_address
  Fix non TBI PHY access; a bad merge undid bug fix in a previous commit.
  net/garp: avoid infinite loop if attribute already exists
  x86 bpf_jit: fix a bug in emitting the 16-bit immediate operand of AND
  bonding: emit event when bonding changes MAC
  mac80211: fix oper channel timestamp updation
  ath9k: Use HW HT capabilites properly
  MAINTAINERS: adding maintainer for ipw2x00
  net: orinoco: add error handling for failed kmalloc().
  net/wireless: ipw2x00: fix a typo in wiphy struct initilization
  ...

25 files changed, 529 insertions, 163 deletions

diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
index e37161f19250..2c9ee552dffc 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
@@ -1173,6 +1173,13 @@ enum {
 };
 
 
+struct bnx2x_prev_path_list {
+        u8 bus;
+        u8 slot;
+        u8 path;
+        struct list_head list;
+};
+
 struct bnx2x {
         /* Fields used in the tx and intr/napi performance paths
          * are grouped together in the beginning of the structure
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
index f1f3ca65667a..44556b719e81 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
@@ -1721,6 +1721,29 @@ static void bnx2x_squeeze_objects(struct bnx2x *bp)
         } while (0)
 #endif
 
+bool bnx2x_test_firmware_version(struct bnx2x *bp, bool is_err)
+{
+        /* build FW version dword */
+        u32 my_fw = (BCM_5710_FW_MAJOR_VERSION) +
+                    (BCM_5710_FW_MINOR_VERSION << 8) +
+                    (BCM_5710_FW_REVISION_VERSION << 16) +
+                    (BCM_5710_FW_ENGINEERING_VERSION << 24);
+
+        /* read loaded FW from chip */
+        u32 loaded_fw = REG_RD(bp, XSEM_REG_PRAM);
+
+        DP(NETIF_MSG_IFUP, "loaded fw %x, my fw %x\n", loaded_fw, my_fw);
+
+        if (loaded_fw != my_fw) {
+                if (is_err)
+                        BNX2X_ERR("bnx2x with FW %x was already loaded, which mismatches my %x FW. aborting\n",
+                                  loaded_fw, my_fw);
+                return false;
+        }
+
+        return true;
+}
+
 /* must be called with rtnl_lock */
 int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
 {
@@ -1815,23 +1838,8 @@ int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                 }
                 if (load_code != FW_MSG_CODE_DRV_LOAD_COMMON_CHIP &&
                     load_code != FW_MSG_CODE_DRV_LOAD_COMMON) {
-                        /* build FW version dword */
-                        u32 my_fw = (BCM_5710_FW_MAJOR_VERSION) +
-                                        (BCM_5710_FW_MINOR_VERSION << 8) +
-                                        (BCM_5710_FW_REVISION_VERSION << 16) +
-                                        (BCM_5710_FW_ENGINEERING_VERSION << 24);
-
-                        /* read loaded FW from chip */
-                        u32 loaded_fw = REG_RD(bp, XSEM_REG_PRAM);
-
-                        DP(BNX2X_MSG_SP, "loaded fw %x, my fw %x",
-                           loaded_fw, my_fw);
-
                         /* abort nic load if version mismatch */
-                        if (my_fw != loaded_fw) {
-                                BNX2X_ERR("bnx2x with FW %x already loaded, "
-                                          "which mismatches my %x FW. aborting",
-                                          loaded_fw, my_fw);
+                        if (!bnx2x_test_firmware_version(bp, true)) {
                                 rc = -EBUSY;
                                 LOAD_ERROR_EXIT(bp, load_error2);
                         }
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h
index 8b163388659a..5c27454d2ec2 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h
@@ -431,6 +431,9 @@ void bnx2x_panic_dump(struct bnx2x *bp);
 
 void bnx2x_fw_dump_lvl(struct bnx2x *bp, const char *lvl);
 
+/* validate currect fw is loaded */
+bool bnx2x_test_firmware_version(struct bnx2x *bp, bool is_err);
+
 /* dev_close main block */
 int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode);
 
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_hsi.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_hsi.h
index 5d71b7d43237..dbff5915b81a 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_hsi.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_hsi.h
@@ -1251,6 +1251,9 @@ struct drv_func_mb {
 
         #define DRV_MSG_CODE_LINK_STATUS_CHANGED        0x01000000
 
+        #define DRV_MSG_CODE_INITIATE_FLR               0x02000000
+        #define REQ_BC_VER_4_INITIATE_FLR               0x00070213
+
         #define BIOS_MSG_CODE_LIC_CHALLENGE             0xff010000
         #define BIOS_MSG_CODE_LIC_RESPONSE              0xff020000
         #define BIOS_MSG_CODE_VIRT_MAC_PRIM             0xff030000
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c
index beb4cdbdb6e1..efa557b76ac7 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c
@@ -35,7 +35,6 @@
 #define ETH_MAX_PACKET_SIZE             1500
 #define ETH_MAX_JUMBO_PACKET_SIZE       9600
 #define MDIO_ACCESS_TIMEOUT             1000
-#define BMAC_CONTROL_RX_ENABLE          2
 #define WC_LANE_MAX                     4
 #define I2C_SWITCH_WIDTH                2
 #define I2C_BSC0                        0
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.h
index 7ba557a610da..763535ee4832 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.h
@@ -89,6 +89,8 @@
 #define PFC_BRB_FULL_LB_XON_THRESHOLD                           250
 
 #define MAXVAL(a, b) (((a) > (b)) ? (a) : (b))
+
+#define BMAC_CONTROL_RX_ENABLE          2
 /***********************************************************/
 /*                         Structs                         */
 /***********************************************************/
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
index f7f9aa807264..e077d2508727 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
@@ -52,6 +52,7 @@
 #include <linux/prefetch.h>
 #include <linux/zlib.h>
 #include <linux/io.h>
+#include <linux/semaphore.h>
 #include <linux/stringify.h>
 #include <linux/vmalloc.h>
 
@@ -211,6 +212,10 @@ static DEFINE_PCI_DEVICE_TABLE(bnx2x_pci_tbl) = {
 
 MODULE_DEVICE_TABLE(pci, bnx2x_pci_tbl);
 
+/* Global resources for unloading a previously loaded device */
+#define BNX2X_PREV_WAIT_NEEDED 1
+static DEFINE_SEMAPHORE(bnx2x_prev_sem);
+static LIST_HEAD(bnx2x_prev_list);
 /****************************************************************************
 * General service functions
 ****************************************************************************/
@@ -8812,109 +8817,371 @@ static inline void bnx2x_undi_int_disable(struct bnx2x *bp)
                 bnx2x_undi_int_disable_e1h(bp);
 }
 
-static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
+static void __devinit bnx2x_prev_unload_close_mac(struct bnx2x *bp)
 {
-        u32 val;
+        u32 val, base_addr, offset, mask, reset_reg;
+        bool mac_stopped = false;
+        u8 port = BP_PORT(bp);
 
-        /* possibly another driver is trying to reset the chip */
-        bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_RESET);
+        reset_reg = REG_RD(bp, MISC_REG_RESET_REG_2);
 
-        /* check if doorbell queue is reset */
-        if (REG_RD(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET)
-            & MISC_REGISTERS_RESET_REG_1_RST_DORQ) {
+        if (!CHIP_IS_E3(bp)) {
+                val = REG_RD(bp, NIG_REG_BMAC0_REGS_OUT_EN + port * 4);
+                mask = MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port;
+                if ((mask & reset_reg) && val) {
+                        u32 wb_data[2];
+                        BNX2X_DEV_INFO("Disable bmac Rx\n");
+                        base_addr = BP_PORT(bp) ? NIG_REG_INGRESS_BMAC1_MEM
+                                                : NIG_REG_INGRESS_BMAC0_MEM;
+                        offset = CHIP_IS_E2(bp) ? BIGMAC2_REGISTER_BMAC_CONTROL
+                                                : BIGMAC_REGISTER_BMAC_CONTROL;
 
-                /*
-                 * Check if it is the UNDI driver
+                        /*
+                         * use rd/wr since we cannot use dmae. This is safe
+                         * since MCP won't access the bus due to the request
+                         * to unload, and no function on the path can be
+                         * loaded at this time.
+                         */
+                        wb_data[0] = REG_RD(bp, base_addr + offset);
+                        wb_data[1] = REG_RD(bp, base_addr + offset + 0x4);
+                        wb_data[0] &= ~BMAC_CONTROL_RX_ENABLE;
+                        REG_WR(bp, base_addr + offset, wb_data[0]);
+                        REG_WR(bp, base_addr + offset + 0x4, wb_data[1]);
+
+                }
+                BNX2X_DEV_INFO("Disable emac Rx\n");
+                REG_WR(bp, NIG_REG_NIG_EMAC0_EN + BP_PORT(bp)*4, 0);
+
+                mac_stopped = true;
+        } else {
+                if (reset_reg & MISC_REGISTERS_RESET_REG_2_XMAC) {
+                        BNX2X_DEV_INFO("Disable xmac Rx\n");
+                        base_addr = BP_PORT(bp) ? GRCBASE_XMAC1 : GRCBASE_XMAC0;
+                        val = REG_RD(bp, base_addr + XMAC_REG_PFC_CTRL_HI);
+                        REG_WR(bp, base_addr + XMAC_REG_PFC_CTRL_HI,
+                               val & ~(1 << 1));
+                        REG_WR(bp, base_addr + XMAC_REG_PFC_CTRL_HI,
+                               val | (1 << 1));
+                        REG_WR(bp, base_addr + XMAC_REG_CTRL, 0);
+                        mac_stopped = true;
+                }
+                mask = MISC_REGISTERS_RESET_REG_2_UMAC0 << port;
+                if (mask & reset_reg) {
+                        BNX2X_DEV_INFO("Disable umac Rx\n");
+                        base_addr = BP_PORT(bp) ? GRCBASE_UMAC1 : GRCBASE_UMAC0;
+                        REG_WR(bp, base_addr + UMAC_REG_COMMAND_CONFIG, 0);
+                        mac_stopped = true;
+                }
+        }
+
+        if (mac_stopped)
+                msleep(20);
+
+}
+
+#define BNX2X_PREV_UNDI_PROD_ADDR(p) (BAR_TSTRORM_INTMEM + 0x1508 + ((p) << 4))
+#define BNX2X_PREV_UNDI_RCQ(val)        ((val) & 0xffff)
+#define BNX2X_PREV_UNDI_BD(val)         ((val) >> 16 & 0xffff)
+#define BNX2X_PREV_UNDI_PROD(rcq, bd)   ((bd) << 16 | (rcq))
+
+static void __devinit bnx2x_prev_unload_undi_inc(struct bnx2x *bp, u8 port,
+                                                 u8 inc)
+{
+        u16 rcq, bd;
+        u32 tmp_reg = REG_RD(bp, BNX2X_PREV_UNDI_PROD_ADDR(port));
+
+        rcq = BNX2X_PREV_UNDI_RCQ(tmp_reg) + inc;
+        bd = BNX2X_PREV_UNDI_BD(tmp_reg) + inc;
+
+        tmp_reg = BNX2X_PREV_UNDI_PROD(rcq, bd);
+        REG_WR(bp, BNX2X_PREV_UNDI_PROD_ADDR(port), tmp_reg);
+
+        BNX2X_DEV_INFO("UNDI producer [%d] rings bd -> 0x%04x, rcq -> 0x%04x\n",
+                       port, bd, rcq);
+}
+
+static int __devinit bnx2x_prev_mcp_done(struct bnx2x *bp)
+{
+        u32 rc = bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE, 0);
+        if (!rc) {
+                BNX2X_ERR("MCP response failure, aborting\n");
+                return -EBUSY;
+        }
+
+        return 0;
+}
+
+static bool __devinit bnx2x_prev_is_path_marked(struct bnx2x *bp)
+{
+        struct bnx2x_prev_path_list *tmp_list;
+        int rc = false;
+
+        if (down_trylock(&bnx2x_prev_sem))
+                return false;
+
+        list_for_each_entry(tmp_list, &bnx2x_prev_list, list) {
+                if (PCI_SLOT(bp->pdev->devfn) == tmp_list->slot &&
+                    bp->pdev->bus->number == tmp_list->bus &&
+                    BP_PATH(bp) == tmp_list->path) {
+                        rc = true;
+                        BNX2X_DEV_INFO("Path %d was already cleaned from previous drivers\n",
+                                       BP_PATH(bp));
+                        break;
+                }
+        }
+
+        up(&bnx2x_prev_sem);
+
+        return rc;
+}
+
+static int __devinit bnx2x_prev_mark_path(struct bnx2x *bp)
+{
+        struct bnx2x_prev_path_list *tmp_list;
+        int rc;
+
+        tmp_list = (struct bnx2x_prev_path_list *)
+                    kmalloc(sizeof(struct bnx2x_prev_path_list), GFP_KERNEL);
+        if (!tmp_list) {
+                BNX2X_ERR("Failed to allocate 'bnx2x_prev_path_list'\n");
+                return -ENOMEM;
+        }
+
+        tmp_list->bus = bp->pdev->bus->number;
+        tmp_list->slot = PCI_SLOT(bp->pdev->devfn);
+        tmp_list->path = BP_PATH(bp);
+
+        rc = down_interruptible(&bnx2x_prev_sem);
+        if (rc) {
+                BNX2X_ERR("Received %d when tried to take lock\n", rc);
+                kfree(tmp_list);
+        } else {
+                BNX2X_DEV_INFO("Marked path [%d] - finished previous unload\n",
+                                BP_PATH(bp));
+                list_add(&tmp_list->list, &bnx2x_prev_list);
+                up(&bnx2x_prev_sem);
+        }
+
+        return rc;
+}
+
+static bool __devinit bnx2x_can_flr(struct bnx2x *bp)
+{
+        int pos;
+        u32 cap;
+        struct pci_dev *dev = bp->pdev;
+
+        pos = pci_pcie_cap(dev);
+        if (!pos)
+                return false;
+
+        pci_read_config_dword(dev, pos + PCI_EXP_DEVCAP, &cap);
+        if (!(cap & PCI_EXP_DEVCAP_FLR))
+                return false;
+
+        return true;
+}
+
+static int __devinit bnx2x_do_flr(struct bnx2x *bp)
+{
+        int i, pos;
+        u16 status;
+        struct pci_dev *dev = bp->pdev;
+
+        /* probe the capability first */
+        if (bnx2x_can_flr(bp))
+                return -ENOTTY;
+
+        pos = pci_pcie_cap(dev);
+        if (!pos)
+                return -ENOTTY;
+
+        /* Wait for Transaction Pending bit clean */
+        for (i = 0; i < 4; i++) {
+                if (i)
+                        msleep((1 << (i - 1)) * 100);
+
+                pci_read_config_word(dev, pos + PCI_EXP_DEVSTA, &status);
+                if (!(status & PCI_EXP_DEVSTA_TRPND))
+                        goto clear;
+        }
+
+        dev_err(&dev->dev,
+                "transaction is not cleared; proceeding with reset anyway\n");
+
+clear:
+        if (bp->common.bc_ver < REQ_BC_VER_4_INITIATE_FLR) {
+                BNX2X_ERR("FLR not supported by BC_VER: 0x%x\n",
+                          bp->common.bc_ver);
+                return -EINVAL;
+        }
+
+        bnx2x_fw_command(bp, DRV_MSG_CODE_INITIATE_FLR, 0);
+
+        return 0;
+}
+
+static int __devinit bnx2x_prev_unload_uncommon(struct bnx2x *bp)
+{
+        int rc;
+
+        BNX2X_DEV_INFO("Uncommon unload Flow\n");
+
+        /* Test if previous unload process was already finished for this path */
+        if (bnx2x_prev_is_path_marked(bp))
+                return bnx2x_prev_mcp_done(bp);
+
+        /* If function has FLR capabilities, and existing FW version matches
+         * the one required, then FLR will be sufficient to clean any residue
+         * left by previous driver
+         */
+        if (bnx2x_test_firmware_version(bp, false) && bnx2x_can_flr(bp))
+                return bnx2x_do_flr(bp);
+
+        /* Close the MCP request, return failure*/
+        rc = bnx2x_prev_mcp_done(bp);
+        if (!rc)
+                rc = BNX2X_PREV_WAIT_NEEDED;
+
+        return rc;
+}
+
+static int __devinit bnx2x_prev_unload_common(struct bnx2x *bp)
+{
+        u32 reset_reg, tmp_reg = 0, rc;
+        /* It is possible a previous function received 'common' answer,
+         * but hasn't loaded yet, therefore creating a scenario of
+         * multiple functions receiving 'common' on the same path.
+         */
+        BNX2X_DEV_INFO("Common unload Flow\n");
+
+        if (bnx2x_prev_is_path_marked(bp))
+                return bnx2x_prev_mcp_done(bp);
+
+        reset_reg = REG_RD(bp, MISC_REG_RESET_REG_1);
+
+        /* Reset should be performed after BRB is emptied */
+        if (reset_reg & MISC_REGISTERS_RESET_REG_1_RST_BRB1) {
+                u32 timer_count = 1000;
+                bool prev_undi = false;
+
+                /* Close the MAC Rx to prevent BRB from filling up */
+                bnx2x_prev_unload_close_mac(bp);
+
+                /* Check if the UNDI driver was previously loaded
                  * UNDI driver initializes CID offset for normal bell to 0x7
                  */
-                val = REG_RD(bp, DORQ_REG_NORM_CID_OFST);
-                if (val == 0x7) {
-                        u32 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
-                        /* save our pf_num */
-                        int orig_pf_num = bp->pf_num;
-                        int port;
-                        u32 swap_en, swap_val, value;
-
-                        /* clear the UNDI indication */
-                        REG_WR(bp, DORQ_REG_NORM_CID_OFST, 0);
-
-                        BNX2X_DEV_INFO("UNDI is active! reset device\n");
-
-                        /* try unload UNDI on port 0 */
-                        bp->pf_num = 0;
-                        bp->fw_seq =
-                              (SHMEM_RD(bp, func_mb[bp->pf_num].drv_mb_header) &
-                                DRV_MSG_SEQ_NUMBER_MASK);
-                        reset_code = bnx2x_fw_command(bp, reset_code, 0);
-
-                        /* if UNDI is loaded on the other port */
-                        if (reset_code != FW_MSG_CODE_DRV_UNLOAD_COMMON) {
-
-                                /* send "DONE" for previous unload */
-                                bnx2x_fw_command(bp,
-                                                 DRV_MSG_CODE_UNLOAD_DONE, 0);
-
-                                /* unload UNDI on port 1 */
-                                bp->pf_num = 1;
-                                bp->fw_seq =
-                              (SHMEM_RD(bp, func_mb[bp->pf_num].drv_mb_header) &
-                                        DRV_MSG_SEQ_NUMBER_MASK);
-                                reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
-
-                                bnx2x_fw_command(bp, reset_code, 0);
+                reset_reg = REG_RD(bp, MISC_REG_RESET_REG_1);
+                if (reset_reg & MISC_REGISTERS_RESET_REG_1_RST_DORQ) {
+                        tmp_reg = REG_RD(bp, DORQ_REG_NORM_CID_OFST);
+                        if (tmp_reg == 0x7) {
+                                BNX2X_DEV_INFO("UNDI previously loaded\n");
+                                prev_undi = true;
+                                /* clear the UNDI indication */
+                                REG_WR(bp, DORQ_REG_NORM_CID_OFST, 0);
                         }
+                }
+                /* wait until BRB is empty */
+                tmp_reg = REG_RD(bp, BRB1_REG_NUM_OF_FULL_BLOCKS);
+                while (timer_count) {
+                        u32 prev_brb = tmp_reg;
 
-                        bnx2x_undi_int_disable(bp);
-                        port = BP_PORT(bp);
-
-                        /* close input traffic and wait for it */
-                        /* Do not rcv packets to BRB */
-                        REG_WR(bp, (port ? NIG_REG_LLH1_BRB1_DRV_MASK :
-                                           NIG_REG_LLH0_BRB1_DRV_MASK), 0x0);
-                        /* Do not direct rcv packets that are not for MCP to
-                         * the BRB */
-                        REG_WR(bp, (port ? NIG_REG_LLH1_BRB1_NOT_MCP :
-                                           NIG_REG_LLH0_BRB1_NOT_MCP), 0x0);
-                        /* clear AEU */
-                        REG_WR(bp, (port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
-                                           MISC_REG_AEU_MASK_ATTN_FUNC_0), 0);
-                        msleep(10);
-
-                        /* save NIG port swap info */
-                        swap_val = REG_RD(bp, NIG_REG_PORT_SWAP);
-                        swap_en = REG_RD(bp, NIG_REG_STRAP_OVERRIDE);
-                        /* reset device */
-                        REG_WR(bp,
-                               GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
-                               0xd3ffffff);
-
-                        value = 0x1400;
-                        if (CHIP_IS_E3(bp)) {
-                                value |= MISC_REGISTERS_RESET_REG_2_MSTAT0;
-                                value |= MISC_REGISTERS_RESET_REG_2_MSTAT1;
-                        }
+                        tmp_reg = REG_RD(bp, BRB1_REG_NUM_OF_FULL_BLOCKS);
+                        if (!tmp_reg)
+                                break;
 
-                        REG_WR(bp,
-                               GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
-                               value);
+                        BNX2X_DEV_INFO("BRB still has 0x%08x\n", tmp_reg);
 
-                        /* take the NIG out of reset and restore swap values */
-                        REG_WR(bp,
-                               GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET,
-                               MISC_REGISTERS_RESET_REG_1_RST_NIG);
-                        REG_WR(bp, NIG_REG_PORT_SWAP, swap_val);
-                        REG_WR(bp, NIG_REG_STRAP_OVERRIDE, swap_en);
+                        /* reset timer as long as BRB actually gets emptied */
+                        if (prev_brb > tmp_reg)
+                                timer_count = 1000;
+                        else
+                                timer_count--;
 
-                        /* send unload done to the MCP */
-                        bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE, 0);
+                        /* If UNDI resides in memory, manually increment it */
+                        if (prev_undi)
+                                bnx2x_prev_unload_undi_inc(bp, BP_PORT(bp), 1);
 
-                        /* restore our func and fw_seq */
-                        bp->pf_num = orig_pf_num;
+                        udelay(10);
                 }
+
+                if (!timer_count)
+                        BNX2X_ERR("Failed to empty BRB, hope for the best\n");
+
         }
 
-        /* now it's safe to release the lock */
-        bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_RESET);
+        /* No packets are in the pipeline, path is ready for reset */
+        bnx2x_reset_common(bp);
+
+        rc = bnx2x_prev_mark_path(bp);
+        if (rc) {
+                bnx2x_prev_mcp_done(bp);
+                return rc;
+        }
+
+        return bnx2x_prev_mcp_done(bp);
+}
+
+static int __devinit bnx2x_prev_unload(struct bnx2x *bp)
+{
+        int time_counter = 10;
+        u32 rc, fw, hw_lock_reg, hw_lock_val;
+        BNX2X_DEV_INFO("Entering Previous Unload Flow\n");
+
+       /* Release previously held locks */
+        hw_lock_reg = (BP_FUNC(bp) <= 5) ?
+                      (MISC_REG_DRIVER_CONTROL_1 + BP_FUNC(bp) * 8) :
+                      (MISC_REG_DRIVER_CONTROL_7 + (BP_FUNC(bp) - 6) * 8);
+
+        hw_lock_val = (REG_RD(bp, hw_lock_reg));
+        if (hw_lock_val) {
+                if (hw_lock_val & HW_LOCK_RESOURCE_NVRAM) {
+                        BNX2X_DEV_INFO("Release Previously held NVRAM lock\n");
+                        REG_WR(bp, MCP_REG_MCPR_NVM_SW_ARB,
+                               (MCPR_NVM_SW_ARB_ARB_REQ_CLR1 << BP_PORT(bp)));
+                }
+
+                BNX2X_DEV_INFO("Release Previously held hw lock\n");
+                REG_WR(bp, hw_lock_reg, 0xffffffff);
+        } else
+                BNX2X_DEV_INFO("No need to release hw/nvram locks\n");
+
+        if (MCPR_ACCESS_LOCK_LOCK & REG_RD(bp, MCP_REG_MCPR_ACCESS_LOCK)) {
+                BNX2X_DEV_INFO("Release previously held alr\n");
+                REG_WR(bp, MCP_REG_MCPR_ACCESS_LOCK, 0);
+        }
+
+
+        do {
+                /* Lock MCP using an unload request */
+                fw = bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS, 0);
+                if (!fw) {
+                        BNX2X_ERR("MCP response failure, aborting\n");
+                        rc = -EBUSY;
+                        break;
+                }
+
+                if (fw == FW_MSG_CODE_DRV_UNLOAD_COMMON) {
+                        rc = bnx2x_prev_unload_common(bp);
+                        break;
+                }
+
+                /* non-common reply from MCP night require looping */
+                rc = bnx2x_prev_unload_uncommon(bp);
+                if (rc != BNX2X_PREV_WAIT_NEEDED)
+                        break;
+
+                msleep(20);
+        } while (--time_counter);
+
+        if (!time_counter || rc) {
+                BNX2X_ERR("Failed unloading previous driver, aborting\n");
+                rc = -EBUSY;
+        }
+
+        BNX2X_DEV_INFO("Finished Previous Unload Flow [%d]\n", rc);
+
+        return rc;
 }
 
 static void __devinit bnx2x_get_common_hwinfo(struct bnx2x *bp)
@@ -10100,8 +10367,16 @@ static int __devinit bnx2x_init_bp(struct bnx2x *bp)
         func = BP_FUNC(bp);
 
         /* need to reset chip if undi was active */
-        if (!BP_NOMCP(bp))
-                bnx2x_undi_unload(bp);
+        if (!BP_NOMCP(bp)) {
+                /* init fw_seq */
+                bp->fw_seq =
+                        SHMEM_RD(bp, func_mb[BP_FW_MB_IDX(bp)].drv_mb_header) &
+                                                        DRV_MSG_SEQ_NUMBER_MASK;
+                BNX2X_DEV_INFO("fw_seq 0x%08x\n", bp->fw_seq);
+
+                bnx2x_prev_unload(bp);
+        }
+
 
         if (CHIP_REV_IS_FPGA(bp))
                 dev_err(&bp->pdev->dev, "FPGA detected\n");
@@ -11431,9 +11706,18 @@ static int __init bnx2x_init(void)
 
 static void __exit bnx2x_cleanup(void)
 {
+        struct list_head *pos, *q;
         pci_unregister_driver(&bnx2x_pci_driver);
 
         destroy_workqueue(bnx2x_wq);
+
+        /* Free globablly allocated resources */
+        list_for_each_safe(pos, q, &bnx2x_prev_list) {
+                struct bnx2x_prev_path_list *tmp =
+                        list_entry(pos, struct bnx2x_prev_path_list, list);
+                list_del(pos);
+                kfree(tmp);
+        }
 }
 
 void bnx2x_notify_link_changed(struct bnx2x *bp)
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_reg.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_reg.h
index fd7fb4581849..ab0a250f95fa 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_reg.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_reg.h
@@ -987,6 +987,7 @@
  * clear; 1 = set. Data valid only in addresses 0-4. all the rest are zero. */
 #define IGU_REG_WRITE_DONE_PENDING                               0x130480
 #define MCP_A_REG_MCPR_SCRATCH                                   0x3a0000
+#define MCP_REG_MCPR_ACCESS_LOCK                                 0x8009c
 #define MCP_REG_MCPR_CPU_PROGRAM_COUNTER                         0x8501c
 #define MCP_REG_MCPR_GP_INPUTS                                   0x800c0
 #define MCP_REG_MCPR_GP_OENABLE                                  0x800c8
@@ -1686,6 +1687,7 @@
    [10] rst_dbg; [11] rst_misc_core; [12] rst_dbue (UART); [13]
    Pci_resetmdio_n; [14] rst_emac0_hard_core; [15] rst_emac1_hard_core; 16]
    rst_pxp_rq_rd_wr; 31:17] reserved */
+#define MISC_REG_RESET_REG_1                                     0xa580
 #define MISC_REG_RESET_REG_2                                     0xa590
 /* [RW 20] 20 bit GRC address where the scratch-pad of the MCP that is
    shared with the driver resides */
@@ -5606,6 +5608,7 @@
 /* [RC 32] Parity register #0 read clear */
 #define XSEM_REG_XSEM_PRTY_STS_CLR_0                             0x280128
 #define XSEM_REG_XSEM_PRTY_STS_CLR_1                             0x280138
+#define MCPR_ACCESS_LOCK_LOCK                                    (1L<<31)
 #define MCPR_NVM_ACCESS_ENABLE_EN                                (1L<<0)
 #define MCPR_NVM_ACCESS_ENABLE_WR_EN                             (1L<<1)
 #define MCPR_NVM_ADDR_NVM_ADDR_VALUE                             (0xffffffL<<0)
@@ -5732,6 +5735,7 @@
 #define MISC_REGISTERS_GPIO_PORT_SHIFT                           4
 #define MISC_REGISTERS_GPIO_SET_POS                              8
 #define MISC_REGISTERS_RESET_REG_1_CLEAR                         0x588
+#define MISC_REGISTERS_RESET_REG_1_RST_BRB1                      (0x1<<0)
 #define MISC_REGISTERS_RESET_REG_1_RST_DORQ                      (0x1<<19)
 #define MISC_REGISTERS_RESET_REG_1_RST_HC                        (0x1<<29)
 #define MISC_REGISTERS_RESET_REG_1_RST_NIG                       (0x1<<7)
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c
index 3f52fadee3ed..513573321625 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c
@@ -3847,7 +3847,7 @@ static bool bnx2x_credit_pool_get_entry(
                         continue;
 
                 /* If we've got here we are going to find a free entry */
-                for (idx = vec * BNX2X_POOL_VEC_SIZE, i = 0;
+                for (idx = vec * BIT_VEC64_ELEM_SZ, i = 0;
                       i < BIT_VEC64_ELEM_SZ; idx++, i++)
 
                         if (BIT_VEC64_TEST_BIT(o->pool_mirror, idx)) {
diff --git a/drivers/net/ethernet/broadcom/tg3.c b/drivers/net/ethernet/broadcom/tg3.c
index 4e4bb3875868..062ac333fde6 100644
--- a/drivers/net/ethernet/broadcom/tg3.c
+++ b/drivers/net/ethernet/broadcom/tg3.c
@@ -2778,7 +2778,9 @@ static void tg3_power_down_phy(struct tg3 *tp, bool do_low_power)
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 ||
             (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780 &&
-             (tp->phy_flags & TG3_PHYFLG_MII_SERDES)))
+             (tp->phy_flags & TG3_PHYFLG_MII_SERDES)) ||
+            (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 &&
+             !tp->pci_fn))
                 return;
 
         if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5784_AX ||
diff --git a/drivers/net/ethernet/freescale/fsl_pq_mdio.c b/drivers/net/ethernet/freescale/fsl_pq_mdio.c
index 9eb815941df5..f7f0bf5d037b 100644
--- a/drivers/net/ethernet/freescale/fsl_pq_mdio.c
+++ b/drivers/net/ethernet/freescale/fsl_pq_mdio.c
@@ -356,13 +356,13 @@ static int fsl_pq_mdio_probe(struct platform_device *ofdev)
 
                 if (prop)
                         tbiaddr = *prop;
-        }
 
-        if (tbiaddr == -1) {
-                err = -EBUSY;
-                goto err_free_irqs;
-        } else {
-                out_be32(tbipa, tbiaddr);
+                if (tbiaddr == -1) {
+                        err = -EBUSY;
+                        goto err_free_irqs;
+                } else {
+                        out_be32(tbipa, tbiaddr);
+                }
         }
 
         err = of_mdiobus_register(new_bus, np);
diff --git a/drivers/net/ethernet/intel/e1000/e1000_main.c b/drivers/net/ethernet/intel/e1000/e1000_main.c
index 0e9aec8f6917..4348b6fd44fa 100644
--- a/drivers/net/ethernet/intel/e1000/e1000_main.c
+++ b/drivers/net/ethernet/intel/e1000/e1000_main.c
@@ -164,6 +164,8 @@ static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
 static bool e1000_vlan_used(struct e1000_adapter *adapter);
 static void e1000_vlan_mode(struct net_device *netdev,
                             netdev_features_t features);
+static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter,
+                                     bool filter_on);
 static int e1000_vlan_rx_add_vid(struct net_device *netdev, u16 vid);
 static int e1000_vlan_rx_kill_vid(struct net_device *netdev, u16 vid);
 static void e1000_restore_vlan(struct e1000_adapter *adapter);
@@ -215,7 +217,8 @@ MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 
-static int debug = NETIF_MSG_DRV | NETIF_MSG_PROBE;
+#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)
+static int debug = -1;
 module_param(debug, int, 0);
 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
 
@@ -979,7 +982,7 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
         adapter = netdev_priv(netdev);
         adapter->netdev = netdev;
         adapter->pdev = pdev;
-        adapter->msg_enable = (1 << debug) - 1;
+        adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
         adapter->bars = bars;
         adapter->need_ioport = need_ioport;
 
@@ -1214,7 +1217,7 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
         if (err)
                 goto err_register;
 
-        e1000_vlan_mode(netdev, netdev->features);
+        e1000_vlan_filter_on_off(adapter, false);
 
         /* print bus type/speed/width info */
         e_info(probe, "(PCI%s:%dMHz:%d-bit) %pM\n",
@@ -4770,6 +4773,22 @@ static bool e1000_vlan_used(struct e1000_adapter *adapter)
         return false;
 }
 
+static void __e1000_vlan_mode(struct e1000_adapter *adapter,
+                              netdev_features_t features)
+{
+        struct e1000_hw *hw = &adapter->hw;
+        u32 ctrl;
+
+        ctrl = er32(CTRL);
+        if (features & NETIF_F_HW_VLAN_RX) {
+                /* enable VLAN tag insert/strip */
+                ctrl |= E1000_CTRL_VME;
+        } else {
+                /* disable VLAN tag insert/strip */
+                ctrl &= ~E1000_CTRL_VME;
+        }
+        ew32(CTRL, ctrl);
+}
 static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter,
                                      bool filter_on)
 {
@@ -4779,6 +4798,7 @@ static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter,
         if (!test_bit(__E1000_DOWN, &adapter->flags))
                 e1000_irq_disable(adapter);
 
+        __e1000_vlan_mode(adapter, adapter->netdev->features);
         if (filter_on) {
                 /* enable VLAN receive filtering */
                 rctl = er32(RCTL);
@@ -4799,24 +4819,14 @@ static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter,
 }
 
 static void e1000_vlan_mode(struct net_device *netdev,
-        netdev_features_t features)
+                            netdev_features_t features)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
-        struct e1000_hw *hw = &adapter->hw;
-        u32 ctrl;
 
         if (!test_bit(__E1000_DOWN, &adapter->flags))
                 e1000_irq_disable(adapter);
 
-        ctrl = er32(CTRL);
-        if (features & NETIF_F_HW_VLAN_RX) {
-                /* enable VLAN tag insert/strip */
-                ctrl |= E1000_CTRL_VME;
-        } else {
-                /* disable VLAN tag insert/strip */
-                ctrl &= ~E1000_CTRL_VME;
-        }
-        ew32(CTRL, ctrl);
+        __e1000_vlan_mode(adapter, features);
 
         if (!test_bit(__E1000_DOWN, &adapter->flags))
                 e1000_irq_enable(adapter);
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index 7152eb11b7b9..2c38a65ade87 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -60,6 +60,11 @@
 char e1000e_driver_name[] = "e1000e";
 const char e1000e_driver_version[] = DRV_VERSION;
 
+#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)
+static int debug = -1;
+module_param(debug, int, 0);
+MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
+
 static void e1000e_disable_aspm(struct pci_dev *pdev, u16 state);
 
 static const struct e1000_info *e1000_info_tbl[] = {
@@ -6172,7 +6177,7 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
         adapter->hw.adapter = adapter;
         adapter->hw.mac.type = ei->mac;
         adapter->max_hw_frame_size = ei->max_hw_frame_size;
-        adapter->msg_enable = (1 << NETIF_MSG_DRV | NETIF_MSG_PROBE) - 1;
+        adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
 
         mmio_start = pci_resource_start(pdev, 0);
         mmio_len = pci_resource_len(pdev, 0);
diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
index c4902411d749..5ec31598ee47 100644
--- a/drivers/net/ethernet/intel/igb/igb_main.c
+++ b/drivers/net/ethernet/intel/igb/igb_main.c
@@ -238,6 +238,11 @@ MODULE_DESCRIPTION("Intel(R) Gigabit Ethernet Network Driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 
+#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)
+static int debug = -1;
+module_param(debug, int, 0);
+MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
+
 struct igb_reg_info {
         u32 ofs;
         char *name;
@@ -1893,7 +1898,7 @@ static int __devinit igb_probe(struct pci_dev *pdev,
         adapter->pdev = pdev;
         hw = &adapter->hw;
         hw->back = adapter;
-        adapter->msg_enable = NETIF_MSG_DRV | NETIF_MSG_PROBE;
+        adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
 
         mmio_start = pci_resource_start(pdev, 0);
         mmio_len = pci_resource_len(pdev, 0);
diff --git a/drivers/net/ethernet/intel/igbvf/netdev.c b/drivers/net/ethernet/intel/igbvf/netdev.c
index 217c143686d2..d61ca2a732f0 100644
--- a/drivers/net/ethernet/intel/igbvf/netdev.c
+++ b/drivers/net/ethernet/intel/igbvf/netdev.c
@@ -55,6 +55,11 @@ static const char igbvf_driver_string[] =
 static const char igbvf_copyright[] =
                   "Copyright (c) 2009 - 2012 Intel Corporation.";
 
+#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)
+static int debug = -1;
+module_param(debug, int, 0);
+MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
+
 static int igbvf_poll(struct napi_struct *napi, int budget);
 static void igbvf_reset(struct igbvf_adapter *);
 static void igbvf_set_interrupt_capability(struct igbvf_adapter *);
@@ -2649,7 +2654,7 @@ static int __devinit igbvf_probe(struct pci_dev *pdev,
         adapter->flags = ei->flags;
         adapter->hw.back = adapter;
         adapter->hw.mac.type = ei->mac;
-        adapter->msg_enable = (1 << NETIF_MSG_DRV | NETIF_MSG_PROBE) - 1;
+        adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
 
         /* PCI config space info */
 
diff --git a/drivers/net/ethernet/intel/ixgb/ixgb_main.c b/drivers/net/ethernet/intel/ixgb/ixgb_main.c
index 82aaa792cbf3..5fce363d810a 100644
--- a/drivers/net/ethernet/intel/ixgb/ixgb_main.c
+++ b/drivers/net/ethernet/intel/ixgb/ixgb_main.c
@@ -134,8 +134,8 @@ MODULE_DESCRIPTION("Intel(R) PRO/10GbE Network Driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 
-#define DEFAULT_DEBUG_LEVEL_SHIFT 3
-static int debug = DEFAULT_DEBUG_LEVEL_SHIFT;
+#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)
+static int debug = -1;
 module_param(debug, int, 0);
 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
 
@@ -442,7 +442,7 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         adapter->netdev = netdev;
         adapter->pdev = pdev;
         adapter->hw.back = adapter;
-        adapter->msg_enable = netif_msg_init(debug, DEFAULT_DEBUG_LEVEL_SHIFT);
+        adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
 
         adapter->hw.hw_addr = pci_ioremap_bar(pdev, BAR_0);
         if (!adapter->hw.hw_addr) {
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe.h b/drivers/net/ethernet/intel/ixgbe/ixgbe.h
index 80e26ff30ebf..74e192107f9a 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe.h
@@ -544,7 +544,7 @@ struct ixgbe_fdir_filter {
         u16 action;
 };
 
-enum ixbge_state_t {
+enum ixgbe_state_t {
         __IXGBE_TESTING,
         __IXGBE_RESETTING,
         __IXGBE_DOWN,
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
index 398fc223cab9..3e26b1f9ac75 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
@@ -63,8 +63,8 @@ static char ixgbe_default_device_descr[] =
                               "Intel(R) 10 Gigabit Network Connection";
 #endif
 #define MAJ 3
-#define MIN 6
-#define BUILD 7
+#define MIN 8
+#define BUILD 21
 #define DRV_VERSION __stringify(MAJ) "." __stringify(MIN) "." \
         __stringify(BUILD) "-k"
 const char ixgbe_driver_version[] = DRV_VERSION;
@@ -141,13 +141,16 @@ module_param(allow_unsupported_sfp, uint, 0);
 MODULE_PARM_DESC(allow_unsupported_sfp,
                  "Allow unsupported and untested SFP+ modules on 82599-based adapters");
 
+#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)
+static int debug = -1;
+module_param(debug, int, 0);
+MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
+
 MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
 MODULE_DESCRIPTION("Intel(R) 10 Gigabit PCI Express Network Driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 
-#define DEFAULT_DEBUG_LEVEL_SHIFT 3
-
 static void ixgbe_service_event_schedule(struct ixgbe_adapter *adapter)
 {
         if (!test_bit(__IXGBE_DOWN, &adapter->state) &&
@@ -6834,7 +6837,7 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
         adapter->pdev = pdev;
         hw = &adapter->hw;
         hw->back = adapter;
-        adapter->msg_enable = (1 << DEFAULT_DEBUG_LEVEL_SHIFT) - 1;
+        adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
 
         hw->hw_addr = ioremap(pci_resource_start(pdev, 0),
                               pci_resource_len(pdev, 0));
diff --git a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
index 581c65976bb4..307611ae831d 100644
--- a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
+++ b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
@@ -91,7 +91,10 @@ MODULE_DESCRIPTION("Intel(R) 82599 Virtual Function Driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 
-#define DEFAULT_DEBUG_LEVEL_SHIFT 3
+#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)
+static int debug = -1;
+module_param(debug, int, 0);
+MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
 
 /* forward decls */
 static void ixgbevf_set_itr_msix(struct ixgbevf_q_vector *q_vector);
@@ -3367,7 +3370,7 @@ static int __devinit ixgbevf_probe(struct pci_dev *pdev,
         adapter->pdev = pdev;
         hw = &adapter->hw;
         hw->back = adapter;
-        adapter->msg_enable = (1 << DEFAULT_DEBUG_LEVEL_SHIFT) - 1;
+        adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
 
         /*
          * call save state here in standalone driver because it relies on
diff --git a/drivers/net/ethernet/marvell/sky2.c b/drivers/net/ethernet/marvell/sky2.c
index 423a1a2a702e..b806d9b4defb 100644
--- a/drivers/net/ethernet/marvell/sky2.c
+++ b/drivers/net/ethernet/marvell/sky2.c
@@ -1767,13 +1767,14 @@ static int sky2_open(struct net_device *dev)
 
         sky2_hw_up(sky2);
 
+        /* Enable interrupts from phy/mac for port */
+        imask = sky2_read32(hw, B0_IMSK);
+
         if (hw->chip_id == CHIP_ID_YUKON_OPT ||
             hw->chip_id == CHIP_ID_YUKON_PRM ||
             hw->chip_id == CHIP_ID_YUKON_OP_2)
                 imask |= Y2_IS_PHY_QLNK;        /* enable PHY Quick Link */
 
-        /* Enable interrupts from phy/mac for port */
-        imask = sky2_read32(hw, B0_IMSK);
         imask |= portirq_msk[port];
         sky2_write32(hw, B0_IMSK, imask);
         sky2_read32(hw, B0_IMSK);
diff --git a/drivers/net/ethernet/nxp/lpc_eth.c b/drivers/net/ethernet/nxp/lpc_eth.c
index 69444247c20b..6dfc26d85e47 100644
--- a/drivers/net/ethernet/nxp/lpc_eth.c
+++ b/drivers/net/ethernet/nxp/lpc_eth.c
@@ -1441,7 +1441,7 @@ static int lpc_eth_drv_probe(struct platform_device *pdev)
         }
 #endif
         if (!is_valid_ether_addr(ndev->dev_addr))
-                dev_hw_addr_random(ndev, ndev->dev_addr);
+                eth_hw_addr_random(ndev);
 
         /* Reset the ethernet controller */
         __lpc_eth_reset(pldat);
diff --git a/drivers/net/ethernet/renesas/Kconfig b/drivers/net/ethernet/renesas/Kconfig
index 9755b49bbefb..3fb2355af37e 100644
--- a/drivers/net/ethernet/renesas/Kconfig
+++ b/drivers/net/ethernet/renesas/Kconfig
@@ -7,7 +7,8 @@ config SH_ETH
         depends on SUPERH && \
                 (CPU_SUBTYPE_SH7710 || CPU_SUBTYPE_SH7712 || \
                  CPU_SUBTYPE_SH7763 || CPU_SUBTYPE_SH7619 || \
-                 CPU_SUBTYPE_SH7724 || CPU_SUBTYPE_SH7757)
+                 CPU_SUBTYPE_SH7724 || CPU_SUBTYPE_SH7734 || \
+                 CPU_SUBTYPE_SH7757)
         select CRC32
         select NET_CORE
         select MII
@@ -16,4 +17,4 @@ config SH_ETH
         ---help---
           Renesas SuperH Ethernet device driver.
           This driver supporting CPUs are:
-                - SH7710, SH7712, SH7763, SH7619, SH7724, and SH7757.
+                - SH7619, SH7710, SH7712, SH7724, SH7734, SH7763 and SH7757.
diff --git a/drivers/net/ethernet/renesas/sh_eth.c b/drivers/net/ethernet/renesas/sh_eth.c
index 8615961c1287..d63e09b29a96 100644
--- a/drivers/net/ethernet/renesas/sh_eth.c
+++ b/drivers/net/ethernet/renesas/sh_eth.c
@@ -1,8 +1,8 @@
 /*
  *  SuperH Ethernet device driver
  *
- *  Copyright (C) 2006-2008 Nobuhiro Iwamatsu
- *  Copyright (C) 2008-2009 Renesas Solutions Corp.
+ *  Copyright (C) 2006-2012 Nobuhiro Iwamatsu
+ *  Copyright (C) 2008-2012 Renesas Solutions Corp.
  *
  *  This program is free software; you can redistribute it and/or modify it
  *  under the terms and conditions of the GNU General Public License,
@@ -38,6 +38,7 @@
 #include <linux/slab.h>
 #include <linux/ethtool.h>
 #include <linux/if_vlan.h>
+#include <linux/clk.h>
 #include <linux/sh_eth.h>
 
 #include "sh_eth.h"
@@ -279,8 +280,9 @@ static struct sh_eth_cpu_data *sh_eth_get_cpu_data(struct sh_eth_private *mdp)
                 return &sh_eth_my_cpu_data;
 }
 
-#elif defined(CONFIG_CPU_SUBTYPE_SH7763)
+#elif defined(CONFIG_CPU_SUBTYPE_SH7734) || defined(CONFIG_CPU_SUBTYPE_SH7763)
 #define SH_ETH_HAS_TSU  1
+static void sh_eth_reset_hw_crc(struct net_device *ndev);
 static void sh_eth_chip_reset(struct net_device *ndev)
 {
         struct sh_eth_private *mdp = netdev_priv(ndev);
@@ -314,6 +316,9 @@ static void sh_eth_reset(struct net_device *ndev)
         sh_eth_write(ndev, 0x0, RDFAR);
         sh_eth_write(ndev, 0x0, RDFXR);
         sh_eth_write(ndev, 0x0, RDFFR);
+
+        /* Reset HW CRC register */
+        sh_eth_reset_hw_crc(ndev);
 }
 
 static void sh_eth_set_duplex(struct net_device *ndev)
@@ -370,8 +375,17 @@ static struct sh_eth_cpu_data sh_eth_my_cpu_data = {
         .no_trimd       = 1,
         .no_ade         = 1,
         .tsu            = 1,
+#if defined(CONFIG_CPU_SUBTYPE_SH7734)
+        .hw_crc     = 1,
+#endif
 };
 
+static void sh_eth_reset_hw_crc(struct net_device *ndev)
+{
+        if (sh_eth_my_cpu_data.hw_crc)
+                sh_eth_write(ndev, 0x0, CSMR);
+}
+
 #elif defined(CONFIG_CPU_SUBTYPE_SH7619)
 #define SH_ETH_RESET_DEFAULT    1
 static struct sh_eth_cpu_data sh_eth_my_cpu_data = {
@@ -790,7 +804,7 @@ static int sh_eth_dev_init(struct net_device *ndev)
         /* all sh_eth int mask */
         sh_eth_write(ndev, 0, EESIPR);
 
-#if defined(__LITTLE_ENDIAN__)
+#if defined(__LITTLE_ENDIAN)
         if (mdp->cd->hw_swap)
                 sh_eth_write(ndev, EDMR_EL, EDMR);
         else
diff --git a/drivers/net/ethernet/renesas/sh_eth.h b/drivers/net/ethernet/renesas/sh_eth.h
index 57dc26261116..0fa14afce23d 100644
--- a/drivers/net/ethernet/renesas/sh_eth.h
+++ b/drivers/net/ethernet/renesas/sh_eth.h
@@ -1,8 +1,8 @@
 /*
  *  SuperH Ethernet device driver
  *
- *  Copyright (C) 2006-2008 Nobuhiro Iwamatsu
- *  Copyright (C) 2008-2011 Renesas Solutions Corp.
+ *  Copyright (C) 2006-2012 Nobuhiro Iwamatsu
+ *  Copyright (C) 2008-2012 Renesas Solutions Corp.
  *
  *  This program is free software; you can redistribute it and/or modify it
  *  under the terms and conditions of the GNU General Public License,
@@ -98,6 +98,8 @@ enum {
         CEECR,
         MAFCR,
         RTRATE,
+        CSMR,
+        RMII_MII,
 
         /* TSU Absolute address */
         ARSTR,
@@ -172,6 +174,7 @@ static const u16 sh_eth_offset_gigabit[SH_ETH_MAX_REGISTER_OFFSET] = {
         [RMCR]  = 0x0458,
         [RPADIR]        = 0x0460,
         [FCFTR] = 0x0468,
+        [CSMR] = 0x04E4,
 
         [ECMR]  = 0x0500,
         [ECSR]  = 0x0510,
@@ -200,6 +203,7 @@ static const u16 sh_eth_offset_gigabit[SH_ETH_MAX_REGISTER_OFFSET] = {
         [CERCR] = 0x0768,
         [CEECR] = 0x0770,
         [MAFCR] = 0x0778,
+        [RMII_MII] =  0x0790,
 
         [ARSTR] = 0x0000,
         [TSU_CTRST]     = 0x0004,
@@ -377,7 +381,7 @@ static const u16 sh_eth_offset_fast_sh3_sh2[SH_ETH_MAX_REGISTER_OFFSET] = {
 /*
  * Register's bits
  */
-#ifdef CONFIG_CPU_SUBTYPE_SH7763
+#if defined(CONFIG_CPU_SUBTYPE_SH7734) || defined(CONFIG_CPU_SUBTYPE_SH7763)
 /* EDSR */
 enum EDSR_BIT {
         EDSR_ENT = 0x01, EDSR_ENR = 0x02,
@@ -689,7 +693,7 @@ enum TSU_FWSLC_BIT {
  */
 struct sh_eth_txdesc {
         u32 status;             /* TD0 */
-#if defined(CONFIG_CPU_LITTLE_ENDIAN)
+#if defined(__LITTLE_ENDIAN)
         u16 pad0;               /* TD1 */
         u16 buffer_length;      /* TD1 */
 #else
@@ -706,7 +710,7 @@ struct sh_eth_txdesc {
  */
 struct sh_eth_rxdesc {
         u32 status;             /* RD0 */
-#if defined(CONFIG_CPU_LITTLE_ENDIAN)
+#if defined(__LITTLE_ENDIAN)
         u16 frame_length;       /* RD1 */
         u16 buffer_length;      /* RD1 */
 #else
@@ -751,6 +755,7 @@ struct sh_eth_cpu_data {
         unsigned rpadir:1;              /* E-DMAC have RPADIR */
         unsigned no_trimd:1;            /* E-DMAC DO NOT have TRIMD */
         unsigned no_ade:1;      /* E-DMAC DO NOT have ADE bit in EESR */
+        unsigned hw_crc:1;      /* E-DMAC have CSMR */
 };
 
 struct sh_eth_private {
diff --git a/drivers/net/ethernet/via/via-rhine.c b/drivers/net/ethernet/via/via-rhine.c
index 39b8cf3dafcd..fcfa01f7ceb6 100644
--- a/drivers/net/ethernet/via/via-rhine.c
+++ b/drivers/net/ethernet/via/via-rhine.c
@@ -503,30 +503,32 @@ static int rhine_vlan_rx_add_vid(struct net_device *dev, unsigned short vid);
 static int rhine_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid);
 static void rhine_restart_tx(struct net_device *dev);
 
-static void rhine_wait_bit(struct rhine_private *rp, u8 reg, u8 mask, bool high)
+static void rhine_wait_bit(struct rhine_private *rp, u8 reg, u8 mask, bool low)
 {
         void __iomem *ioaddr = rp->base;
         int i;
 
         for (i = 0; i < 1024; i++) {
-                if (high ^ !!(ioread8(ioaddr + reg) & mask))
+                bool has_mask_bits = !!(ioread8(ioaddr + reg) & mask);
+
+                if (low ^ has_mask_bits)
                         break;
                 udelay(10);
         }
         if (i > 64) {
                 netif_dbg(rp, hw, rp->dev, "%s bit wait (%02x/%02x) cycle "
-                          "count: %04d\n", high ? "high" : "low", reg, mask, i);
+                          "count: %04d\n", low ? "low" : "high", reg, mask, i);
         }
 }
 
 static void rhine_wait_bit_high(struct rhine_private *rp, u8 reg, u8 mask)
 {
-        rhine_wait_bit(rp, reg, mask, true);
+        rhine_wait_bit(rp, reg, mask, false);
 }
 
 static void rhine_wait_bit_low(struct rhine_private *rp, u8 reg, u8 mask)
 {
-        rhine_wait_bit(rp, reg, mask, false);
+        rhine_wait_bit(rp, reg, mask, true);
 }
 
 static u32 rhine_get_events(struct rhine_private *rp)