69 files changed, 705 insertions, 294 deletions

diff --git a/MAINTAINERS b/MAINTAINERS
index eecf3441ac21..962232d62781 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1251,7 +1251,6 @@ ATHEROS ATH5K WIRELESS DRIVER
 M:      Jiri Slaby <jirislaby@gmail.com>
 M:      Nick Kossifidis <mickflemm@gmail.com>
 M:      "Luis R. Rodriguez" <mcgrof@qca.qualcomm.com>
-M:      Bob Copeland <me@bobcopeland.com>
 L:      linux-wireless@vger.kernel.org
 L:      ath5k-devel@lists.ath5k.org
 W:      http://wireless.kernel.org/en/users/Drivers/ath5k
@@ -3557,17 +3556,13 @@ L:	linux-pm@vger.kernel.org
 S:      Supported
 F:      arch/x86/platform/mrst/pmu.*
 
-INTEL PRO/WIRELESS 2100 NETWORK CONNECTION SUPPORT
+INTEL PRO/WIRELESS 2100, 2200BG, 2915ABG NETWORK CONNECTION SUPPORT
+M:      Stanislav Yakovlev <stas.yakovlev@gmail.com>
 L:      linux-wireless@vger.kernel.org
-S:      Orphan
+S:      Maintained
 F:      Documentation/networking/README.ipw2100
-F:      drivers/net/wireless/ipw2x00/ipw2100.*
-
-INTEL PRO/WIRELESS 2915ABG NETWORK CONNECTION SUPPORT
-L:      linux-wireless@vger.kernel.org
-S:      Orphan
 F:      Documentation/networking/README.ipw2200
-F:      drivers/net/wireless/ipw2x00/ipw2200.*
+F:      drivers/net/wireless/ipw2x00/
 
 INTEL(R) TRUSTED EXECUTION TECHNOLOGY (TXT)
 M:      Joseph Cihula <joseph.cihula@intel.com>
diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c
index 5671752f8d9c..5a5b6e4dd738 100644
--- a/arch/x86/net/bpf_jit_comp.c
+++ b/arch/x86/net/bpf_jit_comp.c
@@ -289,7 +289,7 @@ void bpf_jit_compile(struct sk_filter *fp)
                                         EMIT2(0x24, K & 0xFF); /* and imm8,%al */
                                 } else if (K >= 0xFFFF0000) {
                                         EMIT2(0x66, 0x25);      /* and imm16,%ax */
-                                        EMIT2(K, 2);
+                                        EMIT(K, 2);
                                 } else {
                                         EMIT1_off32(0x25, K);   /* and imm32,%eax */
                                 }
diff --git a/drivers/isdn/hardware/mISDN/avmfritz.c b/drivers/isdn/hardware/mISDN/avmfritz.c
index 05ed4d0cb18b..c0b8c960ee3f 100644
--- a/drivers/isdn/hardware/mISDN/avmfritz.c
+++ b/drivers/isdn/hardware/mISDN/avmfritz.c
@@ -891,7 +891,7 @@ open_bchannel(struct fritzcard *fc, struct channel_req *rq)
 {
         struct bchannel         *bch;
 
-        if (rq->adr.channel > 2)
+        if (rq->adr.channel == 0 || rq->adr.channel > 2)
                 return -EINVAL;
         if (rq->protocol == ISDN_P_NONE)
                 return -EINVAL;
diff --git a/drivers/isdn/hardware/mISDN/hfcpci.c b/drivers/isdn/hardware/mISDN/hfcpci.c
index d055ae7fa040..e2c83a2d7691 100644
--- a/drivers/isdn/hardware/mISDN/hfcpci.c
+++ b/drivers/isdn/hardware/mISDN/hfcpci.c
@@ -1962,7 +1962,7 @@ open_bchannel(struct hfc_pci *hc, struct channel_req *rq)
 {
         struct bchannel         *bch;
 
-        if (rq->adr.channel > 2)
+        if (rq->adr.channel == 0 || rq->adr.channel > 2)
                 return -EINVAL;
         if (rq->protocol == ISDN_P_NONE)
                 return -EINVAL;
diff --git a/drivers/isdn/hardware/mISDN/hfcsusb.c b/drivers/isdn/hardware/mISDN/hfcsusb.c
index 602338734634..8cde2a0538ab 100644
--- a/drivers/isdn/hardware/mISDN/hfcsusb.c
+++ b/drivers/isdn/hardware/mISDN/hfcsusb.c
@@ -486,7 +486,7 @@ open_bchannel(struct hfcsusb *hw, struct channel_req *rq)
 {
         struct bchannel         *bch;
 
-        if (rq->adr.channel > 2)
+        if (rq->adr.channel == 0 || rq->adr.channel > 2)
                 return -EINVAL;
         if (rq->protocol == ISDN_P_NONE)
                 return -EINVAL;
diff --git a/drivers/isdn/hardware/mISDN/mISDNipac.c b/drivers/isdn/hardware/mISDN/mISDNipac.c
index b47e9bed2185..884369f09cad 100644
--- a/drivers/isdn/hardware/mISDN/mISDNipac.c
+++ b/drivers/isdn/hardware/mISDN/mISDNipac.c
@@ -1506,7 +1506,7 @@ open_bchannel(struct ipac_hw *ipac, struct channel_req *rq)
 {
         struct bchannel         *bch;
 
-        if (rq->adr.channel > 2)
+        if (rq->adr.channel == 0 || rq->adr.channel > 2)
                 return -EINVAL;
         if (rq->protocol == ISDN_P_NONE)
                 return -EINVAL;
diff --git a/drivers/isdn/hardware/mISDN/mISDNisar.c b/drivers/isdn/hardware/mISDN/mISDNisar.c
index 10446ab404b5..9a6da6edcfa8 100644
--- a/drivers/isdn/hardware/mISDN/mISDNisar.c
+++ b/drivers/isdn/hardware/mISDN/mISDNisar.c
@@ -1670,7 +1670,7 @@ isar_open(struct isar_hw *isar, struct channel_req *rq)
 {
         struct bchannel         *bch;
 
-        if (rq->adr.channel > 2)
+        if (rq->adr.channel == 0 || rq->adr.channel > 2)
                 return -EINVAL;
         if (rq->protocol == ISDN_P_NONE)
                 return -EINVAL;
diff --git a/drivers/isdn/hardware/mISDN/netjet.c b/drivers/isdn/hardware/mISDN/netjet.c
index dd6de9f7a8a3..c726e09d0981 100644
--- a/drivers/isdn/hardware/mISDN/netjet.c
+++ b/drivers/isdn/hardware/mISDN/netjet.c
@@ -860,7 +860,7 @@ open_bchannel(struct tiger_hw *card, struct channel_req *rq)
 {
         struct bchannel *bch;
 
-        if (rq->adr.channel > 2)
+        if (rq->adr.channel == 0 || rq->adr.channel > 2)
                 return -EINVAL;
         if (rq->protocol == ISDN_P_NONE)
                 return -EINVAL;
diff --git a/drivers/isdn/hardware/mISDN/w6692.c b/drivers/isdn/hardware/mISDN/w6692.c
index 7f1e7ba75cd1..2183357f0799 100644
--- a/drivers/isdn/hardware/mISDN/w6692.c
+++ b/drivers/isdn/hardware/mISDN/w6692.c
@@ -1015,7 +1015,7 @@ open_bchannel(struct w6692_hw *card, struct channel_req *rq)
 {
         struct bchannel *bch;
 
-        if (rq->adr.channel > 2)
+        if (rq->adr.channel == 0 || rq->adr.channel > 2)
                 return -EINVAL;
         if (rq->protocol == ISDN_P_NONE)
                 return -EINVAL;
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 0c76186bb9e7..941b4e189adf 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -891,9 +891,15 @@ static void bond_do_fail_over_mac(struct bonding *bond,
 
         switch (bond->params.fail_over_mac) {
         case BOND_FOM_ACTIVE:
-                if (new_active)
+                if (new_active) {
                         memcpy(bond->dev->dev_addr,  new_active->dev->dev_addr,
                                new_active->dev->addr_len);
+                        write_unlock_bh(&bond->curr_slave_lock);
+                        read_unlock(&bond->lock);
+                        call_netdevice_notifiers(NETDEV_CHANGEADDR, bond->dev);
+                        read_lock(&bond->lock);
+                        write_lock_bh(&bond->curr_slave_lock);
+                }
                 break;
         case BOND_FOM_FOLLOW:
                 /*
diff --git a/drivers/net/eql.c b/drivers/net/eql.c
index a59cf961a436..f219d38acf58 100644
--- a/drivers/net/eql.c
+++ b/drivers/net/eql.c
@@ -125,6 +125,7 @@
 #include <linux/if.h>
 #include <linux/if_arp.h>
 #include <linux/if_eql.h>
+#include <linux/pkt_sched.h>
 
 #include <asm/uaccess.h>
 
@@ -143,7 +144,7 @@ static void eql_timer(unsigned long param)
         equalizer_t *eql = (equalizer_t *) param;
         struct list_head *this, *tmp, *head;
 
-        spin_lock_bh(&eql->queue.lock);
+        spin_lock(&eql->queue.lock);
         head = &eql->queue.all_slaves;
         list_for_each_safe(this, tmp, head) {
                 slave_t *slave = list_entry(this, slave_t, list);
@@ -157,7 +158,7 @@ static void eql_timer(unsigned long param)
                 }
 
         }
-        spin_unlock_bh(&eql->queue.lock);
+        spin_unlock(&eql->queue.lock);
 
         eql->timer.expires = jiffies + EQL_DEFAULT_RESCHED_IVAL;
         add_timer(&eql->timer);
@@ -341,7 +342,7 @@ static netdev_tx_t eql_slave_xmit(struct sk_buff *skb, struct net_device *dev)
                 struct net_device *slave_dev = slave->dev;
 
                 skb->dev = slave_dev;
-                skb->priority = 1;
+                skb->priority = TC_PRIO_FILLER;
                 slave->bytes_queued += skb->len;
                 dev_queue_xmit(skb);
                 dev->stats.tx_packets++;
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)
diff --git a/drivers/net/rionet.c b/drivers/net/rionet.c
index a57f05726b57..91d25888a1b9 100644
--- a/drivers/net/rionet.c
+++ b/drivers/net/rionet.c
@@ -375,8 +375,8 @@ static void rionet_remove(struct rio_dev *rdev)
         struct net_device *ndev = rio_get_drvdata(rdev);
         struct rionet_peer *peer, *tmp;
 
-        free_pages((unsigned long)rionet_active, rdev->net->hport->sys_size ?
-                                        __fls(sizeof(void *)) + 4 : 0);
+        free_pages((unsigned long)rionet_active, get_order(sizeof(void *) *
+                        RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size)));
         unregister_netdev(ndev);
         free_netdev(ndev);
 
@@ -432,15 +432,16 @@ static int rionet_setup_netdev(struct rio_mport *mport, struct net_device *ndev)
         int rc = 0;
         struct rionet_private *rnet;
         u16 device_id;
+        const size_t rionet_active_bytes = sizeof(void *) *
+                                RIO_MAX_ROUTE_ENTRIES(mport->sys_size);
 
         rionet_active = (struct rio_dev **)__get_free_pages(GFP_KERNEL,
-                        mport->sys_size ? __fls(sizeof(void *)) + 4 : 0);
+                        get_order(rionet_active_bytes));
         if (!rionet_active) {
                 rc = -ENOMEM;
                 goto out;
         }
-        memset((void *)rionet_active, 0, sizeof(void *) *
-                                RIO_MAX_ROUTE_ENTRIES(mport->sys_size));
+        memset((void *)rionet_active, 0, rionet_active_bytes);
 
         /* Set up private area */
         rnet = netdev_priv(ndev);
diff --git a/drivers/net/usb/cdc-phonet.c b/drivers/net/usb/cdc-phonet.c
index 3886b30ed373..3e41b00c6806 100644
--- a/drivers/net/usb/cdc-phonet.c
+++ b/drivers/net/usb/cdc-phonet.c
@@ -165,13 +165,13 @@ static void rx_complete(struct urb *req)
                                 memcpy(skb_put(skb, 1), page_address(page), 1);
                                 skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags,
                                                 page, 1, req->actual_length,
-                                                req->actual_length);
+                                                PAGE_SIZE);
                                 page = NULL;
                         }
                 } else {
                         skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags,
                                         page, 0, req->actual_length,
-                                        req->actual_length);
+                                        PAGE_SIZE);
                         page = NULL;
                 }
                 if (req->actual_length < PAGE_SIZE)
diff --git a/drivers/net/usb/cdc_eem.c b/drivers/net/usb/cdc_eem.c
index 439690be519f..685a4e22c768 100644
--- a/drivers/net/usb/cdc_eem.c
+++ b/drivers/net/usb/cdc_eem.c
@@ -93,6 +93,7 @@ static int eem_bind(struct usbnet *dev, struct usb_interface *intf)
         /* no jumbogram (16K) support for now */
 
         dev->net->hard_header_len += EEM_HEAD + ETH_FCS_LEN;
+        dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
 
         return 0;
 }
diff --git a/drivers/net/usb/rtl8150.c b/drivers/net/usb/rtl8150.c
index 6dda2fe5b15b..d363b31053da 100644
--- a/drivers/net/usb/rtl8150.c
+++ b/drivers/net/usb/rtl8150.c
@@ -85,32 +85,6 @@
 #define INT_CRERR_CNT           0x06
 #define INT_COL_CNT             0x07
 
-/* Transmit status register errors */
-#define TSR_ECOL                (1<<5)
-#define TSR_LCOL                (1<<4)
-#define TSR_LOSS_CRS            (1<<3)
-#define TSR_JBR                 (1<<2)
-#define TSR_ERRORS              (TSR_ECOL | TSR_LCOL | TSR_LOSS_CRS | TSR_JBR)
-/* Receive status register errors */
-#define RSR_CRC                 (1<<2)
-#define RSR_FAE                 (1<<1)
-#define RSR_ERRORS              (RSR_CRC | RSR_FAE)
-
-/* Media status register definitions */
-#define MSR_DUPLEX              (1<<4)
-#define MSR_SPEED               (1<<3)
-#define MSR_LINK                (1<<2)
-
-/* Interrupt pipe data */
-#define INT_TSR                 0x00
-#define INT_RSR                 0x01
-#define INT_MSR                 0x02
-#define INT_WAKSR               0x03
-#define INT_TXOK_CNT            0x04
-#define INT_RXLOST_CNT          0x05
-#define INT_CRERR_CNT           0x06
-#define INT_COL_CNT             0x07
-
 
 #define RTL8150_MTU             1540
 #define RTL8150_TX_TIMEOUT      (HZ)
diff --git a/drivers/net/usb/zaurus.c b/drivers/net/usb/zaurus.c
index c3197ce0e2ad..34db195fb8b0 100644
--- a/drivers/net/usb/zaurus.c
+++ b/drivers/net/usb/zaurus.c
@@ -337,6 +337,11 @@ static const struct usb_device_id	products [] = {
         .driver_info = ZAURUS_PXA_INFO,
 },
 {
+        /* Motorola Rokr E6 */
+        USB_DEVICE_AND_INTERFACE_INFO(0x22b8, 0x6027, USB_CLASS_COMM,
+                        USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
+        .driver_info = (unsigned long) &bogus_mdlm_info,
+}, {
         /* Motorola MOTOMAGX phones */
         USB_DEVICE_AND_INTERFACE_INFO(0x22b8, 0x6425, USB_CLASS_COMM,
                         USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 019da012669f..4de2760c5937 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -625,12 +625,13 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
 
         /* This can happen with OOM and indirect buffers. */
         if (unlikely(capacity < 0)) {
-                if (net_ratelimit()) {
-                        if (likely(capacity == -ENOMEM)) {
+                if (likely(capacity == -ENOMEM)) {
+                        if (net_ratelimit()) {
                                 dev_warn(&dev->dev,
                                          "TX queue failure: out of memory\n");
                         } else {
-                                dev->stats.tx_fifo_errors++;
+                        dev->stats.tx_fifo_errors++;
+                        if (net_ratelimit())
                                 dev_warn(&dev->dev,
                                          "Unexpected TX queue failure: %d\n",
                                          capacity);
diff --git a/drivers/net/wimax/i2400m/netdev.c b/drivers/net/wimax/i2400m/netdev.c
index 63e4b709efa9..1d76ae855f07 100644
--- a/drivers/net/wimax/i2400m/netdev.c
+++ b/drivers/net/wimax/i2400m/netdev.c
@@ -597,7 +597,8 @@ static void i2400m_get_drvinfo(struct net_device *net_dev,
         struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
 
         strncpy(info->driver, KBUILD_MODNAME, sizeof(info->driver) - 1);
-        strncpy(info->fw_version, i2400m->fw_name, sizeof(info->fw_version) - 1);
+        strncpy(info->fw_version,
+                i2400m->fw_name ? : "", sizeof(info->fw_version) - 1);
         if (net_dev->dev.parent)
                 strncpy(info->bus_info, dev_name(net_dev->dev.parent),
                         sizeof(info->bus_info) - 1);
diff --git a/drivers/net/wimax/i2400m/usb.c b/drivers/net/wimax/i2400m/usb.c
index 2c1b8b687646..29b1e033a10b 100644
--- a/drivers/net/wimax/i2400m/usb.c
+++ b/drivers/net/wimax/i2400m/usb.c
@@ -339,6 +339,23 @@ int i2400mu_bus_reset(struct i2400m *i2400m, enum i2400m_reset_type rt)
         return result;
 }
 
+static void i2400mu_get_drvinfo(struct net_device *net_dev,
+                                struct ethtool_drvinfo *info)
+{
+        struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
+        struct i2400mu *i2400mu = container_of(i2400m, struct i2400mu, i2400m);
+        struct usb_device *udev = i2400mu->usb_dev;
+
+        strncpy(info->driver, KBUILD_MODNAME, sizeof(info->driver) - 1);
+        strncpy(info->fw_version,
+                i2400m->fw_name ? : "", sizeof(info->fw_version) - 1);
+        usb_make_path(udev, info->bus_info, sizeof(info->bus_info));
+}
+
+static const struct ethtool_ops i2400mu_ethtool_ops = {
+        .get_drvinfo = i2400mu_get_drvinfo,
+        .get_link = ethtool_op_get_link,
+};
 
 static
 void i2400mu_netdev_setup(struct net_device *net_dev)
@@ -347,6 +364,7 @@ void i2400mu_netdev_setup(struct net_device *net_dev)
         struct i2400mu *i2400mu = container_of(i2400m, struct i2400mu, i2400m);
         i2400mu_init(i2400mu);
         i2400m_netdev_setup(net_dev);
+        net_dev->ethtool_ops = &i2400mu_ethtool_ops;
 }
 
 
diff --git a/drivers/net/wireless/ath/ath9k/calib.c b/drivers/net/wireless/ath/ath9k/calib.c
index 2f4b48e6fb03..e5cceb077574 100644
--- a/drivers/net/wireless/ath/ath9k/calib.c
+++ b/drivers/net/wireless/ath/ath9k/calib.c
@@ -20,7 +20,6 @@
 
 /* Common calibration code */
 
-#define ATH9K_NF_TOO_HIGH       -60
 
 static int16_t ath9k_hw_get_nf_hist_mid(int16_t *nfCalBuffer)
 {
@@ -346,10 +345,10 @@ static void ath9k_hw_nf_sanitize(struct ath_hw *ah, s16 *nf)
                         "NF calibrated [%s] [chain %d] is %d\n",
                         (i >= 3 ? "ext" : "ctl"), i % 3, nf[i]);
 
-                if (nf[i] > ATH9K_NF_TOO_HIGH) {
+                if (nf[i] > limit->max) {
                         ath_dbg(common, CALIBRATE,
                                 "NF[%d] (%d) > MAX (%d), correcting to MAX\n",
-                                i, nf[i], ATH9K_NF_TOO_HIGH);
+                                i, nf[i], limit->max);
                         nf[i] = limit->max;
                 } else if (nf[i] < limit->min) {
                         ath_dbg(common, CALIBRATE,
diff --git a/drivers/net/wireless/ath/ath9k/init.c b/drivers/net/wireless/ath/ath9k/init.c
index 60159f4ee532..cb006458fc4b 100644
--- a/drivers/net/wireless/ath/ath9k/init.c
+++ b/drivers/net/wireless/ath/ath9k/init.c
@@ -680,7 +680,7 @@ void ath9k_set_hw_capab(struct ath_softc *sc, struct ieee80211_hw *hw)
         hw->queues = 4;
         hw->max_rates = 4;
         hw->channel_change_time = 5000;
-        hw->max_listen_interval = 10;
+        hw->max_listen_interval = 1;
         hw->max_rate_tries = 10;
         hw->sta_data_size = sizeof(struct ath_node);
         hw->vif_data_size = sizeof(struct ath_vif);
diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c
index 38794850f005..215eb2536b1e 100644
--- a/drivers/net/wireless/ath/ath9k/main.c
+++ b/drivers/net/wireless/ath/ath9k/main.c
@@ -640,7 +640,7 @@ static void ath_node_attach(struct ath_softc *sc, struct ieee80211_sta *sta,
         an->sta = sta;
         an->vif = vif;
 
-        if (sta->ht_cap.ht_supported) {
+        if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) {
                 ath_tx_node_init(sc, an);
                 an->maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
                                      sta->ht_cap.ampdu_factor);
@@ -659,7 +659,7 @@ static void ath_node_detach(struct ath_softc *sc, struct ieee80211_sta *sta)
         an->sta = NULL;
 #endif
 
-        if (sta->ht_cap.ht_supported)
+        if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT)
                 ath_tx_node_cleanup(sc, an);
 }
 
diff --git a/drivers/net/wireless/ath/ath9k/recv.c b/drivers/net/wireless/ath/ath9k/recv.c
index f4ae3ba994a8..1c4583c7ff7c 100644
--- a/drivers/net/wireless/ath/ath9k/recv.c
+++ b/drivers/net/wireless/ath/ath9k/recv.c
@@ -1913,13 +1913,13 @@ int ath_rx_tasklet(struct ath_softc *sc, int flush, bool hp)
                 if (sc->rx.frag) {
                         int space = skb->len - skb_tailroom(hdr_skb);
 
-                        sc->rx.frag = NULL;
-
                         if (pskb_expand_head(hdr_skb, 0, space, GFP_ATOMIC) < 0) {
                                 dev_kfree_skb(skb);
                                 goto requeue_drop_frag;
                         }
 
+                        sc->rx.frag = NULL;
+
                         skb_copy_from_linear_data(skb, skb_put(hdr_skb, skb->len),
                                                   skb->len);
                         dev_kfree_skb_any(skb);
diff --git a/drivers/net/wireless/ipw2x00/ipw2200.c b/drivers/net/wireless/ipw2x00/ipw2200.c
index 4fcdac63a300..2b022571a859 100644
--- a/drivers/net/wireless/ipw2x00/ipw2200.c
+++ b/drivers/net/wireless/ipw2x00/ipw2200.c
@@ -11507,9 +11507,9 @@ static int ipw_wdev_init(struct net_device *dev)
                         rc = -ENOMEM;
                         goto out;
                 }
-                /* translate geo->bg to a_band.channels */
+                /* translate geo->a to a_band.channels */
                 for (i = 0; i < geo->a_channels; i++) {
-                        a_band->channels[i].band = IEEE80211_BAND_2GHZ;
+                        a_band->channels[i].band = IEEE80211_BAND_5GHZ;
                         a_band->channels[i].center_freq = geo->a[i].freq;
                         a_band->channels[i].hw_value = geo->a[i].channel;
                         a_band->channels[i].max_power = geo->a[i].max_power;
diff --git a/drivers/net/wireless/iwlegacy/3945-mac.c b/drivers/net/wireless/iwlegacy/3945-mac.c
index 0c1209390169..faec40467208 100644
--- a/drivers/net/wireless/iwlegacy/3945-mac.c
+++ b/drivers/net/wireless/iwlegacy/3945-mac.c
@@ -2673,8 +2673,6 @@ il3945_bg_restart(struct work_struct *data)
 
         if (test_and_clear_bit(S_FW_ERROR, &il->status)) {
                 mutex_lock(&il->mutex);
-                /* FIXME: vif can be dereferenced */
-                il->vif = NULL;
                 il->is_open = 0;
                 mutex_unlock(&il->mutex);
                 il3945_down(il);
diff --git a/drivers/net/wireless/iwlegacy/4965-mac.c b/drivers/net/wireless/iwlegacy/4965-mac.c
index 17f1c6853182..c46275a92565 100644
--- a/drivers/net/wireless/iwlegacy/4965-mac.c
+++ b/drivers/net/wireless/iwlegacy/4965-mac.c
@@ -5652,8 +5652,6 @@ il4965_bg_restart(struct work_struct *data)
 
         if (test_and_clear_bit(S_FW_ERROR, &il->status)) {
                 mutex_lock(&il->mutex);
-                /* FIXME: do we dereference vif without mutex locked ? */
-                il->vif = NULL;
                 il->is_open = 0;
 
                 __il4965_down(il);
diff --git a/drivers/net/wireless/iwlegacy/common.c b/drivers/net/wireless/iwlegacy/common.c
index e5ac04739bcc..eaf249452e51 100644
--- a/drivers/net/wireless/iwlegacy/common.c
+++ b/drivers/net/wireless/iwlegacy/common.c
@@ -4508,6 +4508,7 @@ il_mac_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
 {
         struct il_priv *il = hw->priv;
         int err;
+        bool reset;
 
         mutex_lock(&il->mutex);
         D_MAC80211("enter: type %d, addr %pM\n", vif->type, vif->addr);
@@ -4518,7 +4519,12 @@ il_mac_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
                 goto out;
         }
 
-        if (il->vif) {
+        /*
+         * We do not support multiple virtual interfaces, but on hardware reset
+         * we have to add the same interface again.
+         */
+        reset = (il->vif == vif);
+        if (il->vif && !reset) {
                 err = -EOPNOTSUPP;
                 goto out;
         }
@@ -4528,8 +4534,11 @@ il_mac_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
 
         err = il_set_mode(il);
         if (err) {
-                il->vif = NULL;
-                il->iw_mode = NL80211_IFTYPE_STATION;
+                IL_WARN("Fail to set mode %d\n", vif->type);
+                if (!reset) {
+                        il->vif = NULL;
+                        il->iw_mode = NL80211_IFTYPE_STATION;
+                }
         }
 
 out:
@@ -5279,9 +5288,9 @@ il_mac_bss_info_changed(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
                 D_MAC80211("BSSID %pM\n", bss_conf->bssid);
 
                 /*
-                 * If there is currently a HW scan going on in the
-                 * background then we need to cancel it else the RXON
-                 * below/in post_associate will fail.
+                 * If there is currently a HW scan going on in the background,
+                 * then we need to cancel it, otherwise sometimes we are not
+                 * able to authenticate (FIXME: why ?)
                  */
                 if (il_scan_cancel_timeout(il, 100)) {
                         D_MAC80211("leave - scan abort failed\n");
@@ -5290,14 +5299,10 @@ il_mac_bss_info_changed(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
                 }
 
                 /* mac80211 only sets assoc when in STATION mode */
-                if (vif->type == NL80211_IFTYPE_ADHOC || bss_conf->assoc) {
-                        memcpy(il->staging.bssid_addr, bss_conf->bssid,
-                               ETH_ALEN);
+                memcpy(il->staging.bssid_addr, bss_conf->bssid, ETH_ALEN);
 
-                        /* currently needed in a few places */
-                        memcpy(il->bssid, bss_conf->bssid, ETH_ALEN);
-                } else
-                        il->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
+                /* FIXME: currently needed in a few places */
+                memcpy(il->bssid, bss_conf->bssid, ETH_ALEN);
         }
 
         /*
diff --git a/drivers/net/wireless/orinoco/main.c b/drivers/net/wireless/orinoco/main.c
index dd6c64ac406e..88e3ad2d1db8 100644
--- a/drivers/net/wireless/orinoco/main.c
+++ b/drivers/net/wireless/orinoco/main.c
@@ -1336,6 +1336,10 @@ static void qbuf_scan(struct orinoco_private *priv, void *buf,
         unsigned long flags;
 
         sd = kmalloc(sizeof(*sd), GFP_ATOMIC);
+        if (!sd) {
+                printk(KERN_ERR "%s: failed to alloc memory\n", __func__);
+                return;
+        }
         sd->buf = buf;
         sd->len = len;
         sd->type = type;
@@ -1353,6 +1357,10 @@ static void qabort_scan(struct orinoco_private *priv)
         unsigned long flags;
 
         sd = kmalloc(sizeof(*sd), GFP_ATOMIC);
+        if (!sd) {
+                printk(KERN_ERR "%s: failed to alloc memory\n", __func__);
+                return;
+        }
         sd->len = -1; /* Abort */
 
         spin_lock_irqsave(&priv->scan_lock, flags);
diff --git a/drivers/net/wireless/rt2x00/rt2800usb.c b/drivers/net/wireless/rt2x00/rt2800usb.c
index cd490abced91..001735f7a661 100644
--- a/drivers/net/wireless/rt2x00/rt2800usb.c
+++ b/drivers/net/wireless/rt2x00/rt2800usb.c
@@ -163,7 +163,13 @@ static bool rt2800usb_tx_sta_fifo_read_completed(struct rt2x00_dev *rt2x00dev,
 
                 /* Reschedule urb to read TX status again instantly */
                 return true;
-        } else if (rt2800usb_txstatus_pending(rt2x00dev)) {
+        }
+
+        /* Check if there is any entry that timedout waiting on TX status */
+        if (rt2800usb_txstatus_timeout(rt2x00dev))
+                queue_work(rt2x00dev->workqueue, &rt2x00dev->txdone_work);
+
+        if (rt2800usb_txstatus_pending(rt2x00dev)) {
                 /* Read register after 250 us */
                 hrtimer_start(&rt2x00dev->txstatus_timer, ktime_set(0, 250000),
                               HRTIMER_MODE_REL);
@@ -178,7 +184,7 @@ stop_reading:
          * here again if status reading is needed.
          */
         if (rt2800usb_txstatus_pending(rt2x00dev) &&
-            test_and_set_bit(TX_STATUS_READING, &rt2x00dev->flags))
+            !test_and_set_bit(TX_STATUS_READING, &rt2x00dev->flags))
                 return true;
         else
                 return false;
diff --git a/drivers/net/wireless/rtlwifi/rtl8192c/phy_common.c b/drivers/net/wireless/rtlwifi/rtl8192c/phy_common.c
index 1eec3a06d1f3..4c016241f340 100644
--- a/drivers/net/wireless/rtlwifi/rtl8192c/phy_common.c
+++ b/drivers/net/wireless/rtlwifi/rtl8192c/phy_common.c
@@ -1893,7 +1893,7 @@ void rtl92c_phy_set_io(struct ieee80211_hw *hw)
                 break;
         case IO_CMD_PAUSE_DM_BY_SCAN:
                 rtlphy->initgain_backup.xaagccore1 = dm_digtable.cur_igvalue;
-                dm_digtable.cur_igvalue = 0x17;
+                dm_digtable.cur_igvalue = 0x37;
                 rtl92c_dm_write_dig(hw);
                 break;
         default:
diff --git a/drivers/net/wireless/rtlwifi/rtl8192de/phy.c b/drivers/net/wireless/rtlwifi/rtl8192de/phy.c
index 34591eeb8376..28fc5fb8057b 100644
--- a/drivers/net/wireless/rtlwifi/rtl8192de/phy.c
+++ b/drivers/net/wireless/rtlwifi/rtl8192de/phy.c
@@ -3077,7 +3077,7 @@ static void rtl92d_phy_set_io(struct ieee80211_hw *hw)
                 break;
         case IO_CMD_PAUSE_DM_BY_SCAN:
                 rtlphy->initgain_backup.xaagccore1 = de_digtable.cur_igvalue;
-                de_digtable.cur_igvalue = 0x17;
+                de_digtable.cur_igvalue = 0x37;
                 rtl92d_dm_write_dig(hw);
                 break;
         default:
diff --git a/drivers/usb/gadget/f_phonet.c b/drivers/usb/gadget/f_phonet.c
index 85a5cebe96b3..965a6293206a 100644
--- a/drivers/usb/gadget/f_phonet.c
+++ b/drivers/usb/gadget/f_phonet.c
@@ -345,7 +345,7 @@ static void pn_rx_complete(struct usb_ep *ep, struct usb_request *req)
                 }
 
                 skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, page,
-                                skb->len <= 1, req->actual, req->actual);
+                                skb->len <= 1, req->actual, PAGE_SIZE);
                 page = NULL;
 
                 if (req->actual < req->length) { /* Last fragment */
diff --git a/include/linux/if_eql.h b/include/linux/if_eql.h
index 79c4f268410d..18a5d02a8644 100644
--- a/include/linux/if_eql.h
+++ b/include/linux/if_eql.h
@@ -22,7 +22,7 @@
 #define EQL_DEFAULT_SLAVE_PRIORITY 28800
 #define EQL_DEFAULT_MAX_SLAVES     4
 #define EQL_DEFAULT_MTU            576
-#define EQL_DEFAULT_RESCHED_IVAL   100
+#define EQL_DEFAULT_RESCHED_IVAL   HZ
 
 #define EQL_ENSLAVE     (SIOCDEVPRIVATE)
 #define EQL_EMANCIPATE  (SIOCDEVPRIVATE + 1)
diff --git a/include/net/cfg80211.h b/include/net/cfg80211.h
index 248fb05feb63..83d800c31e3c 100644
--- a/include/net/cfg80211.h
+++ b/include/net/cfg80211.h
@@ -620,8 +620,10 @@ struct sta_bss_parameters {
  * @llid: mesh local link id
  * @plid: mesh peer link id
  * @plink_state: mesh peer link state
- * @signal: signal strength of last received packet in dBm
- * @signal_avg: signal strength average in dBm
+ * @signal: the signal strength, type depends on the wiphy's signal_type
+        NOTE: For CFG80211_SIGNAL_TYPE_MBM, value is expressed in _dBm_.
+ * @signal_avg: avg signal strength, type depends on the wiphy's signal_type
+        NOTE: For CFG80211_SIGNAL_TYPE_MBM, value is expressed in _dBm_.
  * @txrate: current unicast bitrate from this station
  * @rxrate: current unicast bitrate to this station
  * @rx_packets: packets received from this station
diff --git a/net/802/garp.c b/net/802/garp.c
index 8e21b6db3981..a5c224830439 100644
--- a/net/802/garp.c
+++ b/net/802/garp.c
@@ -167,7 +167,8 @@ static struct garp_attr *garp_attr_lookup(const struct garp_applicant *app,
         return NULL;
 }
 
-static void garp_attr_insert(struct garp_applicant *app, struct garp_attr *new)
+static struct garp_attr *garp_attr_create(struct garp_applicant *app,
+                                          const void *data, u8 len, u8 type)
 {
         struct rb_node *parent = NULL, **p = &app->gid.rb_node;
         struct garp_attr *attr;
@@ -176,21 +177,16 @@ static void garp_attr_insert(struct garp_applicant *app, struct garp_attr *new)
         while (*p) {
                 parent = *p;
                 attr = rb_entry(parent, struct garp_attr, node);
-                d = garp_attr_cmp(attr, new->data, new->dlen, new->type);
+                d = garp_attr_cmp(attr, data, len, type);
                 if (d < 0)
                         p = &parent->rb_left;
                 else if (d > 0)
                         p = &parent->rb_right;
+                else {
+                        /* The attribute already exists; re-use it. */
+                        return attr;
+                }
         }
-        rb_link_node(&new->node, parent, p);
-        rb_insert_color(&new->node, &app->gid);
-}
-
-static struct garp_attr *garp_attr_create(struct garp_applicant *app,
-                                          const void *data, u8 len, u8 type)
-{
-        struct garp_attr *attr;
-
         attr = kmalloc(sizeof(*attr) + len, GFP_ATOMIC);
         if (!attr)
                 return attr;
@@ -198,7 +194,9 @@ static struct garp_attr *garp_attr_create(struct garp_applicant *app,
         attr->type  = type;
         attr->dlen  = len;
         memcpy(attr->data, data, len);
-        garp_attr_insert(app, attr);
+
+        rb_link_node(&attr->node, parent, p);
+        rb_insert_color(&attr->node, &app->gid);
         return attr;
 }
 
diff --git a/net/core/dev.c b/net/core/dev.c
index 5d59155adf2a..6c7dc9d78e10 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -1596,6 +1596,7 @@ int dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
                 kfree_skb(skb);
                 return NET_RX_DROP;
         }
+        skb->skb_iif = 0;
         skb_set_dev(skb, dev);
         skb->tstamp.tv64 = 0;
         skb->pkt_type = PACKET_HOST;
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index 4dc1c104c942..167ea10b521a 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -2041,7 +2041,7 @@ static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
                 if (err < 0)
                         goto e_err;
         }
-        rth = rt_dst_alloc(init_net.loopback_dev,
+        rth = rt_dst_alloc(dev_net(dev)->loopback_dev,
                            IN_DEV_CONF_GET(in_dev, NOPOLICY), false);
         if (!rth)
                 goto e_nobufs;
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index 496b62712fe8..3992e26a6039 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -881,6 +881,16 @@ static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *
         return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
 }
 
+static struct dst_entry *ip6_route_input_lookup(struct net *net,
+                                                struct net_device *dev,
+                                                struct flowi6 *fl6, int flags)
+{
+        if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
+                flags |= RT6_LOOKUP_F_IFACE;
+
+        return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
+}
+
 void ip6_route_input(struct sk_buff *skb)
 {
         const struct ipv6hdr *iph = ipv6_hdr(skb);
@@ -895,10 +905,7 @@ void ip6_route_input(struct sk_buff *skb)
                 .flowi6_proto = iph->nexthdr,
         };
 
-        if (rt6_need_strict(&iph->daddr) && skb->dev->type != ARPHRD_PIMREG)
-                flags |= RT6_LOOKUP_F_IFACE;
-
-        skb_dst_set(skb, fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_input));
+        skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
 }
 
 static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
@@ -2537,7 +2544,7 @@ static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void
         struct sk_buff *skb;
         struct rtmsg *rtm;
         struct flowi6 fl6;
-        int err, iif = 0;
+        int err, iif = 0, oif = 0;
 
         err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
         if (err < 0)
@@ -2564,15 +2571,29 @@ static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void
                 iif = nla_get_u32(tb[RTA_IIF]);
 
         if (tb[RTA_OIF])
-                fl6.flowi6_oif = nla_get_u32(tb[RTA_OIF]);
+                oif = nla_get_u32(tb[RTA_OIF]);
 
         if (iif) {
                 struct net_device *dev;
+                int flags = 0;
+
                 dev = __dev_get_by_index(net, iif);
                 if (!dev) {
                         err = -ENODEV;
                         goto errout;
                 }
+
+                fl6.flowi6_iif = iif;
+
+                if (!ipv6_addr_any(&fl6.saddr))
+                        flags |= RT6_LOOKUP_F_HAS_SADDR;
+
+                rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
+                                                               flags);
+        } else {
+                fl6.flowi6_oif = oif;
+
+                rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
         }
 
         skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
@@ -2587,7 +2608,6 @@ static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void
         skb_reset_mac_header(skb);
         skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
 
-        rt = (struct rt6_info*) ip6_route_output(net, NULL, &fl6);
         skb_dst_set(skb, &rt->dst);
 
         err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
diff --git a/net/mac80211/agg-rx.c b/net/mac80211/agg-rx.c
index 1068f668ac4e..64d3ce5ea1a0 100644
--- a/net/mac80211/agg-rx.c
+++ b/net/mac80211/agg-rx.c
@@ -49,6 +49,8 @@ static void ieee80211_free_tid_rx(struct rcu_head *h)
                 container_of(h, struct tid_ampdu_rx, rcu_head);
         int i;
 
+        del_timer_sync(&tid_rx->reorder_timer);
+
         for (i = 0; i < tid_rx->buf_size; i++)
                 dev_kfree_skb(tid_rx->reorder_buf[i]);
         kfree(tid_rx->reorder_buf);
@@ -91,7 +93,6 @@ void ___ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
                                      tid, WLAN_BACK_RECIPIENT, reason);
 
         del_timer_sync(&tid_rx->session_timer);
-        del_timer_sync(&tid_rx->reorder_timer);
 
         call_rcu(&tid_rx->rcu_head, ieee80211_free_tid_rx);
 }
diff --git a/net/mac80211/main.c b/net/mac80211/main.c
index b581a24fa15c..16336480c631 100644
--- a/net/mac80211/main.c
+++ b/net/mac80211/main.c
@@ -102,9 +102,6 @@ int ieee80211_hw_config(struct ieee80211_local *local, u32 changed)
 
         might_sleep();
 
-        /* If this off-channel logic ever changes,  ieee80211_on_oper_channel
-         * may need to change as well.
-         */
         offchannel_flag = local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL;
         if (local->scan_channel) {
                 chan = local->scan_channel;
diff --git a/net/mac80211/scan.c b/net/mac80211/scan.c
index 33cd16901378..c70e17677135 100644
--- a/net/mac80211/scan.c
+++ b/net/mac80211/scan.c
@@ -370,7 +370,7 @@ static int ieee80211_start_sw_scan(struct ieee80211_local *local)
          */
         drv_sw_scan_start(local);
 
-        local->leave_oper_channel_time = 0;
+        local->leave_oper_channel_time = jiffies;
         local->next_scan_state = SCAN_DECISION;
         local->scan_channel_idx = 0;
 
diff --git a/net/netfilter/nfnetlink_acct.c b/net/netfilter/nfnetlink_acct.c
index 3eb348bfc4fb..d98c868c148b 100644
--- a/net/netfilter/nfnetlink_acct.c
+++ b/net/netfilter/nfnetlink_acct.c
@@ -10,6 +10,7 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
+#include <linux/atomic.h>
 #include <linux/netlink.h>
 #include <linux/rculist.h>
 #include <linux/slab.h>
@@ -17,7 +18,6 @@
 #include <linux/errno.h>
 #include <net/netlink.h>
 #include <net/sock.h>
-#include <asm/atomic.h>
 
 #include <linux/netfilter.h>
 #include <linux/netfilter/nfnetlink.h>
diff --git a/net/rose/rose_dev.c b/net/rose/rose_dev.c
index 1ab8689726ec..906cc05bba63 100644
--- a/net/rose/rose_dev.c
+++ b/net/rose/rose_dev.c
@@ -95,11 +95,11 @@ static int rose_set_mac_address(struct net_device *dev, void *addr)
         struct sockaddr *sa = addr;
         int err;
 
-        if (!memcpy(dev->dev_addr, sa->sa_data, dev->addr_len))
+        if (!memcmp(dev->dev_addr, sa->sa_data, dev->addr_len))
                 return 0;
 
         if (dev->flags & IFF_UP) {
-                err = rose_add_loopback_node((rose_address *)dev->dev_addr);
+                err = rose_add_loopback_node((rose_address *)sa->sa_data);
                 if (err)
                         return err;
 
diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
index 4c1eb9472ddb..e49da2797022 100644
--- a/net/wireless/nl80211.c
+++ b/net/wireless/nl80211.c
@@ -2386,7 +2386,9 @@ nla_put_failure:
 }
 
 static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
-                                int flags, struct net_device *dev,
+                                int flags,
+                                struct cfg80211_registered_device *rdev,
+                                struct net_device *dev,
                                 const u8 *mac_addr, struct station_info *sinfo)
 {
         void *hdr;
@@ -2425,12 +2427,18 @@ static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
         if (sinfo->filled & STATION_INFO_PLINK_STATE)
                 NLA_PUT_U8(msg, NL80211_STA_INFO_PLINK_STATE,
                             sinfo->plink_state);
-        if (sinfo->filled & STATION_INFO_SIGNAL)
-                NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL,
-                           sinfo->signal);
-        if (sinfo->filled & STATION_INFO_SIGNAL_AVG)
-                NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL_AVG,
-                           sinfo->signal_avg);
+        switch (rdev->wiphy.signal_type) {
+        case CFG80211_SIGNAL_TYPE_MBM:
+                if (sinfo->filled & STATION_INFO_SIGNAL)
+                        NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL,
+                                   sinfo->signal);
+                if (sinfo->filled & STATION_INFO_SIGNAL_AVG)
+                        NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL_AVG,
+                                   sinfo->signal_avg);
+                break;
+        default:
+                break;
+        }
         if (sinfo->filled & STATION_INFO_TX_BITRATE) {
                 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
                                           NL80211_STA_INFO_TX_BITRATE))
@@ -2523,7 +2531,7 @@ static int nl80211_dump_station(struct sk_buff *skb,
                 if (nl80211_send_station(skb,
                                 NETLINK_CB(cb->skb).pid,
                                 cb->nlh->nlmsg_seq, NLM_F_MULTI,
-                                netdev, mac_addr,
+                                dev, netdev, mac_addr,
                                 &sinfo) < 0)
                         goto out;
 
@@ -2568,7 +2576,7 @@ static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
                 return -ENOMEM;
 
         if (nl80211_send_station(msg, info->snd_pid, info->snd_seq, 0,
-                                 dev, mac_addr, &sinfo) < 0) {
+                                 rdev, dev, mac_addr, &sinfo) < 0) {
                 nlmsg_free(msg);
                 return -ENOBUFS;
         }
@@ -7596,7 +7604,8 @@ void nl80211_send_sta_event(struct cfg80211_registered_device *rdev,
         if (!msg)
                 return;
 
-        if (nl80211_send_station(msg, 0, 0, 0, dev, mac_addr, sinfo) < 0) {
+        if (nl80211_send_station(msg, 0, 0, 0,
+                                 rdev, dev, mac_addr, sinfo) < 0) {
                 nlmsg_free(msg);
                 return;
         }