132 files changed, 1841 insertions, 1360 deletions
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 9fe8cb7d43ac..6bdfd47d679d 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -1829,7 +1829,7 @@ config 68360_ENET
 config FEC
        bool "FEC ethernet controller (of ColdFire CPUs)"
-        depends on M523x || M527x || M5272 || M528x || M520x
+        depends on M523x || M527x || M5272 || M528x || M520x || M532x
        help
          Say Y here if you want to use the built-in 10/100 Fast ethernet
          controller on some Motorola ColdFire processors.
diff --git a/drivers/net/arm/am79c961a.c b/drivers/net/arm/am79c961a.c
index 0c628a9e5339..c2d012fcc29b 100644
--- a/drivers/net/arm/am79c961a.c
+++ b/drivers/net/arm/am79c961a.c
@@ -208,9 +208,9 @@ am79c961_init_for_open(struct net_device *dev)
        /*
         * Stop the chip.
         */
-        spin_lock_irqsave(priv->chip_lock, flags);
+        spin_lock_irqsave(&priv->chip_lock, flags);
        write_rreg (dev->base_addr, CSR0, CSR0_BABL|CSR0_CERR|CSR0_MISS|CSR0_MERR|CSR0_TINT|CSR0_RINT|CSR0_STOP);
-        spin_unlock_irqrestore(priv->chip_lock, flags);
+        spin_unlock_irqrestore(&priv->chip_lock, flags);
        write_ireg (dev->base_addr, 5, 0x00a0); /* Receive address LED */
        write_ireg (dev->base_addr, 6, 0x0081); /* Collision LED */
@@ -332,10 +332,10 @@ am79c961_close(struct net_device *dev)
        netif_stop_queue(dev);
        netif_carrier_off(dev);
-        spin_lock_irqsave(priv->chip_lock, flags);
+        spin_lock_irqsave(&priv->chip_lock, flags);
        write_rreg (dev->base_addr, CSR0, CSR0_STOP);
        write_rreg (dev->base_addr, CSR3, CSR3_MASKALL);
-        spin_unlock_irqrestore(priv->chip_lock, flags);
+        spin_unlock_irqrestore(&priv->chip_lock, flags);
        free_irq (dev->irq, dev);
@@ -391,7 +391,7 @@ static void am79c961_setmulticastlist (struct net_device *dev)
                        am79c961_mc_hash(dmi, multi_hash);
        }
-        spin_lock_irqsave(priv->chip_lock, flags);
+        spin_lock_irqsave(&priv->chip_lock, flags);
        stopped = read_rreg(dev->base_addr, CSR0) & CSR0_STOP;
@@ -405,9 +405,9 @@ static void am79c961_setmulticastlist (struct net_device *dev)
                 * Spin waiting for chip to report suspend mode
                 */
                while ((read_rreg(dev->base_addr, CTRL1) & CTRL1_SPND) == 0) {
-                        spin_unlock_irqrestore(priv->chip_lock, flags);
+                        spin_unlock_irqrestore(&priv->chip_lock, flags);
                        nop();
-                        spin_lock_irqsave(priv->chip_lock, flags);
+                        spin_lock_irqsave(&priv->chip_lock, flags);
                }
        }
@@ -429,7 +429,7 @@ static void am79c961_setmulticastlist (struct net_device *dev)
                write_rreg(dev->base_addr, CTRL1, 0);
        }
-        spin_unlock_irqrestore(priv->chip_lock, flags);
+        spin_unlock_irqrestore(&priv->chip_lock, flags);
 }
 static void am79c961_timeout(struct net_device *dev)
@@ -467,10 +467,10 @@ am79c961_sendpacket(struct sk_buff *skb, struct net_device *dev)
        am_writeword (dev, hdraddr + 2, TMD_OWN|TMD_STP|TMD_ENP);
        priv->txhead = head;
-        spin_lock_irqsave(priv->chip_lock, flags);
+        spin_lock_irqsave(&priv->chip_lock, flags);
        write_rreg (dev->base_addr, CSR0, CSR0_TDMD|CSR0_IENA);
        dev->trans_start = jiffies;
-        spin_unlock_irqrestore(priv->chip_lock, flags);
+        spin_unlock_irqrestore(&priv->chip_lock, flags);
        /*
         * If the next packet is owned by the ethernet device,
diff --git a/drivers/net/arm/etherh.c b/drivers/net/arm/etherh.c
index 745ac188babe..54b52e5b1821 100644
--- a/drivers/net/arm/etherh.c
+++ b/drivers/net/arm/etherh.c
@@ -646,7 +646,7 @@ static const struct net_device_ops etherh_netdev_ops = {
        .ndo_get_stats          = ei_get_stats,
        .ndo_set_multicast_list = ei_set_multicast_list,
        .ndo_validate_addr      = eth_validate_addr,
-        .ndo_set_mac_addr       = eth_set_mac_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
        .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
        .ndo_poll_controller    = ei_poll,
diff --git a/drivers/net/ax88796.c b/drivers/net/ax88796.c
index 337488ec707c..a4eb6c40678c 100644
--- a/drivers/net/ax88796.c
+++ b/drivers/net/ax88796.c
@@ -37,7 +37,10 @@ static int phy_debug = 0;
 #define __ei_open       ax_ei_open
 #define __ei_close      ax_ei_close
 #define __ei_poll       ax_ei_poll
+#define __ei_start_xmit ax_ei_start_xmit
 #define __ei_tx_timeout ax_ei_tx_timeout
+#define __ei_get_stats  ax_ei_get_stats
+#define __ei_set_multicast_list ax_ei_set_multicast_list
 #define __ei_interrupt  ax_ei_interrupt
 #define ____alloc_ei_netdev ax__alloc_ei_netdev
 #define __NS8390_init   ax_NS8390_init
@@ -623,6 +626,23 @@ static void ax_eeprom_register_write(struct eeprom_93cx6 *eeprom)
 }
 #endif
+static const struct net_device_ops ax_netdev_ops = {
+        .ndo_open               = ax_open,
+        .ndo_stop               = ax_close,
+        .ndo_do_ioctl           = ax_ioctl,
+        .ndo_start_xmit         = ax_ei_start_xmit,
+        .ndo_tx_timeout         = ax_ei_tx_timeout,
+        .ndo_get_stats          = ax_ei_get_stats,
+        .ndo_set_multicast_list = ax_ei_set_multicast_list,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+        .ndo_change_mtu         = eth_change_mtu,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = ax_ei_poll,
+#endif
+};
 /* setup code */
 static void ax_initial_setup(struct net_device *dev, struct ei_device *ei_local)
@@ -738,9 +758,7 @@ static int ax_init_dev(struct net_device *dev, int first_init)
        ei_status.get_8390_hdr  = &ax_get_8390_hdr;
        ei_status.priv = 0;
-        dev->open               = ax_open;
+        dev->netdev_ops         = &ax_netdev_ops;
-        dev->stop               = ax_close;
-        dev->do_ioctl           = ax_ioctl;
        dev->ethtool_ops        = &ax_ethtool_ops;
        ax->msg_enable          = NETIF_MSG_LINK;
@@ -753,9 +771,6 @@ static int ax_init_dev(struct net_device *dev, int first_init)
        ax->mii.mdio_write      = ax_phy_write;
        ax->mii.dev             = dev;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        dev->poll_controller = ax_ei_poll;
-#endif
        ax_NS8390_init(dev, 0);
        if (first_init)
diff --git a/drivers/net/b44.c b/drivers/net/b44.c
index 5ae131c147f9..c38512ebcea6 100644
--- a/drivers/net/b44.c
+++ b/drivers/net/b44.c
@@ -679,6 +679,7 @@ static int b44_alloc_rx_skb(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
                        dev_kfree_skb_any(skb);
                        return -ENOMEM;
                }
+                bp->force_copybreak = 1;
        }
        rh = (struct rx_header *) skb->data;
@@ -800,7 +801,7 @@ static int b44_rx(struct b44 *bp, int budget)
                /* Omit CRC. */
                len -= 4;
-                if (len > RX_COPY_THRESHOLD) {
+                if (!bp->force_copybreak && len > RX_COPY_THRESHOLD) {
                        int skb_size;
                        skb_size = b44_alloc_rx_skb(bp, cons, bp->rx_prod);
                        if (skb_size < 0)
@@ -2152,6 +2153,7 @@ static int __devinit b44_init_one(struct ssb_device *sdev,
        bp = netdev_priv(dev);
        bp->sdev = sdev;
        bp->dev = dev;
+        bp->force_copybreak = 0;
        bp->msg_enable = netif_msg_init(b44_debug, B44_DEF_MSG_ENABLE);
diff --git a/drivers/net/b44.h b/drivers/net/b44.h
index 7db0c84a7950..e678498de6db 100644
--- a/drivers/net/b44.h
+++ b/drivers/net/b44.h
@@ -395,7 +395,7 @@ struct b44 {
        u32                     rx_pending;
        u32                     tx_pending;
        u8                      phy_addr;
+        u8                      force_copybreak;
        struct mii_if_info      mii_if;
 };
diff --git a/drivers/net/bnx2x.h b/drivers/net/bnx2x.h
index fd705d1295a7..15a5cf0f676b 100644
--- a/drivers/net/bnx2x.h
+++ b/drivers/net/bnx2x.h
@@ -1,6 +1,6 @@
 /* bnx2x.h: Broadcom Everest network driver.
 *
- * Copyright (c) 2007-2008 Broadcom Corporation
+ * Copyright (c) 2007-2009 Broadcom Corporation
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -20,6 +20,11 @@
 * (you will need to reboot afterwards) */
 /* #define BNX2X_STOP_ON_ERROR */
+#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
+#define BCM_VLAN                        1
+#endif
 /* error/debug prints */
 #define DRV_MODULE_NAME         "bnx2x"
@@ -78,11 +83,6 @@
 #endif
-#ifdef NETIF_F_HW_VLAN_TX
-#define BCM_VLAN                        1
-#endif
 #define U64_LO(x)                       (u32)(((u64)(x)) & 0xffffffff)
 #define U64_HI(x)                       (u32)(((u64)(x)) >> 32)
 #define HILO_U64(hi, lo)                ((((u64)(hi)) << 32) + (lo))
@@ -150,6 +150,9 @@ struct sw_rx_page {
 #define PAGES_PER_SGE_SHIFT             0
 #define PAGES_PER_SGE                   (1 << PAGES_PER_SGE_SHIFT)
+#define SGE_PAGE_SIZE                   PAGE_SIZE
+#define SGE_PAGE_SHIFT                  PAGE_SHIFT
+#define SGE_PAGE_ALIGN(addr)            PAGE_ALIGN(addr)
 #define BCM_RX_ETH_PAYLOAD_ALIGN        64
@@ -268,14 +271,7 @@ struct bnx2x_fastpath {
 #define bnx2x_fp(bp, nr, var)           (bp->fp[nr].var)
-#define BNX2X_HAS_TX_WORK(fp) \
+#define BNX2X_HAS_WORK(fp)      (bnx2x_has_rx_work(fp) || bnx2x_has_tx_work(fp))
-                        ((fp->tx_pkt_prod != le16_to_cpu(*fp->tx_cons_sb)) || \
-                         (fp->tx_pkt_prod != fp->tx_pkt_cons))
-#define BNX2X_HAS_RX_WORK(fp) \
-                        (fp->rx_comp_cons != rx_cons_sb)
-#define BNX2X_HAS_WORK(fp)      (BNX2X_HAS_RX_WORK(fp) || BNX2X_HAS_TX_WORK(fp))
 /* MC hsi */
@@ -736,7 +732,7 @@ struct bnx2x {
        struct bnx2x_fastpath   fp[MAX_CONTEXT];
        void __iomem            *regview;
        void __iomem            *doorbells;
-#define BNX2X_DB_SIZE           (16*2048)
+#define BNX2X_DB_SIZE           (16*BCM_PAGE_SIZE)
        struct net_device       *dev;
        struct pci_dev          *pdev;
@@ -801,6 +797,8 @@ struct bnx2x {
 #define TPA_ENABLE_FLAG                 0x80
 #define NO_MCP_FLAG                     0x100
 #define BP_NOMCP(bp)                    (bp->flags & NO_MCP_FLAG)
+#define HW_VLAN_TX_FLAG                 0x400
+#define HW_VLAN_RX_FLAG                 0x800
        int                     func;
 #define BP_PORT(bp)                     (bp->func % PORT_MAX)
@@ -811,7 +809,7 @@ struct bnx2x {
        int                     pm_cap;
        int                     pcie_cap;
-        struct work_struct      sp_task;
+        struct delayed_work     sp_task;
        struct work_struct      reset_task;
        struct timer_list       timer;
diff --git a/drivers/net/bnx2x_link.c b/drivers/net/bnx2x_link.c
index fefa6ab13064..aea26b4dc453 100644
--- a/drivers/net/bnx2x_link.c
+++ b/drivers/net/bnx2x_link.c
@@ -1,4 +1,4 @@
-/* Copyright 2008 Broadcom Corporation
+/* Copyright 2008-2009 Broadcom Corporation
 *
 * Unless you and Broadcom execute a separate written software license
 * agreement governing use of this software, this software is licensed to you
@@ -317,6 +317,9 @@ static u8 bnx2x_emac_enable(struct link_params *params,
                val &= ~0x810;
        EMAC_WR(bp, EMAC_REG_EMAC_MODE, val);
+        /* enable emac */
+        REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 1);
        /* enable emac for jumbo packets */
        EMAC_WR(bp, EMAC_REG_EMAC_RX_MTU_SIZE,
                (EMAC_RX_MTU_SIZE_JUMBO_ENA |
@@ -1609,7 +1612,7 @@ static u8 bnx2x_link_settings_status(struct link_params *params,
                                      u32 gp_status)
 {
        struct bnx2x *bp = params->bp;
+        u16 new_line_speed;
        u8 rc = 0;
        vars->link_status = 0;
@@ -1629,7 +1632,7 @@ static u8 bnx2x_link_settings_status(struct link_params *params,
                switch (gp_status & GP_STATUS_SPEED_MASK) {
                case GP_STATUS_10M:
-                        vars->line_speed = SPEED_10;
+                        new_line_speed = SPEED_10;
                        if (vars->duplex == DUPLEX_FULL)
                                vars->link_status |= LINK_10TFD;
                        else
@@ -1637,7 +1640,7 @@ static u8 bnx2x_link_settings_status(struct link_params *params,
                        break;
                case GP_STATUS_100M:
-                        vars->line_speed = SPEED_100;
+                        new_line_speed = SPEED_100;
                        if (vars->duplex == DUPLEX_FULL)
                                vars->link_status |= LINK_100TXFD;
                        else
@@ -1646,7 +1649,7 @@ static u8 bnx2x_link_settings_status(struct link_params *params,
                case GP_STATUS_1G:
                case GP_STATUS_1G_KX:
-                        vars->line_speed = SPEED_1000;
+                        new_line_speed = SPEED_1000;
                        if (vars->duplex == DUPLEX_FULL)
                                vars->link_status |= LINK_1000TFD;
                        else
@@ -1654,7 +1657,7 @@ static u8 bnx2x_link_settings_status(struct link_params *params,
                        break;
                case GP_STATUS_2_5G:
-                        vars->line_speed = SPEED_2500;
+                        new_line_speed = SPEED_2500;
                        if (vars->duplex == DUPLEX_FULL)
                                vars->link_status |= LINK_2500TFD;
                        else
@@ -1671,32 +1674,32 @@ static u8 bnx2x_link_settings_status(struct link_params *params,
                case GP_STATUS_10G_KX4:
                case GP_STATUS_10G_HIG:
                case GP_STATUS_10G_CX4:
-                        vars->line_speed = SPEED_10000;
+                        new_line_speed = SPEED_10000;
                        vars->link_status |= LINK_10GTFD;
                        break;
                case GP_STATUS_12G_HIG:
-                        vars->line_speed = SPEED_12000;
+                        new_line_speed = SPEED_12000;
                        vars->link_status |= LINK_12GTFD;
                        break;
                case GP_STATUS_12_5G:
-                        vars->line_speed = SPEED_12500;
+                        new_line_speed = SPEED_12500;
                        vars->link_status |= LINK_12_5GTFD;
                        break;
                case GP_STATUS_13G:
-                        vars->line_speed = SPEED_13000;
+                        new_line_speed = SPEED_13000;
                        vars->link_status |= LINK_13GTFD;
                        break;
                case GP_STATUS_15G:
-                        vars->line_speed = SPEED_15000;
+                        new_line_speed = SPEED_15000;
                        vars->link_status |= LINK_15GTFD;
                        break;
                case GP_STATUS_16G:
-                        vars->line_speed = SPEED_16000;
+                        new_line_speed = SPEED_16000;
                        vars->link_status |= LINK_16GTFD;
                        break;
@@ -1708,6 +1711,15 @@ static u8 bnx2x_link_settings_status(struct link_params *params,
                        break;
                }
+                /* Upon link speed change set the NIG into drain mode.
+                Comes to deals with possible FIFO glitch due to clk change
+                when speed is decreased without link down indicator */
+                if (new_line_speed != vars->line_speed) {
+                        REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE
+                                    + params->port*4, 0);
+                        msleep(1);
+                }
+                vars->line_speed = new_line_speed;
                vars->link_status |= LINK_STATUS_SERDES_LINK;
                if ((params->req_line_speed == SPEED_AUTO_NEG) &&
@@ -3571,7 +3583,7 @@ static void bnx2x_set_xgxs_loopback(struct link_params *params,
                               (MDIO_REG_BANK_CL73_IEEEB0 +
                                (MDIO_CL73_IEEEB0_CL73_AN_CONTROL & 0xf)),
                               0x6041);
+                msleep(200);
                /* set aer mmd back */
                bnx2x_set_aer_mmd(params, vars);
@@ -3870,9 +3882,15 @@ static u8 bnx2x_link_initialize(struct link_params *params,
        }
        if (vars->phy_flags & PHY_XGXS_FLAG) {
-                if (params->req_line_speed &&
+                if ((params->req_line_speed &&
                    ((params->req_line_speed == SPEED_100) ||
-                     (params->req_line_speed == SPEED_10))) {
+                     (params->req_line_speed == SPEED_10))) ||
+                    (!params->req_line_speed &&
+                     (params->speed_cap_mask >=
+                       PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL) &&
+                     (params->speed_cap_mask <
+                       PORT_HW_CFG_SPEED_CAPABILITY_D0_1G)
+                     ))  {
                        vars->phy_flags |= PHY_SGMII_FLAG;
                } else {
                        vars->phy_flags &= ~PHY_SGMII_FLAG;
@@ -4194,6 +4212,11 @@ static u8 bnx2x_update_link_down(struct link_params *params,
        /* activate nig drain */
        REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + port*4, 1);
+        /* disable emac */
+        REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 0);
+        msleep(10);
        /* reset BigMac */
        bnx2x_bmac_rx_disable(bp, params->port);
        REG_WR(bp, GRCBASE_MISC +
@@ -4238,6 +4261,7 @@ static u8 bnx2x_update_link_up(struct link_params *params,
        /* update shared memory */
        bnx2x_update_mng(params, vars->link_status);
+        msleep(20);
        return rc;
 }
 /* This function should called upon link interrupt */
@@ -4276,6 +4300,9 @@ u8 bnx2x_link_update(struct link_params *params, struct link_vars *vars)
          REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK10G + port*0x68),
          REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK_STATUS + port*0x68));
+        /* disable emac */
+        REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 0);
        ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
        /* Check external link change only for non-direct */
@@ -4377,10 +4404,11 @@ static u8 bnx2x_8073_common_init_phy(struct bnx2x *bp, u32 shmem_base)
                              ext_phy_addr[port],
                              MDIO_PMA_DEVAD,
                              MDIO_PMA_REG_ROM_VER1, &fw_ver1);
-                if (fw_ver1 == 0) {
+                if (fw_ver1 == 0 || fw_ver1 == 0x4321) {
                        DP(NETIF_MSG_LINK,
-                                 "bnx2x_8073_common_init_phy port %x "
+                                 "bnx2x_8073_common_init_phy port %x:"
-                                 "fw Download failed\n", port);
+                                 "Download failed. fw version = 0x%x\n",
+                                 port, fw_ver1);
                        return -EINVAL;
                }
diff --git a/drivers/net/bnx2x_main.c b/drivers/net/bnx2x_main.c
index 4be05847f86f..d3e7775a9ccf 100644
--- a/drivers/net/bnx2x_main.c
+++ b/drivers/net/bnx2x_main.c
@@ -1,6 +1,6 @@
 /* bnx2x_main.c: Broadcom Everest network driver.
 *
- * Copyright (c) 2007-2008 Broadcom Corporation
+ * Copyright (c) 2007-2009 Broadcom Corporation
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -38,9 +38,7 @@
 #include <linux/time.h>
 #include <linux/ethtool.h>
 #include <linux/mii.h>
-#ifdef NETIF_F_HW_VLAN_TX
+#include <linux/if_vlan.h>
-        #include <linux/if_vlan.h>
-#endif
 #include <net/ip.h>
 #include <net/tcp.h>
 #include <net/checksum.h>
@@ -59,8 +57,8 @@
 #include "bnx2x.h"
 #include "bnx2x_init.h"
-#define DRV_MODULE_VERSION      "1.45.23"
+#define DRV_MODULE_VERSION      "1.45.26"
-#define DRV_MODULE_RELDATE      "2008/11/03"
+#define DRV_MODULE_RELDATE      "2009/01/26"
 #define BNX2X_BC_VER            0x040200
 /* Time in jiffies before concluding the transmitter is hung */
@@ -71,7 +69,7 @@ static char version[] __devinitdata =
        DRV_MODULE_NAME " " DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
 MODULE_AUTHOR("Eliezer Tamir");
-MODULE_DESCRIPTION("Broadcom NetXtreme II BCM57710 Driver");
+MODULE_DESCRIPTION("Broadcom NetXtreme II BCM57710/57711/57711E Driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_MODULE_VERSION);
@@ -95,6 +93,7 @@ MODULE_PARM_DESC(debug, "default debug msglevel");
 module_param(use_multi, int, 0);
 MODULE_PARM_DESC(use_multi, "use per-CPU queues");
 #endif
+static struct workqueue_struct *bnx2x_wq;
 enum bnx2x_board_type {
        BCM57710 = 0,
@@ -671,7 +670,8 @@ static void bnx2x_int_disable_sync(struct bnx2x *bp, int disable_hw)
                synchronize_irq(bp->pdev->irq);
        /* make sure sp_task is not running */
-        cancel_work_sync(&bp->sp_task);
+        cancel_delayed_work(&bp->sp_task);
+        flush_workqueue(bnx2x_wq);
 }
 /* fast path */
@@ -733,6 +733,24 @@ static u16 bnx2x_ack_int(struct bnx2x *bp)
 * fast path service functions
 */
+static inline int bnx2x_has_tx_work(struct bnx2x_fastpath *fp)
+{
+        u16 tx_cons_sb;
+        /* Tell compiler that status block fields can change */
+        barrier();
+        tx_cons_sb = le16_to_cpu(*fp->tx_cons_sb);
+        return (fp->tx_pkt_cons != tx_cons_sb);
+}
+static inline int bnx2x_has_tx_work_unload(struct bnx2x_fastpath *fp)
+{
+        /* Tell compiler that consumer and producer can change */
+        barrier();
+        return (fp->tx_pkt_prod != fp->tx_pkt_cons);
+}
 /* free skb in the packet ring at pos idx
 * return idx of last bd freed
 */
@@ -972,7 +990,7 @@ static inline void bnx2x_free_rx_sge(struct bnx2x *bp,
                return;
        pci_unmap_page(bp->pdev, pci_unmap_addr(sw_buf, mapping),
-                       BCM_PAGE_SIZE*PAGES_PER_SGE, PCI_DMA_FROMDEVICE);
+                       SGE_PAGE_SIZE*PAGES_PER_SGE, PCI_DMA_FROMDEVICE);
        __free_pages(page, PAGES_PER_SGE_SHIFT);
        sw_buf->page = NULL;
@@ -1000,7 +1018,7 @@ static inline int bnx2x_alloc_rx_sge(struct bnx2x *bp,
        if (unlikely(page == NULL))
                return -ENOMEM;
-        mapping = pci_map_page(bp->pdev, page, 0, BCM_PAGE_SIZE*PAGES_PER_SGE,
+        mapping = pci_map_page(bp->pdev, page, 0, SGE_PAGE_SIZE*PAGES_PER_SGE,
                               PCI_DMA_FROMDEVICE);
        if (unlikely(dma_mapping_error(&bp->pdev->dev, mapping))) {
                __free_pages(page, PAGES_PER_SGE_SHIFT);
@@ -1096,9 +1114,9 @@ static void bnx2x_update_sge_prod(struct bnx2x_fastpath *fp,
                                  struct eth_fast_path_rx_cqe *fp_cqe)
 {
        struct bnx2x *bp = fp->bp;
-        u16 sge_len = BCM_PAGE_ALIGN(le16_to_cpu(fp_cqe->pkt_len) -
+        u16 sge_len = SGE_PAGE_ALIGN(le16_to_cpu(fp_cqe->pkt_len) -
                                     le16_to_cpu(fp_cqe->len_on_bd)) >>
-                      BCM_PAGE_SHIFT;
+                      SGE_PAGE_SHIFT;
        u16 last_max, last_elem, first_elem;
        u16 delta = 0;
        u16 i;
@@ -1203,22 +1221,22 @@ static int bnx2x_fill_frag_skb(struct bnx2x *bp, struct bnx2x_fastpath *fp,
                               u16 cqe_idx)
 {
        struct sw_rx_page *rx_pg, old_rx_pg;
-        struct page *sge;
        u16 len_on_bd = le16_to_cpu(fp_cqe->len_on_bd);
        u32 i, frag_len, frag_size, pages;
        int err;
        int j;
        frag_size = le16_to_cpu(fp_cqe->pkt_len) - len_on_bd;
-        pages = BCM_PAGE_ALIGN(frag_size) >> BCM_PAGE_SHIFT;
+        pages = SGE_PAGE_ALIGN(frag_size) >> SGE_PAGE_SHIFT;
        /* This is needed in order to enable forwarding support */
        if (frag_size)
-                skb_shinfo(skb)->gso_size = min((u32)BCM_PAGE_SIZE,
+                skb_shinfo(skb)->gso_size = min((u32)SGE_PAGE_SIZE,
                                               max(frag_size, (u32)len_on_bd));
 #ifdef BNX2X_STOP_ON_ERROR
-        if (pages > 8*PAGES_PER_SGE) {
+        if (pages >
+            min((u32)8, (u32)MAX_SKB_FRAGS) * SGE_PAGE_SIZE * PAGES_PER_SGE) {
                BNX2X_ERR("SGL length is too long: %d. CQE index is %d\n",
                          pages, cqe_idx);
                BNX2X_ERR("fp_cqe->pkt_len = %d  fp_cqe->len_on_bd = %d\n",
@@ -1234,9 +1252,8 @@ static int bnx2x_fill_frag_skb(struct bnx2x *bp, struct bnx2x_fastpath *fp,
                /* FW gives the indices of the SGE as if the ring is an array
                   (meaning that "next" element will consume 2 indices) */
-                frag_len = min(frag_size, (u32)(BCM_PAGE_SIZE*PAGES_PER_SGE));
+                frag_len = min(frag_size, (u32)(SGE_PAGE_SIZE*PAGES_PER_SGE));
                rx_pg = &fp->rx_page_ring[sge_idx];
-                sge = rx_pg->page;
                old_rx_pg = *rx_pg;
                /* If we fail to allocate a substitute page, we simply stop
@@ -1249,7 +1266,7 @@ static int bnx2x_fill_frag_skb(struct bnx2x *bp, struct bnx2x_fastpath *fp,
                /* Unmap the page as we r going to pass it to the stack */
                pci_unmap_page(bp->pdev, pci_unmap_addr(&old_rx_pg, mapping),
-                              BCM_PAGE_SIZE*PAGES_PER_SGE, PCI_DMA_FROMDEVICE);
+                              SGE_PAGE_SIZE*PAGES_PER_SGE, PCI_DMA_FROMDEVICE);
                /* Add one frag and update the appropriate fields in the skb */
                skb_fill_page_desc(skb, j, old_rx_pg.page, 0, frag_len);
@@ -1282,6 +1299,13 @@ static void bnx2x_tpa_stop(struct bnx2x *bp, struct bnx2x_fastpath *fp,
        if (likely(new_skb)) {
                /* fix ip xsum and give it to the stack */
                /* (no need to map the new skb) */
+#ifdef BCM_VLAN
+                int is_vlan_cqe =
+                        (le16_to_cpu(cqe->fast_path_cqe.pars_flags.flags) &
+                         PARSING_FLAGS_VLAN);
+                int is_not_hwaccel_vlan_cqe =
+                        (is_vlan_cqe && (!(bp->flags & HW_VLAN_RX_FLAG)));
+#endif
                prefetch(skb);
                prefetch(((char *)(skb)) + 128);
@@ -1306,6 +1330,12 @@ static void bnx2x_tpa_stop(struct bnx2x *bp, struct bnx2x_fastpath *fp,
                        struct iphdr *iph;
                        iph = (struct iphdr *)skb->data;
+#ifdef BCM_VLAN
+                        /* If there is no Rx VLAN offloading -
+                           take VLAN tag into an account */
+                        if (unlikely(is_not_hwaccel_vlan_cqe))
+                                iph = (struct iphdr *)((u8 *)iph + VLAN_HLEN);
+#endif
                        iph->check = 0;
                        iph->check = ip_fast_csum((u8 *)iph, iph->ihl);
                }
@@ -1313,9 +1343,8 @@ static void bnx2x_tpa_stop(struct bnx2x *bp, struct bnx2x_fastpath *fp,
                if (!bnx2x_fill_frag_skb(bp, fp, skb,
                                         &cqe->fast_path_cqe, cqe_idx)) {
 #ifdef BCM_VLAN
-                        if ((bp->vlgrp != NULL) &&
+                        if ((bp->vlgrp != NULL) && is_vlan_cqe &&
-                            (le16_to_cpu(cqe->fast_path_cqe.pars_flags.flags) &
+                            (!is_not_hwaccel_vlan_cqe))
-                             PARSING_FLAGS_VLAN))
                                vlan_hwaccel_receive_skb(skb, bp->vlgrp,
                                                le16_to_cpu(cqe->fast_path_cqe.
                                                            vlan_tag));
@@ -1355,11 +1384,23 @@ static inline void bnx2x_update_rx_prod(struct bnx2x *bp,
        rx_prods.cqe_prod = rx_comp_prod;
        rx_prods.sge_prod = rx_sge_prod;
+        /*
+         * Make sure that the BD and SGE data is updated before updating the
+         * producers since FW might read the BD/SGE right after the producer
+         * is updated.
+         * This is only applicable for weak-ordered memory model archs such
+         * as IA-64. The following barrier is also mandatory since FW will
+         * assumes BDs must have buffers.
+         */
+        wmb();
        for (i = 0; i < sizeof(struct tstorm_eth_rx_producers)/4; i++)
                REG_WR(bp, BAR_TSTRORM_INTMEM +
                       TSTORM_RX_PRODS_OFFSET(BP_PORT(bp), FP_CL_ID(fp)) + i*4,
                       ((u32 *)&rx_prods)[i]);
+        mmiowb(); /* keep prod updates ordered */
        DP(NETIF_MSG_RX_STATUS,
           "Wrote: bd_prod %u  cqe_prod %u  sge_prod %u\n",
           bd_prod, rx_comp_prod, rx_sge_prod);
@@ -1415,7 +1456,7 @@ static int bnx2x_rx_int(struct bnx2x_fastpath *fp, int budget)
                DP(NETIF_MSG_RX_STATUS, "CQE type %x  err %x  status %x"
                   "  queue %x  vlan %x  len %u\n", CQE_TYPE(cqe_fp_flags),
                   cqe_fp_flags, cqe->fast_path_cqe.status_flags,
-                   cqe->fast_path_cqe.rss_hash_result,
+                   le32_to_cpu(cqe->fast_path_cqe.rss_hash_result),
                   le16_to_cpu(cqe->fast_path_cqe.vlan_tag),
                   le16_to_cpu(cqe->fast_path_cqe.pkt_len));
@@ -1547,7 +1588,7 @@ reuse_rx:
                }
 #ifdef BCM_VLAN
-                if ((bp->vlgrp != NULL) &&
+                if ((bp->vlgrp != NULL) && (bp->flags & HW_VLAN_RX_FLAG) &&
                    (le16_to_cpu(cqe->fast_path_cqe.pars_flags.flags) &
                     PARSING_FLAGS_VLAN))
                        vlan_hwaccel_receive_skb(skb, bp->vlgrp,
@@ -1580,7 +1621,6 @@ next_cqe:
        /* Update producers */
        bnx2x_update_rx_prod(bp, fp, bd_prod_fw, sw_comp_prod,
                             fp->rx_sge_prod);
-        mmiowb(); /* keep prod updates ordered */
        fp->rx_pkt += rx_pkt;
        fp->rx_calls++;
@@ -1660,7 +1700,7 @@ static irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
        if (unlikely(status & 0x1)) {
-                schedule_work(&bp->sp_task);
+                queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
                status &= ~0x1;
                if (!status)
@@ -1887,7 +1927,8 @@ static int bnx2x_set_spio(struct bnx2x *bp, int spio_num, u32 mode)
 static void bnx2x_calc_fc_adv(struct bnx2x *bp)
 {
-        switch (bp->link_vars.ieee_fc) {
+        switch (bp->link_vars.ieee_fc &
+                MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) {
        case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE:
                bp->port.advertising &= ~(ADVERTISED_Asym_Pause |
                                          ADVERTISED_Pause);
@@ -1957,10 +1998,11 @@ static u8 bnx2x_initial_phy_init(struct bnx2x *bp)
                rc = bnx2x_phy_init(&bp->link_params, &bp->link_vars);
                bnx2x_release_phy_lock(bp);
+                bnx2x_calc_fc_adv(bp);
                if (bp->link_vars.link_up)
                        bnx2x_link_report(bp);
-                bnx2x_calc_fc_adv(bp);
                return rc;
        }
@@ -2220,9 +2262,7 @@ static void bnx2x_link_attn(struct bnx2x *bp)
        /* Make sure that we are synced with the current statistics */
        bnx2x_stats_handle(bp, STATS_EVENT_STOP);
-        bnx2x_acquire_phy_lock(bp);
        bnx2x_link_update(&bp->link_params, &bp->link_vars);
-        bnx2x_release_phy_lock(bp);
        if (bp->link_vars.link_up) {
@@ -2471,6 +2511,8 @@ static void bnx2x_attn_int_asserted(struct bnx2x *bp, u32 asserted)
        if (asserted & ATTN_HARD_WIRED_MASK) {
                if (asserted & ATTN_NIG_FOR_FUNC) {
+                        bnx2x_acquire_phy_lock(bp);
                        /* save nig interrupt mask */
                        bp->nig_mask = REG_RD(bp, nig_int_mask_addr);
                        REG_WR(bp, nig_int_mask_addr, 0);
@@ -2526,8 +2568,10 @@ static void bnx2x_attn_int_asserted(struct bnx2x *bp, u32 asserted)
        REG_WR(bp, hc_addr, asserted);
        /* now set back the mask */
-        if (asserted & ATTN_NIG_FOR_FUNC)
+        if (asserted & ATTN_NIG_FOR_FUNC) {
                REG_WR(bp, nig_int_mask_addr, bp->nig_mask);
+                bnx2x_release_phy_lock(bp);
+        }
 }
 static inline void bnx2x_attn_int_deasserted0(struct bnx2x *bp, u32 attn)
@@ -2795,8 +2839,10 @@ static void bnx2x_attn_int_deasserted(struct bnx2x *bp, u32 deasserted)
 static void bnx2x_attn_int(struct bnx2x *bp)
 {
        /* read local copy of bits */
-        u32 attn_bits = bp->def_status_blk->atten_status_block.attn_bits;
+        u32 attn_bits = le32_to_cpu(bp->def_status_blk->atten_status_block.
-        u32 attn_ack = bp->def_status_blk->atten_status_block.attn_bits_ack;
+                                                                attn_bits);
+        u32 attn_ack = le32_to_cpu(bp->def_status_blk->atten_status_block.
+                                                                attn_bits_ack);
        u32 attn_state = bp->attn_state;
        /* look for changed bits */
@@ -2820,7 +2866,7 @@ static void bnx2x_attn_int(struct bnx2x *bp)
 static void bnx2x_sp_task(struct work_struct *work)
 {
-        struct bnx2x *bp = container_of(work, struct bnx2x, sp_task);
+        struct bnx2x *bp = container_of(work, struct bnx2x, sp_task.work);
        u16 status;
@@ -2844,7 +2890,7 @@ static void bnx2x_sp_task(struct work_struct *work)
        if (status & 0x2)
                bp->stats_pending = 0;
-        bnx2x_ack_sb(bp, DEF_SB_ID, ATTENTION_ID, bp->def_att_idx,
+        bnx2x_ack_sb(bp, DEF_SB_ID, ATTENTION_ID, le16_to_cpu(bp->def_att_idx),
                     IGU_INT_NOP, 1);
        bnx2x_ack_sb(bp, DEF_SB_ID, USTORM_ID, le16_to_cpu(bp->def_u_idx),
                     IGU_INT_NOP, 1);
@@ -2875,7 +2921,7 @@ static irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance)
                return IRQ_HANDLED;
 #endif
-        schedule_work(&bp->sp_task);
+        queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
        return IRQ_HANDLED;
 }
@@ -2892,7 +2938,7 @@ static irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance)
 #define ADD_64(s_hi, a_hi, s_lo, a_lo) \
        do { \
                s_lo += a_lo; \
-                s_hi += a_hi + (s_lo < a_lo) ? 1 : 0; \
+                s_hi += a_hi + ((s_lo < a_lo) ? 1 : 0); \
        } while (0)
 /* difference = minuend - subtrahend */
@@ -4496,7 +4542,7 @@ static void bnx2x_init_context(struct bnx2x *bp)
 static void bnx2x_init_ind_table(struct bnx2x *bp)
 {
-        int port = BP_PORT(bp);
+        int func = BP_FUNC(bp);
        int i;
        if (!is_multi(bp))
@@ -4505,10 +4551,8 @@ static void bnx2x_init_ind_table(struct bnx2x *bp)
        DP(NETIF_MSG_IFUP, "Initializing indirection table\n");
        for (i = 0; i < TSTORM_INDIRECTION_TABLE_SIZE; i++)
                REG_WR8(bp, BAR_TSTRORM_INTMEM +
-                        TSTORM_INDIRECTION_TABLE_OFFSET(port) + i,
+                        TSTORM_INDIRECTION_TABLE_OFFSET(func) + i,
-                        i % bp->num_queues);
+                        BP_CL_ID(bp) + (i % bp->num_queues));
-        REG_WR(bp, PRS_REG_A_PRSU_20, 0xf);
 }
 static void bnx2x_set_client_config(struct bnx2x *bp)
@@ -4517,12 +4561,12 @@ static void bnx2x_set_client_config(struct bnx2x *bp)
        int port = BP_PORT(bp);
        int i;
-        tstorm_client.mtu = bp->dev->mtu + ETH_OVREHEAD;
+        tstorm_client.mtu = bp->dev->mtu;
        tstorm_client.statistics_counter_id = BP_CL_ID(bp);
        tstorm_client.config_flags =
                                TSTORM_ETH_CLIENT_CONFIG_STATSITICS_ENABLE;
 #ifdef BCM_VLAN
-        if (bp->rx_mode && bp->vlgrp) {
+        if (bp->rx_mode && bp->vlgrp && (bp->flags & HW_VLAN_RX_FLAG)) {
                tstorm_client.config_flags |=
                                TSTORM_ETH_CLIENT_CONFIG_VLAN_REMOVAL_ENABLE;
                DP(NETIF_MSG_IFUP, "vlan removal enabled\n");
@@ -4531,7 +4575,7 @@ static void bnx2x_set_client_config(struct bnx2x *bp)
        if (bp->flags & TPA_ENABLE_FLAG) {
                tstorm_client.max_sges_for_packet =
-                        BCM_PAGE_ALIGN(tstorm_client.mtu) >> BCM_PAGE_SHIFT;
+                        SGE_PAGE_ALIGN(tstorm_client.mtu) >> SGE_PAGE_SHIFT;
                tstorm_client.max_sges_for_packet =
                        ((tstorm_client.max_sges_for_packet +
                          PAGES_PER_SGE - 1) & (~(PAGES_PER_SGE - 1))) >>
@@ -4714,10 +4758,11 @@ static void bnx2x_init_internal_func(struct bnx2x *bp)
                         bp->e1hov);
        }
-        /* Init CQ ring mapping and aggregation size */
+        /* Init CQ ring mapping and aggregation size, the FW limit is 8 frags */
-        max_agg_size = min((u32)(bp->rx_buf_size +
+        max_agg_size =
-                                 8*BCM_PAGE_SIZE*PAGES_PER_SGE),
+                min((u32)(min((u32)8, (u32)MAX_SKB_FRAGS) *
-                           (u32)0xffff);
+                          SGE_PAGE_SIZE * PAGES_PER_SGE),
+                    (u32)0xffff);
        for_each_queue(bp, i) {
                struct bnx2x_fastpath *fp = &bp->fp[i];
@@ -4785,6 +4830,15 @@ static void bnx2x_nic_init(struct bnx2x *bp, u32 load_code)
        bnx2x_init_context(bp);
        bnx2x_init_internal(bp, load_code);
        bnx2x_init_ind_table(bp);
+        bnx2x_stats_init(bp);
+        /* At this point, we are ready for interrupts */
+        atomic_set(&bp->intr_sem, 0);
+        /* flush all before enabling interrupts */
+        mb();
+        mmiowb();
        bnx2x_int_enable(bp);
 }
@@ -5101,12 +5155,21 @@ static void enable_blocks_attention(struct bnx2x *bp)
 }
+static void bnx2x_reset_common(struct bnx2x *bp)
+{
+        /* reset_common */
+        REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
+               0xd3ffff7f);
+        REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR, 0x1403);
+}
 static int bnx2x_init_common(struct bnx2x *bp)
 {
        u32 val, i;
        DP(BNX2X_MSG_MCP, "starting common init  func %d\n", BP_FUNC(bp));
+        bnx2x_reset_common(bp);
        REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0xffffffff);
        REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET, 0xfffc);
@@ -5134,7 +5197,6 @@ static int bnx2x_init_common(struct bnx2x *bp)
        REG_WR(bp, PXP2_REG_RQ_SRC_ENDIAN_M, 1);
        REG_WR(bp, PXP2_REG_RQ_CDU_ENDIAN_M, 1);
        REG_WR(bp, PXP2_REG_RQ_DBG_ENDIAN_M, 1);
-        REG_WR(bp, PXP2_REG_RQ_HC_ENDIAN_M, 1);
 /*      REG_WR(bp, PXP2_REG_RD_PBF_SWAP_MODE, 1); */
        REG_WR(bp, PXP2_REG_RD_QM_SWAP_MODE, 1);
@@ -5212,6 +5274,7 @@ static int bnx2x_init_common(struct bnx2x *bp)
        }
        bnx2x_init_block(bp, PRS_COMMON_START, PRS_COMMON_END);
+        REG_WR(bp, PRS_REG_A_PRSU_20, 0xf);
        /* set NIC mode */
        REG_WR(bp, PRS_REG_NIC_MODE, 1);
        if (CHIP_IS_E1H(bp))
@@ -6087,8 +6150,8 @@ static void bnx2x_netif_start(struct bnx2x *bp)
 static void bnx2x_netif_stop(struct bnx2x *bp, int disable_hw)
 {
        bnx2x_int_disable_sync(bp, disable_hw);
+        bnx2x_napi_disable(bp);
        if (netif_running(bp->dev)) {
-                bnx2x_napi_disable(bp);
                netif_tx_disable(bp->dev);
                bp->dev->trans_start = jiffies; /* prevent tx timeout */
        }
@@ -6108,7 +6171,7 @@ static void bnx2x_set_mac_addr_e1(struct bnx2x *bp, int set)
         * multicast 64-127:port0 128-191:port1
         */
        config->hdr.length_6b = 2;
-        config->hdr.offset = port ? 31 : 0;
+        config->hdr.offset = port ? 32 : 0;
        config->hdr.client_id = BP_CL_ID(bp);
        config->hdr.reserved1 = 0;
@@ -6272,7 +6335,7 @@ static void bnx2x_set_rx_mode(struct net_device *dev);
 static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
 {
        u32 load_code;
-        int i, rc;
+        int i, rc = 0;
 #ifdef BNX2X_STOP_ON_ERROR
        if (unlikely(bp->panic))
                return -EPERM;
@@ -6280,48 +6343,6 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
        bp->state = BNX2X_STATE_OPENING_WAIT4_LOAD;
-        /* Send LOAD_REQUEST command to MCP
-           Returns the type of LOAD command:
-           if it is the first port to be initialized
-           common blocks should be initialized, otherwise - not
-        */
-        if (!BP_NOMCP(bp)) {
-                load_code = bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_REQ);
-                if (!load_code) {
-                        BNX2X_ERR("MCP response failure, aborting\n");
-                        return -EBUSY;
-                }
-                if (load_code == FW_MSG_CODE_DRV_LOAD_REFUSED)
-                        return -EBUSY; /* other port in diagnostic mode */
-        } else {
-                int port = BP_PORT(bp);
-                DP(NETIF_MSG_IFUP, "NO MCP load counts before us %d, %d, %d\n",
-                   load_count[0], load_count[1], load_count[2]);
-                load_count[0]++;
-                load_count[1 + port]++;
-                DP(NETIF_MSG_IFUP, "NO MCP new load counts       %d, %d, %d\n",
-                   load_count[0], load_count[1], load_count[2]);
-                if (load_count[0] == 1)
-                        load_code = FW_MSG_CODE_DRV_LOAD_COMMON;
-                else if (load_count[1 + port] == 1)
-                        load_code = FW_MSG_CODE_DRV_LOAD_PORT;
-                else
-                        load_code = FW_MSG_CODE_DRV_LOAD_FUNCTION;
-        }
-        if ((load_code == FW_MSG_CODE_DRV_LOAD_COMMON) ||
-            (load_code == FW_MSG_CODE_DRV_LOAD_PORT))
-                bp->port.pmf = 1;
-        else
-                bp->port.pmf = 0;
-        DP(NETIF_MSG_LINK, "pmf %d\n", bp->port.pmf);
-        /* if we can't use MSI-X we only need one fp,
-         * so try to enable MSI-X with the requested number of fp's
-         * and fallback to inta with one fp
-         */
        if (use_inta) {
                bp->num_queues = 1;
@@ -6336,7 +6357,15 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                else
                        bp->num_queues = 1;
-                if (bnx2x_enable_msix(bp)) {
+                DP(NETIF_MSG_IFUP,
+                   "set number of queues to %d\n", bp->num_queues);
+                /* if we can't use MSI-X we only need one fp,
+                 * so try to enable MSI-X with the requested number of fp's
+                 * and fallback to MSI or legacy INTx with one fp
+                 */
+                rc = bnx2x_enable_msix(bp);
+                if (rc) {
                        /* failed to enable MSI-X */
                        bp->num_queues = 1;
                        if (use_multi)
@@ -6344,8 +6373,6 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                                          " to enable MSI-X\n");
                }
        }
-        DP(NETIF_MSG_IFUP,
-           "set number of queues to %d\n", bp->num_queues);
        if (bnx2x_alloc_mem(bp))
                return -ENOMEM;
@@ -6354,30 +6381,85 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                bnx2x_fp(bp, i, disable_tpa) =
                                        ((bp->flags & TPA_ENABLE_FLAG) == 0);
+        for_each_queue(bp, i)
+                netif_napi_add(bp->dev, &bnx2x_fp(bp, i, napi),
+                               bnx2x_poll, 128);
+#ifdef BNX2X_STOP_ON_ERROR
+        for_each_queue(bp, i) {
+                struct bnx2x_fastpath *fp = &bp->fp[i];
+                fp->poll_no_work = 0;
+                fp->poll_calls = 0;
+                fp->poll_max_calls = 0;
+                fp->poll_complete = 0;
+                fp->poll_exit = 0;
+        }
+#endif
+        bnx2x_napi_enable(bp);
        if (bp->flags & USING_MSIX_FLAG) {
                rc = bnx2x_req_msix_irqs(bp);
                if (rc) {
                        pci_disable_msix(bp->pdev);
-                        goto load_error;
+                        goto load_error1;
                }
+                printk(KERN_INFO PFX "%s: using MSI-X\n", bp->dev->name);
        } else {
                bnx2x_ack_int(bp);
                rc = bnx2x_req_irq(bp);
                if (rc) {
-                        BNX2X_ERR("IRQ request failed, aborting\n");
+                        BNX2X_ERR("IRQ request failed  rc %d, aborting\n", rc);
-                        goto load_error;
+                        goto load_error1;
                }
        }
-        for_each_queue(bp, i)
+        /* Send LOAD_REQUEST command to MCP
-                netif_napi_add(bp->dev, &bnx2x_fp(bp, i, napi),
+           Returns the type of LOAD command:
-                               bnx2x_poll, 128);
+           if it is the first port to be initialized
+           common blocks should be initialized, otherwise - not
+        */
+        if (!BP_NOMCP(bp)) {
+                load_code = bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_REQ);
+                if (!load_code) {
+                        BNX2X_ERR("MCP response failure, aborting\n");
+                        rc = -EBUSY;
+                        goto load_error2;
+                }
+                if (load_code == FW_MSG_CODE_DRV_LOAD_REFUSED) {
+                        rc = -EBUSY; /* other port in diagnostic mode */
+                        goto load_error2;
+                }
+        } else {
+                int port = BP_PORT(bp);
+                DP(NETIF_MSG_IFUP, "NO MCP load counts before us %d, %d, %d\n",
+                   load_count[0], load_count[1], load_count[2]);
+                load_count[0]++;
+                load_count[1 + port]++;
+                DP(NETIF_MSG_IFUP, "NO MCP new load counts       %d, %d, %d\n",
+                   load_count[0], load_count[1], load_count[2]);
+                if (load_count[0] == 1)
+                        load_code = FW_MSG_CODE_DRV_LOAD_COMMON;
+                else if (load_count[1 + port] == 1)
+                        load_code = FW_MSG_CODE_DRV_LOAD_PORT;
+                else
+                        load_code = FW_MSG_CODE_DRV_LOAD_FUNCTION;
+        }
+        if ((load_code == FW_MSG_CODE_DRV_LOAD_COMMON) ||
+            (load_code == FW_MSG_CODE_DRV_LOAD_PORT))
+                bp->port.pmf = 1;
+        else
+                bp->port.pmf = 0;
+        DP(NETIF_MSG_LINK, "pmf %d\n", bp->port.pmf);
        /* Initialize HW */
        rc = bnx2x_init_hw(bp, load_code);
        if (rc) {
                BNX2X_ERR("HW init failed, aborting\n");
-                goto load_int_disable;
+                goto load_error2;
        }
        /* Setup NIC internals and enable interrupts */
@@ -6389,25 +6471,16 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                if (!load_code) {
                        BNX2X_ERR("MCP response failure, aborting\n");
                        rc = -EBUSY;
-                        goto load_rings_free;
+                        goto load_error3;
                }
        }
-        bnx2x_stats_init(bp);
        bp->state = BNX2X_STATE_OPENING_WAIT4_PORT;
-        /* Enable Rx interrupt handling before sending the ramrod
-           as it's completed on Rx FP queue */
-        bnx2x_napi_enable(bp);
-        /* Enable interrupt handling */
-        atomic_set(&bp->intr_sem, 0);
        rc = bnx2x_setup_leading(bp);
        if (rc) {
                BNX2X_ERR("Setup leading failed!\n");
-                goto load_netif_stop;
+                goto load_error3;
        }
        if (CHIP_IS_E1H(bp))
@@ -6420,7 +6493,7 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                for_each_nondefault_queue(bp, i) {
                        rc = bnx2x_setup_multi(bp, i);
                        if (rc)
-                                goto load_netif_stop;
+                                goto load_error3;
                }
        if (CHIP_IS_E1(bp))
@@ -6436,18 +6509,18 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
        case LOAD_NORMAL:
                /* Tx queue should be only reenabled */
                netif_wake_queue(bp->dev);
+                /* Initialize the receive filter. */
                bnx2x_set_rx_mode(bp->dev);
                break;
        case LOAD_OPEN:
                netif_start_queue(bp->dev);
+                /* Initialize the receive filter. */
                bnx2x_set_rx_mode(bp->dev);
-                if (bp->flags & USING_MSIX_FLAG)
-                        printk(KERN_INFO PFX "%s: using MSI-X\n",
-                               bp->dev->name);
                break;
        case LOAD_DIAG:
+                /* Initialize the receive filter. */
                bnx2x_set_rx_mode(bp->dev);
                bp->state = BNX2X_STATE_DIAG;
                break;
@@ -6465,20 +6538,25 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
        return 0;
-load_netif_stop:
+load_error3:
-        bnx2x_napi_disable(bp);
+        bnx2x_int_disable_sync(bp, 1);
-load_rings_free:
+        if (!BP_NOMCP(bp)) {
+                bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP);
+                bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE);
+        }
+        bp->port.pmf = 0;
        /* Free SKBs, SGEs, TPA pool and driver internals */
        bnx2x_free_skbs(bp);
        for_each_queue(bp, i)
                bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
-load_int_disable:
+load_error2:
-        bnx2x_int_disable_sync(bp, 1);
        /* Release IRQs */
        bnx2x_free_irq(bp);
-load_error:
+load_error1:
+        bnx2x_napi_disable(bp);
+        for_each_queue(bp, i)
+                netif_napi_del(&bnx2x_fp(bp, i, napi));
        bnx2x_free_mem(bp);
-        bp->port.pmf = 0;
        /* TBD we really need to reset the chip
           if we want to recover from this */
@@ -6551,6 +6629,7 @@ static int bnx2x_stop_leading(struct bnx2x *bp)
                }
                cnt--;
                msleep(1);
+                rmb(); /* Refresh the dsb_sp_prod */
        }
        bp->state = BNX2X_STATE_CLOSING_WAIT4_UNLOAD;
        bp->fp[0].state = BNX2X_FP_STATE_CLOSED;
@@ -6602,14 +6681,6 @@ static void bnx2x_reset_port(struct bnx2x *bp)
        /* TODO: Close Doorbell port? */
 }
-static void bnx2x_reset_common(struct bnx2x *bp)
-{
-        /* reset_common */
-        REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
-               0xd3ffff7f);
-        REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR, 0x1403);
-}
 static void bnx2x_reset_chip(struct bnx2x *bp, u32 reset_code)
 {
        DP(BNX2X_MSG_MCP, "function %d  reset_code %x\n",
@@ -6650,20 +6721,22 @@ static int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
        bnx2x_set_storm_rx_mode(bp);
        bnx2x_netif_stop(bp, 1);
-        if (!netif_running(bp->dev))
-                bnx2x_napi_disable(bp);
        del_timer_sync(&bp->timer);
        SHMEM_WR(bp, func_mb[BP_FUNC(bp)].drv_pulse_mb,
                 (DRV_PULSE_ALWAYS_ALIVE | bp->fw_drv_pulse_wr_seq));
        bnx2x_stats_handle(bp, STATS_EVENT_STOP);
+        /* Release IRQs */
+        bnx2x_free_irq(bp);
        /* Wait until tx fast path tasks complete */
        for_each_queue(bp, i) {
                struct bnx2x_fastpath *fp = &bp->fp[i];
                cnt = 1000;
                smp_rmb();
-                while (BNX2X_HAS_TX_WORK(fp)) {
+                while (bnx2x_has_tx_work_unload(fp)) {
                        bnx2x_tx_int(fp, 1000);
                        if (!cnt) {
@@ -6684,9 +6757,6 @@ static int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
        /* Give HW time to discard old tx messages */
        msleep(1);
-        /* Release IRQs */
-        bnx2x_free_irq(bp);
        if (CHIP_IS_E1(bp)) {
                struct mac_configuration_cmd *config =
                                                bnx2x_sp(bp, mcast_config);
@@ -6795,6 +6865,8 @@ unload_error:
        bnx2x_free_skbs(bp);
        for_each_queue(bp, i)
                bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
+        for_each_queue(bp, i)
+                netif_napi_del(&bnx2x_fp(bp, i, napi));
        bnx2x_free_mem(bp);
        bp->state = BNX2X_STATE_CLOSED;
@@ -6847,10 +6919,6 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
                 */
                bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
                val = REG_RD(bp, DORQ_REG_NORM_CID_OFST);
-                if (val == 0x7)
-                        REG_WR(bp, DORQ_REG_NORM_CID_OFST, 0);
-                bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
                if (val == 0x7) {
                        u32 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
                        /* save our func */
@@ -6858,6 +6926,9 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
                        u32 swap_en;
                        u32 swap_val;
+                        /* 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 */
@@ -6883,6 +6954,9 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
                                bnx2x_fw_command(bp, reset_code);
                        }
+                        /* now it's safe to release the lock */
+                        bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
                        REG_WR(bp, (BP_PORT(bp) ? HC_REG_CONFIG_1 :
                                    HC_REG_CONFIG_0), 0x1000);
@@ -6927,7 +7001,9 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
                        bp->fw_seq =
                               (SHMEM_RD(bp, func_mb[bp->func].drv_mb_header) &
                                DRV_MSG_SEQ_NUMBER_MASK);
-                }
+                } else
+                        bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
        }
 }
@@ -6944,7 +7020,7 @@ static void __devinit bnx2x_get_common_hwinfo(struct bnx2x *bp)
        id |= ((val & 0xf) << 12);
        val = REG_RD(bp, MISC_REG_CHIP_METAL);
        id |= ((val & 0xff) << 4);
-        REG_RD(bp, MISC_REG_BOND_ID);
+        val = REG_RD(bp, MISC_REG_BOND_ID);
        id |= (val & 0xf);
        bp->common.chip_id = id;
        bp->link_params.chip_id = bp->common.chip_id;
@@ -7501,7 +7577,7 @@ static int __devinit bnx2x_init_bp(struct bnx2x *bp)
        mutex_init(&bp->port.phy_mutex);
-        INIT_WORK(&bp->sp_task, bnx2x_sp_task);
+        INIT_DELAYED_WORK(&bp->sp_task, bnx2x_sp_task);
        INIT_WORK(&bp->reset_task, bnx2x_reset_task);
        rc = bnx2x_get_hwinfo(bp);
@@ -8076,6 +8152,9 @@ static int bnx2x_get_eeprom(struct net_device *dev,
        struct bnx2x *bp = netdev_priv(dev);
        int rc;
+        if (!netif_running(dev))
+                return -EAGAIN;
        DP(BNX2X_MSG_NVM, "ethtool_eeprom: cmd %d\n"
           DP_LEVEL "  magic 0x%x  offset 0x%x (%d)  len 0x%x (%d)\n",
           eeprom->cmd, eeprom->magic, eeprom->offset, eeprom->offset,
@@ -8678,18 +8757,17 @@ static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode, u8 link_up)
        if (loopback_mode == BNX2X_MAC_LOOPBACK) {
                bp->link_params.loopback_mode = LOOPBACK_BMAC;
-                bnx2x_acquire_phy_lock(bp);
                bnx2x_phy_init(&bp->link_params, &bp->link_vars);
-                bnx2x_release_phy_lock(bp);
        } else if (loopback_mode == BNX2X_PHY_LOOPBACK) {
+                u16 cnt = 1000;
                bp->link_params.loopback_mode = LOOPBACK_XGXS_10;
-                bnx2x_acquire_phy_lock(bp);
                bnx2x_phy_init(&bp->link_params, &bp->link_vars);
-                bnx2x_release_phy_lock(bp);
                /* wait until link state is restored */
-                bnx2x_wait_for_link(bp, link_up);
+                if (link_up)
+                        while (cnt-- && bnx2x_test_link(&bp->link_params,
+                                                        &bp->link_vars))
+                                msleep(10);
        } else
                return -EINVAL;
@@ -8727,6 +8805,8 @@ static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode, u8 link_up)
        tx_bd->general_data = ((UNICAST_ADDRESS <<
                                ETH_TX_BD_ETH_ADDR_TYPE_SHIFT) | 1);
+        wmb();
        fp->hw_tx_prods->bds_prod =
                cpu_to_le16(le16_to_cpu(fp->hw_tx_prods->bds_prod) + 1);
        mb(); /* FW restriction: must not reorder writing nbd and packets */
@@ -8778,7 +8858,6 @@ test_loopback_rx_exit:
        /* Update producers */
        bnx2x_update_rx_prod(bp, fp, fp->rx_bd_prod, fp->rx_comp_prod,
                             fp->rx_sge_prod);
-        mmiowb(); /* keep prod updates ordered */
 test_loopback_exit:
        bp->link_params.loopback_mode = LOOPBACK_NONE;
@@ -8794,6 +8873,7 @@ static int bnx2x_test_loopback(struct bnx2x *bp, u8 link_up)
                return BNX2X_LOOPBACK_FAILED;
        bnx2x_netif_stop(bp, 1);
+        bnx2x_acquire_phy_lock(bp);
        if (bnx2x_run_loopback(bp, BNX2X_MAC_LOOPBACK, link_up)) {
                DP(NETIF_MSG_PROBE, "MAC loopback failed\n");
@@ -8805,6 +8885,7 @@ static int bnx2x_test_loopback(struct bnx2x *bp, u8 link_up)
                rc |= BNX2X_PHY_LOOPBACK_FAILED;
        }
+        bnx2x_release_phy_lock(bp);
        bnx2x_netif_start(bp);
        return rc;
@@ -8878,7 +8959,10 @@ static int bnx2x_test_intr(struct bnx2x *bp)
                return -ENODEV;
        config->hdr.length_6b = 0;
-        config->hdr.offset = 0;
+        if (CHIP_IS_E1(bp))
+                config->hdr.offset = (BP_PORT(bp) ? 32 : 0);
+        else
+                config->hdr.offset = BP_FUNC(bp);
        config->hdr.client_id = BP_CL_ID(bp);
        config->hdr.reserved1 = 0;
@@ -9243,6 +9327,18 @@ static int bnx2x_set_power_state(struct bnx2x *bp, pci_power_t state)
        return 0;
 }
+static inline int bnx2x_has_rx_work(struct bnx2x_fastpath *fp)
+{
+        u16 rx_cons_sb;
+        /* Tell compiler that status block fields can change */
+        barrier();
+        rx_cons_sb = le16_to_cpu(*fp->rx_cons_sb);
+        if ((rx_cons_sb & MAX_RCQ_DESC_CNT) == MAX_RCQ_DESC_CNT)
+                rx_cons_sb++;
+        return (fp->rx_comp_cons != rx_cons_sb);
+}
 /*
 * net_device service functions
 */
@@ -9253,7 +9349,6 @@ static int bnx2x_poll(struct napi_struct *napi, int budget)
                                                 napi);
        struct bnx2x *bp = fp->bp;
        int work_done = 0;
-        u16 rx_cons_sb;
 #ifdef BNX2X_STOP_ON_ERROR
        if (unlikely(bp->panic))
@@ -9266,19 +9361,12 @@ static int bnx2x_poll(struct napi_struct *napi, int budget)
        bnx2x_update_fpsb_idx(fp);
-        if (BNX2X_HAS_TX_WORK(fp))
+        if (bnx2x_has_tx_work(fp))
                bnx2x_tx_int(fp, budget);
-        rx_cons_sb = le16_to_cpu(*fp->rx_cons_sb);
+        if (bnx2x_has_rx_work(fp))
-        if ((rx_cons_sb & MAX_RCQ_DESC_CNT) == MAX_RCQ_DESC_CNT)
-                rx_cons_sb++;
-        if (BNX2X_HAS_RX_WORK(fp))
                work_done = bnx2x_rx_int(fp, budget);
        rmb(); /* BNX2X_HAS_WORK() reads the status block */
-        rx_cons_sb = le16_to_cpu(*fp->rx_cons_sb);
-        if ((rx_cons_sb & MAX_RCQ_DESC_CNT) == MAX_RCQ_DESC_CNT)
-                rx_cons_sb++;
        /* must not complete if we consumed full budget */
        if ((work_done < budget) && !BNX2X_HAS_WORK(fp)) {
@@ -9389,6 +9477,7 @@ static inline u32 bnx2x_xmit_type(struct bnx2x *bp, struct sk_buff *skb)
        return rc;
 }
+#if (MAX_SKB_FRAGS >= MAX_FETCH_BD - 3)
 /* check if packet requires linearization (packet is too fragmented) */
 static int bnx2x_pkt_req_lin(struct bnx2x *bp, struct sk_buff *skb,
                             u32 xmit_type)
@@ -9466,6 +9555,7 @@ exit_lbl:
        return to_copy;
 }
+#endif
 /* called with netif_tx_lock
 * bnx2x_tx_int() runs without netif_tx_lock unless it needs to call
@@ -9506,6 +9596,7 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
           skb->ip_summed, skb->protocol, ipv6_hdr(skb)->nexthdr,
           ip_hdr(skb)->protocol, skb_shinfo(skb)->gso_type, xmit_type);
+#if (MAX_SKB_FRAGS >= MAX_FETCH_BD - 3)
        /* First, check if we need to linearize the skb
           (due to FW restrictions) */
        if (bnx2x_pkt_req_lin(bp, skb, xmit_type)) {
@@ -9518,6 +9609,7 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
                        return NETDEV_TX_OK;
                }
        }
+#endif
        /*
        Please read carefully. First we use one BD which we mark as start,
@@ -9549,11 +9641,14 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
           "sending pkt %u @%p  next_idx %u  bd %u @%p\n",
           pkt_prod, tx_buf, fp->tx_pkt_prod, bd_prod, tx_bd);
-        if ((bp->vlgrp != NULL) && vlan_tx_tag_present(skb)) {
+#ifdef BCM_VLAN
+        if ((bp->vlgrp != NULL) && vlan_tx_tag_present(skb) &&
+            (bp->flags & HW_VLAN_TX_FLAG)) {
                tx_bd->vlan = cpu_to_le16(vlan_tx_tag_get(skb));
                tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_VLAN_TAG;
                vlan_off += 4;
        } else
+#endif
                tx_bd->vlan = cpu_to_le16(pkt_prod);
        if (xmit_type) {
@@ -9705,6 +9800,15 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
        DP(NETIF_MSG_TX_QUEUED, "doorbell: nbd %d  bd %u\n", nbd, bd_prod);
+        /*
+         * Make sure that the BD data is updated before updating the producer
+         * since FW might read the BD right after the producer is updated.
+         * This is only applicable for weak-ordered memory model archs such
+         * as IA-64. The following barrier is also mandatory since FW will
+         * assumes packets must have BDs.
+         */
+        wmb();
        fp->hw_tx_prods->bds_prod =
                cpu_to_le16(le16_to_cpu(fp->hw_tx_prods->bds_prod) + nbd);
        mb(); /* FW restriction: must not reorder writing nbd and packets */
@@ -9718,6 +9822,9 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
        dev->trans_start = jiffies;
        if (unlikely(bnx2x_tx_avail(fp) < MAX_SKB_FRAGS + 3)) {
+                /* We want bnx2x_tx_int to "see" the updated tx_bd_prod
+                   if we put Tx into XOFF state. */
+                smp_mb();
                netif_stop_queue(dev);
                bp->eth_stats.driver_xoff++;
                if (bnx2x_tx_avail(fp) >= MAX_SKB_FRAGS + 3)
@@ -9733,6 +9840,8 @@ static int bnx2x_open(struct net_device *dev)
 {
        struct bnx2x *bp = netdev_priv(dev);
+        netif_carrier_off(dev);
        bnx2x_set_power_state(bp, PCI_D0);
        return bnx2x_nic_load(bp, LOAD_OPEN);
@@ -9816,7 +9925,7 @@ static void bnx2x_set_rx_mode(struct net_device *dev)
                                for (; i < old; i++) {
                                        if (CAM_IS_INVALID(config->
                                                           config_table[i])) {
-                                                i--; /* already invalidated */
+                                                /* already invalidated */
                                                break;
                                        }
                                        /* invalidate */
@@ -9987,6 +10096,16 @@ static void bnx2x_vlan_rx_register(struct net_device *dev,
        struct bnx2x *bp = netdev_priv(dev);
        bp->vlgrp = vlgrp;
+        /* Set flags according to the required capabilities */
+        bp->flags &= ~(HW_VLAN_RX_FLAG | HW_VLAN_TX_FLAG);
+        if (dev->features & NETIF_F_HW_VLAN_TX)
+                bp->flags |= HW_VLAN_TX_FLAG;
+        if (dev->features & NETIF_F_HW_VLAN_RX)
+                bp->flags |= HW_VLAN_RX_FLAG;
        if (netif_running(dev))
                bnx2x_set_client_config(bp);
 }
@@ -10143,6 +10262,7 @@ static int __devinit bnx2x_init_dev(struct pci_dev *pdev,
                dev->features |= NETIF_F_HIGHDMA;
 #ifdef BCM_VLAN
        dev->features |= (NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX);
+        bp->flags |= (HW_VLAN_RX_FLAG | HW_VLAN_TX_FLAG);
 #endif
        dev->features |= (NETIF_F_TSO | NETIF_F_TSO_ECN);
        dev->features |= NETIF_F_TSO6;
@@ -10215,22 +10335,18 @@ static int __devinit bnx2x_init_one(struct pci_dev *pdev,
                return rc;
        }
-        rc = register_netdev(dev);
-        if (rc) {
-                dev_err(&pdev->dev, "Cannot register net device\n");
-                goto init_one_exit;
-        }
        pci_set_drvdata(pdev, dev);
        rc = bnx2x_init_bp(bp);
+        if (rc)
+                goto init_one_exit;
+        rc = register_netdev(dev);
        if (rc) {
-                unregister_netdev(dev);
+                dev_err(&pdev->dev, "Cannot register net device\n");
                goto init_one_exit;
        }
-        netif_carrier_off(dev);
        bp->common.name = board_info[ent->driver_data].name;
        printk(KERN_INFO "%s: %s (%c%d) PCI-E x%d %s found at mem %lx,"
               " IRQ %d, ", dev->name, bp->common.name,
@@ -10378,6 +10494,8 @@ static int bnx2x_eeh_nic_unload(struct bnx2x *bp)
        bnx2x_free_skbs(bp);
        for_each_queue(bp, i)
                bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
+        for_each_queue(bp, i)
+                netif_napi_del(&bnx2x_fp(bp, i, napi));
        bnx2x_free_mem(bp);
        bp->state = BNX2X_STATE_CLOSED;
@@ -10519,12 +10637,20 @@ static struct pci_driver bnx2x_pci_driver = {
 static int __init bnx2x_init(void)
 {
+        bnx2x_wq = create_singlethread_workqueue("bnx2x");
+        if (bnx2x_wq == NULL) {
+                printk(KERN_ERR PFX "Cannot create workqueue\n");
+                return -ENOMEM;
+        }
        return pci_register_driver(&bnx2x_pci_driver);
 }
 static void __exit bnx2x_cleanup(void)
 {
        pci_unregister_driver(&bnx2x_pci_driver);
+        destroy_workqueue(bnx2x_wq);
 }
 module_init(bnx2x_init);
diff --git a/drivers/net/bnx2x_reg.h b/drivers/net/bnx2x_reg.h
index a67b0c358ae4..d084e5fc4b51 100644
--- a/drivers/net/bnx2x_reg.h
+++ b/drivers/net/bnx2x_reg.h
@@ -1,6 +1,6 @@
 /* bnx2x_reg.h: Broadcom Everest network driver.
 *
- * Copyright (c) 2007-2008 Broadcom Corporation
+ * Copyright (c) 2007-2009 Broadcom Corporation
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
diff --git a/drivers/net/cassini.c b/drivers/net/cassini.c
index 840b3d1a22f5..bbbc3bb08aa5 100644
--- a/drivers/net/cassini.c
+++ b/drivers/net/cassini.c
@@ -806,7 +806,7 @@ static int cas_reset_mii_phy(struct cas *cp)
        cas_phy_write(cp, MII_BMCR, BMCR_RESET);
        udelay(100);
-        while (limit--) {
+        while (--limit) {
                val = cas_phy_read(cp, MII_BMCR);
                if ((val & BMCR_RESET) == 0)
                        break;
@@ -979,7 +979,7 @@ static void cas_phy_init(struct cas *cp)
                writel(val, cp->regs + REG_PCS_MII_CTRL);
                limit = STOP_TRIES;
-                while (limit-- > 0) {
+                while (--limit > 0) {
                        udelay(10);
                        if ((readl(cp->regs + REG_PCS_MII_CTRL) &
                             PCS_MII_RESET) == 0)
diff --git a/drivers/net/cxgb3/sge.c b/drivers/net/cxgb3/sge.c
index 14f9fb3e8795..d31791f60292 100644
--- a/drivers/net/cxgb3/sge.c
+++ b/drivers/net/cxgb3/sge.c
@@ -2104,6 +2104,7 @@ static void init_lro_mgr(struct sge_qset *qs, struct net_lro_mgr *lro_mgr)
 {
        lro_mgr->dev = qs->netdev;
        lro_mgr->features = LRO_F_NAPI;
+        lro_mgr->frag_align_pad = NET_IP_ALIGN;
        lro_mgr->ip_summed = CHECKSUM_UNNECESSARY;
        lro_mgr->ip_summed_aggr = CHECKSUM_UNNECESSARY;
        lro_mgr->max_desc = T3_MAX_LRO_SES;
@@ -2275,8 +2276,7 @@ no_mem:
                } else if ((len = ntohl(r->len_cq)) != 0) {
                        struct sge_fl *fl;
-                        if (eth)
+                        lro &= eth && is_eth_tcp(rss_hi);
-                                lro = qs->lro_enabled && is_eth_tcp(rss_hi);
                        fl = (len & F_RSPD_FLQ) ? &qs->fl[1] : &qs->fl[0];
                        if (fl->use_pages) {
diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index 26474c92193f..6bd63cc67b3e 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -31,7 +31,7 @@
 char e1000_driver_name[] = "e1000";
 static char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
-#define DRV_VERSION "7.3.20-k3-NAPI"
+#define DRV_VERSION "7.3.21-k3-NAPI"
 const char e1000_driver_version[] = DRV_VERSION;
 static const char e1000_copyright[] = "Copyright (c) 1999-2006 Intel Corporation.";
@@ -940,7 +940,7 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
                err = pci_enable_device(pdev);
        } else {
                bars = pci_select_bars(pdev, IORESOURCE_MEM);
-                err = pci_enable_device(pdev);
+                err = pci_enable_device_mem(pdev);
        }
        if (err)
                return err;
@@ -3712,7 +3712,7 @@ static irqreturn_t e1000_intr(int irq, void *data)
        struct e1000_hw *hw = &adapter->hw;
        u32 rctl, icr = er32(ICR);
-        if (unlikely(!icr))
+        if (unlikely((!icr) || test_bit(__E1000_RESETTING, &adapter->flags)))
                return IRQ_NONE;  /* Not our interrupt */
        /* IMS will not auto-mask if INT_ASSERTED is not set, and if it is
diff --git a/drivers/net/e1000e/82571.c b/drivers/net/e1000e/82571.c
index cf43ee743b3c..0890162953e9 100644
--- a/drivers/net/e1000e/82571.c
+++ b/drivers/net/e1000e/82571.c
@@ -981,11 +981,15 @@ static void e1000_initialize_hw_bits_82571(struct e1000_hw *hw)
                ew32(PBA_ECC, reg);
        }
-        /* PCI-Ex Control Register */
+        /* PCI-Ex Control Registers */
        if (hw->mac.type == e1000_82574) {
                reg = er32(GCR);
                reg |= (1 << 22);
                ew32(GCR, reg);
+                reg = er32(GCR2);
+                reg |= 1;
+                ew32(GCR2, reg);
        }
        return;
diff --git a/drivers/net/e1000e/hw.h b/drivers/net/e1000e/hw.h
index f25e961c6b3b..2d4ce0492df0 100644
--- a/drivers/net/e1000e/hw.h
+++ b/drivers/net/e1000e/hw.h
@@ -206,6 +206,7 @@ enum e1e_registers {
        E1000_MANC2H    = 0x05860, /* Management Control To Host - RW */
        E1000_SW_FW_SYNC = 0x05B5C, /* Software-Firmware Synchronization - RW */
        E1000_GCR       = 0x05B00, /* PCI-Ex Control */
+        E1000_GCR2      = 0x05B64, /* PCI-Ex Control #2 */
        E1000_FACTPS    = 0x05B30, /* Function Active and Power State to MNG */
        E1000_SWSM      = 0x05B50, /* SW Semaphore */
        E1000_FWSM      = 0x05B54, /* FW Semaphore */
diff --git a/drivers/net/ehea/ehea_main.c b/drivers/net/ehea/ehea_main.c
index e3131ea629cd..dfe92264e825 100644
--- a/drivers/net/ehea/ehea_main.c
+++ b/drivers/net/ehea/ehea_main.c
@@ -132,7 +132,7 @@ void ehea_dump(void *adr, int len, char *msg)
        int x;
        unsigned char *deb = adr;
        for (x = 0; x < len; x += 16) {
-                printk(DRV_NAME " %s adr=%p ofs=%04x %016lx %016lx\n", msg,
+                printk(DRV_NAME " %s adr=%p ofs=%04x %016llx %016llx\n", msg,
                          deb, x, *((u64 *)&deb[0]), *((u64 *)&deb[8]));
                deb += 16;
        }
@@ -883,7 +883,7 @@ static irqreturn_t ehea_qp_aff_irq_handler(int irq, void *param)
        while (eqe) {
                qp_token = EHEA_BMASK_GET(EHEA_EQE_QP_TOKEN, eqe->entry);
-                ehea_error("QP aff_err: entry=0x%lx, token=0x%x",
+                ehea_error("QP aff_err: entry=0x%llx, token=0x%x",
                           eqe->entry, qp_token);
                qp = port->port_res[qp_token].qp;
@@ -1159,7 +1159,7 @@ static void ehea_parse_eqe(struct ehea_adapter *adapter, u64 eqe)
                netif_stop_queue(port->netdev);
                break;
        default:
-                ehea_error("unknown event code %x, eqe=0x%lX", ec, eqe);
+                ehea_error("unknown event code %x, eqe=0x%llX", ec, eqe);
                break;
        }
 }
@@ -1971,7 +1971,7 @@ static void ehea_set_multicast_list(struct net_device *dev)
                }
                if (dev->mc_count > port->adapter->max_mc_mac) {
-                        ehea_info("Mcast registration limit reached (0x%lx). "
+                        ehea_info("Mcast registration limit reached (0x%llx). "
                                  "Use ALLMULTI!",
                                  port->adapter->max_mc_mac);
                        goto out;
diff --git a/drivers/net/ehea/ehea_qmr.c b/drivers/net/ehea/ehea_qmr.c
index 225c692b5d99..49d766ebbcf4 100644
--- a/drivers/net/ehea/ehea_qmr.c
+++ b/drivers/net/ehea/ehea_qmr.c
@@ -168,7 +168,7 @@ struct ehea_cq *ehea_create_cq(struct ehea_adapter *adapter,
                                             cq->fw_handle, rpage, 1);
                if (hret < H_SUCCESS) {
                        ehea_error("register_rpage_cq failed ehea_cq=%p "
-                                   "hret=%lx counter=%i act_pages=%i",
+                                   "hret=%llx counter=%i act_pages=%i",
                                   cq, hret, counter, cq->attr.nr_pages);
                        goto out_kill_hwq;
                }
@@ -178,13 +178,13 @@ struct ehea_cq *ehea_create_cq(struct ehea_adapter *adapter,
                        if ((hret != H_SUCCESS) || (vpage)) {
                                ehea_error("registration of pages not "
-                                           "complete hret=%lx\n", hret);
+                                           "complete hret=%llx\n", hret);
                                goto out_kill_hwq;
                        }
                } else {
                        if (hret != H_PAGE_REGISTERED) {
                                ehea_error("CQ: registration of page failed "
-                                           "hret=%lx\n", hret);
+                                           "hret=%llx\n", hret);
                                goto out_kill_hwq;
                        }
                }
@@ -986,15 +986,15 @@ void print_error_data(u64 *data)
                length = EHEA_PAGESIZE;
        if (type == 0x8) /* Queue Pair */
-                ehea_error("QP (resource=%lX) state: AER=0x%lX, AERR=0x%lX, "
+                ehea_error("QP (resource=%llX) state: AER=0x%llX, AERR=0x%llX, "
-                           "port=%lX", resource, data[6], data[12], data[22]);
+                           "port=%llX", resource, data[6], data[12], data[22]);
        if (type == 0x4) /* Completion Queue */
-                ehea_error("CQ (resource=%lX) state: AER=0x%lX", resource,
+                ehea_error("CQ (resource=%llX) state: AER=0x%llX", resource,
                           data[6]);
        if (type == 0x3) /* Event Queue */
-                ehea_error("EQ (resource=%lX) state: AER=0x%lX", resource,
+                ehea_error("EQ (resource=%llX) state: AER=0x%llX", resource,
                           data[6]);
        ehea_dump(data, length, "error data");
@@ -1016,11 +1016,11 @@ void ehea_error_data(struct ehea_adapter *adapter, u64 res_handle)
                                rblock);
        if (ret == H_R_STATE)
-                ehea_error("No error data is available: %lX.", res_handle);
+                ehea_error("No error data is available: %llX.", res_handle);
        else if (ret == H_SUCCESS)
                print_error_data(rblock);
        else
-                ehea_error("Error data could not be fetched: %lX", res_handle);
+                ehea_error("Error data could not be fetched: %llX", res_handle);
        kfree(rblock);
 }
diff --git a/drivers/net/fec.c b/drivers/net/fec.c
index 7e33c129d51c..2769083bfe83 100644
--- a/drivers/net/fec.c
+++ b/drivers/net/fec.c
@@ -1698,7 +1698,7 @@ static void __inline__ fec_set_mii(struct net_device *dev, struct fec_enet_priva
        /*
         * Set MII speed to 2.5 MHz
         */
-        fep->phy_speed = ((((MCF_CLK / 2) / (2500000 / 10)) + 5) / 10) * 2;
+        fep->phy_speed = (MCF_CLK / 3) / (2500000 * 2 ) * 2;
        fecp->fec_mii_speed = fep->phy_speed;
        fec_restart(dev, 0);
diff --git a/drivers/net/fs_enet/fs_enet-main.c b/drivers/net/fs_enet/fs_enet-main.c
index 4e6a9195fe5f..ce900e54d8d1 100644
--- a/drivers/net/fs_enet/fs_enet-main.c
+++ b/drivers/net/fs_enet/fs_enet-main.c
@@ -795,6 +795,7 @@ static int fs_enet_open(struct net_device *dev)
        err = fs_init_phy(dev);
        if (err) {
+                free_irq(fep->interrupt, dev);
                if (fep->fpi->use_napi)
                        napi_disable(&fep->napi);
                return err;
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index efcbeb6c8673..acae2d8cd688 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -351,6 +351,9 @@ static int gfar_probe(struct of_device *ofdev,
        /* Reset MAC layer */
        gfar_write(&priv->regs->maccfg1, MACCFG1_SOFT_RESET);
+        /* We need to delay at least 3 TX clocks */
+        udelay(2);
        tempval = (MACCFG1_TX_FLOW | MACCFG1_RX_FLOW);
        gfar_write(&priv->regs->maccfg1, tempval);
@@ -1423,15 +1426,11 @@ static void gfar_vlan_rx_register(struct net_device *dev,
 {
        struct gfar_private *priv = netdev_priv(dev);
        unsigned long flags;
-        struct vlan_group *old_grp;
        u32 tempval;
        spin_lock_irqsave(&priv->rxlock, flags);
-        old_grp = priv->vlgrp;
+        priv->vlgrp = grp;
-        if (old_grp == grp)
-                return;
        if (grp) {
                /* Enable VLAN tag insertion */
@@ -1622,10 +1621,18 @@ static int gfar_clean_tx_ring(struct net_device *dev)
 static void gfar_schedule_cleanup(struct net_device *dev)
 {
        struct gfar_private *priv = netdev_priv(dev);
+        unsigned long flags;
+        spin_lock_irqsave(&priv->txlock, flags);
+        spin_lock(&priv->rxlock);
        if (netif_rx_schedule_prep(&priv->napi)) {
                gfar_write(&priv->regs->imask, IMASK_RTX_DISABLED);
                __netif_rx_schedule(&priv->napi);
        }
+        spin_unlock(&priv->rxlock);
+        spin_unlock_irqrestore(&priv->txlock, flags);
 }
 /* Interrupt Handler for Transmit complete */
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index b1a83344acc7..eaa86897f5c3 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -312,7 +312,7 @@ extern const char gfar_driver_version[];
 #define ATTRELI_EI(x) (x)
 #define BD_LFLAG(flags) ((flags) << 16)
-#define BD_LENGTH_MASK          0x00ff
+#define BD_LENGTH_MASK          0x0000ffff
 /* TxBD status field bits */
 #define TXBD_READY              0x8000
diff --git a/drivers/net/gianfar_mii.c b/drivers/net/gianfar_mii.c
index f3706e415b45..f49a426ad681 100644
--- a/drivers/net/gianfar_mii.c
+++ b/drivers/net/gianfar_mii.c
@@ -234,6 +234,8 @@ static int gfar_mdio_probe(struct of_device *ofdev,
        if (NULL == new_bus)
                return -ENOMEM;
+        device_init_wakeup(&ofdev->dev, 1);
        new_bus->name = "Gianfar MII Bus",
        new_bus->read = &gfar_mdio_read,
        new_bus->write = &gfar_mdio_write,
diff --git a/drivers/net/ibm_newemac/mal.c b/drivers/net/ibm_newemac/mal.c
index ecf9798987fa..2a2fc17b2878 100644
--- a/drivers/net/ibm_newemac/mal.c
+++ b/drivers/net/ibm_newemac/mal.c
@@ -613,7 +613,9 @@ static int __devinit mal_probe(struct of_device *ofdev,
        INIT_LIST_HEAD(&mal->list);
        spin_lock_init(&mal->lock);
-        netif_napi_add(NULL, &mal->napi, mal_poll,
+        init_dummy_netdev(&mal->dummy_dev);
+        netif_napi_add(&mal->dummy_dev, &mal->napi, mal_poll,
                       CONFIG_IBM_NEW_EMAC_POLL_WEIGHT);
        /* Load power-on reset defaults */
diff --git a/drivers/net/ibm_newemac/mal.h b/drivers/net/ibm_newemac/mal.h
index 2f0a87360844..9ededfbf0726 100644
--- a/drivers/net/ibm_newemac/mal.h
+++ b/drivers/net/ibm_newemac/mal.h
@@ -214,6 +214,8 @@ struct mal_instance {
        int                     index;
        spinlock_t              lock;
+        struct net_device       dummy_dev;
        unsigned int features;
 };
diff --git a/drivers/net/ibm_newemac/phy.c b/drivers/net/ibm_newemac/phy.c
index c40cd8df2212..ac9d964e59ec 100644
--- a/drivers/net/ibm_newemac/phy.c
+++ b/drivers/net/ibm_newemac/phy.c
@@ -60,7 +60,7 @@ int emac_mii_reset_phy(struct mii_phy *phy)
        udelay(300);
-        while (limit--) {
+        while (--limit) {
                val = phy_read(phy, MII_BMCR);
                if (val >= 0 && (val & BMCR_RESET) == 0)
                        break;
@@ -84,7 +84,7 @@ int emac_mii_reset_gpcs(struct mii_phy *phy)
        udelay(300);
-        while (limit--) {
+        while (--limit) {
                val = gpcs_phy_read(phy, MII_BMCR);
                if (val >= 0 && (val & BMCR_RESET) == 0)
                        break;
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index ca3bb9f7321b..dfa6348ac1dc 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -602,7 +602,7 @@ static int ibmveth_open(struct net_device *netdev)
        if(lpar_rc != H_SUCCESS) {
                ibmveth_error_printk("h_register_logical_lan failed with %ld\n", lpar_rc);
-                ibmveth_error_printk("buffer TCE:0x%lx filter TCE:0x%lx rxq desc:0x%lx MAC:0x%lx\n",
+                ibmveth_error_printk("buffer TCE:0x%llx filter TCE:0x%llx rxq desc:0x%llx MAC:0x%llx\n",
                                     adapter->buffer_list_dma,
                                     adapter->filter_list_dma,
                                     rxq_desc.desc,
@@ -1378,13 +1378,13 @@ static int ibmveth_show(struct seq_file *seq, void *v)
        seq_printf(seq, "Firmware MAC:    %pM\n", firmware_mac);
        seq_printf(seq, "\nAdapter Statistics:\n");
-        seq_printf(seq, "  TX:  vio_map_single failres:      %ld\n", adapter->tx_map_failed);
+        seq_printf(seq, "  TX:  vio_map_single failres:      %lld\n", adapter->tx_map_failed);
-        seq_printf(seq, "       send failures:               %ld\n", adapter->tx_send_failed);
+        seq_printf(seq, "       send failures:               %lld\n", adapter->tx_send_failed);
-        seq_printf(seq, "  RX:  replenish task cycles:       %ld\n", adapter->replenish_task_cycles);
+        seq_printf(seq, "  RX:  replenish task cycles:       %lld\n", adapter->replenish_task_cycles);
-        seq_printf(seq, "       alloc_skb_failures:          %ld\n", adapter->replenish_no_mem);
+        seq_printf(seq, "       alloc_skb_failures:          %lld\n", adapter->replenish_no_mem);
-        seq_printf(seq, "       add buffer failures:         %ld\n", adapter->replenish_add_buff_failure);
+        seq_printf(seq, "       add buffer failures:         %lld\n", adapter->replenish_add_buff_failure);
-        seq_printf(seq, "       invalid buffers:             %ld\n", adapter->rx_invalid_buffer);
+        seq_printf(seq, "       invalid buffers:             %lld\n", adapter->rx_invalid_buffer);
-        seq_printf(seq, "       no buffers:                  %ld\n", adapter->rx_no_buffer);
+        seq_printf(seq, "       no buffers:                  %lld\n", adapter->rx_no_buffer);
        return 0;
 }
diff --git a/drivers/net/igb/e1000_82575.c b/drivers/net/igb/e1000_82575.c
index f5e2e7235fcb..13ca73f96ec6 100644
--- a/drivers/net/igb/e1000_82575.c
+++ b/drivers/net/igb/e1000_82575.c
@@ -699,11 +699,18 @@ static s32 igb_check_for_link_82575(struct e1000_hw *hw)
        /* SGMII link check is done through the PCS register. */
        if ((hw->phy.media_type != e1000_media_type_copper) ||
-            (igb_sgmii_active_82575(hw)))
+            (igb_sgmii_active_82575(hw))) {
                ret_val = igb_get_pcs_speed_and_duplex_82575(hw, &speed,
                                                             &duplex);
-        else
+                /*
+                 * Use this flag to determine if link needs to be checked or
+                 * not.  If  we have link clear the flag so that we do not
+                 * continue to check for link.
+                 */
+                hw->mac.get_link_status = !hw->mac.serdes_has_link;
+        } else {
                ret_val = igb_check_for_copper_link(hw);
+        }
        return ret_val;
 }
diff --git a/drivers/net/igb/igb.h b/drivers/net/igb/igb.h
index 5a27825cc48a..aebef8e48e76 100644
--- a/drivers/net/igb/igb.h
+++ b/drivers/net/igb/igb.h
@@ -300,11 +300,10 @@ struct igb_adapter {
 #define IGB_FLAG_HAS_MSI           (1 << 0)
 #define IGB_FLAG_MSI_ENABLE        (1 << 1)
-#define IGB_FLAG_HAS_DCA           (1 << 2)
+#define IGB_FLAG_DCA_ENABLED       (1 << 2)
-#define IGB_FLAG_DCA_ENABLED       (1 << 3)
+#define IGB_FLAG_IN_NETPOLL        (1 << 3)
-#define IGB_FLAG_IN_NETPOLL        (1 << 5)
+#define IGB_FLAG_QUAD_PORT_A       (1 << 4)
-#define IGB_FLAG_QUAD_PORT_A       (1 << 6)
+#define IGB_FLAG_NEED_CTX_IDX      (1 << 5)
-#define IGB_FLAG_NEED_CTX_IDX      (1 << 7)
 enum e1000_state_t {
        __IGB_TESTING,
diff --git a/drivers/net/igb/igb_main.c b/drivers/net/igb/igb_main.c
index b82b0fb2056c..a50db5398fa5 100644
--- a/drivers/net/igb/igb_main.c
+++ b/drivers/net/igb/igb_main.c
@@ -206,10 +206,11 @@ static int __init igb_init_module(void)
        global_quad_port_a = 0;
-        ret = pci_register_driver(&igb_driver);
 #ifdef CONFIG_IGB_DCA
        dca_register_notify(&dca_notifier);
 #endif
+        ret = pci_register_driver(&igb_driver);
        return ret;
 }
@@ -1156,11 +1157,10 @@ static int __devinit igb_probe(struct pci_dev *pdev,
        /* set flags */
        switch (hw->mac.type) {
-        case e1000_82576:
        case e1000_82575:
-                adapter->flags |= IGB_FLAG_HAS_DCA;
                adapter->flags |= IGB_FLAG_NEED_CTX_IDX;
                break;
+        case e1000_82576:
        default:
                break;
        }
@@ -1310,8 +1310,7 @@ static int __devinit igb_probe(struct pci_dev *pdev,
                goto err_register;
 #ifdef CONFIG_IGB_DCA
-        if ((adapter->flags & IGB_FLAG_HAS_DCA) &&
+        if (dca_add_requester(&pdev->dev) == 0) {
-            (dca_add_requester(&pdev->dev) == 0)) {
                adapter->flags |= IGB_FLAG_DCA_ENABLED;
                dev_info(&pdev->dev, "DCA enabled\n");
                /* Always use CB2 mode, difference is masked
@@ -1835,11 +1834,11 @@ static void igb_setup_rctl(struct igb_adapter *adapter)
        rctl |= E1000_RCTL_SECRC;
        /*
-         * disable store bad packets, long packet enable, and clear size bits.
+         * disable store bad packets and clear size bits.
         */
-        rctl &= ~(E1000_RCTL_SBP | E1000_RCTL_LPE | E1000_RCTL_SZ_256);
+        rctl &= ~(E1000_RCTL_SBP | E1000_RCTL_SZ_256);
-        if (adapter->netdev->mtu > ETH_DATA_LEN)
+        /* enable LPE when to prevent packets larger than max_frame_size */
                rctl |= E1000_RCTL_LPE;
        /* Setup buffer sizes */
@@ -1865,7 +1864,7 @@ static void igb_setup_rctl(struct igb_adapter *adapter)
         */
        /* allocations using alloc_page take too long for regular MTU
         * so only enable packet split for jumbo frames */
-        if (rctl & E1000_RCTL_LPE) {
+        if (adapter->netdev->mtu > ETH_DATA_LEN) {
                adapter->rx_ps_hdr_size = IGB_RXBUFFER_128;
                srrctl |= adapter->rx_ps_hdr_size <<
                         E1000_SRRCTL_BSIZEHDRSIZE_SHIFT;
@@ -3473,19 +3472,16 @@ static int __igb_notify_dca(struct device *dev, void *data)
        struct e1000_hw *hw = &adapter->hw;
        unsigned long event = *(unsigned long *)data;
-        if (!(adapter->flags & IGB_FLAG_HAS_DCA))
-                goto out;
        switch (event) {
        case DCA_PROVIDER_ADD:
                /* if already enabled, don't do it again */
                if (adapter->flags & IGB_FLAG_DCA_ENABLED)
                        break;
-                adapter->flags |= IGB_FLAG_DCA_ENABLED;
                /* Always use CB2 mode, difference is masked
                 * in the CB driver. */
                wr32(E1000_DCA_CTRL, 2);
                if (dca_add_requester(dev) == 0) {
+                        adapter->flags |= IGB_FLAG_DCA_ENABLED;
                        dev_info(&adapter->pdev->dev, "DCA enabled\n");
                        igb_setup_dca(adapter);
                        break;
@@ -3502,7 +3498,7 @@ static int __igb_notify_dca(struct device *dev, void *data)
                }
                break;
        }
-out:
        return 0;
 }
diff --git a/drivers/net/irda/irda-usb.c b/drivers/net/irda/irda-usb.c
index 29118f58a141..3a22dc41b656 100644
--- a/drivers/net/irda/irda-usb.c
+++ b/drivers/net/irda/irda-usb.c
@@ -1073,7 +1073,7 @@ static int stir421x_patch_device(struct irda_usb_cb *self)
 {
        unsigned int i;
        int ret;
-        char stir421x_fw_name[11];
+        char stir421x_fw_name[12];
        const struct firmware *fw;
        const unsigned char *fw_version_ptr; /* pointer to version string */
        unsigned long fw_version = 0;
diff --git a/drivers/net/iseries_veth.c b/drivers/net/iseries_veth.c
index c7457f97259d..cb793c2bade2 100644
--- a/drivers/net/iseries_veth.c
+++ b/drivers/net/iseries_veth.c
@@ -429,7 +429,7 @@ SIMPLE_PORT_ATTR(promiscuous);
 SIMPLE_PORT_ATTR(num_mcast);
 CUSTOM_PORT_ATTR(lpar_map, "0x%X\n", port->lpar_map);
 CUSTOM_PORT_ATTR(stopped_map, "0x%X\n", port->stopped_map);
-CUSTOM_PORT_ATTR(mac_addr, "0x%lX\n", port->mac_addr);
+CUSTOM_PORT_ATTR(mac_addr, "0x%llX\n", port->mac_addr);
 #define GET_PORT_ATTR(_name)    (&veth_port_attr_##_name.attr)
 static struct attribute *veth_port_default_attrs[] = {
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index acef3c65cd2c..d2f4d5f508b7 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -318,6 +318,9 @@ static void ixgbe_update_rx_dca(struct ixgbe_adapter *adapter,
                rxctrl |= dca3_get_tag(&adapter->pdev->dev, cpu);
                rxctrl |= IXGBE_DCA_RXCTRL_DESC_DCA_EN;
                rxctrl |= IXGBE_DCA_RXCTRL_HEAD_DCA_EN;
+                rxctrl &= ~(IXGBE_DCA_RXCTRL_DESC_RRO_EN);
+                rxctrl &= ~(IXGBE_DCA_RXCTRL_DESC_WRO_EN |
+                            IXGBE_DCA_RXCTRL_DESC_HSRO_EN);
                IXGBE_WRITE_REG(&adapter->hw, IXGBE_DCA_RXCTRL(q), rxctrl);
                rx_ring->cpu = cpu;
        }
@@ -1741,6 +1744,32 @@ static void ixgbe_configure_rx(struct ixgbe_adapter *adapter)
        IXGBE_WRITE_REG(hw, IXGBE_RXCSUM, rxcsum);
 }
+static void ixgbe_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
+{
+        struct ixgbe_adapter *adapter = netdev_priv(netdev);
+        struct ixgbe_hw *hw = &adapter->hw;
+        /* add VID to filter table */
+        hw->mac.ops.set_vfta(&adapter->hw, vid, 0, true);
+}
+static void ixgbe_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
+{
+        struct ixgbe_adapter *adapter = netdev_priv(netdev);
+        struct ixgbe_hw *hw = &adapter->hw;
+        if (!test_bit(__IXGBE_DOWN, &adapter->state))
+                ixgbe_irq_disable(adapter);
+        vlan_group_set_device(adapter->vlgrp, vid, NULL);
+        if (!test_bit(__IXGBE_DOWN, &adapter->state))
+                ixgbe_irq_enable(adapter);
+        /* remove VID from filter table */
+        hw->mac.ops.set_vfta(&adapter->hw, vid, 0, false);
+}
 static void ixgbe_vlan_rx_register(struct net_device *netdev,
                                   struct vlan_group *grp)
 {
@@ -1760,6 +1789,7 @@ static void ixgbe_vlan_rx_register(struct net_device *netdev,
        ctrl |= IXGBE_VLNCTRL_VME;
        ctrl &= ~IXGBE_VLNCTRL_CFIEN;
        IXGBE_WRITE_REG(&adapter->hw, IXGBE_VLNCTRL, ctrl);
+        ixgbe_vlan_rx_add_vid(netdev, 0);
        if (grp) {
                /* enable VLAN tag insert/strip */
@@ -1773,32 +1803,6 @@ static void ixgbe_vlan_rx_register(struct net_device *netdev,
                ixgbe_irq_enable(adapter);
 }
-static void ixgbe_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
-{
-        struct ixgbe_adapter *adapter = netdev_priv(netdev);
-        struct ixgbe_hw *hw = &adapter->hw;
-        /* add VID to filter table */
-        hw->mac.ops.set_vfta(&adapter->hw, vid, 0, true);
-}
-static void ixgbe_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
-{
-        struct ixgbe_adapter *adapter = netdev_priv(netdev);
-        struct ixgbe_hw *hw = &adapter->hw;
-        if (!test_bit(__IXGBE_DOWN, &adapter->state))
-                ixgbe_irq_disable(adapter);
-        vlan_group_set_device(adapter->vlgrp, vid, NULL);
-        if (!test_bit(__IXGBE_DOWN, &adapter->state))
-                ixgbe_irq_enable(adapter);
-        /* remove VID from filter table */
-        hw->mac.ops.set_vfta(&adapter->hw, vid, 0, false);
-}
 static void ixgbe_restore_vlan(struct ixgbe_adapter *adapter)
 {
        ixgbe_vlan_rx_register(adapter->netdev, adapter->vlgrp);
@@ -2074,6 +2078,9 @@ static int ixgbe_up_complete(struct ixgbe_adapter *adapter)
        ixgbe_irq_enable(adapter);
+        /* enable transmits */
+        netif_tx_start_all_queues(netdev);
        /* bring the link up in the watchdog, this could race with our first
         * link up interrupt but shouldn't be a problem */
        adapter->flags |= IXGBE_FLAG_NEED_LINK_UPDATE;
@@ -3475,7 +3482,6 @@ static void ixgbe_watchdog_task(struct work_struct *work)
                                (FLOW_TX ? "TX" : "None"))));
                        netif_carrier_on(netdev);
-                        netif_tx_wake_all_queues(netdev);
                } else {
                        /* Force detection of hung controller */
                        adapter->detect_tx_hung = true;
@@ -3487,7 +3493,6 @@ static void ixgbe_watchdog_task(struct work_struct *work)
                        printk(KERN_INFO "ixgbe: %s NIC Link is Down\n",
                               netdev->name);
                        netif_carrier_off(netdev);
-                        netif_tx_stop_all_queues(netdev);
                }
        }
@@ -4218,7 +4223,6 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
        }
        netif_carrier_off(netdev);
-        netif_tx_stop_all_queues(netdev);
        strcpy(netdev->name, "eth%d");
        err = register_netdev(netdev);
diff --git a/drivers/net/ixgbe/ixgbe_type.h b/drivers/net/ixgbe/ixgbe_type.h
index 83a11ff9ffd1..f011c57c9205 100644
--- a/drivers/net/ixgbe/ixgbe_type.h
+++ b/drivers/net/ixgbe/ixgbe_type.h
@@ -404,6 +404,9 @@
 #define IXGBE_DCA_RXCTRL_DESC_DCA_EN (1 << 5) /* DCA Rx Desc enable */
 #define IXGBE_DCA_RXCTRL_HEAD_DCA_EN (1 << 6) /* DCA Rx Desc header enable */
 #define IXGBE_DCA_RXCTRL_DATA_DCA_EN (1 << 7) /* DCA Rx Desc payload enable */
+#define IXGBE_DCA_RXCTRL_DESC_RRO_EN (1 << 9) /* DCA Rx rd Desc Relax Order */
+#define IXGBE_DCA_RXCTRL_DESC_WRO_EN (1 << 13) /* DCA Rx wr Desc Relax Order */
+#define IXGBE_DCA_RXCTRL_DESC_HSRO_EN (1 << 15) /* DCA Rx Split Header RO */
 #define IXGBE_DCA_TXCTRL_CPUID_MASK 0x0000001F /* Tx CPUID Mask */
 #define IXGBE_DCA_TXCTRL_DESC_DCA_EN (1 << 5) /* DCA Tx Desc enable */
diff --git a/drivers/net/korina.c b/drivers/net/korina.c
index 4a5580c1126a..75010cac76ac 100644
--- a/drivers/net/korina.c
+++ b/drivers/net/korina.c
@@ -84,7 +84,10 @@
 #define KORINA_NUM_RDS  64  /* number of receive descriptors */
 #define KORINA_NUM_TDS  64  /* number of transmit descriptors */
-#define KORINA_RBSIZE   536 /* size of one resource buffer = Ether MTU */
+/* KORINA_RBSIZE is the hardware's default maximum receive
+ * frame size in bytes. Having this hardcoded means that there
+ * is no support for MTU sizes greater than 1500. */
+#define KORINA_RBSIZE   1536 /* size of one resource buffer = Ether MTU */
 #define KORINA_RDS_MASK (KORINA_NUM_RDS - 1)
 #define KORINA_TDS_MASK (KORINA_NUM_TDS - 1)
 #define RD_RING_SIZE    (KORINA_NUM_RDS * sizeof(struct dma_desc))
@@ -196,7 +199,7 @@ static int korina_send_packet(struct sk_buff *skb, struct net_device *dev)
        struct korina_private *lp = netdev_priv(dev);
        unsigned long flags;
        u32 length;
-        u32 chain_index;
+        u32 chain_prev, chain_next;
        struct dma_desc *td;
        spin_lock_irqsave(&lp->lock, flags);
@@ -228,8 +231,8 @@ static int korina_send_packet(struct sk_buff *skb, struct net_device *dev)
        /* Setup the transmit descriptor. */
        dma_cache_inv((u32) td, sizeof(*td));
        td->ca = CPHYSADDR(skb->data);
-        chain_index = (lp->tx_chain_tail - 1) &
+        chain_prev = (lp->tx_chain_tail - 1) & KORINA_TDS_MASK;
-                        KORINA_TDS_MASK;
+        chain_next = (lp->tx_chain_tail + 1) & KORINA_TDS_MASK;
        if (readl(&(lp->tx_dma_regs->dmandptr)) == 0) {
                if (lp->tx_chain_status == desc_empty) {
@@ -237,7 +240,7 @@ static int korina_send_packet(struct sk_buff *skb, struct net_device *dev)
                        td->control = DMA_COUNT(length) |
                                        DMA_DESC_COF | DMA_DESC_IOF;
                        /* Move tail */
-                        lp->tx_chain_tail = chain_index;
+                        lp->tx_chain_tail = chain_next;
                        /* Write to NDPTR */
                        writel(CPHYSADDR(&lp->td_ring[lp->tx_chain_head]),
                                        &lp->tx_dma_regs->dmandptr);
@@ -248,12 +251,12 @@ static int korina_send_packet(struct sk_buff *skb, struct net_device *dev)
                        td->control = DMA_COUNT(length) |
                                        DMA_DESC_COF | DMA_DESC_IOF;
                        /* Link to prev */
-                        lp->td_ring[chain_index].control &=
+                        lp->td_ring[chain_prev].control &=
                                        ~DMA_DESC_COF;
                        /* Link to prev */
-                        lp->td_ring[chain_index].link =  CPHYSADDR(td);
+                        lp->td_ring[chain_prev].link =  CPHYSADDR(td);
                        /* Move tail */
-                        lp->tx_chain_tail = chain_index;
+                        lp->tx_chain_tail = chain_next;
                        /* Write to NDPTR */
                        writel(CPHYSADDR(&lp->td_ring[lp->tx_chain_head]),
                                        &(lp->tx_dma_regs->dmandptr));
@@ -267,17 +270,16 @@ static int korina_send_packet(struct sk_buff *skb, struct net_device *dev)
                        td->control = DMA_COUNT(length) |
                                        DMA_DESC_COF | DMA_DESC_IOF;
                        /* Move tail */
-                        lp->tx_chain_tail = chain_index;
+                        lp->tx_chain_tail = chain_next;
                        lp->tx_chain_status = desc_filled;
-                        netif_stop_queue(dev);
                } else {
                        /* Update tail */
                        td->control = DMA_COUNT(length) |
                                        DMA_DESC_COF | DMA_DESC_IOF;
-                        lp->td_ring[chain_index].control &=
+                        lp->td_ring[chain_prev].control &=
                                        ~DMA_DESC_COF;
-                        lp->td_ring[chain_index].link =  CPHYSADDR(td);
+                        lp->td_ring[chain_prev].link =  CPHYSADDR(td);
-                        lp->tx_chain_tail = chain_index;
+                        lp->tx_chain_tail = chain_next;
                }
        }
        dma_cache_wback((u32) td, sizeof(*td));
@@ -327,13 +329,13 @@ static irqreturn_t korina_rx_dma_interrupt(int irq, void *dev_id)
        dmas = readl(&lp->rx_dma_regs->dmas);
        if (dmas & (DMA_STAT_DONE | DMA_STAT_HALT | DMA_STAT_ERR)) {
-                netif_rx_schedule_prep(&lp->napi);
                dmasm = readl(&lp->rx_dma_regs->dmasm);
                writel(dmasm | (DMA_STAT_DONE |
                                DMA_STAT_HALT | DMA_STAT_ERR),
                                &lp->rx_dma_regs->dmasm);
+                netif_rx_schedule(&lp->napi);
                if (dmas & DMA_STAT_ERR)
                        printk(KERN_ERR DRV_NAME "%s: DMA error\n", dev->name);
@@ -350,15 +352,20 @@ static int korina_rx(struct net_device *dev, int limit)
        struct dma_desc *rd = &lp->rd_ring[lp->rx_next_done];
        struct sk_buff *skb, *skb_new;
        u8 *pkt_buf;
-        u32 devcs, pkt_len, dmas, rx_free_desc;
+        u32 devcs, pkt_len, dmas;
        int count;
        dma_cache_inv((u32)rd, sizeof(*rd));
        for (count = 0; count < limit; count++) {
+                skb = lp->rx_skb[lp->rx_next_done];
+                skb_new = NULL;
                devcs = rd->devcs;
+                if ((KORINA_RBSIZE - (u32)DMA_COUNT(rd->control)) == 0)
+                        break;
                /* Update statistics counters */
                if (devcs & ETH_RX_CRC)
                        dev->stats.rx_crc_errors++;
@@ -381,63 +388,58 @@ static int korina_rx(struct net_device *dev, int limit)
                         * in Rc32434 (errata ref #077) */
                        dev->stats.rx_errors++;
                        dev->stats.rx_dropped++;
-                }
+                } else if ((devcs & ETH_RX_ROK)) {
-                while ((rx_free_desc = KORINA_RBSIZE - (u32)DMA_COUNT(rd->control)) != 0) {
-                        /* init the var. used for the later
-                         * operations within the while loop */
-                        skb_new = NULL;
                        pkt_len = RCVPKT_LENGTH(devcs);
-                        skb = lp->rx_skb[lp->rx_next_done];
+                        /* must be the (first and) last
-                        if ((devcs & ETH_RX_ROK)) {
+                         * descriptor then */
-                                /* must be the (first and) last
+                        pkt_buf = (u8 *)lp->rx_skb[lp->rx_next_done]->data;
-                                 * descriptor then */
-                                pkt_buf = (u8 *)lp->rx_skb[lp->rx_next_done]->data;
+                        /* invalidate the cache */
+                        dma_cache_inv((unsigned long)pkt_buf, pkt_len - 4);
-                                /* invalidate the cache */
-                                dma_cache_inv((unsigned long)pkt_buf, pkt_len - 4);
+                        /* Malloc up new buffer. */
+                        skb_new = netdev_alloc_skb(dev, KORINA_RBSIZE + 2);
-                                /* Malloc up new buffer. */
-                                skb_new = netdev_alloc_skb(dev, KORINA_RBSIZE + 2);
+                        if (!skb_new)
+                                break;
-                                if (!skb_new)
+                        /* Do not count the CRC */
-                                        break;
+                        skb_put(skb, pkt_len - 4);
-                                /* Do not count the CRC */
+                        skb->protocol = eth_type_trans(skb, dev);
-                                skb_put(skb, pkt_len - 4);
-                                skb->protocol = eth_type_trans(skb, dev);
+                        /* Pass the packet to upper layers */
+                        netif_receive_skb(skb);
-                                /* Pass the packet to upper layers */
+                        dev->stats.rx_packets++;
-                                netif_receive_skb(skb);
+                        dev->stats.rx_bytes += pkt_len;
-                                dev->stats.rx_packets++;
-                                dev->stats.rx_bytes += pkt_len;
+                        /* Update the mcast stats */
+                        if (devcs & ETH_RX_MP)
-                                /* Update the mcast stats */
+                                dev->stats.multicast++;
-                                if (devcs & ETH_RX_MP)
-                                        dev->stats.multicast++;
+                        /* 16 bit align */
+                        skb_reserve(skb_new, 2);
-                                lp->rx_skb[lp->rx_next_done] = skb_new;
-                        }
+                        lp->rx_skb[lp->rx_next_done] = skb_new;
-                        rd->devcs = 0;
-                        /* Restore descriptor's curr_addr */
-                        if (skb_new)
-                                rd->ca = CPHYSADDR(skb_new->data);
-                        else
-                                rd->ca = CPHYSADDR(skb->data);
-                        rd->control = DMA_COUNT(KORINA_RBSIZE) |
-                                DMA_DESC_COD | DMA_DESC_IOD;
-                        lp->rd_ring[(lp->rx_next_done - 1) &
-                                KORINA_RDS_MASK].control &=
-                                ~DMA_DESC_COD;
-                        lp->rx_next_done = (lp->rx_next_done + 1) & KORINA_RDS_MASK;
-                        dma_cache_wback((u32)rd, sizeof(*rd));
-                        rd = &lp->rd_ring[lp->rx_next_done];
-                        writel(~DMA_STAT_DONE, &lp->rx_dma_regs->dmas);
                }
+                rd->devcs = 0;
+                /* Restore descriptor's curr_addr */
+                if (skb_new)
+                        rd->ca = CPHYSADDR(skb_new->data);
+                else
+                        rd->ca = CPHYSADDR(skb->data);
+                rd->control = DMA_COUNT(KORINA_RBSIZE) |
+                        DMA_DESC_COD | DMA_DESC_IOD;
+                lp->rd_ring[(lp->rx_next_done - 1) &
+                        KORINA_RDS_MASK].control &=
+                        ~DMA_DESC_COD;
+                lp->rx_next_done = (lp->rx_next_done + 1) & KORINA_RDS_MASK;
+                dma_cache_wback((u32)rd, sizeof(*rd));
+                rd = &lp->rd_ring[lp->rx_next_done];
+                writel(~DMA_STAT_DONE, &lp->rx_dma_regs->dmas);
        }
        dmas = readl(&lp->rx_dma_regs->dmas);
@@ -623,12 +625,12 @@ korina_tx_dma_interrupt(int irq, void *dev_id)
        dmas = readl(&lp->tx_dma_regs->dmas);
        if (dmas & (DMA_STAT_FINI | DMA_STAT_ERR)) {
-                korina_tx(dev);
                dmasm = readl(&lp->tx_dma_regs->dmasm);
                writel(dmasm | (DMA_STAT_FINI | DMA_STAT_ERR),
                                &lp->tx_dma_regs->dmasm);
+                korina_tx(dev);
                if (lp->tx_chain_status == desc_filled &&
                        (readl(&(lp->tx_dma_regs->dmandptr)) == 0)) {
                        writel(CPHYSADDR(&lp->td_ring[lp->tx_chain_head]),
@@ -741,6 +743,7 @@ static struct ethtool_ops netdev_ethtool_ops = {
 static void korina_alloc_ring(struct net_device *dev)
 {
        struct korina_private *lp = netdev_priv(dev);
+        struct sk_buff *skb;
        int i;
        /* Initialize the transmit descriptors */
@@ -756,8 +759,6 @@ static void korina_alloc_ring(struct net_device *dev)
        /* Initialize the receive descriptors */
        for (i = 0; i < KORINA_NUM_RDS; i++) {
-                struct sk_buff *skb = lp->rx_skb[i];
                skb = dev_alloc_skb(KORINA_RBSIZE + 2);
                if (!skb)
                        break;
@@ -770,11 +771,12 @@ static void korina_alloc_ring(struct net_device *dev)
                lp->rd_ring[i].link = CPHYSADDR(&lp->rd_ring[i+1]);
        }
-        /* loop back */
+        /* loop back receive descriptors, so the last
-        lp->rd_ring[i].link = CPHYSADDR(&lp->rd_ring[0]);
+         * descriptor points to the first one */
-        lp->rx_next_done  = 0;
+        lp->rd_ring[i - 1].link = CPHYSADDR(&lp->rd_ring[0]);
+        lp->rd_ring[i - 1].control |= DMA_DESC_COD;
-        lp->rd_ring[i].control |= DMA_DESC_COD;
+        lp->rx_next_done  = 0;
        lp->rx_chain_head = 0;
        lp->rx_chain_tail = 0;
        lp->rx_chain_status = desc_empty;
@@ -901,6 +903,8 @@ static int korina_restart(struct net_device *dev)
        korina_free_ring(dev);
+        napi_disable(&lp->napi);
        ret = korina_init(dev);
        if (ret < 0) {
                printk(KERN_ERR DRV_NAME "%s: cannot restart device\n",
@@ -999,14 +1003,14 @@ static int korina_open(struct net_device *dev)
         * that handles the Done Finished
         * Ovr and Und Events */
        ret = request_irq(lp->rx_irq, &korina_rx_dma_interrupt,
-                IRQF_SHARED | IRQF_DISABLED, "Korina ethernet Rx", dev);
+                        IRQF_DISABLED, "Korina ethernet Rx", dev);
        if (ret < 0) {
                printk(KERN_ERR DRV_NAME "%s: unable to get Rx DMA IRQ %d\n",
                    dev->name, lp->rx_irq);
                goto err_release;
        }
        ret = request_irq(lp->tx_irq, &korina_tx_dma_interrupt,
-                IRQF_SHARED | IRQF_DISABLED, "Korina ethernet Tx", dev);
+                        IRQF_DISABLED, "Korina ethernet Tx", dev);
        if (ret < 0) {
                printk(KERN_ERR DRV_NAME "%s: unable to get Tx DMA IRQ %d\n",
                    dev->name, lp->tx_irq);
@@ -1015,7 +1019,7 @@ static int korina_open(struct net_device *dev)
        /* Install handler for overrun error. */
        ret = request_irq(lp->ovr_irq, &korina_ovr_interrupt,
-                        IRQF_SHARED | IRQF_DISABLED, "Ethernet Overflow", dev);
+                        IRQF_DISABLED, "Ethernet Overflow", dev);
        if (ret < 0) {
                printk(KERN_ERR DRV_NAME"%s: unable to get OVR IRQ %d\n",
                    dev->name, lp->ovr_irq);
@@ -1024,7 +1028,7 @@ static int korina_open(struct net_device *dev)
        /* Install handler for underflow error. */
        ret = request_irq(lp->und_irq, &korina_und_interrupt,
-                        IRQF_SHARED | IRQF_DISABLED, "Ethernet Underflow", dev);
+                        IRQF_DISABLED, "Ethernet Underflow", dev);
        if (ret < 0) {
                printk(KERN_ERR DRV_NAME "%s: unable to get UND IRQ %d\n",
                    dev->name, lp->und_irq);
@@ -1067,6 +1071,8 @@ static int korina_close(struct net_device *dev)
        korina_free_ring(dev);
+        napi_disable(&lp->napi);
        free_irq(lp->rx_irq, dev);
        free_irq(lp->tx_irq, dev);
        free_irq(lp->ovr_irq, dev);
@@ -1089,7 +1095,6 @@ static int korina_probe(struct platform_device *pdev)
                return -ENOMEM;
        }
        SET_NETDEV_DEV(dev, &pdev->dev);
-        platform_set_drvdata(pdev, dev);
        lp = netdev_priv(dev);
        bif->dev = dev;
diff --git a/drivers/net/macb.c b/drivers/net/macb.c
index a04da4ecaa88..f6c4936e2fa8 100644
--- a/drivers/net/macb.c
+++ b/drivers/net/macb.c
@@ -321,6 +321,10 @@ static void macb_tx(struct macb *bp)
                printk(KERN_ERR "%s: TX underrun, resetting buffers\n",
                        bp->dev->name);
+                /* Transfer ongoing, disable transmitter, to avoid confusion */
+                if (status & MACB_BIT(TGO))
+                        macb_writel(bp, NCR, macb_readl(bp, NCR) & ~MACB_BIT(TE));
                head = bp->tx_head;
                /*Mark all the buffer as used to avoid sending a lost buffer*/
@@ -343,6 +347,10 @@ static void macb_tx(struct macb *bp)
                }
                bp->tx_head = bp->tx_tail = 0;
+                /* Enable the transmitter again */
+                if (status & MACB_BIT(TGO))
+                        macb_writel(bp, NCR, macb_readl(bp, NCR) | MACB_BIT(TE));
        }
        if (!(status & MACB_BIT(COMP)))
diff --git a/drivers/net/mlx4/main.c b/drivers/net/mlx4/main.c
index 710c79e7a2db..6ef2490d5c3e 100644
--- a/drivers/net/mlx4/main.c
+++ b/drivers/net/mlx4/main.c
@@ -912,8 +912,8 @@ static void mlx4_enable_msi_x(struct mlx4_dev *dev)
        int i;
        if (msi_x) {
-                nreq = min(dev->caps.num_eqs - dev->caps.reserved_eqs,
+                nreq = min_t(int, dev->caps.num_eqs - dev->caps.reserved_eqs,
-                           num_possible_cpus() + 1);
+                             num_possible_cpus() + 1);
                entries = kcalloc(nreq, sizeof *entries, GFP_KERNEL);
                if (!entries)
                        goto no_msi;
diff --git a/drivers/net/mlx4/profile.c b/drivers/net/mlx4/profile.c
index 919fb9eb1b62..cebdf3243ca1 100644
--- a/drivers/net/mlx4/profile.c
+++ b/drivers/net/mlx4/profile.c
@@ -107,9 +107,9 @@ u64 mlx4_make_profile(struct mlx4_dev *dev,
        profile[MLX4_RES_AUXC].num    = request->num_qp;
        profile[MLX4_RES_SRQ].num     = request->num_srq;
        profile[MLX4_RES_CQ].num      = request->num_cq;
-        profile[MLX4_RES_EQ].num      = min(dev_cap->max_eqs,
+        profile[MLX4_RES_EQ].num      = min_t(unsigned, dev_cap->max_eqs,
-                                            dev_cap->reserved_eqs +
+                                              dev_cap->reserved_eqs +
-                                            num_possible_cpus() + 1);
+                                              num_possible_cpus() + 1);
        profile[MLX4_RES_DMPT].num    = request->num_mpt;
        profile[MLX4_RES_CMPT].num    = MLX4_NUM_CMPTS;
        profile[MLX4_RES_MTT].num     = request->num_mtt;
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index 7253a499d9c8..5f31bbb614af 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -136,21 +136,23 @@ static char mv643xx_eth_driver_version[] = "1.4";
 /*
 * SDMA configuration register.
 */
+#define RX_BURST_SIZE_4_64BIT           (2 << 1)
 #define RX_BURST_SIZE_16_64BIT          (4 << 1)
 #define BLM_RX_NO_SWAP                  (1 << 4)
 #define BLM_TX_NO_SWAP                  (1 << 5)
+#define TX_BURST_SIZE_4_64BIT           (2 << 22)
 #define TX_BURST_SIZE_16_64BIT          (4 << 22)
 #if defined(__BIG_ENDIAN)
 #define PORT_SDMA_CONFIG_DEFAULT_VALUE          \
-                (RX_BURST_SIZE_16_64BIT |       \
+                (RX_BURST_SIZE_4_64BIT  |       \
-                TX_BURST_SIZE_16_64BIT)
+                 TX_BURST_SIZE_4_64BIT)
 #elif defined(__LITTLE_ENDIAN)
 #define PORT_SDMA_CONFIG_DEFAULT_VALUE          \
-                (RX_BURST_SIZE_16_64BIT |       \
+                (RX_BURST_SIZE_4_64BIT  |       \
-                BLM_RX_NO_SWAP          |       \
+                 BLM_RX_NO_SWAP         |       \
-                BLM_TX_NO_SWAP          |       \
+                 BLM_TX_NO_SWAP         |       \
-                TX_BURST_SIZE_16_64BIT)
+                 TX_BURST_SIZE_4_64BIT)
 #else
 #error One of __BIG_ENDIAN or __LITTLE_ENDIAN must be defined
 #endif
@@ -1594,7 +1596,7 @@ oom:
                        entry = addr_crc(a);
                }
-                table[entry >> 2] |= 1 << (entry & 3);
+                table[entry >> 2] |= 1 << (8 * (entry & 3));
        }
        for (i = 0; i < 0x100; i += 4) {
@@ -2210,6 +2212,7 @@ static int mv643xx_eth_stop(struct net_device *dev)
        struct mv643xx_eth_private *mp = netdev_priv(dev);
        int i;
+        wrlp(mp, INT_MASK_EXT, 0x00000000);
        wrlp(mp, INT_MASK, 0x00000000);
        rdlp(mp, INT_MASK);
diff --git a/drivers/net/myri10ge/myri10ge.c b/drivers/net/myri10ge/myri10ge.c
index 6bb71b687f7b..e9c1296b267e 100644
--- a/drivers/net/myri10ge/myri10ge.c
+++ b/drivers/net/myri10ge/myri10ge.c
@@ -1,7 +1,7 @@
 /*************************************************************************
 * myri10ge.c: Myricom Myri-10G Ethernet driver.
 *
- * Copyright (C) 2005 - 2007 Myricom, Inc.
+ * Copyright (C) 2005 - 2009 Myricom, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -75,7 +75,7 @@
 #include "myri10ge_mcp.h"
 #include "myri10ge_mcp_gen_header.h"
-#define MYRI10GE_VERSION_STR "1.4.4-1.398"
+#define MYRI10GE_VERSION_STR "1.4.4-1.401"
 MODULE_DESCRIPTION("Myricom 10G driver (10GbE)");
 MODULE_AUTHOR("Maintainer: help@myri.com");
@@ -3786,7 +3786,7 @@ static int myri10ge_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        if (status != 0) {
                dev_err(&pdev->dev, "Error %d writing PCI_EXP_DEVCTL\n",
                        status);
-                goto abort_with_netdev;
+                goto abort_with_enabled;
        }
        pci_set_master(pdev);
@@ -3801,13 +3801,13 @@ static int myri10ge_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        }
        if (status != 0) {
                dev_err(&pdev->dev, "Error %d setting DMA mask\n", status);
-                goto abort_with_netdev;
+                goto abort_with_enabled;
        }
        (void)pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
        mgp->cmd = dma_alloc_coherent(&pdev->dev, sizeof(*mgp->cmd),
                                      &mgp->cmd_bus, GFP_KERNEL);
        if (mgp->cmd == NULL)
-                goto abort_with_netdev;
+                goto abort_with_enabled;
        mgp->board_span = pci_resource_len(pdev, 0);
        mgp->iomem_base = pci_resource_start(pdev, 0);
@@ -3943,8 +3943,10 @@ abort_with_mtrr:
        dma_free_coherent(&pdev->dev, sizeof(*mgp->cmd),
                          mgp->cmd, mgp->cmd_bus);
-abort_with_netdev:
+abort_with_enabled:
+        pci_disable_device(pdev);
+abort_with_netdev:
        free_netdev(netdev);
        return status;
 }
@@ -3990,6 +3992,7 @@ static void myri10ge_remove(struct pci_dev *pdev)
                          mgp->cmd, mgp->cmd_bus);
        free_netdev(netdev);
+        pci_disable_device(pdev);
        pci_set_drvdata(pdev, NULL);
 }
diff --git a/drivers/net/netxen/netxen_nic.h b/drivers/net/netxen/netxen_nic.h
index f8e601c51da7..9c78c963b721 100644
--- a/drivers/net/netxen/netxen_nic.h
+++ b/drivers/net/netxen/netxen_nic.h
@@ -146,7 +146,7 @@
 #define MAX_RX_BUFFER_LENGTH            1760
 #define MAX_RX_JUMBO_BUFFER_LENGTH      8062
-#define MAX_RX_LRO_BUFFER_LENGTH        ((48*1024)-512)
+#define MAX_RX_LRO_BUFFER_LENGTH        (8062)
 #define RX_DMA_MAP_LEN                  (MAX_RX_BUFFER_LENGTH - 2)
 #define RX_JUMBO_DMA_MAP_LEN    \
        (MAX_RX_JUMBO_BUFFER_LENGTH - 2)
@@ -207,11 +207,11 @@
 #define MAX_CMD_DESCRIPTORS             4096
 #define MAX_RCV_DESCRIPTORS             16384
-#define MAX_CMD_DESCRIPTORS_HOST        (MAX_CMD_DESCRIPTORS / 4)
+#define MAX_CMD_DESCRIPTORS_HOST        1024
-#define MAX_RCV_DESCRIPTORS_1G          (MAX_RCV_DESCRIPTORS / 4)
+#define MAX_RCV_DESCRIPTORS_1G          2048
-#define MAX_RCV_DESCRIPTORS_10G         8192
+#define MAX_RCV_DESCRIPTORS_10G         4096
 #define MAX_JUMBO_RCV_DESCRIPTORS       1024
-#define MAX_LRO_RCV_DESCRIPTORS         64
+#define MAX_LRO_RCV_DESCRIPTORS         8
 #define MAX_RCVSTATUS_DESCRIPTORS       MAX_RCV_DESCRIPTORS
 #define MAX_JUMBO_RCV_DESC      MAX_JUMBO_RCV_DESCRIPTORS
 #define MAX_RCV_DESC            MAX_RCV_DESCRIPTORS
@@ -308,27 +308,16 @@ struct netxen_ring_ctx {
 #define netxen_set_cmd_desc_ctxid(cmd_desc, var)        \
        ((cmd_desc)->port_ctxid |= ((var) << 4 & 0xF0))
-#define netxen_set_cmd_desc_flags(cmd_desc, val)        \
+#define netxen_set_tx_port(_desc, _port) \
-        (cmd_desc)->flags_opcode = ((cmd_desc)->flags_opcode & \
+        (_desc)->port_ctxid = ((_port) & 0xf) | (((_port) << 4) & 0xf0)
-                ~cpu_to_le16(0x7f)) | cpu_to_le16((val) & 0x7f)
-#define netxen_set_cmd_desc_opcode(cmd_desc, val)       \
+#define netxen_set_tx_flags_opcode(_desc, _flags, _opcode) \
-        (cmd_desc)->flags_opcode = ((cmd_desc)->flags_opcode & \
+        (_desc)->flags_opcode = \
-                ~cpu_to_le16((u16)0x3f << 7)) | cpu_to_le16(((val) & 0x3f) << 7)
+        cpu_to_le16(((_flags) & 0x7f) | (((_opcode) & 0x3f) << 7))
-#define netxen_set_cmd_desc_num_of_buff(cmd_desc, val)  \
+#define netxen_set_tx_frags_len(_desc, _frags, _len) \
-        (cmd_desc)->num_of_buffers_total_length = \
+        (_desc)->num_of_buffers_total_length = \
-                ((cmd_desc)->num_of_buffers_total_length & \
+        cpu_to_le32(((_frags) & 0xff) | (((_len) & 0xffffff) << 8))
-                ~cpu_to_le32(0xff)) | cpu_to_le32((val) & 0xff)
-#define netxen_set_cmd_desc_totallength(cmd_desc, val)  \
-        (cmd_desc)->num_of_buffers_total_length = \
-                ((cmd_desc)->num_of_buffers_total_length & \
-                ~cpu_to_le32((u32)0xffffff << 8)) | \
-                cpu_to_le32(((val) & 0xffffff) << 8)
-#define netxen_get_cmd_desc_opcode(cmd_desc)    \
-        ((le16_to_cpu((cmd_desc)->flags_opcode) >> 7) & 0x003f)
-#define netxen_get_cmd_desc_totallength(cmd_desc)       \
-        ((le32_to_cpu((cmd_desc)->num_of_buffers_total_length) >> 8) & 0xffffff)
 struct cmd_desc_type0 {
        u8 tcp_hdr_offset;      /* For LSO only */
@@ -510,7 +499,8 @@ typedef enum {
        NETXEN_BRDTYPE_P3_10G_SFP_CT = 0x002a,
        NETXEN_BRDTYPE_P3_10G_SFP_QT = 0x002b,
        NETXEN_BRDTYPE_P3_10G_CX4 = 0x0031,
-        NETXEN_BRDTYPE_P3_10G_XFP = 0x0032
+        NETXEN_BRDTYPE_P3_10G_XFP = 0x0032,
+        NETXEN_BRDTYPE_P3_10G_TP = 0x0080
 } netxen_brdtype_t;
@@ -757,7 +747,7 @@ extern char netxen_nic_driver_name[];
 */
 struct netxen_skb_frag {
        u64 dma;
-        u32 length;
+        ulong length;
 };
 #define _netxen_set_bits(config_word, start, bits, val) {\
@@ -783,13 +773,7 @@ struct netxen_skb_frag {
 struct netxen_cmd_buffer {
        struct sk_buff *skb;
        struct netxen_skb_frag frag_array[MAX_BUFFERS_PER_CMD + 1];
-        u32 total_length;
+        u32 frag_count;
-        u32 mss;
-        u16 port;
-        u8 cmd;
-        u8 frag_count;
-        unsigned long time_stamp;
-        u32 state;
 };
 /* In rx_buffer, we do not need multiple fragments as is a single buffer */
@@ -876,7 +860,6 @@ struct nx_host_rds_ring {
        u32 skb_size;
        struct netxen_rx_buffer *rx_buf_arr;    /* rx buffers for receive   */
        struct list_head free_list;
-        int begin_alloc;
 };
 /*
@@ -995,31 +978,31 @@ struct netxen_recv_context {
 */
 typedef struct {
-        u64 host_phys_addr;     /* Ring base addr */
+        __le64 host_phys_addr;  /* Ring base addr */
-        u32 ring_size;          /* Ring entries */
+        __le32 ring_size;               /* Ring entries */
-        u16 msi_index;
+        __le16 msi_index;
-        u16 rsvd;               /* Padding */
+        __le16 rsvd;            /* Padding */
 } nx_hostrq_sds_ring_t;
 typedef struct {
-        u64 host_phys_addr;     /* Ring base addr */
+        __le64 host_phys_addr;  /* Ring base addr */
-        u64 buff_size;          /* Packet buffer size */
+        __le64 buff_size;               /* Packet buffer size */
-        u32 ring_size;          /* Ring entries */
+        __le32 ring_size;               /* Ring entries */
-        u32 ring_kind;          /* Class of ring */
+        __le32 ring_kind;               /* Class of ring */
 } nx_hostrq_rds_ring_t;
 typedef struct {
-        u64 host_rsp_dma_addr;  /* Response dma'd here */
+        __le64 host_rsp_dma_addr;       /* Response dma'd here */
-        u32 capabilities[4];    /* Flag bit vector */
+        __le32 capabilities[4]; /* Flag bit vector */
-        u32 host_int_crb_mode;  /* Interrupt crb usage */
+        __le32 host_int_crb_mode;       /* Interrupt crb usage */
-        u32 host_rds_crb_mode;  /* RDS crb usage */
+        __le32 host_rds_crb_mode;       /* RDS crb usage */
        /* These ring offsets are relative to data[0] below */
-        u32 rds_ring_offset;    /* Offset to RDS config */
+        __le32 rds_ring_offset; /* Offset to RDS config */
-        u32 sds_ring_offset;    /* Offset to SDS config */
+        __le32 sds_ring_offset; /* Offset to SDS config */
-        u16 num_rds_rings;      /* Count of RDS rings */
+        __le16 num_rds_rings;   /* Count of RDS rings */
-        u16 num_sds_rings;      /* Count of SDS rings */
+        __le16 num_sds_rings;   /* Count of SDS rings */
-        u16 rsvd1;              /* Padding */
+        __le16 rsvd1;           /* Padding */
-        u16 rsvd2;              /* Padding */
+        __le16 rsvd2;           /* Padding */
        u8  reserved[128];      /* reserve space for future expansion*/
        /* MUST BE 64-bit aligned.
           The following is packed:
@@ -1029,24 +1012,24 @@ typedef struct {
 } nx_hostrq_rx_ctx_t;
 typedef struct {
-        u32 host_producer_crb;  /* Crb to use */
+        __le32 host_producer_crb;       /* Crb to use */
-        u32 rsvd1;              /* Padding */
+        __le32 rsvd1;           /* Padding */
 } nx_cardrsp_rds_ring_t;
 typedef struct {
-        u32 host_consumer_crb;  /* Crb to use */
+        __le32 host_consumer_crb;       /* Crb to use */
-        u32 interrupt_crb;      /* Crb to use */
+        __le32 interrupt_crb;   /* Crb to use */
 } nx_cardrsp_sds_ring_t;
 typedef struct {
        /* These ring offsets are relative to data[0] below */
-        u32 rds_ring_offset;    /* Offset to RDS config */
+        __le32 rds_ring_offset; /* Offset to RDS config */
-        u32 sds_ring_offset;    /* Offset to SDS config */
+        __le32 sds_ring_offset; /* Offset to SDS config */
-        u32 host_ctx_state;     /* Starting State */
+        __le32 host_ctx_state;  /* Starting State */
-        u32 num_fn_per_port;    /* How many PCI fn share the port */
+        __le32 num_fn_per_port; /* How many PCI fn share the port */
-        u16 num_rds_rings;      /* Count of RDS rings */
+        __le16 num_rds_rings;   /* Count of RDS rings */
-        u16 num_sds_rings;      /* Count of SDS rings */
+        __le16 num_sds_rings;   /* Count of SDS rings */
-        u16 context_id;         /* Handle for context */
+        __le16 context_id;              /* Handle for context */
        u8  phys_port;          /* Physical id of port */
        u8  virt_port;          /* Virtual/Logical id of port */
        u8  reserved[128];      /* save space for future expansion */
@@ -1072,34 +1055,34 @@ typedef struct {
 */
 typedef struct {
-        u64 host_phys_addr;     /* Ring base addr */
+        __le64 host_phys_addr;  /* Ring base addr */
-        u32 ring_size;          /* Ring entries */
+        __le32 ring_size;               /* Ring entries */
-        u32 rsvd;               /* Padding */
+        __le32 rsvd;            /* Padding */
 } nx_hostrq_cds_ring_t;
 typedef struct {
-        u64 host_rsp_dma_addr;  /* Response dma'd here */
+        __le64 host_rsp_dma_addr;       /* Response dma'd here */
-        u64 cmd_cons_dma_addr;  /*  */
+        __le64 cmd_cons_dma_addr;       /*  */
-        u64 dummy_dma_addr;     /*  */
+        __le64 dummy_dma_addr;  /*  */
-        u32 capabilities[4];    /* Flag bit vector */
+        __le32 capabilities[4]; /* Flag bit vector */
-        u32 host_int_crb_mode;  /* Interrupt crb usage */
+        __le32 host_int_crb_mode;       /* Interrupt crb usage */
-        u32 rsvd1;              /* Padding */
+        __le32 rsvd1;           /* Padding */
-        u16 rsvd2;              /* Padding */
+        __le16 rsvd2;           /* Padding */
-        u16 interrupt_ctl;
+        __le16 interrupt_ctl;
-        u16 msi_index;
+        __le16 msi_index;
-        u16 rsvd3;              /* Padding */
+        __le16 rsvd3;           /* Padding */
        nx_hostrq_cds_ring_t cds_ring;  /* Desc of cds ring */
        u8  reserved[128];      /* future expansion */
 } nx_hostrq_tx_ctx_t;
 typedef struct {
-        u32 host_producer_crb;  /* Crb to use */
+        __le32 host_producer_crb;       /* Crb to use */
-        u32 interrupt_crb;      /* Crb to use */
+        __le32 interrupt_crb;   /* Crb to use */
 } nx_cardrsp_cds_ring_t;
 typedef struct {
-        u32 host_ctx_state;     /* Starting state */
+        __le32 host_ctx_state;  /* Starting state */
-        u16 context_id;         /* Handle for context */
+        __le16 context_id;              /* Handle for context */
        u8  phys_port;          /* Physical id of port */
        u8  virt_port;          /* Virtual/Logical id of port */
        nx_cardrsp_cds_ring_t cds_ring; /* Card cds settings */
@@ -1202,9 +1185,9 @@ enum {
 #define VPORT_MISS_MODE_ACCEPT_MULTI    2 /* accept unmatched multicast */
 typedef struct {
-        u64 qhdr;
+        __le64 qhdr;
-        u64 req_hdr;
+        __le64 req_hdr;
-        u64 words[6];
+        __le64 words[6];
 } nx_nic_req_t;
 typedef struct {
@@ -1486,8 +1469,6 @@ void netxen_release_tx_buffers(struct netxen_adapter *adapter);
 void netxen_initialize_adapter_ops(struct netxen_adapter *adapter);
 int netxen_init_firmware(struct netxen_adapter *adapter);
-void netxen_tso_check(struct netxen_adapter *adapter,
-                      struct cmd_desc_type0 *desc, struct sk_buff *skb);
 void netxen_nic_clear_stats(struct netxen_adapter *adapter);
 void netxen_watchdog_task(struct work_struct *work);
 void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx,
@@ -1496,6 +1477,7 @@ int netxen_process_cmd_ring(struct netxen_adapter *adapter);
 u32 netxen_process_rcv_ring(struct netxen_adapter *adapter, int ctx, int max);
 void netxen_p2_nic_set_multi(struct net_device *netdev);
 void netxen_p3_nic_set_multi(struct net_device *netdev);
+void netxen_p3_free_mac_list(struct netxen_adapter *adapter);
 int netxen_p3_nic_set_promisc(struct netxen_adapter *adapter, u32);
 int netxen_config_intr_coalesce(struct netxen_adapter *adapter);
diff --git a/drivers/net/netxen/netxen_nic_ctx.c b/drivers/net/netxen/netxen_nic_ctx.c
index 64b51643c626..746bdb470418 100644
--- a/drivers/net/netxen/netxen_nic_ctx.c
+++ b/drivers/net/netxen/netxen_nic_ctx.c
@@ -76,7 +76,7 @@ netxen_api_unlock(struct netxen_adapter *adapter)
 static u32
 netxen_poll_rsp(struct netxen_adapter *adapter)
 {
-        u32 raw_rsp, rsp = NX_CDRP_RSP_OK;
+        u32 rsp = NX_CDRP_RSP_OK;
        int     timeout = 0;
        do {
@@ -86,10 +86,7 @@ netxen_poll_rsp(struct netxen_adapter *adapter)
                if (++timeout > NX_OS_CRB_RETRY_COUNT)
                        return NX_CDRP_RSP_TIMEOUT;
-                netxen_nic_read_w1(adapter, NX_CDRP_CRB_OFFSET,
+                netxen_nic_read_w1(adapter, NX_CDRP_CRB_OFFSET, &rsp);
-                                &raw_rsp);
-                rsp = le32_to_cpu(raw_rsp);
        } while (!NX_CDRP_IS_RSP(rsp));
        return rsp;
@@ -109,20 +106,16 @@ netxen_issue_cmd(struct netxen_adapter *adapter,
        if (netxen_api_lock(adapter))
                return NX_RCODE_TIMEOUT;
-        netxen_nic_write_w1(adapter, NX_SIGN_CRB_OFFSET,
+        netxen_nic_write_w1(adapter, NX_SIGN_CRB_OFFSET, signature);
-                        cpu_to_le32(signature));
-        netxen_nic_write_w1(adapter, NX_ARG1_CRB_OFFSET,
+        netxen_nic_write_w1(adapter, NX_ARG1_CRB_OFFSET, arg1);
-                        cpu_to_le32(arg1));
-        netxen_nic_write_w1(adapter, NX_ARG2_CRB_OFFSET,
+        netxen_nic_write_w1(adapter, NX_ARG2_CRB_OFFSET, arg2);
-                        cpu_to_le32(arg2));
-        netxen_nic_write_w1(adapter, NX_ARG3_CRB_OFFSET,
+        netxen_nic_write_w1(adapter, NX_ARG3_CRB_OFFSET, arg3);
-                        cpu_to_le32(arg3));
        netxen_nic_write_w1(adapter, NX_CDRP_CRB_OFFSET,
-                        cpu_to_le32(NX_CDRP_FORM_CMD(cmd)));
+                        NX_CDRP_FORM_CMD(cmd));
        rsp = netxen_poll_rsp(adapter);
@@ -133,7 +126,6 @@ netxen_issue_cmd(struct netxen_adapter *adapter,
                rcode = NX_RCODE_TIMEOUT;
        } else if (rsp == NX_CDRP_RSP_FAIL) {
                netxen_nic_read_w1(adapter, NX_ARG1_CRB_OFFSET, &rcode);
-                rcode = le32_to_cpu(rcode);
                printk(KERN_ERR "%s: failed card response code:0x%x\n",
                                netxen_nic_driver_name, rcode);
@@ -183,7 +175,7 @@ nx_fw_cmd_create_rx_ctx(struct netxen_adapter *adapter)
        int i, nrds_rings, nsds_rings;
        size_t rq_size, rsp_size;
-        u32 cap, reg;
+        u32 cap, reg, val;
        int err;
@@ -225,11 +217,14 @@ nx_fw_cmd_create_rx_ctx(struct netxen_adapter *adapter)
        prq->num_rds_rings = cpu_to_le16(nrds_rings);
        prq->num_sds_rings = cpu_to_le16(nsds_rings);
-        prq->rds_ring_offset = 0;
+        prq->rds_ring_offset = cpu_to_le32(0);
-        prq->sds_ring_offset = prq->rds_ring_offset +
+        val = le32_to_cpu(prq->rds_ring_offset) +
                (sizeof(nx_hostrq_rds_ring_t) * nrds_rings);
+        prq->sds_ring_offset = cpu_to_le32(val);
-        prq_rds = (nx_hostrq_rds_ring_t *)(prq->data + prq->rds_ring_offset);
+        prq_rds = (nx_hostrq_rds_ring_t *)(prq->data +
+                        le32_to_cpu(prq->rds_ring_offset));
        for (i = 0; i < nrds_rings; i++) {
@@ -241,17 +236,14 @@ nx_fw_cmd_create_rx_ctx(struct netxen_adapter *adapter)
                prq_rds[i].buff_size = cpu_to_le64(rds_ring->dma_size);
        }
-        prq_sds = (nx_hostrq_sds_ring_t *)(prq->data + prq->sds_ring_offset);
+        prq_sds = (nx_hostrq_sds_ring_t *)(prq->data +
+                        le32_to_cpu(prq->sds_ring_offset));
        prq_sds[0].host_phys_addr =
                cpu_to_le64(recv_ctx->rcv_status_desc_phys_addr);
        prq_sds[0].ring_size = cpu_to_le32(adapter->max_rx_desc_count);
        /* only one msix vector for now */
-        prq_sds[0].msi_index = cpu_to_le32(0);
+        prq_sds[0].msi_index = cpu_to_le16(0);
-        /* now byteswap offsets */
-        prq->rds_ring_offset = cpu_to_le32(prq->rds_ring_offset);
-        prq->sds_ring_offset = cpu_to_le32(prq->sds_ring_offset);
        phys_addr = hostrq_phys_addr;
        err = netxen_issue_cmd(adapter,
@@ -269,9 +261,9 @@ nx_fw_cmd_create_rx_ctx(struct netxen_adapter *adapter)
        prsp_rds = ((nx_cardrsp_rds_ring_t *)
-                         &prsp->data[prsp->rds_ring_offset]);
+                         &prsp->data[le32_to_cpu(prsp->rds_ring_offset)]);
-        for (i = 0; i < le32_to_cpu(prsp->num_rds_rings); i++) {
+        for (i = 0; i < le16_to_cpu(prsp->num_rds_rings); i++) {
                rds_ring = &recv_ctx->rds_rings[i];
                reg = le32_to_cpu(prsp_rds[i].host_producer_crb);
@@ -279,7 +271,7 @@ nx_fw_cmd_create_rx_ctx(struct netxen_adapter *adapter)
        }
        prsp_sds = ((nx_cardrsp_sds_ring_t *)
-                        &prsp->data[prsp->sds_ring_offset]);
+                        &prsp->data[le32_to_cpu(prsp->sds_ring_offset)]);
        reg = le32_to_cpu(prsp_sds[0].host_consumer_crb);
        recv_ctx->crb_sts_consumer = NETXEN_NIC_REG(reg - 0x200);
@@ -288,7 +280,7 @@ nx_fw_cmd_create_rx_ctx(struct netxen_adapter *adapter)
        recv_ctx->state = le32_to_cpu(prsp->host_ctx_state);
        recv_ctx->context_id = le16_to_cpu(prsp->context_id);
-        recv_ctx->virt_port = le16_to_cpu(prsp->virt_port);
+        recv_ctx->virt_port = prsp->virt_port;
 out_free_rsp:
        pci_free_consistent(adapter->pdev, rsp_size, prsp, cardrsp_phys_addr);
diff --git a/drivers/net/netxen/netxen_nic_ethtool.c b/drivers/net/netxen/netxen_nic_ethtool.c
index e45ce2951729..0894a7be0225 100644
--- a/drivers/net/netxen/netxen_nic_ethtool.c
+++ b/drivers/net/netxen/netxen_nic_ethtool.c
@@ -136,11 +136,9 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
                ecmd->port = PORT_TP;
-                if (netif_running(dev)) {
+                ecmd->speed = adapter->link_speed;
-                        ecmd->speed = adapter->link_speed;
+                ecmd->duplex = adapter->link_duplex;
-                        ecmd->duplex = adapter->link_duplex;
+                ecmd->autoneg = adapter->link_autoneg;
-                        ecmd->autoneg = adapter->link_autoneg;
-                }
        } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
                u32 val;
@@ -171,7 +169,7 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
        } else
                return -EIO;
-        ecmd->phy_address = adapter->portnum;
+        ecmd->phy_address = adapter->physical_port;
        ecmd->transceiver = XCVR_EXTERNAL;
        switch ((netxen_brdtype_t) boardinfo->board_type) {
@@ -180,13 +178,13 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
        case NETXEN_BRDTYPE_P3_REF_QG:
        case NETXEN_BRDTYPE_P3_4_GB:
        case NETXEN_BRDTYPE_P3_4_GB_MM:
-        case NETXEN_BRDTYPE_P3_10000_BASE_T:
                ecmd->supported |= SUPPORTED_Autoneg;
                ecmd->advertising |= ADVERTISED_Autoneg;
        case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
        case NETXEN_BRDTYPE_P3_10G_CX4:
        case NETXEN_BRDTYPE_P3_10G_CX4_LP:
+        case NETXEN_BRDTYPE_P3_10000_BASE_T:
                ecmd->supported |= SUPPORTED_TP;
                ecmd->advertising |= ADVERTISED_TP;
                ecmd->port = PORT_TP;
@@ -204,16 +202,33 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
                ecmd->port = PORT_FIBRE;
                ecmd->autoneg = AUTONEG_DISABLE;
                break;
-        case NETXEN_BRDTYPE_P2_SB31_10G:
        case NETXEN_BRDTYPE_P3_10G_SFP_PLUS:
        case NETXEN_BRDTYPE_P3_10G_SFP_CT:
        case NETXEN_BRDTYPE_P3_10G_SFP_QT:
+                ecmd->advertising |= ADVERTISED_TP;
+                ecmd->supported |= SUPPORTED_TP;
+        case NETXEN_BRDTYPE_P2_SB31_10G:
        case NETXEN_BRDTYPE_P3_10G_XFP:
                ecmd->supported |= SUPPORTED_FIBRE;
                ecmd->advertising |= ADVERTISED_FIBRE;
                ecmd->port = PORT_FIBRE;
                ecmd->autoneg = AUTONEG_DISABLE;
                break;
+        case NETXEN_BRDTYPE_P3_10G_TP:
+                if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
+                        ecmd->autoneg = AUTONEG_DISABLE;
+                        ecmd->supported |= (SUPPORTED_FIBRE | SUPPORTED_TP);
+                        ecmd->advertising |=
+                                (ADVERTISED_FIBRE | ADVERTISED_TP);
+                        ecmd->port = PORT_FIBRE;
+                } else {
+                        ecmd->autoneg = AUTONEG_ENABLE;
+                        ecmd->supported |= (SUPPORTED_TP |SUPPORTED_Autoneg);
+                        ecmd->advertising |=
+                                (ADVERTISED_TP | ADVERTISED_Autoneg);
+                        ecmd->port = PORT_TP;
+                }
+                break;
        default:
                printk(KERN_ERR "netxen-nic: Unsupported board model %d\n",
                       (netxen_brdtype_t) boardinfo->board_type);
@@ -546,7 +561,10 @@ netxen_nic_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
        }
        ring->tx_pending = adapter->max_tx_desc_count;
-        ring->rx_max_pending = MAX_RCV_DESCRIPTORS;
+        if (adapter->ahw.board_type == NETXEN_NIC_GBE)
+                ring->rx_max_pending = MAX_RCV_DESCRIPTORS_1G;
+        else
+                ring->rx_max_pending = MAX_RCV_DESCRIPTORS_10G;
        ring->tx_max_pending = MAX_CMD_DESCRIPTORS_HOST;
        ring->rx_jumbo_max_pending = MAX_JUMBO_RCV_DESCRIPTORS;
        ring->rx_mini_max_pending = 0;
diff --git a/drivers/net/netxen/netxen_nic_hw.c b/drivers/net/netxen/netxen_nic_hw.c
index aa6e603bfcbf..821cff68b3f3 100644
--- a/drivers/net/netxen/netxen_nic_hw.c
+++ b/drivers/net/netxen/netxen_nic_hw.c
@@ -503,17 +503,15 @@ netxen_send_cmd_descs(struct netxen_adapter *adapter,
        i = 0;
+        netif_tx_lock_bh(adapter->netdev);
        producer = adapter->cmd_producer;
        do {
                cmd_desc = &cmd_desc_arr[i];
                pbuf = &adapter->cmd_buf_arr[producer];
-                pbuf->mss = 0;
-                pbuf->total_length = 0;
                pbuf->skb = NULL;
-                pbuf->cmd = 0;
                pbuf->frag_count = 0;
-                pbuf->port = 0;
                /* adapter->ahw.cmd_desc_head[producer] = *cmd_desc; */
                memcpy(&adapter->ahw.cmd_desc_head[producer],
@@ -531,6 +529,8 @@ netxen_send_cmd_descs(struct netxen_adapter *adapter,
        netxen_nic_update_cmd_producer(adapter, adapter->cmd_producer);
+        netif_tx_unlock_bh(adapter->netdev);
        return 0;
 }
@@ -539,16 +539,19 @@ static int nx_p3_sre_macaddr_change(struct net_device *dev,
 {
        struct netxen_adapter *adapter = netdev_priv(dev);
        nx_nic_req_t req;
-        nx_mac_req_t mac_req;
+        nx_mac_req_t *mac_req;
+        u64 word;
        int rv;
        memset(&req, 0, sizeof(nx_nic_req_t));
-        req.qhdr |= (NX_NIC_REQUEST << 23);
+        req.qhdr = cpu_to_le64(NX_NIC_REQUEST << 23);
-        req.req_hdr |= NX_MAC_EVENT;
-        req.req_hdr |= ((u64)adapter->portnum << 16);
+        word = NX_MAC_EVENT | ((u64)adapter->portnum << 16);
-        mac_req.op = op;
+        req.req_hdr = cpu_to_le64(word);
-        memcpy(&mac_req.mac_addr, addr, 6);
-        req.words[0] = cpu_to_le64(*(u64 *)&mac_req);
+        mac_req = (nx_mac_req_t *)&req.words[0];
+        mac_req->op = op;
+        memcpy(mac_req->mac_addr, addr, 6);
        rv = netxen_send_cmd_descs(adapter, (struct cmd_desc_type0 *)&req, 1);
        if (rv != 0) {
@@ -612,18 +615,35 @@ send_fw_cmd:
 int netxen_p3_nic_set_promisc(struct netxen_adapter *adapter, u32 mode)
 {
        nx_nic_req_t req;
+        u64 word;
        memset(&req, 0, sizeof(nx_nic_req_t));
-        req.qhdr |= (NX_HOST_REQUEST << 23);
+        req.qhdr = cpu_to_le64(NX_HOST_REQUEST << 23);
-        req.req_hdr |= NX_NIC_H2C_OPCODE_PROXY_SET_VPORT_MISS_MODE;
-        req.req_hdr |= ((u64)adapter->portnum << 16);
+        word = NX_NIC_H2C_OPCODE_PROXY_SET_VPORT_MISS_MODE |
+                        ((u64)adapter->portnum << 16);
+        req.req_hdr = cpu_to_le64(word);
        req.words[0] = cpu_to_le64(mode);
        return netxen_send_cmd_descs(adapter,
                                (struct cmd_desc_type0 *)&req, 1);
 }
+void netxen_p3_free_mac_list(struct netxen_adapter *adapter)
+{
+        nx_mac_list_t *cur, *next;
+        cur = adapter->mac_list;
+        while (cur) {
+                next = cur->next;
+                kfree(cur);
+                cur = next;
+        }
+}
 #define NETXEN_CONFIG_INTR_COALESCE     3
 /*
@@ -632,13 +652,15 @@ int netxen_p3_nic_set_promisc(struct netxen_adapter *adapter, u32 mode)
 int netxen_config_intr_coalesce(struct netxen_adapter *adapter)
 {
        nx_nic_req_t req;
+        u64 word;
        int rv;
        memset(&req, 0, sizeof(nx_nic_req_t));
-        req.qhdr |= (NX_NIC_REQUEST << 23);
+        req.qhdr = cpu_to_le64(NX_NIC_REQUEST << 23);
-        req.req_hdr |= NETXEN_CONFIG_INTR_COALESCE;
-        req.req_hdr |= ((u64)adapter->portnum << 16);
+        word = NETXEN_CONFIG_INTR_COALESCE | ((u64)adapter->portnum << 16);
+        req.req_hdr = cpu_to_le64(word);
        memcpy(&req.words[0], &adapter->coal, sizeof(adapter->coal));
@@ -772,13 +794,10 @@ int netxen_p3_get_mac_addr(struct netxen_adapter *adapter, __le64 *mac)
        adapter->hw_read_wx(adapter, crbaddr, &mac_lo, 4);
        adapter->hw_read_wx(adapter, crbaddr+4, &mac_hi, 4);
-        mac_hi = cpu_to_le32(mac_hi);
-        mac_lo = cpu_to_le32(mac_lo);
        if (pci_func & 1)
-                *mac = ((mac_lo >> 16) | ((u64)mac_hi << 16));
+                *mac = le64_to_cpu((mac_lo >> 16) | ((u64)mac_hi << 16));
        else
-                *mac = ((mac_lo) | ((u64)mac_hi << 32));
+                *mac = le64_to_cpu((u64)mac_lo | ((u64)mac_hi << 32));
        return 0;
 }
@@ -937,7 +956,7 @@ int netxen_load_firmware(struct netxen_adapter *adapter)
 {
        int i;
        u32 data, size = 0;
-        u32 flashaddr = NETXEN_BOOTLD_START, memaddr = NETXEN_BOOTLD_START;
+        u32 flashaddr = NETXEN_BOOTLD_START;
        size = (NETXEN_IMAGE_START - NETXEN_BOOTLD_START)/4;
@@ -949,10 +968,8 @@ int netxen_load_firmware(struct netxen_adapter *adapter)
                if (netxen_rom_fast_read(adapter, flashaddr, (int *)&data) != 0)
                        return -EIO;
-                adapter->pci_mem_write(adapter, memaddr, &data, 4);
+                adapter->pci_mem_write(adapter, flashaddr, &data, 4);
                flashaddr += 4;
-                memaddr += 4;
-                cond_resched();
        }
        msleep(1);
@@ -2034,7 +2051,13 @@ int netxen_nic_get_board_info(struct netxen_adapter *adapter)
                rv = -1;
        }
-        DPRINTK(INFO, "Discovered board type:0x%x  ", boardinfo->board_type);
+        if (boardinfo->board_type == NETXEN_BRDTYPE_P3_4_GB_MM) {
+                u32 gpio = netxen_nic_reg_read(adapter,
+                                NETXEN_ROMUSB_GLB_PAD_GPIO_I);
+                if ((gpio & 0x8000) == 0)
+                        boardinfo->board_type = NETXEN_BRDTYPE_P3_10G_TP;
+        }
        switch ((netxen_brdtype_t) boardinfo->board_type) {
        case NETXEN_BRDTYPE_P2_SB35_4G:
                adapter->ahw.board_type = NETXEN_NIC_GBE;
@@ -2053,7 +2076,6 @@ int netxen_nic_get_board_info(struct netxen_adapter *adapter)
        case NETXEN_BRDTYPE_P3_10G_SFP_QT:
        case NETXEN_BRDTYPE_P3_10G_XFP:
        case NETXEN_BRDTYPE_P3_10000_BASE_T:
                adapter->ahw.board_type = NETXEN_NIC_XGBE;
                break;
        case NETXEN_BRDTYPE_P1_BD:
@@ -2063,9 +2085,12 @@ int netxen_nic_get_board_info(struct netxen_adapter *adapter)
        case NETXEN_BRDTYPE_P3_REF_QG:
        case NETXEN_BRDTYPE_P3_4_GB:
        case NETXEN_BRDTYPE_P3_4_GB_MM:
                adapter->ahw.board_type = NETXEN_NIC_GBE;
                break;
+        case NETXEN_BRDTYPE_P3_10G_TP:
+                adapter->ahw.board_type = (adapter->portnum < 2) ?
+                        NETXEN_NIC_XGBE : NETXEN_NIC_GBE;
+                break;
        default:
                printk("%s: Unknown(%x)\n", netxen_nic_driver_name,
                       boardinfo->board_type);
@@ -2110,12 +2135,16 @@ void netxen_nic_set_link_parameters(struct netxen_adapter *adapter)
 {
        __u32 status;
        __u32 autoneg;
-        __u32 mode;
        __u32 port_mode;
-        netxen_nic_read_w0(adapter, NETXEN_NIU_MODE, &mode);
+        if (!netif_carrier_ok(adapter->netdev)) {
-        if (netxen_get_niu_enable_ge(mode)) {   /* Gb 10/100/1000 Mbps mode */
+                adapter->link_speed   = 0;
+                adapter->link_duplex  = -1;
+                adapter->link_autoneg = AUTONEG_ENABLE;
+                return;
+        }
+        if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
                adapter->hw_read_wx(adapter,
                                NETXEN_PORT_MODE_ADDR, &port_mode, 4);
                if (port_mode == NETXEN_PORT_MODE_802_3_AP) {
@@ -2141,7 +2170,7 @@ void netxen_nic_set_link_parameters(struct netxen_adapter *adapter)
                                        adapter->link_speed = SPEED_1000;
                                        break;
                                default:
-                                        adapter->link_speed = -1;
+                                        adapter->link_speed = 0;
                                        break;
                                }
                                switch (netxen_get_phy_duplex(status)) {
@@ -2164,7 +2193,7 @@ void netxen_nic_set_link_parameters(struct netxen_adapter *adapter)
                                goto link_down;
                } else {
                      link_down:
-                        adapter->link_speed = -1;
+                        adapter->link_speed = 0;
                        adapter->link_duplex = -1;
                }
        }
diff --git a/drivers/net/netxen/netxen_nic_init.c b/drivers/net/netxen/netxen_nic_init.c
index d924468e506e..ffd37bea1628 100644
--- a/drivers/net/netxen/netxen_nic_init.c
+++ b/drivers/net/netxen/netxen_nic_init.c
@@ -308,7 +308,6 @@ int netxen_alloc_sw_resources(struct netxen_adapter *adapter)
                        }
                        memset(rds_ring->rx_buf_arr, 0, RCV_BUFFSIZE);
                        INIT_LIST_HEAD(&rds_ring->free_list);
-                        rds_ring->begin_alloc = 0;
                        /*
                         * Now go through all of them, set reference handles
                         * and put them in the queues.
@@ -439,6 +438,8 @@ static int netxen_wait_rom_done(struct netxen_adapter *adapter)
        long timeout = 0;
        long done = 0;
+        cond_resched();
        while (done == 0) {
                done = netxen_nic_reg_read(adapter, NETXEN_ROMUSB_GLB_STATUS);
                done &= 2;
@@ -533,12 +534,9 @@ static int do_rom_fast_write(struct netxen_adapter *adapter, int addr,
 static int do_rom_fast_read(struct netxen_adapter *adapter,
                            int addr, int *valp)
 {
-        cond_resched();
        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ADDRESS, addr);
-        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
-        udelay(100);            /* prevent bursting on CRB */
        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
+        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE, 0xb);
        if (netxen_wait_rom_done(adapter)) {
                printk("Error waiting for rom done\n");
@@ -546,7 +544,7 @@ static int do_rom_fast_read(struct netxen_adapter *adapter,
        }
        /* reset abyte_cnt and dummy_byte_cnt */
        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
-        udelay(100);            /* prevent bursting on CRB */
+        udelay(10);
        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
        *valp = netxen_nic_reg_read(adapter, NETXEN_ROMUSB_ROM_RDATA);
@@ -884,14 +882,16 @@ int netxen_flash_unlock(struct netxen_adapter *adapter)
 int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
 {
        int addr, val;
-        int i, init_delay = 0;
+        int i, n, init_delay = 0;
        struct crb_addr_pair *buf;
-        unsigned offset, n;
+        unsigned offset;
        u32 off;
        /* resetall */
+        rom_lock(adapter);
        netxen_crb_writelit_adapter(adapter, NETXEN_ROMUSB_GLB_SW_RESET,
                                    0xffffffff);
+        netxen_rom_unlock(adapter);
        if (verbose) {
                if (netxen_rom_fast_read(adapter, NETXEN_BOARDTYPE, &val) == 0)
@@ -910,7 +910,7 @@ int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
                if (netxen_rom_fast_read(adapter, 0, &n) != 0 ||
-                        (n != 0xcafecafeUL) ||
+                        (n != 0xcafecafe) ||
                        netxen_rom_fast_read(adapter, 4, &n) != 0) {
                        printk(KERN_ERR "%s: ERROR Reading crb_init area: "
                                        "n: %08x\n", netxen_nic_driver_name, n);
@@ -947,8 +947,10 @@ int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
        }
        for (i = 0; i < n; i++) {
                if (netxen_rom_fast_read(adapter, 8*i + 4*offset, &val) != 0 ||
-                netxen_rom_fast_read(adapter, 8*i + 4*offset + 4, &addr) != 0)
+                netxen_rom_fast_read(adapter, 8*i + 4*offset + 4, &addr) != 0) {
+                        kfree(buf);
                        return -EIO;
+                }
                buf[i].addr = addr;
                buf[i].data = val;
@@ -975,6 +977,14 @@ int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
                        /* do not reset PCI */
                        if (off == (ROMUSB_GLB + 0xbc))
                                continue;
+                        if (off == (ROMUSB_GLB + 0xa8))
+                                continue;
+                        if (off == (ROMUSB_GLB + 0xc8)) /* core clock */
+                                continue;
+                        if (off == (ROMUSB_GLB + 0x24)) /* MN clock */
+                                continue;
+                        if (off == (ROMUSB_GLB + 0x1c)) /* MS clock */
+                                continue;
                        if (off == (NETXEN_CRB_PEG_NET_1 + 0x18))
                                buf[i].data = 0x1020;
                        /* skip the function enable register */
@@ -992,23 +1002,21 @@ int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
                        continue;
                }
+                init_delay = 1;
                /* After writing this register, HW needs time for CRB */
                /* to quiet down (else crb_window returns 0xffffffff) */
                if (off == NETXEN_ROMUSB_GLB_SW_RESET) {
-                        init_delay = 1;
+                        init_delay = 1000;
                        if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
                                /* hold xdma in reset also */
                                buf[i].data = NETXEN_NIC_XDMA_RESET;
+                                buf[i].data = 0x8000ff;
                        }
                }
                adapter->hw_write_wx(adapter, off, &buf[i].data, 4);
-                if (init_delay == 1) {
+                msleep(init_delay);
-                        msleep(1000);
-                        init_delay = 0;
-                }
-                msleep(1);
        }
        kfree(buf);
@@ -1277,7 +1285,7 @@ static void netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
                dev_kfree_skb_any(skb);
                for (i = 0; i < nr_frags; i++) {
-                        index = frag_desc->frag_handles[i];
+                        index = le16_to_cpu(frag_desc->frag_handles[i]);
                        skb = netxen_process_rxbuf(adapter,
                                        rds_ring, index, cksum);
                        if (skb)
@@ -1428,7 +1436,6 @@ void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx, u32 ringid)
        struct rcv_desc *pdesc;
        struct netxen_rx_buffer *buffer;
        int count = 0;
-        int index = 0;
        netxen_ctx_msg msg = 0;
        dma_addr_t dma;
        struct list_head *head;
@@ -1436,7 +1443,6 @@ void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx, u32 ringid)
        rds_ring = &recv_ctx->rds_rings[ringid];
        producer = rds_ring->producer;
-        index = rds_ring->begin_alloc;
        head = &rds_ring->free_list;
        /* We can start writing rx descriptors into the phantom memory. */
@@ -1444,39 +1450,37 @@ void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx, u32 ringid)
                skb = dev_alloc_skb(rds_ring->skb_size);
                if (unlikely(!skb)) {
-                        rds_ring->begin_alloc = index;
                        break;
                }
+                if (!adapter->ahw.cut_through)
+                        skb_reserve(skb, 2);
+                dma = pci_map_single(pdev, skb->data,
+                                rds_ring->dma_size, PCI_DMA_FROMDEVICE);
+                if (pci_dma_mapping_error(pdev, dma)) {
+                        dev_kfree_skb_any(skb);
+                        break;
+                }
+                count++;
                buffer = list_entry(head->next, struct netxen_rx_buffer, list);
                list_del(&buffer->list);
-                count++;        /* now there should be no failure */
-                pdesc = &rds_ring->desc_head[producer];
-                if (!adapter->ahw.cut_through)
-                        skb_reserve(skb, 2);
-                /* This will be setup when we receive the
-                 * buffer after it has been filled  FSL  TBD TBD
-                 * skb->dev = netdev;
-                 */
-                dma = pci_map_single(pdev, skb->data, rds_ring->dma_size,
-                                     PCI_DMA_FROMDEVICE);
-                pdesc->addr_buffer = cpu_to_le64(dma);
                buffer->skb = skb;
                buffer->state = NETXEN_BUFFER_BUSY;
                buffer->dma = dma;
                /* make a rcv descriptor  */
+                pdesc = &rds_ring->desc_head[producer];
+                pdesc->addr_buffer = cpu_to_le64(dma);
                pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
                pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
-                DPRINTK(INFO, "done writing descripter\n");
-                producer =
+                producer = get_next_index(producer, rds_ring->max_rx_desc_count);
-                    get_next_index(producer, rds_ring->max_rx_desc_count);
-                index = get_next_index(index, rds_ring->max_rx_desc_count);
        }
        /* if we did allocate buffers, then write the count to Phantom */
        if (count) {
-                rds_ring->begin_alloc = index;
                rds_ring->producer = producer;
                        /* Window = 1 */
                adapter->pci_write_normalize(adapter,
@@ -1515,49 +1519,50 @@ static void netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter,
        struct rcv_desc *pdesc;
        struct netxen_rx_buffer *buffer;
        int count = 0;
-        int index = 0;
        struct list_head *head;
+        dma_addr_t dma;
        rds_ring = &recv_ctx->rds_rings[ringid];
        producer = rds_ring->producer;
-        index = rds_ring->begin_alloc;
        head = &rds_ring->free_list;
        /* We can start writing rx descriptors into the phantom memory. */
        while (!list_empty(head)) {
                skb = dev_alloc_skb(rds_ring->skb_size);
                if (unlikely(!skb)) {
-                        rds_ring->begin_alloc = index;
                        break;
                }
+                if (!adapter->ahw.cut_through)
+                        skb_reserve(skb, 2);
+                dma = pci_map_single(pdev, skb->data,
+                                rds_ring->dma_size, PCI_DMA_FROMDEVICE);
+                if (pci_dma_mapping_error(pdev, dma)) {
+                        dev_kfree_skb_any(skb);
+                        break;
+                }
+                count++;
                buffer = list_entry(head->next, struct netxen_rx_buffer, list);
                list_del(&buffer->list);
-                count++;        /* now there should be no failure */
-                pdesc = &rds_ring->desc_head[producer];
-                if (!adapter->ahw.cut_through)
-                        skb_reserve(skb, 2);
                buffer->skb = skb;
                buffer->state = NETXEN_BUFFER_BUSY;
-                buffer->dma = pci_map_single(pdev, skb->data,
+                buffer->dma = dma;
-                                             rds_ring->dma_size,
-                                             PCI_DMA_FROMDEVICE);
                /* make a rcv descriptor  */
+                pdesc = &rds_ring->desc_head[producer];
                pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
                pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
                pdesc->addr_buffer = cpu_to_le64(buffer->dma);
-                producer =
-                    get_next_index(producer, rds_ring->max_rx_desc_count);
+                producer = get_next_index(producer, rds_ring->max_rx_desc_count);
-                index = get_next_index(index, rds_ring->max_rx_desc_count);
-                buffer = &rds_ring->rx_buf_arr[index];
        }
        /* if we did allocate buffers, then write the count to Phantom */
        if (count) {
-                rds_ring->begin_alloc = index;
                rds_ring->producer = producer;
                        /* Window = 1 */
                adapter->pci_write_normalize(adapter,
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index ba01524b5531..645d384fe87e 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -39,7 +39,9 @@
 #include "netxen_nic_phan_reg.h"
 #include <linux/dma-mapping.h>
+#include <linux/if_vlan.h>
 #include <net/ip.h>
+#include <linux/ipv6.h>
 MODULE_DESCRIPTION("NetXen Multi port (1/10) Gigabit Network Driver");
 MODULE_LICENSE("GPL");
@@ -242,7 +244,7 @@ static void netxen_check_options(struct netxen_adapter *adapter)
        case NETXEN_BRDTYPE_P3_4_GB:
        case NETXEN_BRDTYPE_P3_4_GB_MM:
                adapter->msix_supported = !!use_msi_x;
-                adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS_10G;
+                adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS_1G;
                break;
        case NETXEN_BRDTYPE_P2_SB35_4G:
@@ -251,6 +253,14 @@ static void netxen_check_options(struct netxen_adapter *adapter)
                adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS_1G;
                break;
+        case NETXEN_BRDTYPE_P3_10G_TP:
+                adapter->msix_supported = !!use_msi_x;
+                if (adapter->ahw.board_type == NETXEN_NIC_XGBE)
+                        adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS_10G;
+                else
+                        adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS_1G;
+                break;
        default:
                adapter->msix_supported = 0;
                adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS_1G;
@@ -271,10 +281,15 @@ static void netxen_check_options(struct netxen_adapter *adapter)
 static int
 netxen_check_hw_init(struct netxen_adapter *adapter, int first_boot)
 {
-        int ret = 0;
+        u32 val, timeout;
        if (first_boot == 0x55555555) {
                /* This is the first boot after power up */
+                adapter->pci_write_normalize(adapter,
+                        NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
+                if (!NX_IS_REVISION_P2(adapter->ahw.revision_id))
+                        return 0;
                /* PCI bus master workaround */
                adapter->hw_read_wx(adapter,
@@ -294,18 +309,26 @@ netxen_check_hw_init(struct netxen_adapter *adapter, int first_boot)
                        /* clear the register for future unloads/loads */
                        adapter->pci_write_normalize(adapter,
                                        NETXEN_CAM_RAM(0x1fc), 0);
-                        ret = -1;
+                        return -EIO;
                }
-                if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
+                /* Start P2 boot loader */
-                        /* Start P2 boot loader */
+                val = adapter->pci_read_normalize(adapter,
-                        adapter->pci_write_normalize(adapter,
+                                NETXEN_ROMUSB_GLB_PEGTUNE_DONE);
-                                NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
+                adapter->pci_write_normalize(adapter,
-                        adapter->pci_write_normalize(adapter,
+                                NETXEN_ROMUSB_GLB_PEGTUNE_DONE, val | 0x1);
-                                        NETXEN_ROMUSB_GLB_PEGTUNE_DONE, 1);
+                timeout = 0;
-                }
+                do {
+                        msleep(1);
+                        val = adapter->pci_read_normalize(adapter,
+                                        NETXEN_CAM_RAM(0x1fc));
+                        if (++timeout > 5000)
+                                return -EIO;
+                } while (val == NETXEN_BDINFO_MAGIC);
        }
-        return ret;
+        return 0;
 }
 static void netxen_set_port_mode(struct netxen_adapter *adapter)
@@ -712,17 +735,18 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
-        /* ScatterGather support */
+        netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
-        netdev->features = NETIF_F_SG;
+        netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
-        netdev->features |= NETIF_F_IP_CSUM;
-        netdev->features |= NETIF_F_TSO;
        if (NX_IS_REVISION_P3(revision_id)) {
-                netdev->features |= NETIF_F_IPV6_CSUM;
+                netdev->features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
-                netdev->features |= NETIF_F_TSO6;
+                netdev->vlan_features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
        }
-        if (adapter->pci_using_dac)
+        if (adapter->pci_using_dac) {
                netdev->features |= NETIF_F_HIGHDMA;
+                netdev->vlan_features |= NETIF_F_HIGHDMA;
+        }
        /*
         * Set the CRB window to invalid. If any register in window 0 is
@@ -784,8 +808,8 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                                                CRB_CMDPEG_STATE, 0);
                        netxen_pinit_from_rom(adapter, 0);
                        msleep(1);
-                        netxen_load_firmware(adapter);
                }
+                netxen_load_firmware(adapter);
                if (NX_IS_REVISION_P3(revision_id))
                        netxen_pcie_strap_init(adapter);
@@ -801,13 +825,6 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                }
-                if ((first_boot == 0x55555555) &&
-                        (NX_IS_REVISION_P2(revision_id))) {
-                        /* Unlock the HW, prompting the boot sequence */
-                        adapter->pci_write_normalize(adapter,
-                                        NETXEN_ROMUSB_GLB_PEGTUNE_DONE, 1);
-                }
                err = netxen_initialize_adapter_offload(adapter);
                if (err)
                        goto err_out_iounmap;
@@ -821,7 +838,9 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                adapter->pci_write_normalize(adapter, CRB_DRIVER_VERSION, i);
                /* Handshake with the card before we register the devices. */
-                netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
+                err = netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
+                if (err)
+                        goto err_out_free_offload;
        }       /* first_driver */
@@ -925,6 +944,7 @@ err_out_disable_msi:
        if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
                pci_disable_msi(pdev);
+err_out_free_offload:
        if (first_driver)
                netxen_free_adapter_offload(adapter);
@@ -968,6 +988,9 @@ static void __devexit netxen_nic_remove(struct pci_dev *pdev)
                netxen_free_hw_resources(adapter);
                netxen_release_rx_buffers(adapter);
                netxen_free_sw_resources(adapter);
+                if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
+                        netxen_p3_free_mac_list(adapter);
        }
        if (adapter->portnum == 0)
@@ -983,8 +1006,10 @@ static void __devexit netxen_nic_remove(struct pci_dev *pdev)
        iounmap(adapter->ahw.db_base);
        iounmap(adapter->ahw.pci_base0);
-        iounmap(adapter->ahw.pci_base1);
+        if (adapter->ahw.pci_base1 != NULL)
-        iounmap(adapter->ahw.pci_base2);
+                iounmap(adapter->ahw.pci_base1);
+        if (adapter->ahw.pci_base2 != NULL)
+                iounmap(adapter->ahw.pci_base2);
        pci_release_regions(pdev);
        pci_disable_device(pdev);
@@ -1137,29 +1162,72 @@ static int netxen_nic_close(struct net_device *netdev)
        return 0;
 }
-void netxen_tso_check(struct netxen_adapter *adapter,
+static bool netxen_tso_check(struct net_device *netdev,
                      struct cmd_desc_type0 *desc, struct sk_buff *skb)
 {
-        if (desc->mss) {
+        bool tso = false;
-                desc->total_hdr_length = (sizeof(struct ethhdr) +
+        u8 opcode = TX_ETHER_PKT;
-                                          ip_hdrlen(skb) + tcp_hdrlen(skb));
+        __be16 protocol = skb->protocol;
+        u16 flags = 0;
+        if (protocol == __constant_htons(ETH_P_8021Q)) {
+                struct vlan_ethhdr *vh = (struct vlan_ethhdr *)skb->data;
+                protocol = vh->h_vlan_encapsulated_proto;
+                flags = FLAGS_VLAN_TAGGED;
+        }
-                if ((NX_IS_REVISION_P3(adapter->ahw.revision_id)) &&
+        if ((netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
-                                (skb->protocol == htons(ETH_P_IPV6)))
+                        skb_shinfo(skb)->gso_size > 0) {
-                        netxen_set_cmd_desc_opcode(desc, TX_TCP_LSO6);
-                else
+                desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
-                        netxen_set_cmd_desc_opcode(desc, TX_TCP_LSO);
+                desc->total_hdr_length =
+                        skb_transport_offset(skb) + tcp_hdrlen(skb);
+                opcode = (protocol == __constant_htons(ETH_P_IPV6)) ?
+                                TX_TCP_LSO6 : TX_TCP_LSO;
+                tso = true;
        } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
-                if (ip_hdr(skb)->protocol == IPPROTO_TCP)
+                u8 l4proto;
-                        netxen_set_cmd_desc_opcode(desc, TX_TCP_PKT);
-                else if (ip_hdr(skb)->protocol == IPPROTO_UDP)
+                if (protocol == __constant_htons(ETH_P_IP)) {
-                        netxen_set_cmd_desc_opcode(desc, TX_UDP_PKT);
+                        l4proto = ip_hdr(skb)->protocol;
-                else
-                        return;
+                        if (l4proto == IPPROTO_TCP)
+                                opcode = TX_TCP_PKT;
+                        else if(l4proto == IPPROTO_UDP)
+                                opcode = TX_UDP_PKT;
+                } else if (protocol == __constant_htons(ETH_P_IPV6)) {
+                        l4proto = ipv6_hdr(skb)->nexthdr;
+                        if (l4proto == IPPROTO_TCP)
+                                opcode = TX_TCPV6_PKT;
+                        else if(l4proto == IPPROTO_UDP)
+                                opcode = TX_UDPV6_PKT;
+                }
        }
        desc->tcp_hdr_offset = skb_transport_offset(skb);
        desc->ip_hdr_offset = skb_network_offset(skb);
+        netxen_set_tx_flags_opcode(desc, flags, opcode);
+        return tso;
+}
+static void
+netxen_clean_tx_dma_mapping(struct pci_dev *pdev,
+                struct netxen_cmd_buffer *pbuf, int last)
+{
+        int k;
+        struct netxen_skb_frag *buffrag;
+        buffrag = &pbuf->frag_array[0];
+        pci_unmap_single(pdev, buffrag->dma,
+                        buffrag->length, PCI_DMA_TODEVICE);
+        for (k = 1; k < last; k++) {
+                buffrag = &pbuf->frag_array[k];
+                pci_unmap_page(pdev, buffrag->dma,
+                        buffrag->length, PCI_DMA_TODEVICE);
+        }
 }
 static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
@@ -1167,33 +1235,22 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
        struct netxen_adapter *adapter = netdev_priv(netdev);
        struct netxen_hardware_context *hw = &adapter->ahw;
        unsigned int first_seg_len = skb->len - skb->data_len;
+        struct netxen_cmd_buffer *pbuf;
        struct netxen_skb_frag *buffrag;
-        unsigned int i;
+        struct cmd_desc_type0 *hwdesc;
+        struct pci_dev *pdev = adapter->pdev;
+        dma_addr_t temp_dma;
+        int i, k;
        u32 producer, consumer;
-        u32 saved_producer = 0;
+        int frag_count, no_of_desc;
-        struct cmd_desc_type0 *hwdesc;
-        int k;
-        struct netxen_cmd_buffer *pbuf = NULL;
-        int frag_count;
-        int no_of_desc;
        u32 num_txd = adapter->max_tx_desc_count;
+        bool is_tso = false;
        frag_count = skb_shinfo(skb)->nr_frags + 1;
        /* There 4 fragments per descriptor */
        no_of_desc = (frag_count + 3) >> 2;
-        if (netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) {
-                if (skb_shinfo(skb)->gso_size > 0) {
-                        no_of_desc++;
-                        if ((ip_hdrlen(skb) + tcp_hdrlen(skb) +
-                             sizeof(struct ethhdr)) >
-                            (sizeof(struct cmd_desc_type0) - 2)) {
-                                no_of_desc++;
-                        }
-                }
-        }
        producer = adapter->cmd_producer;
        smp_mb();
@@ -1205,34 +1262,26 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
        }
        /* Copy the descriptors into the hardware    */
-        saved_producer = producer;
        hwdesc = &hw->cmd_desc_head[producer];
        memset(hwdesc, 0, sizeof(struct cmd_desc_type0));
        /* Take skb->data itself */
        pbuf = &adapter->cmd_buf_arr[producer];
-        if ((netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
-                        skb_shinfo(skb)->gso_size > 0) {
+        is_tso = netxen_tso_check(netdev, hwdesc, skb);
-                pbuf->mss = skb_shinfo(skb)->gso_size;
-                hwdesc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
-        } else {
-                pbuf->mss = 0;
-                hwdesc->mss = 0;
-        }
-        pbuf->total_length = skb->len;
        pbuf->skb = skb;
-        pbuf->cmd = TX_ETHER_PKT;
        pbuf->frag_count = frag_count;
-        pbuf->port = adapter->portnum;
        buffrag = &pbuf->frag_array[0];
-        buffrag->dma = pci_map_single(adapter->pdev, skb->data, first_seg_len,
+        temp_dma = pci_map_single(pdev, skb->data, first_seg_len,
                                      PCI_DMA_TODEVICE);
+        if (pci_dma_mapping_error(pdev, temp_dma))
+                goto drop_packet;
+        buffrag->dma = temp_dma;
        buffrag->length = first_seg_len;
-        netxen_set_cmd_desc_totallength(hwdesc, skb->len);
+        netxen_set_tx_frags_len(hwdesc, frag_count, skb->len);
-        netxen_set_cmd_desc_num_of_buff(hwdesc, frag_count);
+        netxen_set_tx_port(hwdesc, adapter->portnum);
-        netxen_set_cmd_desc_opcode(hwdesc, TX_ETHER_PKT);
-        netxen_set_cmd_desc_port(hwdesc, adapter->portnum);
-        netxen_set_cmd_desc_ctxid(hwdesc, adapter->portnum);
        hwdesc->buffer1_length = cpu_to_le16(first_seg_len);
        hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
@@ -1240,7 +1289,6 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                struct skb_frag_struct *frag;
                int len, temp_len;
                unsigned long offset;
-                dma_addr_t temp_dma;
                /* move to next desc. if there is a need */
                if ((i & 0x3) == 0) {
@@ -1256,8 +1304,12 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                offset = frag->page_offset;
                temp_len = len;
-                temp_dma = pci_map_page(adapter->pdev, frag->page, offset,
+                temp_dma = pci_map_page(pdev, frag->page, offset,
                                        len, PCI_DMA_TODEVICE);
+                if (pci_dma_mapping_error(pdev, temp_dma)) {
+                        netxen_clean_tx_dma_mapping(pdev, pbuf, i);
+                        goto drop_packet;
+                }
                buffrag++;
                buffrag->dma = temp_dma;
@@ -1285,16 +1337,12 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
        }
        producer = get_next_index(producer, num_txd);
-        /* might change opcode to TX_TCP_LSO */
-        netxen_tso_check(adapter, &hw->cmd_desc_head[saved_producer], skb);
        /* For LSO, we need to copy the MAC/IP/TCP headers into
         * the descriptor ring
         */
-        if (netxen_get_cmd_desc_opcode(&hw->cmd_desc_head[saved_producer])
+        if (is_tso) {
-            == TX_TCP_LSO) {
                int hdr_len, first_hdr_len, more_hdr;
-                hdr_len = hw->cmd_desc_head[saved_producer].total_hdr_length;
+                hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
                if (hdr_len > (sizeof(struct cmd_desc_type0) - 2)) {
                        first_hdr_len = sizeof(struct cmd_desc_type0) - 2;
                        more_hdr = 1;
@@ -1336,6 +1384,11 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
        netdev->trans_start = jiffies;
        return NETDEV_TX_OK;
+drop_packet:
+        adapter->stats.txdropped++;
+        dev_kfree_skb_any(skb);
+        return NETDEV_TX_OK;
 }
 static int netxen_nic_check_temp(struct netxen_adapter *adapter)
@@ -1407,6 +1460,8 @@ static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
                        netif_carrier_off(netdev);
                        netif_stop_queue(netdev);
                }
+                netxen_nic_set_link_parameters(adapter);
        } else if (!adapter->ahw.linkup && linkup) {
                printk(KERN_INFO "%s: %s NIC Link is up\n",
                       netxen_nic_driver_name, netdev->name);
@@ -1415,6 +1470,8 @@ static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
                        netif_carrier_on(netdev);
                        netif_wake_queue(netdev);
                }
+                netxen_nic_set_link_parameters(adapter);
        }
 }
diff --git a/drivers/net/pasemi_mac.c b/drivers/net/pasemi_mac.c
index 5b7a574ce571..d0349e7d73ea 100644
--- a/drivers/net/pasemi_mac.c
+++ b/drivers/net/pasemi_mac.c
@@ -712,7 +712,7 @@ static inline void pasemi_mac_rx_error(const struct pasemi_mac *mac,
        rcmdsta = read_dma_reg(PAS_DMA_RXINT_RCMDSTA(mac->dma_if));
        ccmdsta = read_dma_reg(PAS_DMA_RXCHAN_CCMDSTA(chan->chno));
-        printk(KERN_ERR "pasemi_mac: rx error. macrx %016lx, rx status %lx\n",
+        printk(KERN_ERR "pasemi_mac: rx error. macrx %016llx, rx status %llx\n",
                macrx, *chan->status);
        printk(KERN_ERR "pasemi_mac: rcmdsta %08x ccmdsta %08x\n",
@@ -730,8 +730,8 @@ static inline void pasemi_mac_tx_error(const struct pasemi_mac *mac,
        cmdsta = read_dma_reg(PAS_DMA_TXCHAN_TCMDSTA(chan->chno));
-        printk(KERN_ERR "pasemi_mac: tx error. mactx 0x%016lx, "\
+        printk(KERN_ERR "pasemi_mac: tx error. mactx 0x%016llx, "\
-                "tx status 0x%016lx\n", mactx, *chan->status);
+                "tx status 0x%016llx\n", mactx, *chan->status);
        printk(KERN_ERR "pasemi_mac: tcmdsta 0x%08x\n", cmdsta);
 }
diff --git a/drivers/net/pcmcia/pcnet_cs.c b/drivers/net/pcmcia/pcnet_cs.c
index c38ed777f0a8..a6999403f37b 100644
--- a/drivers/net/pcmcia/pcnet_cs.c
+++ b/drivers/net/pcmcia/pcnet_cs.c
@@ -586,7 +586,7 @@ static int pcnet_config(struct pcmcia_device *link)
    }
    if ((link->conf.ConfigBase == 0x03c0)
-        && (link->manf_id == 0x149) && (link->card_id = 0xc1ab)) {
+        && (link->manf_id == 0x149) && (link->card_id == 0xc1ab)) {
        printk(KERN_INFO "pcnet_cs: this is an AX88190 card!\n");
        printk(KERN_INFO "pcnet_cs: use axnet_cs instead.\n");
        goto failed;
diff --git a/drivers/net/phy/mdio_bus.c b/drivers/net/phy/mdio_bus.c
index 11adf6ed4628..811a637695ca 100644
--- a/drivers/net/phy/mdio_bus.c
+++ b/drivers/net/phy/mdio_bus.c
@@ -296,9 +296,8 @@ static int mdio_bus_suspend(struct device * dev, pm_message_t state)
        struct phy_driver *phydrv = to_phy_driver(drv);
        struct phy_device *phydev = to_phy_device(dev);
-        if ((!device_may_wakeup(phydev->dev.parent)) &&
+        if (drv && phydrv->suspend && !device_may_wakeup(phydev->dev.parent))
-                (phydrv && phydrv->suspend))
+                ret = phydrv->suspend(phydev);
-                        ret = phydrv->suspend(phydev);
        return ret;
 }
@@ -310,8 +309,7 @@ static int mdio_bus_resume(struct device * dev)
        struct phy_driver *phydrv = to_phy_driver(drv);
        struct phy_device *phydev = to_phy_device(dev);
-        if ((!device_may_wakeup(phydev->dev.parent)) &&
+        if (drv && phydrv->resume && !device_may_wakeup(phydev->dev.parent))
-                (phydrv && phydrv->resume))
                ret = phydrv->resume(phydev);
        return ret;
diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c
index e35460165bf7..0a06e4fd37d9 100644
--- a/drivers/net/phy/phy_device.c
+++ b/drivers/net/phy/phy_device.c
@@ -231,15 +231,6 @@ struct phy_device * get_phy_device(struct mii_bus *bus, int addr)
        if ((phy_id & 0x1fffffff) == 0x1fffffff)
                return NULL;
-        /*
-         * Broken hardware is sometimes missing the pull-up resistor on the
-         * MDIO line, which results in reads to non-existent devices returning
-         * 0 rather than 0xffff. Catch this here and treat 0 as a non-existent
-         * device as well.
-         */
-        if (phy_id == 0)
-                return NULL;
        dev = phy_device_create(bus, addr, phy_id);
        return dev;
diff --git a/drivers/net/phy/smsc.c b/drivers/net/phy/smsc.c
index c05d38d46350..1387187543e4 100644
--- a/drivers/net/phy/smsc.c
+++ b/drivers/net/phy/smsc.c
@@ -81,6 +81,9 @@ static struct phy_driver lan83c185_driver = {
        .ack_interrupt  = smsc_phy_ack_interrupt,
        .config_intr    = smsc_phy_config_intr,
+        .suspend        = genphy_suspend,
+        .resume         = genphy_resume,
        .driver         = { .owner = THIS_MODULE, }
 };
@@ -102,6 +105,9 @@ static struct phy_driver lan8187_driver = {
        .ack_interrupt  = smsc_phy_ack_interrupt,
        .config_intr    = smsc_phy_config_intr,
+        .suspend        = genphy_suspend,
+        .resume         = genphy_resume,
        .driver         = { .owner = THIS_MODULE, }
 };
@@ -123,6 +129,9 @@ static struct phy_driver lan8700_driver = {
        .ack_interrupt  = smsc_phy_ack_interrupt,
        .config_intr    = smsc_phy_config_intr,
+        .suspend        = genphy_suspend,
+        .resume         = genphy_resume,
        .driver         = { .owner = THIS_MODULE, }
 };
@@ -144,6 +153,9 @@ static struct phy_driver lan911x_int_driver = {
        .ack_interrupt  = smsc_phy_ack_interrupt,
        .config_intr    = smsc_phy_config_intr,
+        .suspend        = genphy_suspend,
+        .resume         = genphy_resume,
        .driver         = { .owner = THIS_MODULE, }
 };
diff --git a/drivers/net/ppp_generic.c b/drivers/net/ppp_generic.c
index 06b448285eb5..7b2728b8f1b7 100644
--- a/drivers/net/ppp_generic.c
+++ b/drivers/net/ppp_generic.c
@@ -250,6 +250,7 @@ static int ppp_connect_channel(struct channel *pch, int unit);
 static int ppp_disconnect_channel(struct channel *pch);
 static void ppp_destroy_channel(struct channel *pch);
 static int unit_get(struct idr *p, void *ptr);
+static int unit_set(struct idr *p, void *ptr, int n);
 static void unit_put(struct idr *p, int n);
 static void *unit_find(struct idr *p, int n);
@@ -2432,11 +2433,18 @@ ppp_create_interface(int unit, int *retp)
        } else {
                if (unit_find(&ppp_units_idr, unit))
                        goto out2; /* unit already exists */
-                else {
+                /*
-                        /* darn, someone is cheating us? */
+                 * if caller need a specified unit number
-                        *retp = -EINVAL;
+                 * lets try to satisfy him, otherwise --
+                 * he should better ask us for new unit number
+                 *
+                 * NOTE: yes I know that returning EEXIST it's not
+                 * fair but at least pppd will ask us to allocate
+                 * new unit in this case so user is happy :)
+                 */
+                unit = unit_set(&ppp_units_idr, ppp, unit);
+                if (unit < 0)
                        goto out2;
-                }
        }
        /* Initialize the new ppp unit */
@@ -2677,14 +2685,37 @@ static void __exit ppp_cleanup(void)
 * by holding all_ppp_mutex
 */
+/* associate pointer with specified number */
+static int unit_set(struct idr *p, void *ptr, int n)
+{
+        int unit, err;
+again:
+        if (!idr_pre_get(p, GFP_KERNEL)) {
+                printk(KERN_ERR "PPP: No free memory for idr\n");
+                return -ENOMEM;
+        }
+        err = idr_get_new_above(p, ptr, n, &unit);
+        if (err == -EAGAIN)
+                goto again;
+        if (unit != n) {
+                idr_remove(p, unit);
+                return -EINVAL;
+        }
+        return unit;
+}
 /* get new free unit number and associate pointer with it */
 static int unit_get(struct idr *p, void *ptr)
 {
        int unit, err;
 again:
-        if (idr_pre_get(p, GFP_KERNEL) == 0) {
+        if (!idr_pre_get(p, GFP_KERNEL)) {
-                printk(KERN_ERR "Out of memory expanding drawable idr\n");
+                printk(KERN_ERR "PPP: No free memory for idr\n");
                return -ENOMEM;
        }
diff --git a/drivers/net/ps3_gelic_wireless.c b/drivers/net/ps3_gelic_wireless.c
index ec2314246682..335da4831ab3 100644
--- a/drivers/net/ps3_gelic_wireless.c
+++ b/drivers/net/ps3_gelic_wireless.c
@@ -2168,7 +2168,7 @@ static void gelic_wl_connected_event(struct gelic_wl_info *wl,
                complete(&wl->assoc_done);
                netif_carrier_on(port_to_netdev(wl_port(wl)));
        } else
-                pr_debug("%s: event %#lx under wpa\n",
+                pr_debug("%s: event %#llx under wpa\n",
                                 __func__, event);
 }
diff --git a/drivers/net/qlge/qlge.h b/drivers/net/qlge/qlge.h
index c1dadadfab18..e6fdce9206cc 100644
--- a/drivers/net/qlge/qlge.h
+++ b/drivers/net/qlge/qlge.h
@@ -787,12 +787,12 @@ struct mbox_params {
 struct flash_params {
        u8 dev_id_str[4];
-        u16 size;
+        __le16 size;
-        u16 csum;
+        __le16 csum;
-        u16 ver;
+        __le16 ver;
-        u16 sub_dev_id;
+        __le16 sub_dev_id;
        u8 mac_addr[6];
-        u16 res;
+        __le16 res;
 };
diff --git a/drivers/net/qlge/qlge_main.c b/drivers/net/qlge/qlge_main.c
index 45421c8b6010..3d1d7b6e55aa 100644
--- a/drivers/net/qlge/qlge_main.c
+++ b/drivers/net/qlge/qlge_main.c
@@ -641,7 +641,7 @@ static void ql_enable_all_completion_interrupts(struct ql_adapter *qdev)
 }
-static int ql_read_flash_word(struct ql_adapter *qdev, int offset, u32 *data)
+static int ql_read_flash_word(struct ql_adapter *qdev, int offset, __le32 *data)
 {
        int status = 0;
        /* wait for reg to come ready */
@@ -656,8 +656,11 @@ static int ql_read_flash_word(struct ql_adapter *qdev, int offset, u32 *data)
                        FLASH_ADDR, FLASH_ADDR_RDY, FLASH_ADDR_ERR);
        if (status)
                goto exit;
-        /* get the data */
+         /* This data is stored on flash as an array of
-        *data = ql_read32(qdev, FLASH_DATA);
+         * __le32.  Since ql_read32() returns cpu endian
+         * we need to swap it back.
+         */
+        *data = cpu_to_le32(ql_read32(qdev, FLASH_DATA));
 exit:
        return status;
 }
@@ -666,13 +669,20 @@ static int ql_get_flash_params(struct ql_adapter *qdev)
 {
        int i;
        int status;
-        u32 *p = (u32 *)&qdev->flash;
+        __le32 *p = (__le32 *)&qdev->flash;
+        u32 offset = 0;
+        /* Second function's parameters follow the first
+         * function's.
+         */
+        if (qdev->func)
+                offset = sizeof(qdev->flash) / sizeof(u32);
        if (ql_sem_spinlock(qdev, SEM_FLASH_MASK))
                return -ETIMEDOUT;
        for (i = 0; i < sizeof(qdev->flash) / sizeof(u32); i++, p++) {
-                status = ql_read_flash_word(qdev, i, p);
+                status = ql_read_flash_word(qdev, i+offset, p);
                if (status) {
                        QPRINTK(qdev, IFUP, ERR, "Error reading flash.\n");
                        goto exit;
@@ -3826,7 +3836,7 @@ static int qlge_suspend(struct pci_dev *pdev, pm_message_t state)
 {
        struct net_device *ndev = pci_get_drvdata(pdev);
        struct ql_adapter *qdev = netdev_priv(ndev);
-        int err;
+        int err, i;
        netif_device_detach(ndev);
@@ -3836,6 +3846,9 @@ static int qlge_suspend(struct pci_dev *pdev, pm_message_t state)
                        return err;
        }
+        for (i = qdev->rss_ring_first_cq_id; i < qdev->rx_ring_count; i++)
+                netif_napi_del(&qdev->rx_ring[i].napi);
        err = pci_save_state(pdev);
        if (err)
                return err;
diff --git a/drivers/net/r6040.c b/drivers/net/r6040.c
index 72fd9e97c190..b2dcdb5ed8bd 100644
--- a/drivers/net/r6040.c
+++ b/drivers/net/r6040.c
@@ -438,7 +438,6 @@ static void r6040_down(struct net_device *dev)
 {
        struct r6040_private *lp = netdev_priv(dev);
        void __iomem *ioaddr = lp->base;
-        struct pci_dev *pdev = lp->pdev;
        int limit = 2048;
        u16 *adrp;
        u16 cmd;
diff --git a/drivers/net/sfc/efx.c b/drivers/net/sfc/efx.c
index 7673fd92eaf5..ab0e09bf154d 100644
--- a/drivers/net/sfc/efx.c
+++ b/drivers/net/sfc/efx.c
@@ -676,9 +676,8 @@ static int efx_init_port(struct efx_nic *efx)
        rc = efx->phy_op->init(efx);
        if (rc)
                return rc;
-        efx->phy_op->reconfigure(efx);
        mutex_lock(&efx->mac_lock);
+        efx->phy_op->reconfigure(efx);
        rc = falcon_switch_mac(efx);
        mutex_unlock(&efx->mac_lock);
        if (rc)
@@ -686,7 +685,7 @@ static int efx_init_port(struct efx_nic *efx)
        efx->mac_op->reconfigure(efx);
        efx->port_initialized = true;
-        efx->stats_enabled = true;
+        efx_stats_enable(efx);
        return 0;
 fail:
@@ -735,6 +734,7 @@ static void efx_fini_port(struct efx_nic *efx)
        if (!efx->port_initialized)
                return;
+        efx_stats_disable(efx);
        efx->phy_op->fini(efx);
        efx->port_initialized = false;
@@ -1361,6 +1361,20 @@ static int efx_net_stop(struct net_device *net_dev)
        return 0;
 }
+void efx_stats_disable(struct efx_nic *efx)
+{
+        spin_lock(&efx->stats_lock);
+        ++efx->stats_disable_count;
+        spin_unlock(&efx->stats_lock);
+}
+void efx_stats_enable(struct efx_nic *efx)
+{
+        spin_lock(&efx->stats_lock);
+        --efx->stats_disable_count;
+        spin_unlock(&efx->stats_lock);
+}
 /* Context: process, dev_base_lock or RTNL held, non-blocking. */
 static struct net_device_stats *efx_net_stats(struct net_device *net_dev)
 {
@@ -1369,12 +1383,12 @@ static struct net_device_stats *efx_net_stats(struct net_device *net_dev)
        struct net_device_stats *stats = &net_dev->stats;
        /* Update stats if possible, but do not wait if another thread
-         * is updating them (or resetting the NIC); slightly stale
+         * is updating them or if MAC stats fetches are temporarily
-         * stats are acceptable.
+         * disabled; slightly stale stats are acceptable.
         */
        if (!spin_trylock(&efx->stats_lock))
                return stats;
-        if (efx->stats_enabled) {
+        if (!efx->stats_disable_count) {
                efx->mac_op->update_stats(efx);
                falcon_update_nic_stats(efx);
        }
@@ -1622,16 +1636,12 @@ static void efx_unregister_netdev(struct efx_nic *efx)
 /* Tears down the entire software state and most of the hardware state
 * before reset.  */
-void efx_reset_down(struct efx_nic *efx, struct ethtool_cmd *ecmd)
+void efx_reset_down(struct efx_nic *efx, enum reset_type method,
+                    struct ethtool_cmd *ecmd)
 {
        EFX_ASSERT_RESET_SERIALISED(efx);
-        /* The net_dev->get_stats handler is quite slow, and will fail
+        efx_stats_disable(efx);
-         * if a fetch is pending over reset. Serialise against it. */
-        spin_lock(&efx->stats_lock);
-        efx->stats_enabled = false;
-        spin_unlock(&efx->stats_lock);
        efx_stop_all(efx);
        mutex_lock(&efx->mac_lock);
        mutex_lock(&efx->spi_lock);
@@ -1639,6 +1649,8 @@ void efx_reset_down(struct efx_nic *efx, struct ethtool_cmd *ecmd)
        efx->phy_op->get_settings(efx, ecmd);
        efx_fini_channels(efx);
+        if (efx->port_initialized && method != RESET_TYPE_INVISIBLE)
+                efx->phy_op->fini(efx);
 }
 /* This function will always ensure that the locks acquired in
@@ -1646,7 +1658,8 @@ void efx_reset_down(struct efx_nic *efx, struct ethtool_cmd *ecmd)
 * that we were unable to reinitialise the hardware, and the
 * driver should be disabled. If ok is false, then the rx and tx
 * engines are not restarted, pending a RESET_DISABLE. */
-int efx_reset_up(struct efx_nic *efx, struct ethtool_cmd *ecmd, bool ok)
+int efx_reset_up(struct efx_nic *efx, enum reset_type method,
+                 struct ethtool_cmd *ecmd, bool ok)
 {
        int rc;
@@ -1658,6 +1671,15 @@ int efx_reset_up(struct efx_nic *efx, struct ethtool_cmd *ecmd, bool ok)
                ok = false;
        }
+        if (efx->port_initialized && method != RESET_TYPE_INVISIBLE) {
+                if (ok) {
+                        rc = efx->phy_op->init(efx);
+                        if (rc)
+                                ok = false;
+                } else
+                        efx->port_initialized = false;
+        }
        if (ok) {
                efx_init_channels(efx);
@@ -1670,7 +1692,7 @@ int efx_reset_up(struct efx_nic *efx, struct ethtool_cmd *ecmd, bool ok)
        if (ok) {
                efx_start_all(efx);
-                efx->stats_enabled = true;
+                efx_stats_enable(efx);
        }
        return rc;
 }
@@ -1702,7 +1724,7 @@ static int efx_reset(struct efx_nic *efx)
        EFX_INFO(efx, "resetting (%d)\n", method);
-        efx_reset_down(efx, &ecmd);
+        efx_reset_down(efx, method, &ecmd);
        rc = falcon_reset_hw(efx, method);
        if (rc) {
@@ -1721,10 +1743,10 @@ static int efx_reset(struct efx_nic *efx)
        /* Leave device stopped if necessary */
        if (method == RESET_TYPE_DISABLE) {
-                efx_reset_up(efx, &ecmd, false);
+                efx_reset_up(efx, method, &ecmd, false);
                rc = -EIO;
        } else {
-                rc = efx_reset_up(efx, &ecmd, true);
+                rc = efx_reset_up(efx, method, &ecmd, true);
        }
 out_disable:
@@ -1876,6 +1898,7 @@ static int efx_init_struct(struct efx_nic *efx, struct efx_nic_type *type,
        efx->rx_checksum_enabled = true;
        spin_lock_init(&efx->netif_stop_lock);
        spin_lock_init(&efx->stats_lock);
+        efx->stats_disable_count = 1;
        mutex_init(&efx->mac_lock);
        efx->mac_op = &efx_dummy_mac_operations;
        efx->phy_op = &efx_dummy_phy_operations;
diff --git a/drivers/net/sfc/efx.h b/drivers/net/sfc/efx.h
index 0dd7a532c78a..55d0f131b0e9 100644
--- a/drivers/net/sfc/efx.h
+++ b/drivers/net/sfc/efx.h
@@ -36,13 +36,16 @@ extern void efx_process_channel_now(struct efx_channel *channel);
 extern void efx_flush_queues(struct efx_nic *efx);
 /* Ports */
+extern void efx_stats_disable(struct efx_nic *efx);
+extern void efx_stats_enable(struct efx_nic *efx);
 extern void efx_reconfigure_port(struct efx_nic *efx);
 extern void __efx_reconfigure_port(struct efx_nic *efx);
 /* Reset handling */
-extern void efx_reset_down(struct efx_nic *efx, struct ethtool_cmd *ecmd);
+extern void efx_reset_down(struct efx_nic *efx, enum reset_type method,
-extern int efx_reset_up(struct efx_nic *efx, struct ethtool_cmd *ecmd,
+                           struct ethtool_cmd *ecmd);
-                        bool ok);
+extern int efx_reset_up(struct efx_nic *efx, enum reset_type method,
+                        struct ethtool_cmd *ecmd, bool ok);
 /* Global */
 extern void efx_schedule_reset(struct efx_nic *efx, enum reset_type type);
diff --git a/drivers/net/sfc/ethtool.c b/drivers/net/sfc/ethtool.c
index 53d259e90187..7b5924c039b3 100644
--- a/drivers/net/sfc/ethtool.c
+++ b/drivers/net/sfc/ethtool.c
@@ -219,9 +219,6 @@ int efx_ethtool_set_settings(struct net_device *net_dev,
        struct efx_nic *efx = netdev_priv(net_dev);
        int rc;
-        if (EFX_WORKAROUND_13963(efx) && !ecmd->autoneg)
-                return -EINVAL;
        /* Falcon GMAC does not support 1000Mbps HD */
        if (ecmd->speed == SPEED_1000 && ecmd->duplex != DUPLEX_FULL) {
                EFX_LOG(efx, "rejecting unsupported 1000Mbps HD"
diff --git a/drivers/net/sfc/falcon.c b/drivers/net/sfc/falcon.c
index 5b9f2d9cc4ed..d5378e60fcdd 100644
--- a/drivers/net/sfc/falcon.c
+++ b/drivers/net/sfc/falcon.c
@@ -824,10 +824,6 @@ static void falcon_handle_rx_not_ok(struct efx_rx_queue *rx_queue,
                            rx_ev_pause_frm ? " [PAUSE]" : "");
        }
 #endif
-        if (unlikely(rx_ev_eth_crc_err && EFX_WORKAROUND_10750(efx) &&
-                     efx->phy_type == PHY_TYPE_SFX7101))
-                tenxpress_crc_err(efx);
 }
 /* Handle receive events that are not in-order. */
@@ -1887,7 +1883,7 @@ static int falcon_reset_macs(struct efx_nic *efx)
        /* MAC stats will fail whilst the TX fifo is draining. Serialise
         * the drain sequence with the statistics fetch */
-        spin_lock(&efx->stats_lock);
+        efx_stats_disable(efx);
        falcon_read(efx, &reg, MAC0_CTRL_REG_KER);
        EFX_SET_OWORD_FIELD(reg, TXFIFO_DRAIN_EN_B0, 1);
@@ -1917,7 +1913,7 @@ static int falcon_reset_macs(struct efx_nic *efx)
                udelay(10);
        }
-        spin_unlock(&efx->stats_lock);
+        efx_stats_enable(efx);
        /* If we've reset the EM block and the link is up, then
         * we'll have to kick the XAUI link so the PHY can recover */
@@ -2277,6 +2273,10 @@ int falcon_switch_mac(struct efx_nic *efx)
        struct efx_mac_operations *old_mac_op = efx->mac_op;
        efx_oword_t nic_stat;
        unsigned strap_val;
+        int rc = 0;
+        /* Don't try to fetch MAC stats while we're switching MACs */
+        efx_stats_disable(efx);
        /* Internal loopbacks override the phy speed setting */
        if (efx->loopback_mode == LOOPBACK_GMAC) {
@@ -2287,16 +2287,12 @@ int falcon_switch_mac(struct efx_nic *efx)
                efx->link_fd = true;
        }
+        WARN_ON(!mutex_is_locked(&efx->mac_lock));
        efx->mac_op = (EFX_IS10G(efx) ?
                       &falcon_xmac_operations : &falcon_gmac_operations);
-        if (old_mac_op == efx->mac_op)
-                return 0;
-        WARN_ON(!mutex_is_locked(&efx->mac_lock));
-        /* Not all macs support a mac-level link state */
-        efx->mac_up = true;
+        /* Always push the NIC_STAT_REG setting even if the mac hasn't
+         * changed, because this function is run post online reset */
        falcon_read(efx, &nic_stat, NIC_STAT_REG);
        strap_val = EFX_IS10G(efx) ? 5 : 3;
        if (falcon_rev(efx) >= FALCON_REV_B0) {
@@ -2309,9 +2305,17 @@ int falcon_switch_mac(struct efx_nic *efx)
                BUG_ON(EFX_OWORD_FIELD(nic_stat, STRAP_PINS) != strap_val);
        }
+        if (old_mac_op == efx->mac_op)
+                goto out;
        EFX_LOG(efx, "selected %cMAC\n", EFX_IS10G(efx) ? 'X' : 'G');
-        return falcon_reset_macs(efx);
+        /* Not all macs support a mac-level link state */
+        efx->mac_up = true;
+        rc = falcon_reset_macs(efx);
+out:
+        efx_stats_enable(efx);
+        return rc;
 }
 /* This call is responsible for hooking in the MAC and PHY operations */
diff --git a/drivers/net/sfc/mdio_10g.c b/drivers/net/sfc/mdio_10g.c
index f6a16428113d..f9e2f95c3b48 100644
--- a/drivers/net/sfc/mdio_10g.c
+++ b/drivers/net/sfc/mdio_10g.c
@@ -15,6 +15,7 @@
 #include "net_driver.h"
 #include "mdio_10g.h"
 #include "boards.h"
+#include "workarounds.h"
 int mdio_clause45_reset_mmd(struct efx_nic *port, int mmd,
                            int spins, int spintime)
@@ -179,17 +180,12 @@ bool mdio_clause45_links_ok(struct efx_nic *efx, unsigned int mmd_mask)
                return false;
        else if (efx_phy_mode_disabled(efx->phy_mode))
                return false;
-        else if (efx->loopback_mode == LOOPBACK_PHYXS) {
+        else if (efx->loopback_mode == LOOPBACK_PHYXS)
                mmd_mask &= ~(MDIO_MMDREG_DEVS_PHYXS |
                              MDIO_MMDREG_DEVS_PCS |
                              MDIO_MMDREG_DEVS_PMAPMD |
                              MDIO_MMDREG_DEVS_AN);
-                if (!mmd_mask) {
+        else if (efx->loopback_mode == LOOPBACK_PCS)
-                        reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_PHYXS,
-                                                 MDIO_PHYXS_STATUS2);
-                        return !(reg & (1 << MDIO_PHYXS_STATUS2_RX_FAULT_LBN));
-                }
-        } else if (efx->loopback_mode == LOOPBACK_PCS)
                mmd_mask &= ~(MDIO_MMDREG_DEVS_PCS |
                              MDIO_MMDREG_DEVS_PMAPMD |
                              MDIO_MMDREG_DEVS_AN);
@@ -197,6 +193,13 @@ bool mdio_clause45_links_ok(struct efx_nic *efx, unsigned int mmd_mask)
                mmd_mask &= ~(MDIO_MMDREG_DEVS_PMAPMD |
                              MDIO_MMDREG_DEVS_AN);
+        if (!mmd_mask) {
+                /* Use presence of XGMII faults in leui of link state */
+                reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_PHYXS,
+                                         MDIO_PHYXS_STATUS2);
+                return !(reg & (1 << MDIO_PHYXS_STATUS2_RX_FAULT_LBN));
+        }
        while (mmd_mask) {
                if (mmd_mask & 1) {
                        /* Double reads because link state is latched, and a
@@ -263,7 +266,7 @@ void mdio_clause45_set_mmds_lpower(struct efx_nic *efx,
        }
 }
-static u32 mdio_clause45_get_an(struct efx_nic *efx, u16 addr, u32 xnp)
+static u32 mdio_clause45_get_an(struct efx_nic *efx, u16 addr)
 {
        int phy_id = efx->mii.phy_id;
        u32 result = 0;
@@ -278,9 +281,6 @@ static u32 mdio_clause45_get_an(struct efx_nic *efx, u16 addr, u32 xnp)
                result |= ADVERTISED_100baseT_Half;
        if (reg & ADVERTISE_100FULL)
                result |= ADVERTISED_100baseT_Full;
-        if (reg & LPA_RESV)
-                result |= xnp;
        return result;
 }
@@ -310,7 +310,7 @@ void mdio_clause45_get_settings(struct efx_nic *efx,
 */
 void mdio_clause45_get_settings_ext(struct efx_nic *efx,
                                    struct ethtool_cmd *ecmd,
-                                    u32 xnp, u32 xnp_lpa)
+                                    u32 npage_adv, u32 npage_lpa)
 {
        int phy_id = efx->mii.phy_id;
        int reg;
@@ -361,8 +361,8 @@ void mdio_clause45_get_settings_ext(struct efx_nic *efx,
                        ecmd->autoneg = AUTONEG_ENABLE;
                        ecmd->advertising |=
                                ADVERTISED_Autoneg |
-                                mdio_clause45_get_an(efx,
+                                mdio_clause45_get_an(efx, MDIO_AN_ADVERTISE) |
-                                                     MDIO_AN_ADVERTISE, xnp);
+                                npage_adv;
                } else
                        ecmd->autoneg = AUTONEG_DISABLE;
        } else
@@ -371,27 +371,30 @@ void mdio_clause45_get_settings_ext(struct efx_nic *efx,
        if (ecmd->autoneg) {
                /* If AN is complete, report best common mode,
                 * otherwise report best advertised mode. */
-                u32 common = ecmd->advertising;
+                u32 modes = 0;
                if (mdio_clause45_read(efx, phy_id, MDIO_MMD_AN,
                                       MDIO_MMDREG_STAT1) &
-                    (1 << MDIO_AN_STATUS_AN_DONE_LBN)) {
+                    (1 << MDIO_AN_STATUS_AN_DONE_LBN))
-                        common &= mdio_clause45_get_an(efx, MDIO_AN_LPA,
+                        modes = (ecmd->advertising &
-                                                       xnp_lpa);
+                                 (mdio_clause45_get_an(efx, MDIO_AN_LPA) |
-                }
+                                  npage_lpa));
-                if (common & ADVERTISED_10000baseT_Full) {
+                if (modes == 0)
+                        modes = ecmd->advertising;
+                if (modes & ADVERTISED_10000baseT_Full) {
                        ecmd->speed = SPEED_10000;
                        ecmd->duplex = DUPLEX_FULL;
-                } else if (common & (ADVERTISED_1000baseT_Full |
+                } else if (modes & (ADVERTISED_1000baseT_Full |
-                                     ADVERTISED_1000baseT_Half)) {
+                                    ADVERTISED_1000baseT_Half)) {
                        ecmd->speed = SPEED_1000;
-                        ecmd->duplex = !!(common & ADVERTISED_1000baseT_Full);
+                        ecmd->duplex = !!(modes & ADVERTISED_1000baseT_Full);
-                } else if (common & (ADVERTISED_100baseT_Full |
+                } else if (modes & (ADVERTISED_100baseT_Full |
-                                     ADVERTISED_100baseT_Half)) {
+                                    ADVERTISED_100baseT_Half)) {
                        ecmd->speed = SPEED_100;
-                        ecmd->duplex = !!(common & ADVERTISED_100baseT_Full);
+                        ecmd->duplex = !!(modes & ADVERTISED_100baseT_Full);
                } else {
                        ecmd->speed = SPEED_10;
-                        ecmd->duplex = !!(common & ADVERTISED_10baseT_Full);
+                        ecmd->duplex = !!(modes & ADVERTISED_10baseT_Full);
                }
        } else {
                /* Report forced settings */
@@ -415,7 +418,7 @@ int mdio_clause45_set_settings(struct efx_nic *efx,
        int phy_id = efx->mii.phy_id;
        struct ethtool_cmd prev;
        u32 required;
-        int ctrl1_bits, reg;
+        int reg;
        efx->phy_op->get_settings(efx, &prev);
@@ -430,99 +433,83 @@ int mdio_clause45_set_settings(struct efx_nic *efx,
        if (prev.port != PORT_TP || ecmd->port != PORT_TP)
                return -EINVAL;
-        /* Check that PHY supports these settings and work out the
+        /* Check that PHY supports these settings */
-         * basic control bits */
+        if (ecmd->autoneg) {
-        if (ecmd->duplex) {
+                required = SUPPORTED_Autoneg;
+        } else if (ecmd->duplex) {
                switch (ecmd->speed) {
-                case SPEED_10:
+                case SPEED_10:  required = SUPPORTED_10baseT_Full;  break;
-                        ctrl1_bits = BMCR_FULLDPLX;
+                case SPEED_100: required = SUPPORTED_100baseT_Full; break;
-                        required = SUPPORTED_10baseT_Full;
+                default:        return -EINVAL;
-                        break;
-                case SPEED_100:
-                        ctrl1_bits = BMCR_SPEED100 | BMCR_FULLDPLX;
-                        required = SUPPORTED_100baseT_Full;
-                        break;
-                case SPEED_1000:
-                        ctrl1_bits = BMCR_SPEED1000 | BMCR_FULLDPLX;
-                        required = SUPPORTED_1000baseT_Full;
-                        break;
-                case SPEED_10000:
-                        ctrl1_bits = (BMCR_SPEED1000 | BMCR_SPEED100 |
-                                      BMCR_FULLDPLX);
-                        required = SUPPORTED_10000baseT_Full;
-                        break;
-                default:
-                        return -EINVAL;
                }
        } else {
                switch (ecmd->speed) {
-                case SPEED_10:
+                case SPEED_10:  required = SUPPORTED_10baseT_Half;  break;
-                        ctrl1_bits = 0;
+                case SPEED_100: required = SUPPORTED_100baseT_Half; break;
-                        required = SUPPORTED_10baseT_Half;
+                default:        return -EINVAL;
-                        break;
-                case SPEED_100:
-                        ctrl1_bits = BMCR_SPEED100;
-                        required = SUPPORTED_100baseT_Half;
-                        break;
-                case SPEED_1000:
-                        ctrl1_bits = BMCR_SPEED1000;
-                        required = SUPPORTED_1000baseT_Half;
-                        break;
-                default:
-                        return -EINVAL;
                }
        }
-        if (ecmd->autoneg)
-                required |= SUPPORTED_Autoneg;
        required |= ecmd->advertising;
        if (required & ~prev.supported)
                return -EINVAL;
-        /* Set the basic control bits */
+        if (ecmd->autoneg) {
-        reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_PMAPMD,
+                bool xnp = (ecmd->advertising & ADVERTISED_10000baseT_Full
-                                 MDIO_MMDREG_CTRL1);
+                            || EFX_WORKAROUND_13204(efx));
-        reg &= ~(BMCR_SPEED1000 | BMCR_SPEED100 | BMCR_FULLDPLX | 0x003c);
-        reg |= ctrl1_bits;
+                /* Set up the base page */
-        mdio_clause45_write(efx, phy_id, MDIO_MMD_PMAPMD, MDIO_MMDREG_CTRL1,
+                reg = ADVERTISE_CSMA;
-                            reg);
+                if (ecmd->advertising & ADVERTISED_10baseT_Half)
+                        reg |= ADVERTISE_10HALF;
-        /* Set the AN registers */
+                if (ecmd->advertising & ADVERTISED_10baseT_Full)
-        if (ecmd->autoneg != prev.autoneg ||
+                        reg |= ADVERTISE_10FULL;
-            ecmd->advertising != prev.advertising) {
+                if (ecmd->advertising & ADVERTISED_100baseT_Half)
-                bool xnp = false;
+                        reg |= ADVERTISE_100HALF;
+                if (ecmd->advertising & ADVERTISED_100baseT_Full)
-                if (efx->phy_op->set_xnp_advertise)
+                        reg |= ADVERTISE_100FULL;
-                        xnp = efx->phy_op->set_xnp_advertise(efx,
+                if (xnp)
-                                                             ecmd->advertising);
+                        reg |= ADVERTISE_RESV;
+                else if (ecmd->advertising & (ADVERTISED_1000baseT_Half |
-                if (ecmd->autoneg) {
+                                              ADVERTISED_1000baseT_Full))
-                        reg = 0;
+                        reg |= ADVERTISE_NPAGE;
-                        if (ecmd->advertising & ADVERTISED_10baseT_Half)
+                reg |= efx_fc_advertise(efx->wanted_fc);
-                                reg |= ADVERTISE_10HALF;
+                mdio_clause45_write(efx, phy_id, MDIO_MMD_AN,
-                        if (ecmd->advertising & ADVERTISED_10baseT_Full)
+                                    MDIO_AN_ADVERTISE, reg);
-                                reg |= ADVERTISE_10FULL;
-                        if (ecmd->advertising & ADVERTISED_100baseT_Half)
+                /* Set up the (extended) next page if necessary */
-                                reg |= ADVERTISE_100HALF;
+                if (efx->phy_op->set_npage_adv)
-                        if (ecmd->advertising & ADVERTISED_100baseT_Full)
+                        efx->phy_op->set_npage_adv(efx, ecmd->advertising);
-                                reg |= ADVERTISE_100FULL;
-                        if (xnp)
-                                reg |= ADVERTISE_RESV;
-                        mdio_clause45_write(efx, phy_id, MDIO_MMD_AN,
-                                            MDIO_AN_ADVERTISE, reg);
-                }
+                /* Enable and restart AN */
                reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_AN,
                                         MDIO_MMDREG_CTRL1);
-                if (ecmd->autoneg)
+                reg |= BMCR_ANENABLE;
-                        reg |= BMCR_ANENABLE | BMCR_ANRESTART;
+                if (!(EFX_WORKAROUND_15195(efx) &&
-                else
+                      LOOPBACK_MASK(efx) & efx->phy_op->loopbacks))
-                        reg &= ~BMCR_ANENABLE;
+                        reg |= BMCR_ANRESTART;
                if (xnp)
                        reg |= 1 << MDIO_AN_CTRL_XNP_LBN;
                else
                        reg &= ~(1 << MDIO_AN_CTRL_XNP_LBN);
                mdio_clause45_write(efx, phy_id, MDIO_MMD_AN,
                                    MDIO_MMDREG_CTRL1, reg);
+        } else {
+                /* Disable AN */
+                mdio_clause45_set_flag(efx, phy_id, MDIO_MMD_AN,
+                                       MDIO_MMDREG_CTRL1,
+                                       __ffs(BMCR_ANENABLE), false);
+                /* Set the basic control bits */
+                reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_PMAPMD,
+                                         MDIO_MMDREG_CTRL1);
+                reg &= ~(BMCR_SPEED1000 | BMCR_SPEED100 | BMCR_FULLDPLX |
+                         0x003c);
+                if (ecmd->speed == SPEED_100)
+                        reg |= BMCR_SPEED100;
+                if (ecmd->duplex)
+                        reg |= BMCR_FULLDPLX;
+                mdio_clause45_write(efx, phy_id, MDIO_MMD_PMAPMD,
+                                    MDIO_MMDREG_CTRL1, reg);
        }
        return 0;
diff --git a/drivers/net/sfc/mdio_10g.h b/drivers/net/sfc/mdio_10g.h
index 09bf801d0569..8ba49773ce7e 100644
--- a/drivers/net/sfc/mdio_10g.h
+++ b/drivers/net/sfc/mdio_10g.h
@@ -155,7 +155,8 @@
 #define MDIO_AN_XNP                     22
 #define MDIO_AN_LPA_XNP                 25
-#define MDIO_AN_10GBT_ADVERTISE         32
+#define MDIO_AN_10GBT_CTRL              32
+#define MDIO_AN_10GBT_CTRL_ADV_10G_LBN  12
 #define MDIO_AN_10GBT_STATUS            (33)
 #define MDIO_AN_10GBT_STATUS_MS_FLT_LBN (15) /* MASTER/SLAVE config fault */
 #define MDIO_AN_10GBT_STATUS_MS_LBN     (14) /* MASTER/SLAVE config */
diff --git a/drivers/net/sfc/net_driver.h b/drivers/net/sfc/net_driver.h
index 5f255f75754e..e019ad1fb9a0 100644
--- a/drivers/net/sfc/net_driver.h
+++ b/drivers/net/sfc/net_driver.h
@@ -566,7 +566,7 @@ struct efx_mac_operations {
 * @poll: Poll for hardware state. Serialised by the mac_lock.
 * @get_settings: Get ethtool settings. Serialised by the mac_lock.
 * @set_settings: Set ethtool settings. Serialised by the mac_lock.
- * @set_xnp_advertise: Set abilities advertised in Extended Next Page
+ * @set_npage_adv: Set abilities advertised in (Extended) Next Page
 *      (only needed where AN bit is set in mmds)
 * @num_tests: Number of PHY-specific tests/results
 * @test_names: Names of the tests/results
@@ -586,7 +586,7 @@ struct efx_phy_operations {
                              struct ethtool_cmd *ecmd);
        int (*set_settings) (struct efx_nic *efx,
                             struct ethtool_cmd *ecmd);
-        bool (*set_xnp_advertise) (struct efx_nic *efx, u32);
+        void (*set_npage_adv) (struct efx_nic *efx, u32);
        u32 num_tests;
        const char *const *test_names;
        int (*run_tests) (struct efx_nic *efx, int *results, unsigned flags);
@@ -754,8 +754,7 @@ union efx_multicast_hash {
 *      &struct net_device_stats.
 * @stats_buffer: DMA buffer for statistics
 * @stats_lock: Statistics update lock. Serialises statistics fetches
- * @stats_enabled: Temporarily disable statistics fetches.
+ * @stats_disable_count: Nest count for disabling statistics fetches
- *      Serialised by @stats_lock
 * @mac_op: MAC interface
 * @mac_address: Permanent MAC address
 * @phy_type: PHY type
@@ -837,7 +836,7 @@ struct efx_nic {
        struct efx_mac_stats mac_stats;
        struct efx_buffer stats_buffer;
        spinlock_t stats_lock;
-        bool stats_enabled;
+        unsigned int stats_disable_count;
        struct efx_mac_operations *mac_op;
        unsigned char mac_address[ETH_ALEN];
diff --git a/drivers/net/sfc/phy.h b/drivers/net/sfc/phy.h
index 58c493ef81bb..07e855c148bc 100644
--- a/drivers/net/sfc/phy.h
+++ b/drivers/net/sfc/phy.h
@@ -17,7 +17,6 @@ extern struct efx_phy_operations falcon_sfx7101_phy_ops;
 extern struct efx_phy_operations falcon_sft9001_phy_ops;
 extern void tenxpress_phy_blink(struct efx_nic *efx, bool blink);
-extern void tenxpress_crc_err(struct efx_nic *efx);
 /****************************************************************************
 * Exported functions from the driver for XFP optical PHYs
diff --git a/drivers/net/sfc/selftest.c b/drivers/net/sfc/selftest.c
index dba0d64d50cd..0a598084c513 100644
--- a/drivers/net/sfc/selftest.c
+++ b/drivers/net/sfc/selftest.c
@@ -665,6 +665,7 @@ int efx_selftest(struct efx_nic *efx, struct efx_self_tests *tests,
 {
        enum efx_loopback_mode loopback_mode = efx->loopback_mode;
        int phy_mode = efx->phy_mode;
+        enum reset_type reset_method = RESET_TYPE_INVISIBLE;
        struct ethtool_cmd ecmd;
        struct efx_channel *channel;
        int rc_test = 0, rc_reset = 0, rc;
@@ -718,21 +719,21 @@ int efx_selftest(struct efx_nic *efx, struct efx_self_tests *tests,
        mutex_unlock(&efx->mac_lock);
        /* free up all consumers of SRAM (including all the queues) */
-        efx_reset_down(efx, &ecmd);
+        efx_reset_down(efx, reset_method, &ecmd);
        rc = efx_test_chip(efx, tests);
        if (rc && !rc_test)
                rc_test = rc;
        /* reset the chip to recover from the register test */
-        rc_reset = falcon_reset_hw(efx, RESET_TYPE_ALL);
+        rc_reset = falcon_reset_hw(efx, reset_method);
        /* Ensure that the phy is powered and out of loopback
         * for the bist and loopback tests */
        efx->phy_mode &= ~PHY_MODE_LOW_POWER;
        efx->loopback_mode = LOOPBACK_NONE;
-        rc = efx_reset_up(efx, &ecmd, rc_reset == 0);
+        rc = efx_reset_up(efx, reset_method, &ecmd, rc_reset == 0);
        if (rc && !rc_reset)
                rc_reset = rc;
diff --git a/drivers/net/sfc/sfe4001.c b/drivers/net/sfc/sfe4001.c
index 16b80acb9992..cb25ae5b257a 100644
--- a/drivers/net/sfc/sfe4001.c
+++ b/drivers/net/sfc/sfe4001.c
@@ -186,19 +186,22 @@ static int sfn4111t_reset(struct efx_nic *efx)
 {
        efx_oword_t reg;
-        /* GPIO pins are also used for I2C, so block that temporarily */
+        /* GPIO 3 and the GPIO register are shared with I2C, so block that */
        mutex_lock(&efx->i2c_adap.bus_lock);
+        /* Pull RST_N (GPIO 2) low then let it up again, setting the
+         * FLASH_CFG_1 strap (GPIO 3) appropriately.  Only change the
+         * output enables; the output levels should always be 0 (low)
+         * and we rely on external pull-ups. */
        falcon_read(efx, &reg, GPIO_CTL_REG_KER);
        EFX_SET_OWORD_FIELD(reg, GPIO2_OEN, true);
-        EFX_SET_OWORD_FIELD(reg, GPIO2_OUT, false);
        falcon_write(efx, &reg, GPIO_CTL_REG_KER);
        msleep(1000);
-        EFX_SET_OWORD_FIELD(reg, GPIO2_OUT, true);
+        EFX_SET_OWORD_FIELD(reg, GPIO2_OEN, false);
-        EFX_SET_OWORD_FIELD(reg, GPIO3_OEN, true);
+        EFX_SET_OWORD_FIELD(reg, GPIO3_OEN,
-        EFX_SET_OWORD_FIELD(reg, GPIO3_OUT,
+                            !!(efx->phy_mode & PHY_MODE_SPECIAL));
-                            !(efx->phy_mode & PHY_MODE_SPECIAL));
        falcon_write(efx, &reg, GPIO_CTL_REG_KER);
+        msleep(1);
        mutex_unlock(&efx->i2c_adap.bus_lock);
@@ -232,12 +235,18 @@ static ssize_t set_phy_flash_cfg(struct device *dev,
        } else if (efx->state != STATE_RUNNING || netif_running(efx->net_dev)) {
                err = -EBUSY;
        } else {
+                /* Reset the PHY, reconfigure the MAC and enable/disable
+                 * MAC stats accordingly. */
                efx->phy_mode = new_mode;
+                if (new_mode & PHY_MODE_SPECIAL)
+                        efx_stats_disable(efx);
                if (efx->board_info.type == EFX_BOARD_SFE4001)
                        err = sfe4001_poweron(efx);
                else
                        err = sfn4111t_reset(efx);
                efx_reconfigure_port(efx);
+                if (!(new_mode & PHY_MODE_SPECIAL))
+                        efx_stats_enable(efx);
        }
        rtnl_unlock();
@@ -326,6 +335,11 @@ int sfe4001_init(struct efx_nic *efx)
        efx->board_info.monitor = sfe4001_check_hw;
        efx->board_info.fini = sfe4001_fini;
+        if (efx->phy_mode & PHY_MODE_SPECIAL) {
+                /* PHY won't generate a 156.25 MHz clock and MAC stats fetch
+                 * will fail. */
+                efx_stats_disable(efx);
+        }
        rc = sfe4001_poweron(efx);
        if (rc)
                goto fail_ioexp;
@@ -372,17 +386,25 @@ static void sfn4111t_fini(struct efx_nic *efx)
        i2c_unregister_device(efx->board_info.hwmon_client);
 }
-static struct i2c_board_info sfn4111t_hwmon_info = {
+static struct i2c_board_info sfn4111t_a0_hwmon_info = {
        I2C_BOARD_INFO("max6647", 0x4e),
        .irq            = -1,
 };
+static struct i2c_board_info sfn4111t_r5_hwmon_info = {
+        I2C_BOARD_INFO("max6646", 0x4d),
+        .irq            = -1,
+};
 int sfn4111t_init(struct efx_nic *efx)
 {
        int rc;
        efx->board_info.hwmon_client =
-                i2c_new_device(&efx->i2c_adap, &sfn4111t_hwmon_info);
+                i2c_new_device(&efx->i2c_adap,
+                               (efx->board_info.minor < 5) ?
+                               &sfn4111t_a0_hwmon_info :
+                               &sfn4111t_r5_hwmon_info);
        if (!efx->board_info.hwmon_client)
                return -EIO;
@@ -394,8 +416,10 @@ int sfn4111t_init(struct efx_nic *efx)
        if (rc)
                goto fail_hwmon;
-        if (efx->phy_mode & PHY_MODE_SPECIAL)
+        if (efx->phy_mode & PHY_MODE_SPECIAL) {
+                efx_stats_disable(efx);
                sfn4111t_reset(efx);
+        }
        return 0;
diff --git a/drivers/net/sfc/tenxpress.c b/drivers/net/sfc/tenxpress.c
index 9ecb77da9545..f0efd246962c 100644
--- a/drivers/net/sfc/tenxpress.c
+++ b/drivers/net/sfc/tenxpress.c
@@ -67,6 +67,8 @@
 #define PMA_PMD_EXT_CLK312_WIDTH 1
 #define PMA_PMD_EXT_LPOWER_LBN  12
 #define PMA_PMD_EXT_LPOWER_WIDTH 1
+#define PMA_PMD_EXT_ROBUST_LBN  14
+#define PMA_PMD_EXT_ROBUST_WIDTH 1
 #define PMA_PMD_EXT_SSR_LBN     15
 #define PMA_PMD_EXT_SSR_WIDTH   1
@@ -177,35 +179,24 @@
 #define C22EXT_STATUS_LINK_LBN  2
 #define C22EXT_STATUS_LINK_WIDTH 1
-#define C22EXT_MSTSLV_REG       49162
+#define C22EXT_MSTSLV_CTRL                      49161
-#define C22EXT_MSTSLV_1000_HD_LBN 10
+#define C22EXT_MSTSLV_CTRL_ADV_1000_HD_LBN      8
-#define C22EXT_MSTSLV_1000_HD_WIDTH 1
+#define C22EXT_MSTSLV_CTRL_ADV_1000_FD_LBN      9
-#define C22EXT_MSTSLV_1000_FD_LBN 11
-#define C22EXT_MSTSLV_1000_FD_WIDTH 1
+#define C22EXT_MSTSLV_STATUS                    49162
+#define C22EXT_MSTSLV_STATUS_LP_1000_HD_LBN     10
+#define C22EXT_MSTSLV_STATUS_LP_1000_FD_LBN     11
 /* Time to wait between powering down the LNPGA and turning off the power
 * rails */
 #define LNPGA_PDOWN_WAIT        (HZ / 5)
-static int crc_error_reset_threshold = 100;
-module_param(crc_error_reset_threshold, int, 0644);
-MODULE_PARM_DESC(crc_error_reset_threshold,
-                 "Max number of CRC errors before XAUI reset");
 struct tenxpress_phy_data {
        enum efx_loopback_mode loopback_mode;
-        atomic_t bad_crc_count;
        enum efx_phy_mode phy_mode;
        int bad_lp_tries;
 };
-void tenxpress_crc_err(struct efx_nic *efx)
-{
-        struct tenxpress_phy_data *phy_data = efx->phy_data;
-        if (phy_data != NULL)
-                atomic_inc(&phy_data->bad_crc_count);
-}
 static ssize_t show_phy_short_reach(struct device *dev,
                                    struct device_attribute *attr, char *buf)
 {
@@ -284,7 +275,9 @@ static int tenxpress_init(struct efx_nic *efx)
                                         PMA_PMD_XCONTROL_REG);
                reg |= ((1 << PMA_PMD_EXT_GMII_EN_LBN) |
                        (1 << PMA_PMD_EXT_CLK_OUT_LBN) |
-                        (1 << PMA_PMD_EXT_CLK312_LBN));
+                        (1 << PMA_PMD_EXT_CLK312_LBN) |
+                        (1 << PMA_PMD_EXT_ROBUST_LBN));
                mdio_clause45_write(efx, phy_id, MDIO_MMD_PMAPMD,
                                    PMA_PMD_XCONTROL_REG, reg);
                mdio_clause45_set_flag(efx, phy_id, MDIO_MMD_C22EXT,
@@ -346,6 +339,7 @@ static int tenxpress_phy_init(struct efx_nic *efx)
        rc = tenxpress_init(efx);
        if (rc < 0)
                goto fail;
+        mdio_clause45_set_pause(efx);
        if (efx->phy_type == PHY_TYPE_SFT9001B) {
                rc = device_create_file(&efx->pci_dev->dev,
@@ -376,8 +370,8 @@ static int tenxpress_special_reset(struct efx_nic *efx)
        /* The XGMAC clock is driven from the SFC7101/SFT9001 312MHz clock, so
         * a special software reset can glitch the XGMAC sufficiently for stats
-         * requests to fail. Since we don't often special_reset, just lock. */
+         * requests to fail. */
-        spin_lock(&efx->stats_lock);
+        efx_stats_disable(efx);
        /* Initiate reset */
        reg = mdio_clause45_read(efx, efx->mii.phy_id,
@@ -392,17 +386,17 @@ static int tenxpress_special_reset(struct efx_nic *efx)
        rc = mdio_clause45_wait_reset_mmds(efx,
                                           TENXPRESS_REQUIRED_DEVS);
        if (rc < 0)
-                goto unlock;
+                goto out;
        /* Try and reconfigure the device */
        rc = tenxpress_init(efx);
        if (rc < 0)
-                goto unlock;
+                goto out;
        /* Wait for the XGXS state machine to churn */
        mdelay(10);
-unlock:
+out:
-        spin_unlock(&efx->stats_lock);
+        efx_stats_enable(efx);
        return rc;
 }
@@ -520,7 +514,7 @@ static void tenxpress_phy_reconfigure(struct efx_nic *efx)
 {
        struct tenxpress_phy_data *phy_data = efx->phy_data;
        struct ethtool_cmd ecmd;
-        bool phy_mode_change, loop_reset, loop_toggle, loopback;
+        bool phy_mode_change, loop_reset;
        if (efx->phy_mode & (PHY_MODE_OFF | PHY_MODE_SPECIAL)) {
                phy_data->phy_mode = efx->phy_mode;
@@ -531,12 +525,10 @@ static void tenxpress_phy_reconfigure(struct efx_nic *efx)
        phy_mode_change = (efx->phy_mode == PHY_MODE_NORMAL &&
                           phy_data->phy_mode != PHY_MODE_NORMAL);
-        loopback = LOOPBACK_MASK(efx) & efx->phy_op->loopbacks;
-        loop_toggle = LOOPBACK_CHANGED(phy_data, efx, efx->phy_op->loopbacks);
        loop_reset = (LOOPBACK_OUT_OF(phy_data, efx, efx->phy_op->loopbacks) ||
                      LOOPBACK_CHANGED(phy_data, efx, 1 << LOOPBACK_GPHY));
-        if (loop_reset || loop_toggle || loopback || phy_mode_change) {
+        if (loop_reset || phy_mode_change) {
                int rc;
                efx->phy_op->get_settings(efx, &ecmd);
@@ -551,20 +543,6 @@ static void tenxpress_phy_reconfigure(struct efx_nic *efx)
                                falcon_reset_xaui(efx);
                }
-                if (efx->phy_type != PHY_TYPE_SFX7101) {
-                        /* Only change autoneg once, on coming out or
-                         * going into loopback */
-                        if (loop_toggle)
-                                ecmd.autoneg = !loopback;
-                        if (loopback) {
-                                ecmd.duplex = DUPLEX_FULL;
-                                if (efx->loopback_mode == LOOPBACK_GPHY)
-                                        ecmd.speed = SPEED_1000;
-                                else
-                                        ecmd.speed = SPEED_10000;
-                        }
-                }
                rc = efx->phy_op->set_settings(efx, &ecmd);
                WARN_ON(rc);
        }
@@ -623,13 +601,6 @@ static void tenxpress_phy_poll(struct efx_nic *efx)
        if (phy_data->phy_mode != PHY_MODE_NORMAL)
                return;
-        if (EFX_WORKAROUND_10750(efx) &&
-            atomic_read(&phy_data->bad_crc_count) > crc_error_reset_threshold) {
-                EFX_ERR(efx, "Resetting XAUI due to too many CRC errors\n");
-                falcon_reset_xaui(efx);
-                atomic_set(&phy_data->bad_crc_count, 0);
-        }
 }
 static void tenxpress_phy_fini(struct efx_nic *efx)
@@ -772,107 +743,76 @@ reset:
        return rc;
 }
-static u32 tenxpress_get_xnp_lpa(struct efx_nic *efx)
+static void
+tenxpress_get_settings(struct efx_nic *efx, struct ethtool_cmd *ecmd)
 {
-        int phy = efx->mii.phy_id;
+        int phy_id = efx->mii.phy_id;
-        u32 lpa = 0;
+        u32 adv = 0, lpa = 0;
        int reg;
        if (efx->phy_type != PHY_TYPE_SFX7101) {
-                reg = mdio_clause45_read(efx, phy, MDIO_MMD_C22EXT,
+                reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_C22EXT,
-                                         C22EXT_MSTSLV_REG);
+                                         C22EXT_MSTSLV_CTRL);
-                if (reg & (1 << C22EXT_MSTSLV_1000_HD_LBN))
+                if (reg & (1 << C22EXT_MSTSLV_CTRL_ADV_1000_FD_LBN))
+                        adv |= ADVERTISED_1000baseT_Full;
+                reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_C22EXT,
+                                         C22EXT_MSTSLV_STATUS);
+                if (reg & (1 << C22EXT_MSTSLV_STATUS_LP_1000_HD_LBN))
                        lpa |= ADVERTISED_1000baseT_Half;
-                if (reg & (1 << C22EXT_MSTSLV_1000_FD_LBN))
+                if (reg & (1 << C22EXT_MSTSLV_STATUS_LP_1000_FD_LBN))
                        lpa |= ADVERTISED_1000baseT_Full;
        }
-        reg = mdio_clause45_read(efx, phy, MDIO_MMD_AN, MDIO_AN_10GBT_STATUS);
+        reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_AN,
+                                 MDIO_AN_10GBT_CTRL);
+        if (reg & (1 << MDIO_AN_10GBT_CTRL_ADV_10G_LBN))
+                adv |= ADVERTISED_10000baseT_Full;
+        reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_AN,
+                                 MDIO_AN_10GBT_STATUS);
        if (reg & (1 << MDIO_AN_10GBT_STATUS_LP_10G_LBN))
                lpa |= ADVERTISED_10000baseT_Full;
-        return lpa;
-}
-static void sfx7101_get_settings(struct efx_nic *efx, struct ethtool_cmd *ecmd)
+        mdio_clause45_get_settings_ext(efx, ecmd, adv, lpa);
-{
-        mdio_clause45_get_settings_ext(efx, ecmd, ADVERTISED_10000baseT_Full,
+        if (efx->phy_type != PHY_TYPE_SFX7101)
-                                       tenxpress_get_xnp_lpa(efx));
+                ecmd->supported |= (SUPPORTED_100baseT_Full |
-        ecmd->supported |= SUPPORTED_10000baseT_Full;
+                                    SUPPORTED_1000baseT_Full);
-        ecmd->advertising |= ADVERTISED_10000baseT_Full;
+        /* In loopback, the PHY automatically brings up the correct interface,
+         * but doesn't advertise the correct speed. So override it */
+        if (efx->loopback_mode == LOOPBACK_GPHY)
+                ecmd->speed = SPEED_1000;
+        else if (LOOPBACK_MASK(efx) & efx->phy_op->loopbacks)
+                ecmd->speed = SPEED_10000;
 }
-static void sft9001_get_settings(struct efx_nic *efx, struct ethtool_cmd *ecmd)
+static int tenxpress_set_settings(struct efx_nic *efx, struct ethtool_cmd *ecmd)
 {
-        int phy_id = efx->mii.phy_id;
+        if (!ecmd->autoneg)
-        u32 xnp_adv = 0;
+                return -EINVAL;
-        int reg;
-        reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_PMAPMD,
-                                 PMA_PMD_SPEED_ENABLE_REG);
-        if (EFX_WORKAROUND_13204(efx) && (reg & (1 << PMA_PMD_100TX_ADV_LBN)))
-                xnp_adv |= ADVERTISED_100baseT_Full;
-        if (reg & (1 << PMA_PMD_1000T_ADV_LBN))
-                xnp_adv |= ADVERTISED_1000baseT_Full;
-        if (reg & (1 << PMA_PMD_10000T_ADV_LBN))
-                xnp_adv |= ADVERTISED_10000baseT_Full;
-        mdio_clause45_get_settings_ext(efx, ecmd, xnp_adv,
-                                       tenxpress_get_xnp_lpa(efx));
-        ecmd->supported |= (SUPPORTED_100baseT_Half |
-                            SUPPORTED_100baseT_Full |
-                            SUPPORTED_1000baseT_Full);
-        /* Use the vendor defined C22ext register for duplex settings */
+        return mdio_clause45_set_settings(efx, ecmd);
-        if (ecmd->speed != SPEED_10000 && !ecmd->autoneg) {
-                reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_C22EXT,
-                                         GPHY_XCONTROL_REG);
-                ecmd->duplex = (reg & (1 << GPHY_DUPLEX_LBN) ?
-                                DUPLEX_FULL : DUPLEX_HALF);
-        }
 }
-static int sft9001_set_settings(struct efx_nic *efx, struct ethtool_cmd *ecmd)
+static void sfx7101_set_npage_adv(struct efx_nic *efx, u32 advertising)
 {
-        int phy_id = efx->mii.phy_id;
+        mdio_clause45_set_flag(efx, efx->mii.phy_id, MDIO_MMD_AN,
-        int rc;
+                               MDIO_AN_10GBT_CTRL,
+                               MDIO_AN_10GBT_CTRL_ADV_10G_LBN,
-        rc = mdio_clause45_set_settings(efx, ecmd);
+                               advertising & ADVERTISED_10000baseT_Full);
-        if (rc)
-                return rc;
-        if (ecmd->speed != SPEED_10000 && !ecmd->autoneg)
-                mdio_clause45_set_flag(efx, phy_id, MDIO_MMD_C22EXT,
-                                       GPHY_XCONTROL_REG, GPHY_DUPLEX_LBN,
-                                       ecmd->duplex == DUPLEX_FULL);
-        return rc;
 }
-static bool sft9001_set_xnp_advertise(struct efx_nic *efx, u32 advertising)
+static void sft9001_set_npage_adv(struct efx_nic *efx, u32 advertising)
 {
-        int phy = efx->mii.phy_id;
+        int phy_id = efx->mii.phy_id;
-        int reg = mdio_clause45_read(efx, phy, MDIO_MMD_PMAPMD,
-                                     PMA_PMD_SPEED_ENABLE_REG);
+        mdio_clause45_set_flag(efx, phy_id, MDIO_MMD_C22EXT,
-        bool enabled;
+                               C22EXT_MSTSLV_CTRL,
+                               C22EXT_MSTSLV_CTRL_ADV_1000_FD_LBN,
-        reg &= ~((1 << 2) | (1 << 3));
+                               advertising & ADVERTISED_1000baseT_Full);
-        if (EFX_WORKAROUND_13204(efx) &&
+        mdio_clause45_set_flag(efx, phy_id, MDIO_MMD_AN,
-            (advertising & ADVERTISED_100baseT_Full))
+                               MDIO_AN_10GBT_CTRL,
-                reg |= 1 << PMA_PMD_100TX_ADV_LBN;
+                               MDIO_AN_10GBT_CTRL_ADV_10G_LBN,
-        if (advertising & ADVERTISED_1000baseT_Full)
+                               advertising & ADVERTISED_10000baseT_Full);
-                reg |= 1 << PMA_PMD_1000T_ADV_LBN;
-        if (advertising & ADVERTISED_10000baseT_Full)
-                reg |= 1 << PMA_PMD_10000T_ADV_LBN;
-        mdio_clause45_write(efx, phy, MDIO_MMD_PMAPMD,
-                            PMA_PMD_SPEED_ENABLE_REG, reg);
-        enabled = (advertising &
-                   (ADVERTISED_1000baseT_Half |
-                    ADVERTISED_1000baseT_Full |
-                    ADVERTISED_10000baseT_Full));
-        if (EFX_WORKAROUND_13204(efx))
-                enabled |= (advertising & ADVERTISED_100baseT_Full);
-        return enabled;
 }
 struct efx_phy_operations falcon_sfx7101_phy_ops = {
@@ -882,8 +822,9 @@ struct efx_phy_operations falcon_sfx7101_phy_ops = {
        .poll             = tenxpress_phy_poll,
        .fini             = tenxpress_phy_fini,
        .clear_interrupt  = efx_port_dummy_op_void,
-        .get_settings     = sfx7101_get_settings,
+        .get_settings     = tenxpress_get_settings,
-        .set_settings     = mdio_clause45_set_settings,
+        .set_settings     = tenxpress_set_settings,
+        .set_npage_adv    = sfx7101_set_npage_adv,
        .num_tests        = ARRAY_SIZE(sfx7101_test_names),
        .test_names       = sfx7101_test_names,
        .run_tests        = sfx7101_run_tests,
@@ -898,9 +839,9 @@ struct efx_phy_operations falcon_sft9001_phy_ops = {
        .poll             = tenxpress_phy_poll,
        .fini             = tenxpress_phy_fini,
        .clear_interrupt  = efx_port_dummy_op_void,
-        .get_settings     = sft9001_get_settings,
+        .get_settings     = tenxpress_get_settings,
-        .set_settings     = sft9001_set_settings,
+        .set_settings     = tenxpress_set_settings,
-        .set_xnp_advertise = sft9001_set_xnp_advertise,
+        .set_npage_adv    = sft9001_set_npage_adv,
        .num_tests        = ARRAY_SIZE(sft9001_test_names),
        .test_names       = sft9001_test_names,
        .run_tests        = sft9001_run_tests,
diff --git a/drivers/net/sfc/workarounds.h b/drivers/net/sfc/workarounds.h
index 82e03e1d7371..78de68f4a95b 100644
--- a/drivers/net/sfc/workarounds.h
+++ b/drivers/net/sfc/workarounds.h
@@ -18,8 +18,8 @@
 #define EFX_WORKAROUND_ALWAYS(efx) 1
 #define EFX_WORKAROUND_FALCON_A(efx) (falcon_rev(efx) <= FALCON_REV_A1)
 #define EFX_WORKAROUND_10G(efx) EFX_IS10G(efx)
-#define EFX_WORKAROUND_SFX7101(efx) ((efx)->phy_type == PHY_TYPE_SFX7101)
+#define EFX_WORKAROUND_SFT9001(efx) ((efx)->phy_type == PHY_TYPE_SFT9001A || \
-#define EFX_WORKAROUND_SFT9001A(efx) ((efx)->phy_type == PHY_TYPE_SFT9001A)
+                                     (efx)->phy_type == PHY_TYPE_SFT9001B)
 /* XAUI resets if link not detected */
 #define EFX_WORKAROUND_5147 EFX_WORKAROUND_ALWAYS
@@ -29,8 +29,6 @@
 #define EFX_WORKAROUND_7884 EFX_WORKAROUND_10G
 /* TX pkt parser problem with <= 16 byte TXes */
 #define EFX_WORKAROUND_9141 EFX_WORKAROUND_ALWAYS
-/* Low rate CRC errors require XAUI reset */
-#define EFX_WORKAROUND_10750 EFX_WORKAROUND_SFX7101
 /* TX_EV_PKT_ERR can be caused by a dangling TX descriptor
 * or a PCIe error (bug 11028) */
 #define EFX_WORKAROUND_10727 EFX_WORKAROUND_ALWAYS
@@ -55,8 +53,8 @@
 #define EFX_WORKAROUND_8071 EFX_WORKAROUND_FALCON_A
 /* Need to send XNP pages for 100BaseT */
-#define EFX_WORKAROUND_13204 EFX_WORKAROUND_SFT9001A
+#define EFX_WORKAROUND_13204 EFX_WORKAROUND_SFT9001
-/* Need to keep AN enabled */
+/* Don't restart AN in near-side loopback */
-#define EFX_WORKAROUND_13963 EFX_WORKAROUND_SFT9001A
+#define EFX_WORKAROUND_15195 EFX_WORKAROUND_SFT9001
 #endif /* EFX_WORKAROUNDS_H */
diff --git a/drivers/net/sis900.c b/drivers/net/sis900.c
index 6cbefcae9ac2..be4465bc0a69 100644
--- a/drivers/net/sis900.c
+++ b/drivers/net/sis900.c
@@ -509,10 +509,10 @@ static int __devinit sis900_probe(struct pci_dev *pci_dev,
        else
                ret = sis900_get_mac_addr(pci_dev, net_dev);
-        if (ret == 0) {
+        if (!ret || !is_valid_ether_addr(net_dev->dev_addr)) {
-                printk(KERN_WARNING "%s: Cannot read MAC address.\n", dev_name);
+                random_ether_addr(net_dev->dev_addr);
-                ret = -ENODEV;
+                printk(KERN_WARNING "%s: Unreadable or invalid MAC address,"
-                goto err_unmap_rx;
+                                "using random generated one\n", dev_name);
        }
        /* 630ET : set the mii access mode as software-mode */
diff --git a/drivers/net/skfp/skfddi.c b/drivers/net/skfp/skfddi.c
index 607efeaf0bc5..9a00e5566af7 100644
--- a/drivers/net/skfp/skfddi.c
+++ b/drivers/net/skfp/skfddi.c
@@ -1003,9 +1003,9 @@ static int skfp_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
                break;
        case SKFP_CLR_STATS:    /* Zero out the driver statistics */
                if (!capable(CAP_NET_ADMIN)) {
-                        memset(&lp->MacStat, 0, sizeof(lp->MacStat));
-                } else {
                        status = -EPERM;
+                } else {
+                        memset(&lp->MacStat, 0, sizeof(lp->MacStat));
                }
                break;
        default:
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index 3668e81e474d..994703cc0db3 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -1403,9 +1403,6 @@ static int sky2_up(struct net_device *dev)
        }
-        if (netif_msg_ifup(sky2))
-                printk(KERN_INFO PFX "%s: enabling interface\n", dev->name);
        netif_carrier_off(dev);
        /* must be power of 2 */
@@ -1484,6 +1481,9 @@ static int sky2_up(struct net_device *dev)
        sky2_write32(hw, B0_IMSK, imask);
        sky2_set_multicast(dev);
+        if (netif_msg_ifup(sky2))
+                printk(KERN_INFO PFX "%s: enabling interface\n", dev->name);
        return 0;
 err_out:
diff --git a/drivers/net/smc911x.c b/drivers/net/smc911x.c
index bf3aa2a1effe..223cde0d43be 100644
--- a/drivers/net/smc911x.c
+++ b/drivers/net/smc911x.c
@@ -220,9 +220,9 @@ static void smc911x_reset(struct net_device *dev)
        /* make sure EEPROM has finished loading before setting GPIO_CFG */
        timeout=1000;
-        while ( timeout-- && (SMC_GET_E2P_CMD(lp) & E2P_CMD_EPC_BUSY_)) {
+        while (--timeout && (SMC_GET_E2P_CMD(lp) & E2P_CMD_EPC_BUSY_))
                udelay(10);
-        }
        if (timeout == 0){
                PRINTK("%s: smc911x_reset timeout waiting for EEPROM busy\n", dev->name);
                return;
diff --git a/drivers/net/smsc911x.c b/drivers/net/smsc911x.c
index f513bdf1c887..783c1a7b869e 100644
--- a/drivers/net/smsc911x.c
+++ b/drivers/net/smsc911x.c
@@ -953,7 +953,7 @@ smsc911x_rx_fastforward(struct smsc911x_data *pdata, unsigned int pktbytes)
                do {
                        udelay(1);
                        val = smsc911x_reg_read(pdata, RX_DP_CTRL);
-                } while (timeout-- && (val & RX_DP_CTRL_RX_FFWD_));
+                } while (--timeout && (val & RX_DP_CTRL_RX_FFWD_));
                if (unlikely(timeout == 0))
                        SMSC_WARNING(HW, "Timed out waiting for "
diff --git a/drivers/net/smsc9420.c b/drivers/net/smsc9420.c
index c14a4c6452c7..a1e4b3895b33 100644
--- a/drivers/net/smsc9420.c
+++ b/drivers/net/smsc9420.c
@@ -498,7 +498,7 @@ static void smsc9420_check_mac_address(struct net_device *dev)
 static void smsc9420_stop_tx(struct smsc9420_pdata *pd)
 {
        u32 dmac_control, mac_cr, dma_intr_ena;
-        int timeOut = 1000;
+        int timeout = 1000;
        /* disable TX DMAC */
        dmac_control = smsc9420_reg_read(pd, DMAC_CONTROL);
@@ -506,13 +506,13 @@ static void smsc9420_stop_tx(struct smsc9420_pdata *pd)
        smsc9420_reg_write(pd, DMAC_CONTROL, dmac_control);
        /* Wait max 10ms for transmit process to stop */
-        while (timeOut--) {
+        while (--timeout) {
                if (smsc9420_reg_read(pd, DMAC_STATUS) & DMAC_STS_TS_)
                        break;
                udelay(10);
        }
-        if (!timeOut)
+        if (!timeout)
                smsc_warn(IFDOWN, "TX DMAC failed to stop");
        /* ACK Tx DMAC stop bit */
@@ -596,7 +596,7 @@ static void smsc9420_free_rx_ring(struct smsc9420_pdata *pd)
 static void smsc9420_stop_rx(struct smsc9420_pdata *pd)
 {
-        int timeOut = 1000;
+        int timeout = 1000;
        u32 mac_cr, dmac_control, dma_intr_ena;
        /* mask RX DMAC interrupts */
@@ -617,13 +617,13 @@ static void smsc9420_stop_rx(struct smsc9420_pdata *pd)
        smsc9420_pci_flush_write(pd);
        /* wait up to 10ms for receive to stop */
-        while (timeOut--) {
+        while (--timeout) {
                if (smsc9420_reg_read(pd, DMAC_STATUS) & DMAC_STS_RS_)
                        break;
                udelay(10);
        }
-        if (!timeOut)
+        if (!timeout)
                smsc_warn(IFDOWN, "RX DMAC did not stop! timeout.");
        /* ACK the Rx DMAC stop bit */
@@ -1378,6 +1378,7 @@ static int smsc9420_open(struct net_device *dev)
        /* test the IRQ connection to the ISR */
        smsc_dbg(IFUP, "Testing ISR using IRQ %d", dev->irq);
+        pd->software_irq_signal = false;
        spin_lock_irqsave(&pd->int_lock, flags);
        /* configure interrupt deassertion timer and enable interrupts */
@@ -1393,8 +1394,6 @@ static int smsc9420_open(struct net_device *dev)
        smsc9420_pci_flush_write(pd);
        timeout = 1000;
-        pd->software_irq_signal = false;
-        smp_wmb();
        while (timeout--) {
                if (pd->software_irq_signal)
                        break;
diff --git a/drivers/net/sungem.c b/drivers/net/sungem.c
index 86c765d83de1..b17efa9cc530 100644
--- a/drivers/net/sungem.c
+++ b/drivers/net/sungem.c
@@ -148,7 +148,7 @@ static u16 __phy_read(struct gem *gp, int phy_addr, int reg)
        cmd |= (MIF_FRAME_TAMSB);
        writel(cmd, gp->regs + MIF_FRAME);
-        while (limit--) {
+        while (--limit) {
                cmd = readl(gp->regs + MIF_FRAME);
                if (cmd & MIF_FRAME_TALSB)
                        break;
diff --git a/drivers/net/sungem_phy.c b/drivers/net/sungem_phy.c
index 61843fd57525..78f8cee5fd74 100644
--- a/drivers/net/sungem_phy.c
+++ b/drivers/net/sungem_phy.c
@@ -79,7 +79,7 @@ static int reset_one_mii_phy(struct mii_phy* phy, int phy_id)
        udelay(100);
-        while (limit--) {
+        while (--limit) {
                val = __phy_read(phy, phy_id, MII_BMCR);
                if ((val & BMCR_RESET) == 0)
                        break;
diff --git a/drivers/net/sunqe.c b/drivers/net/sunqe.c
index 6e8f377355fe..fe0c3f244562 100644
--- a/drivers/net/sunqe.c
+++ b/drivers/net/sunqe.c
@@ -227,7 +227,7 @@ static int qe_init(struct sunqe *qep, int from_irq)
        if (!(sbus_readb(mregs + MREGS_PHYCONFIG) & MREGS_PHYCONFIG_LTESTDIS)) {
                int tries = 50;
-                while (tries--) {
+                while (--tries) {
                        u8 tmp;
                        mdelay(5);
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index 5e2dbaee125b..8b3f84685387 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -7535,11 +7535,58 @@ static int tg3_test_msi(struct tg3 *tp)
        return err;
 }
+static int tg3_request_firmware(struct tg3 *tp)
+{
+        const __be32 *fw_data;
+        if (request_firmware(&tp->fw, tp->fw_needed, &tp->pdev->dev)) {
+                printk(KERN_ERR "%s: Failed to load firmware \"%s\"\n",
+                       tp->dev->name, tp->fw_needed);
+                return -ENOENT;
+        }
+        fw_data = (void *)tp->fw->data;
+        /* Firmware blob starts with version numbers, followed by
+         * start address and _full_ length including BSS sections
+         * (which must be longer than the actual data, of course
+         */
+        tp->fw_len = be32_to_cpu(fw_data[2]);   /* includes bss */
+        if (tp->fw_len < (tp->fw->size - 12)) {
+                printk(KERN_ERR "%s: bogus length %d in \"%s\"\n",
+                       tp->dev->name, tp->fw_len, tp->fw_needed);
+                release_firmware(tp->fw);
+                tp->fw = NULL;
+                return -EINVAL;
+        }
+        /* We no longer need firmware; we have it. */
+        tp->fw_needed = NULL;
+        return 0;
+}
 static int tg3_open(struct net_device *dev)
 {
        struct tg3 *tp = netdev_priv(dev);
        int err;
+        if (tp->fw_needed) {
+                err = tg3_request_firmware(tp);
+                if (tp->pci_chip_rev_id == CHIPREV_ID_5701_A0) {
+                        if (err)
+                                return err;
+                } else if (err) {
+                        printk(KERN_WARNING "%s: TSO capability disabled.\n",
+                               tp->dev->name);
+                        tp->tg3_flags2 &= ~TG3_FLG2_TSO_CAPABLE;
+                } else if (!(tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE)) {
+                        printk(KERN_NOTICE "%s: TSO capability restored.\n",
+                               tp->dev->name);
+                        tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE;
+                }
+        }
        netif_carrier_off(tp->dev);
        err = tg3_set_power_state(tp, PCI_D0);
@@ -12934,7 +12981,6 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
        struct net_device *dev;
        struct tg3 *tp;
        int err, pm_cap;
-        const char *fw_name = NULL;
        char str[40];
        u64 dma_mask, persist_dma_mask;
@@ -13091,7 +13137,7 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
        tg3_init_bufmgr_config(tp);
        if (tp->pci_chip_rev_id == CHIPREV_ID_5701_A0)
-                fw_name = FIRMWARE_TG3;
+                tp->fw_needed = FIRMWARE_TG3;
        if (tp->tg3_flags2 & TG3_FLG2_HW_TSO) {
                tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE;
@@ -13104,37 +13150,10 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
                tp->tg3_flags2 &= ~TG3_FLG2_TSO_CAPABLE;
        } else {
                tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE | TG3_FLG2_TSO_BUG;
-        }
-        if (tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE) {
                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705)
-                        fw_name = FIRMWARE_TG3TSO5;
+                        tp->fw_needed = FIRMWARE_TG3TSO5;
                else
-                        fw_name = FIRMWARE_TG3TSO;
+                        tp->fw_needed = FIRMWARE_TG3TSO;
-        }
-        if (fw_name) {
-                const __be32 *fw_data;
-                err = request_firmware(&tp->fw, fw_name, &tp->pdev->dev);
-                if (err) {
-                        printk(KERN_ERR "tg3: Failed to load firmware \"%s\"\n",
-                               fw_name);
-                        goto err_out_iounmap;
-                }
-                fw_data = (void *)tp->fw->data;
-                /* Firmware blob starts with version numbers, followed by
-                   start address and _full_ length including BSS sections
-                   (which must be longer than the actual data, of course */
-                tp->fw_len = be32_to_cpu(fw_data[2]);   /* includes bss */
-                if (tp->fw_len < (tp->fw->size - 12)) {
-                        printk(KERN_ERR "tg3: bogus length %d in \"%s\"\n",
-                               tp->fw_len, fw_name);
-                        err = -EINVAL;
-                        goto err_out_fw;
-                }
        }
        /* TSO is on by default on chips that support hardware TSO.
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index ae5da603c6af..508def3e077f 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -2764,6 +2764,7 @@ struct tg3 {
        struct ethtool_coalesce         coal;
        /* firmware info */
+        const char                      *fw_needed;
        const struct firmware           *fw;
        u32                             fw_len; /* includes BSS */
 };
diff --git a/drivers/net/tsi108_eth.c b/drivers/net/tsi108_eth.c
index 75461dbd4876..a9fd2b2ccaf6 100644
--- a/drivers/net/tsi108_eth.c
+++ b/drivers/net/tsi108_eth.c
@@ -1237,7 +1237,7 @@ static void tsi108_init_phy(struct net_device *dev)
        spin_lock_irqsave(&phy_lock, flags);
        tsi108_write_mii(data, MII_BMCR, BMCR_RESET);
-        while (i--){
+        while (--i) {
                if(!(tsi108_read_mii(data, MII_BMCR) & BMCR_RESET))
                        break;
                udelay(10);
diff --git a/drivers/net/tulip/21142.c b/drivers/net/tulip/21142.c
index 1210fb3748a7..db7d5e11855d 100644
--- a/drivers/net/tulip/21142.c
+++ b/drivers/net/tulip/21142.c
@@ -9,6 +9,11 @@
        Please refer to Documentation/DocBook/tulip-user.{pdf,ps,html}
        for more information on this driver.
+        DC21143 manual "21143 PCI/CardBus 10/100Mb/s Ethernet LAN Controller
+        Hardware Reference Manual" is currently available at :
+        http://developer.intel.com/design/network/manuals/278074.htm
        Please submit bugs to http://bugzilla.kernel.org/ .
 */
@@ -32,7 +37,11 @@ void t21142_media_task(struct work_struct *work)
        int csr12 = ioread32(ioaddr + CSR12);
        int next_tick = 60*HZ;
        int new_csr6 = 0;
+        int csr14 = ioread32(ioaddr + CSR14);
+        /* CSR12[LS10,LS100] are not reliable during autonegotiation */
+        if ((csr14 & 0x80) && (csr12 & 0x7000) != 0x5000)
+                csr12 |= 6;
        if (tulip_debug > 2)
                printk(KERN_INFO"%s: 21143 negotiation status %8.8x, %s.\n",
                           dev->name, csr12, medianame[dev->if_port]);
@@ -76,7 +85,7 @@ void t21142_media_task(struct work_struct *work)
                        new_csr6 = 0x83860000;
                        dev->if_port = 3;
                        iowrite32(0, ioaddr + CSR13);
-                        iowrite32(0x0003FF7F, ioaddr + CSR14);
+                        iowrite32(0x0003FFFF, ioaddr + CSR14);
                        iowrite16(8, ioaddr + CSR15);
                        iowrite32(1, ioaddr + CSR13);
                }
@@ -132,10 +141,14 @@ void t21142_lnk_change(struct net_device *dev, int csr5)
        struct tulip_private *tp = netdev_priv(dev);
        void __iomem *ioaddr = tp->base_addr;
        int csr12 = ioread32(ioaddr + CSR12);
+        int csr14 = ioread32(ioaddr + CSR14);
+        /* CSR12[LS10,LS100] are not reliable during autonegotiation */
+        if ((csr14 & 0x80) && (csr12 & 0x7000) != 0x5000)
+                csr12 |= 6;
        if (tulip_debug > 1)
                printk(KERN_INFO"%s: 21143 link status interrupt %8.8x, CSR5 %x, "
-                           "%8.8x.\n", dev->name, csr12, csr5, ioread32(ioaddr + CSR14));
+                           "%8.8x.\n", dev->name, csr12, csr5, csr14);
        /* If NWay finished and we have a negotiated partner capability. */
        if (tp->nway  &&  !tp->nwayset  &&  (csr12 & 0x7000) == 0x5000) {
@@ -143,7 +156,9 @@ void t21142_lnk_change(struct net_device *dev, int csr5)
                int negotiated = tp->sym_advertise & (csr12 >> 16);
                tp->lpar = csr12 >> 16;
                tp->nwayset = 1;
-                if (negotiated & 0x0100)                dev->if_port = 5;
+                /* If partner cannot negotiate, it is 10Mbps Half Duplex */
+                if (!(csr12 & 0x8000))          dev->if_port = 0;
+                else if (negotiated & 0x0100)   dev->if_port = 5;
                else if (negotiated & 0x0080)   dev->if_port = 3;
                else if (negotiated & 0x0040)   dev->if_port = 4;
                else if (negotiated & 0x0020)   dev->if_port = 0;
@@ -214,7 +229,7 @@ void t21142_lnk_change(struct net_device *dev, int csr5)
                        tp->timer.expires = RUN_AT(3*HZ);
                        add_timer(&tp->timer);
                } else if (dev->if_port == 5)
-                        iowrite32(ioread32(ioaddr + CSR14) & ~0x080, ioaddr + CSR14);
+                        iowrite32(csr14 & ~0x080, ioaddr + CSR14);
        } else if (dev->if_port == 0  ||  dev->if_port == 4) {
                if ((csr12 & 4) == 0)
                        printk(KERN_INFO"%s: 21143 10baseT link beat good.\n",
diff --git a/drivers/net/tulip/de2104x.c b/drivers/net/tulip/de2104x.c
index d5d53b633cf8..0bf2114738be 100644
--- a/drivers/net/tulip/de2104x.c
+++ b/drivers/net/tulip/de2104x.c
@@ -392,7 +392,7 @@ static void de_rx (struct de_private *de)
        unsigned drop = 0;
        int rc;
-        while (rx_work--) {
+        while (--rx_work) {
                u32 status, len;
                dma_addr_t mapping;
                struct sk_buff *skb, *copy_skb;
diff --git a/drivers/net/ucc_geth.c b/drivers/net/ucc_geth.c
index 11441225bf41..e87986867ba5 100644
--- a/drivers/net/ucc_geth.c
+++ b/drivers/net/ucc_geth.c
@@ -1536,6 +1536,11 @@ static void adjust_link(struct net_device *dev)
 static int init_phy(struct net_device *dev)
 {
        struct ucc_geth_private *priv = netdev_priv(dev);
+        struct device_node *np = priv->node;
+        struct device_node *phy, *mdio;
+        const phandle *ph;
+        char bus_name[MII_BUS_ID_SIZE];
+        const unsigned int *id;
        struct phy_device *phydev;
        char phy_id[BUS_ID_SIZE];
@@ -1543,8 +1548,18 @@ static int init_phy(struct net_device *dev)
        priv->oldspeed = 0;
        priv->oldduplex = -1;
-        snprintf(phy_id, sizeof(phy_id), PHY_ID_FMT, priv->ug_info->mdio_bus,
+        ph = of_get_property(np, "phy-handle", NULL);
-                 priv->ug_info->phy_address);
+        phy = of_find_node_by_phandle(*ph);
+        mdio = of_get_parent(phy);
+        id = of_get_property(phy, "reg", NULL);
+        of_node_put(phy);
+        of_node_put(mdio);
+        uec_mdio_bus_name(bus_name, mdio);
+        snprintf(phy_id, sizeof(phy_id), "%s:%02x",
+                                bus_name, *id);
        phydev = phy_connect(dev, phy_id, &adjust_link, 0, priv->phy_interface);
@@ -3748,6 +3763,7 @@ static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *ma
        ugeth->ug_info = ug_info;
        ugeth->dev = dev;
+        ugeth->node = np;
        return 0;
 }
diff --git a/drivers/net/ucc_geth.h b/drivers/net/ucc_geth.h
index 8f699cb773ee..16cbe42ba43c 100644
--- a/drivers/net/ucc_geth.h
+++ b/drivers/net/ucc_geth.h
@@ -1186,6 +1186,8 @@ struct ucc_geth_private {
        int oldspeed;
        int oldduplex;
        int oldlink;
+        struct device_node *node;
 };
 void uec_set_ethtool_ops(struct net_device *netdev);
diff --git a/drivers/net/ucc_geth_mii.c b/drivers/net/ucc_geth_mii.c
index c001d261366b..54635911305c 100644
--- a/drivers/net/ucc_geth_mii.c
+++ b/drivers/net/ucc_geth_mii.c
@@ -156,7 +156,7 @@ static int uec_mdio_probe(struct of_device *ofdev, const struct of_device_id *ma
        if (err)
                goto reg_map_fail;
-        snprintf(new_bus->id, MII_BUS_ID_SIZE, "%x", res.start);
+        uec_mdio_bus_name(new_bus->id, np);
        new_bus->irq = kmalloc(32 * sizeof(int), GFP_KERNEL);
@@ -283,3 +283,13 @@ void uec_mdio_exit(void)
 {
        of_unregister_platform_driver(&uec_mdio_driver);
 }
+void uec_mdio_bus_name(char *name, struct device_node *np)
+{
+        const u32 *reg;
+        reg = of_get_property(np, "reg", NULL);
+        snprintf(name, MII_BUS_ID_SIZE, "%s@%x", np->name, reg ? *reg : 0);
+}
diff --git a/drivers/net/ucc_geth_mii.h b/drivers/net/ucc_geth_mii.h
index 1e45b2028a50..840cf80235b7 100644
--- a/drivers/net/ucc_geth_mii.h
+++ b/drivers/net/ucc_geth_mii.h
@@ -97,4 +97,5 @@ int uec_mdio_read(struct mii_bus *bus, int mii_id, int regnum);
 int uec_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value);
 int __init uec_mdio_init(void);
 void uec_mdio_exit(void);
+void uec_mdio_bus_name(char *name, struct device_node *np);
 #endif                          /* __UEC_MII_H */
diff --git a/drivers/net/usb/hso.c b/drivers/net/usb/hso.c
index c4918b86ed19..fe98acaead97 100644
--- a/drivers/net/usb/hso.c
+++ b/drivers/net/usb/hso.c
@@ -455,6 +455,7 @@ static const struct usb_device_id hso_ids[] = {
        {icon321_port_device(0x0af0, 0xd033)},  /* Icon-322 */
        {USB_DEVICE(0x0af0, 0x7301)},           /* GE40x */
        {USB_DEVICE(0x0af0, 0x7361)},           /* GE40x */
+        {USB_DEVICE(0x0af0, 0x7381)},           /* GE40x */
        {USB_DEVICE(0x0af0, 0x7401)},           /* GI 0401 */
        {USB_DEVICE(0x0af0, 0x7501)},           /* GTM 382 */
        {USB_DEVICE(0x0af0, 0x7601)},           /* GE40x */
@@ -462,7 +463,8 @@ static const struct usb_device_id hso_ids[] = {
        {USB_DEVICE(0x0af0, 0x7801)},
        {USB_DEVICE(0x0af0, 0x7901)},
        {USB_DEVICE(0x0af0, 0x7361)},
-        {icon321_port_device(0x0af0, 0xd051)},
+        {USB_DEVICE(0x0af0, 0xd057)},
+        {USB_DEVICE(0x0af0, 0xd055)},
        {}
 };
 MODULE_DEVICE_TABLE(usb, hso_ids);
@@ -1297,6 +1299,7 @@ static int hso_serial_open(struct tty_struct *tty, struct file *filp)
        /* setup */
        spin_lock_irq(&serial->serial_lock);
        tty->driver_data = serial;
+        tty_kref_put(serial->tty);
        serial->tty = tty_kref_get(tty);
        spin_unlock_irq(&serial->serial_lock);
@@ -1792,8 +1795,8 @@ static int mux_device_request(struct hso_serial *serial, u8 type, u16 port,
        /* initialize */
        ctrl_req->wValue = 0;
-        ctrl_req->wIndex = hso_port_to_mux(port);
+        ctrl_req->wIndex = cpu_to_le16(hso_port_to_mux(port));
-        ctrl_req->wLength = size;
+        ctrl_req->wLength = cpu_to_le16(size);
        if (type == USB_CDC_GET_ENCAPSULATED_RESPONSE) {
                /* Reading command */
@@ -2043,9 +2046,8 @@ static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial)
                return -2;
        }
-        spin_lock(&serial->serial_lock);
+        /* All callers to put_rxbuf_data hold serial_lock */
        tty = tty_kref_get(serial->tty);
-        spin_unlock(&serial->serial_lock);
        /* Push data to tty */
        if (tty) {
@@ -2053,8 +2055,10 @@ static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial)
                        serial->curr_rx_urb_offset;
                D1("data to push to tty");
                while (write_length_remaining) {
-                        if (test_bit(TTY_THROTTLED, &tty->flags))
+                        if (test_bit(TTY_THROTTLED, &tty->flags)) {
+                                tty_kref_put(tty);
                                return -1;
+                        }
                        curr_write_len =  tty_insert_flip_string
                                (tty, urb->transfer_buffer +
                                 serial->curr_rx_urb_offset,
diff --git a/drivers/net/usb/mcs7830.c b/drivers/net/usb/mcs7830.c
index 5385d66b306e..ced8f36ebd01 100644
--- a/drivers/net/usb/mcs7830.c
+++ b/drivers/net/usb/mcs7830.c
@@ -94,10 +94,18 @@ static int mcs7830_get_reg(struct usbnet *dev, u16 index, u16 size, void *data)
 {
        struct usb_device *xdev = dev->udev;
        int ret;
+        void *buffer;
+        buffer = kmalloc(size, GFP_NOIO);
+        if (buffer == NULL)
+                return -ENOMEM;
        ret = usb_control_msg(xdev, usb_rcvctrlpipe(xdev, 0), MCS7830_RD_BREQ,
-                              MCS7830_RD_BMREQ, 0x0000, index, data,
+                              MCS7830_RD_BMREQ, 0x0000, index, buffer,
                              size, MCS7830_CTRL_TIMEOUT);
+        memcpy(data, buffer, size);
+        kfree(buffer);
        return ret;
 }
@@ -105,10 +113,18 @@ static int mcs7830_set_reg(struct usbnet *dev, u16 index, u16 size, void *data)
 {
        struct usb_device *xdev = dev->udev;
        int ret;
+        void *buffer;
+        buffer = kmalloc(size, GFP_NOIO);
+        if (buffer == NULL)
+                return -ENOMEM;
+        memcpy(buffer, data, size);
        ret = usb_control_msg(xdev, usb_sndctrlpipe(xdev, 0), MCS7830_WR_BREQ,
-                              MCS7830_WR_BMREQ, 0x0000, index, data,
+                              MCS7830_WR_BMREQ, 0x0000, index, buffer,
                              size, MCS7830_CTRL_TIMEOUT);
+        kfree(buffer);
        return ret;
 }
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index a75f91dc3153..c5691fdb7079 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -1302,7 +1302,7 @@ static void velocity_free_rd_ring(struct velocity_info *vptr)
 static int velocity_init_td_ring(struct velocity_info *vptr)
 {
        dma_addr_t curr;
-        unsigned int j;
+        int j;
        /* Init the TD ring entries */
        for (j = 0; j < vptr->tx.numq; j++) {
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 43f6523c40be..c68808336c8c 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -24,6 +24,7 @@
 #include <linux/virtio.h>
 #include <linux/virtio_net.h>
 #include <linux/scatterlist.h>
+#include <linux/if_vlan.h>
 static int napi_weight = 128;
 module_param(napi_weight, int, 0444);
@@ -33,7 +34,7 @@ module_param(csum, bool, 0444);
 module_param(gso, bool, 0444);
 /* FIXME: MTU in config. */
-#define MAX_PACKET_LEN (ETH_HLEN+ETH_DATA_LEN)
+#define MAX_PACKET_LEN (ETH_HLEN + VLAN_HLEN + ETH_DATA_LEN)
 #define GOOD_COPY_LEN   128
 struct virtnet_info
@@ -286,7 +287,7 @@ static void try_fill_recv_maxbufs(struct virtnet_info *vi)
                skb_put(skb, MAX_PACKET_LEN);
                hdr = skb_vnet_hdr(skb);
-                sg_init_one(sg, hdr, sizeof(*hdr));
+                sg_set_buf(sg, hdr, sizeof(*hdr));
                if (vi->big_packets) {
                        for (i = 0; i < MAX_SKB_FRAGS; i++) {
@@ -487,9 +488,9 @@ static int xmit_skb(struct virtnet_info *vi, struct sk_buff *skb)
        /* Encode metadata header at front. */
        if (vi->mergeable_rx_bufs)
-                sg_init_one(sg, mhdr, sizeof(*mhdr));
+                sg_set_buf(sg, mhdr, sizeof(*mhdr));
        else
-                sg_init_one(sg, hdr, sizeof(*hdr));
+                sg_set_buf(sg, hdr, sizeof(*hdr));
        num = skb_to_sgvec(skb, sg+1, 0, skb->len) + 1;
diff --git a/drivers/net/wan/ixp4xx_hss.c b/drivers/net/wan/ixp4xx_hss.c
index 2dc241689d37..0dbd85b0162d 100644
--- a/drivers/net/wan/ixp4xx_hss.c
+++ b/drivers/net/wan/ixp4xx_hss.c
@@ -622,7 +622,7 @@ static void hss_hdlc_rx_irq(void *pdev)
        printk(KERN_DEBUG "%s: hss_hdlc_rx_irq\n", dev->name);
 #endif
        qmgr_disable_irq(queue_ids[port->id].rx);
-        netif_rx_schedule(dev, &port->napi);
+        netif_rx_schedule(&port->napi);
 }
 static int hss_hdlc_poll(struct napi_struct *napi, int budget)
@@ -651,7 +651,7 @@ static int hss_hdlc_poll(struct napi_struct *napi, int budget)
                        printk(KERN_DEBUG "%s: hss_hdlc_poll"
                               " netif_rx_complete\n", dev->name);
 #endif
-                        netif_rx_complete(dev, napi);
+                        netif_rx_complete(napi);
                        qmgr_enable_irq(rxq);
                        if (!qmgr_stat_empty(rxq) &&
                            netif_rx_reschedule(napi)) {
@@ -1069,7 +1069,7 @@ static int hss_hdlc_open(struct net_device *dev)
        hss_start_hdlc(port);
        /* we may already have RX data, enables IRQ */
-        netif_rx_schedule(dev, &port->napi);
+        netif_rx_schedule(&port->napi);
        return 0;
 err_unlock:
diff --git a/drivers/net/wimax/i2400m/control.c b/drivers/net/wimax/i2400m/control.c
index d3d37fed6893..15d9f51b292c 100644
--- a/drivers/net/wimax/i2400m/control.c
+++ b/drivers/net/wimax/i2400m/control.c
@@ -609,7 +609,7 @@ void i2400m_msg_to_dev_cancel_wait(struct i2400m *i2400m, int code)
        spin_lock_irqsave(&i2400m->rx_lock, flags);
        ack_skb = i2400m->ack_skb;
        if (ack_skb && !IS_ERR(ack_skb))
-                kfree(ack_skb);
+                kfree_skb(ack_skb);
        i2400m->ack_skb = ERR_PTR(code);
        spin_unlock_irqrestore(&i2400m->rx_lock, flags);
 }
diff --git a/drivers/net/wimax/i2400m/debugfs.c b/drivers/net/wimax/i2400m/debugfs.c
index 626632985977..9b81af3f80a9 100644
--- a/drivers/net/wimax/i2400m/debugfs.c
+++ b/drivers/net/wimax/i2400m/debugfs.c
@@ -234,20 +234,6 @@ struct dentry *debugfs_create_i2400m_reset(
                                   &fops_i2400m_reset);
 }
-/*
- * Debug levels control; see debug.h
- */
-struct d_level D_LEVEL[] = {
-        D_SUBMODULE_DEFINE(control),
-        D_SUBMODULE_DEFINE(driver),
-        D_SUBMODULE_DEFINE(debugfs),
-        D_SUBMODULE_DEFINE(fw),
-        D_SUBMODULE_DEFINE(netdev),
-        D_SUBMODULE_DEFINE(rfkill),
-        D_SUBMODULE_DEFINE(rx),
-        D_SUBMODULE_DEFINE(tx),
-};
-size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL);
 #define __debugfs_register(prefix, name, parent)                        \
 do {                                                                    \
diff --git a/drivers/net/wimax/i2400m/driver.c b/drivers/net/wimax/i2400m/driver.c
index 5f98047e18cf..e80a0b65a754 100644
--- a/drivers/net/wimax/i2400m/driver.c
+++ b/drivers/net/wimax/i2400m/driver.c
@@ -707,6 +707,22 @@ void i2400m_release(struct i2400m *i2400m)
 EXPORT_SYMBOL_GPL(i2400m_release);
+/*
+ * Debug levels control; see debug.h
+ */
+struct d_level D_LEVEL[] = {
+        D_SUBMODULE_DEFINE(control),
+        D_SUBMODULE_DEFINE(driver),
+        D_SUBMODULE_DEFINE(debugfs),
+        D_SUBMODULE_DEFINE(fw),
+        D_SUBMODULE_DEFINE(netdev),
+        D_SUBMODULE_DEFINE(rfkill),
+        D_SUBMODULE_DEFINE(rx),
+        D_SUBMODULE_DEFINE(tx),
+};
+size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL);
 static
 int __init i2400m_driver_init(void)
 {
diff --git a/drivers/net/wimax/i2400m/usb-rx.c b/drivers/net/wimax/i2400m/usb-rx.c
index 074cc1f89853..a314799967cf 100644
--- a/drivers/net/wimax/i2400m/usb-rx.c
+++ b/drivers/net/wimax/i2400m/usb-rx.c
@@ -184,6 +184,8 @@ void i2400mu_rx_size_maybe_shrink(struct i2400mu *i2400mu)
 *   NOTE: this function might realloc the skb (if it is too small),
 *   so always update with the one returned.
 *   ERR_PTR() is < 0 on error.
+ *   Will return NULL if it cannot reallocate -- this can be
+ *   considered a transient retryable error.
 */
 static
 struct sk_buff *i2400mu_rx(struct i2400mu *i2400mu, struct sk_buff *rx_skb)
@@ -243,8 +245,8 @@ retry:
                        if (printk_ratelimit())
                                dev_err(dev, "RX: Can't reallocate skb to %d; "
                                        "RX dropped\n", rx_size);
-                        kfree(rx_skb);
+                        kfree_skb(rx_skb);
-                        result = 0;
+                        rx_skb = NULL;
                        goto out;       /* drop it...*/
                }
                kfree_skb(rx_skb);
@@ -344,7 +346,8 @@ int i2400mu_rxd(void *_i2400mu)
                if (IS_ERR(rx_skb))
                        goto out;
                atomic_dec(&i2400mu->rx_pending_count);
-                if (rx_skb->len == 0) { /* some ignorable condition */
+                if (rx_skb == NULL || rx_skb->len == 0) {
+                        /* some "ignorable" condition */
                        kfree_skb(rx_skb);
                        continue;
                }
diff --git a/drivers/net/wireless/Kconfig b/drivers/net/wireless/Kconfig
index ea543fcf2687..e4f9f747de88 100644
--- a/drivers/net/wireless/Kconfig
+++ b/drivers/net/wireless/Kconfig
@@ -111,7 +111,7 @@ config WLAN_80211
          lets you choose drivers.
 config PCMCIA_RAYCS
-        tristate "Aviator/Raytheon 2.4MHz wireless support"
+        tristate "Aviator/Raytheon 2.4GHz wireless support"
        depends on PCMCIA && WLAN_80211
        select WIRELESS_EXT
        ---help---
diff --git a/drivers/net/wireless/ath5k/base.c b/drivers/net/wireless/ath5k/base.c
index 4af2607deec0..a533ed60bb4d 100644
--- a/drivers/net/wireless/ath5k/base.c
+++ b/drivers/net/wireless/ath5k/base.c
@@ -1028,6 +1028,8 @@ ath5k_setup_bands(struct ieee80211_hw *hw)
 * it's done by reseting the chip.  To accomplish this we must
 * first cleanup any pending DMA, then restart stuff after a la
 * ath5k_init.
+ *
+ * Called with sc->lock.
 */
 static int
 ath5k_chan_set(struct ath5k_softc *sc, struct ieee80211_channel *chan)
@@ -2644,7 +2646,7 @@ ath5k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
                if (skb_headroom(skb) < padsize) {
                        ATH5K_ERR(sc, "tx hdrlen not %%4: %d not enough"
                                  " headroom to pad %d\n", hdrlen, padsize);
-                        return -1;
+                        return NETDEV_TX_BUSY;
                }
                skb_push(skb, padsize);
                memmove(skb->data, skb->data+padsize, hdrlen);
@@ -2655,7 +2657,7 @@ ath5k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
                ATH5K_ERR(sc, "no further txbuf available, dropping packet\n");
                spin_unlock_irqrestore(&sc->txbuflock, flags);
                ieee80211_stop_queue(hw, skb_get_queue_mapping(skb));
-                return -1;
+                return NETDEV_TX_BUSY;
        }
        bf = list_first_entry(&sc->txbuf, struct ath5k_buf, list);
        list_del(&bf->list);
@@ -2673,10 +2675,10 @@ ath5k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
                sc->txbuf_len++;
                spin_unlock_irqrestore(&sc->txbuflock, flags);
                dev_kfree_skb_any(skb);
-                return 0;
+                return NETDEV_TX_OK;
        }
-        return 0;
+        return NETDEV_TX_OK;
 }
 static int
@@ -2814,11 +2816,17 @@ ath5k_config(struct ieee80211_hw *hw, u32 changed)
 {
        struct ath5k_softc *sc = hw->priv;
        struct ieee80211_conf *conf = &hw->conf;
+        int ret;
+        mutex_lock(&sc->lock);
        sc->bintval = conf->beacon_int;
        sc->power_level = conf->power_level;
-        return ath5k_chan_set(sc, conf->channel);
+        ret = ath5k_chan_set(sc, conf->channel);
+        mutex_unlock(&sc->lock);
+        return ret;
 }
 static int
diff --git a/drivers/net/wireless/ath5k/pcu.c b/drivers/net/wireless/ath5k/pcu.c
index 0cac05c6a9ce..75eb9f43c741 100644
--- a/drivers/net/wireless/ath5k/pcu.c
+++ b/drivers/net/wireless/ath5k/pcu.c
@@ -65,7 +65,7 @@ int ath5k_hw_set_opmode(struct ath5k_hw *ah)
                if (ah->ah_version == AR5K_AR5210)
                        pcu_reg |= AR5K_STA_ID1_NO_PSPOLL;
                else
-                        AR5K_REG_DISABLE_BITS(ah, AR5K_CFG, AR5K_CFG_ADHOC);
+                        AR5K_REG_ENABLE_BITS(ah, AR5K_CFG, AR5K_CFG_IBSS);
                break;
        case NL80211_IFTYPE_AP:
@@ -75,7 +75,7 @@ int ath5k_hw_set_opmode(struct ath5k_hw *ah)
                if (ah->ah_version == AR5K_AR5210)
                        pcu_reg |= AR5K_STA_ID1_NO_PSPOLL;
                else
-                        AR5K_REG_ENABLE_BITS(ah, AR5K_CFG, AR5K_CFG_ADHOC);
+                        AR5K_REG_DISABLE_BITS(ah, AR5K_CFG, AR5K_CFG_IBSS);
                break;
        case NL80211_IFTYPE_STATION:
diff --git a/drivers/net/wireless/ath5k/reg.h b/drivers/net/wireless/ath5k/reg.h
index 91aaeaf88199..9189ab13286c 100644
--- a/drivers/net/wireless/ath5k/reg.h
+++ b/drivers/net/wireless/ath5k/reg.h
@@ -73,7 +73,7 @@
 #define AR5K_CFG_SWRD           0x00000004      /* Byte-swap RX descriptor */
 #define AR5K_CFG_SWRB           0x00000008      /* Byte-swap RX buffer */
 #define AR5K_CFG_SWRG           0x00000010      /* Byte-swap Register access */
-#define AR5K_CFG_ADHOC          0x00000020      /* AP/Adhoc indication [5211+] */
+#define AR5K_CFG_IBSS           0x00000020      /* 0-BSS, 1-IBSS [5211+] */
 #define AR5K_CFG_PHY_OK         0x00000100      /* [5211+] */
 #define AR5K_CFG_EEBS           0x00000200      /* EEPROM is busy */
 #define AR5K_CFG_CLKGD          0x00000400      /* Clock gated (Disable dynamic clock) */
diff --git a/drivers/net/wireless/ath9k/Kconfig b/drivers/net/wireless/ath9k/Kconfig
index c43bd321f97f..90a8dd873786 100644
--- a/drivers/net/wireless/ath9k/Kconfig
+++ b/drivers/net/wireless/ath9k/Kconfig
@@ -1,6 +1,7 @@
 config ATH9K
        tristate "Atheros 802.11n wireless cards support"
        depends on PCI && MAC80211 && WLAN_80211
+        depends on RFKILL || RFKILL=n
        select MAC80211_LEDS
        select LEDS_CLASS
        select NEW_LEDS
diff --git a/drivers/net/wireless/ath9k/main.c b/drivers/net/wireless/ath9k/main.c
index 191eec50dc75..727f067aca4f 100644
--- a/drivers/net/wireless/ath9k/main.c
+++ b/drivers/net/wireless/ath9k/main.c
@@ -2164,13 +2164,13 @@ static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
                                                    conf->ht.channel_type);
                }
+                ath_update_chainmask(sc, conf->ht.enabled);
                if (ath_set_channel(sc, &sc->sc_ah->ah_channels[pos]) < 0) {
                        DPRINTF(sc, ATH_DBG_FATAL, "Unable to set channel\n");
                        mutex_unlock(&sc->mutex);
                        return -EINVAL;
                }
-                ath_update_chainmask(sc, conf->ht.enabled);
        }
        if (changed & IEEE80211_CONF_CHANGE_POWER)
diff --git a/drivers/net/wireless/ath9k/rc.c b/drivers/net/wireless/ath9k/rc.c
index 04ab457a8faa..1b71b934bb5e 100644
--- a/drivers/net/wireless/ath9k/rc.c
+++ b/drivers/net/wireless/ath9k/rc.c
@@ -490,7 +490,7 @@ static inline int ath_rc_get_nextvalid_txrate(struct ath_rate_table *rate_table,
 static int ath_rc_valid_phyrate(u32 phy, u32 capflag, int ignore_cw)
 {
-        if (WLAN_RC_PHY_HT(phy) & !(capflag & WLAN_RC_HT_FLAG))
+        if (WLAN_RC_PHY_HT(phy) && !(capflag & WLAN_RC_HT_FLAG))
                return 0;
        if (WLAN_RC_PHY_DS(phy) && !(capflag & WLAN_RC_DS_FLAG))
                return 0;
diff --git a/drivers/net/wireless/ath9k/regd_common.h b/drivers/net/wireless/ath9k/regd_common.h
index 9112c030b1e8..6df1b3b77c25 100644
--- a/drivers/net/wireless/ath9k/regd_common.h
+++ b/drivers/net/wireless/ath9k/regd_common.h
@@ -228,7 +228,7 @@ enum {
 };
 #define REG_DOMAIN_2GHZ_MASK    (REQ_MASK & \
-        (!(ADHOC_NO_11A | DISALLOW_ADHOC_11A | DISALLOW_ADHOC_11A_TURB)))
+        (~(ADHOC_NO_11A | DISALLOW_ADHOC_11A | DISALLOW_ADHOC_11A_TURB)))
 #define REG_DOMAIN_5GHZ_MASK    REQ_MASK
 static struct reg_dmn_pair_mapping regDomainPairs[] = {
diff --git a/drivers/net/wireless/ath9k/xmit.c b/drivers/net/wireless/ath9k/xmit.c
index 3bfc3b90f256..c92f0c6e4adc 100644
--- a/drivers/net/wireless/ath9k/xmit.c
+++ b/drivers/net/wireless/ath9k/xmit.c
@@ -126,15 +126,7 @@ static void ath_tx_complete(struct ath_softc *sc, struct sk_buff *skb,
                tx_info->flags |= IEEE80211_TX_STAT_ACK;
        }
-        tx_info->status.rates[0].count = tx_status->retries;
+        tx_info->status.rates[0].count = tx_status->retries + 1;
-        if (tx_info->status.rates[0].flags & IEEE80211_TX_RC_MCS) {
-                /* Change idx from internal table index to MCS index */
-                int idx = tx_info->status.rates[0].idx;
-                struct ath_rate_table *rate_table = sc->cur_rate_table;
-                if (idx >= 0 && idx < rate_table->rate_cnt)
-                        tx_info->status.rates[0].idx =
-                                rate_table->info[idx].ratecode & 0x7f;
-        }
        hdrlen = ieee80211_get_hdrlen_from_skb(skb);
        padsize = hdrlen & 3;
@@ -264,25 +256,22 @@ static void assign_aggr_tid_seqno(struct sk_buff *skb,
        }
        /* Get seqno */
+        /* For HT capable stations, we save tidno for later use.
-        if (ieee80211_is_data(fc) && !is_pae(skb)) {
+         * We also override seqno set by upper layer with the one
-                /* For HT capable stations, we save tidno for later use.
+         * in tx aggregation state.
-                 * We also override seqno set by upper layer with the one
+         *
-                 * in tx aggregation state.
+         * If fragmentation is on, the sequence number is
-                 *
+         * not overridden, since it has been
-                 * If fragmentation is on, the sequence number is
+         * incremented by the fragmentation routine.
-                 * not overridden, since it has been
+         *
-                 * incremented by the fragmentation routine.
+         * FIXME: check if the fragmentation threshold exceeds
-                 *
+         * IEEE80211 max.
-                 * FIXME: check if the fragmentation threshold exceeds
+         */
-                 * IEEE80211 max.
+        tid = ATH_AN_2_TID(an, bf->bf_tidno);
-                 */
+        hdr->seq_ctrl = cpu_to_le16(tid->seq_next <<
-                tid = ATH_AN_2_TID(an, bf->bf_tidno);
+                        IEEE80211_SEQ_SEQ_SHIFT);
-                hdr->seq_ctrl = cpu_to_le16(tid->seq_next <<
+        bf->bf_seqno = tid->seq_next;
-                                            IEEE80211_SEQ_SEQ_SHIFT);
+        INCR(tid->seq_next, IEEE80211_SEQ_MAX);
-                bf->bf_seqno = tid->seq_next;
-                INCR(tid->seq_next, IEEE80211_SEQ_MAX);
-        }
 }
 static int setup_tx_flags(struct ath_softc *sc, struct sk_buff *skb,
@@ -1718,11 +1707,10 @@ static int ath_tx_setup_buffer(struct ath_softc *sc, struct ath_buf *bf,
        /* Assign seqno, tidno */
-        if (bf_isht(bf) && (sc->sc_flags & SC_OP_TXAGGR))
+        if (ieee80211_is_data_qos(fc) && (sc->sc_flags & SC_OP_TXAGGR))
                assign_aggr_tid_seqno(skb, bf);
        /* DMA setup */
        bf->bf_mpdu = skb;
        bf->bf_dmacontext = pci_map_single(sc->pdev, skb->data,
diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index 7b31a327b24a..c788bad10661 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -3261,7 +3261,7 @@ static int b43_switch_band(struct b43_wl *wl, struct ieee80211_channel *chan)
        struct b43_wldev *down_dev;
        struct b43_wldev *d;
        int err;
-        bool gmode;
+        bool uninitialized_var(gmode);
        int prev_status;
        /* Find a device and PHY which supports the band. */
diff --git a/drivers/net/wireless/b43legacy/main.c b/drivers/net/wireless/b43legacy/main.c
index c1324e31d2f6..fb996c27a19b 100644
--- a/drivers/net/wireless/b43legacy/main.c
+++ b/drivers/net/wireless/b43legacy/main.c
@@ -2465,7 +2465,7 @@ static void b43legacy_put_phy_into_reset(struct b43legacy_wldev *dev)
 static int b43legacy_switch_phymode(struct b43legacy_wl *wl,
                                      unsigned int new_mode)
 {
-        struct b43legacy_wldev *up_dev;
+        struct b43legacy_wldev *uninitialized_var(up_dev);
        struct b43legacy_wldev *down_dev;
        int err;
        bool gmode = 0;
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945-rs.c b/drivers/net/wireless/iwlwifi/iwl-3945-rs.c
index 9b60a0c5de5f..21c841847d88 100644
--- a/drivers/net/wireless/iwlwifi/iwl-3945-rs.c
+++ b/drivers/net/wireless/iwlwifi/iwl-3945-rs.c
@@ -638,12 +638,16 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
        s8 scale_action = 0;
        unsigned long flags;
        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
-        u16 fc, rate_mask;
+        u16 fc;
+        u16 rate_mask = 0;
        struct iwl3945_priv *priv = (struct iwl3945_priv *)priv_r;
        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
        IWL_DEBUG_RATE("enter\n");
+        if (sta)
+                rate_mask = sta->supp_rates[sband->band];
        /* Send management frames and broadcast/multicast data using lowest
         * rate. */
        fc = le16_to_cpu(hdr->frame_control);
@@ -651,11 +655,15 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
            is_multicast_ether_addr(hdr->addr1) ||
            !sta || !priv_sta) {
                IWL_DEBUG_RATE("leave: No STA priv data to update!\n");
-                info->control.rates[0].idx = rate_lowest_index(sband, sta);
+                if (!rate_mask)
+                        info->control.rates[0].idx =
+                                        rate_lowest_index(sband, NULL);
+                else
+                        info->control.rates[0].idx =
+                                        rate_lowest_index(sband, sta);
                return;
        }
-        rate_mask = sta->supp_rates[sband->band];
        index = min(rs_sta->last_txrate_idx & 0xffff, IWL_RATE_COUNT - 1);
        if (sband->band == IEEE80211_BAND_5GHZ)
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945.c b/drivers/net/wireless/iwlwifi/iwl-3945.c
index 8fdb34222c0a..45cfa1cf194a 100644
--- a/drivers/net/wireless/iwlwifi/iwl-3945.c
+++ b/drivers/net/wireless/iwlwifi/iwl-3945.c
@@ -2219,7 +2219,7 @@ int iwl3945_txpower_set_from_eeprom(struct iwl3945_priv *priv)
                /* set tx power value for all OFDM rates */
                for (rate_index = 0; rate_index < IWL_OFDM_RATES;
                     rate_index++) {
-                        s32 power_idx;
+                        s32 uninitialized_var(power_idx);
                        int rc;
                        /* use channel group's clip-power table,
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-rs.c b/drivers/net/wireless/iwlwifi/iwl-agn-rs.c
index f3f17929ca0b..27f50471aed8 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn-rs.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-rs.c
@@ -944,7 +944,8 @@ static void rs_tx_status(void *priv_r, struct ieee80211_supported_band *sband,
        }
        /* See if there's a better rate or modulation mode to try. */
-        rs_rate_scale_perform(priv, hdr, sta, lq_sta);
+        if (sta && sta->supp_rates[sband->band])
+                rs_rate_scale_perform(priv, hdr, sta, lq_sta);
 out:
        return;
 }
@@ -2101,14 +2102,23 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta, void *priv_sta,
        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
        struct iwl_lq_sta *lq_sta = priv_sta;
        int rate_idx;
+        u64 mask_bit = 0;
        IWL_DEBUG_RATE_LIMIT("rate scale calculate new rate for skb\n");
+        if (sta)
+                mask_bit = sta->supp_rates[sband->band];
        /* Send management frames and broadcast/multicast data using lowest
         * rate. */
        if (!ieee80211_is_data(hdr->frame_control) ||
            is_multicast_ether_addr(hdr->addr1) || !sta || !lq_sta) {
-                info->control.rates[0].idx = rate_lowest_index(sband, sta);
+                if (!mask_bit)
+                        info->control.rates[0].idx =
+                                        rate_lowest_index(sband, NULL);
+                else
+                        info->control.rates[0].idx =
+                                        rate_lowest_index(sband, sta);
                return;
        }
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.c b/drivers/net/wireless/iwlwifi/iwl-agn.c
index 5da6b35cd26d..c01ea48da5fe 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn.c
@@ -1719,6 +1719,10 @@ static int iwl_read_ucode(struct iwl_priv *priv)
        priv->ucode_data_backup.len = data_size;
        iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data_backup);
+        if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
+            !priv->ucode_data_backup.v_addr)
+                goto err_pci_alloc;
        /* Initialization instructions and data */
        if (init_size && init_data_size) {
                priv->ucode_init.len = init_size;
@@ -2482,7 +2486,7 @@ static int iwl_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
                dev_kfree_skb_any(skb);
        IWL_DEBUG_MACDUMP("leave\n");
-        return 0;
+        return NETDEV_TX_OK;
 }
 static int iwl_mac_add_interface(struct ieee80211_hw *hw,
@@ -4038,6 +4042,7 @@ static int iwl_pci_suspend(struct pci_dev *pdev, pm_message_t state)
                priv->is_open = 1;
        }
+        pci_save_state(pdev);
        pci_set_power_state(pdev, PCI_D3hot);
        return 0;
@@ -4048,6 +4053,7 @@ static int iwl_pci_resume(struct pci_dev *pdev)
        struct iwl_priv *priv = pci_get_drvdata(pdev);
        pci_set_power_state(pdev, PCI_D0);
+        pci_restore_state(pdev);
        if (priv->is_open)
                iwl_mac_start(priv->hw);
diff --git a/drivers/net/wireless/iwlwifi/iwl-commands.h b/drivers/net/wireless/iwlwifi/iwl-commands.h
index 52966ffbef6e..ba997204c8d4 100644
--- a/drivers/net/wireless/iwlwifi/iwl-commands.h
+++ b/drivers/net/wireless/iwlwifi/iwl-commands.h
@@ -255,7 +255,7 @@ struct iwl_cmd_header {
 *        0x3)  54 Mbps
 *
 * Legacy CCK rate format for bits 7:0 (bit 8 must be "0", bit 9 "1"):
- *  3-0:   10)  1 Mbps
+ *  6-0:   10)  1 Mbps
 *         20)  2 Mbps
 *         55)  5.5 Mbps
 *        110)  11 Mbps
diff --git a/drivers/net/wireless/iwlwifi/iwl-hcmd.c b/drivers/net/wireless/iwlwifi/iwl-hcmd.c
index 01a2169cecec..4b35b30e493e 100644
--- a/drivers/net/wireless/iwlwifi/iwl-hcmd.c
+++ b/drivers/net/wireless/iwlwifi/iwl-hcmd.c
@@ -51,6 +51,7 @@ const char *get_cmd_string(u8 cmd)
                IWL_CMD(REPLY_REMOVE_STA);
                IWL_CMD(REPLY_REMOVE_ALL_STA);
                IWL_CMD(REPLY_WEPKEY);
+                IWL_CMD(REPLY_3945_RX);
                IWL_CMD(REPLY_TX);
                IWL_CMD(REPLY_RATE_SCALE);
                IWL_CMD(REPLY_LEDS_CMD);
@@ -223,7 +224,7 @@ int iwl_send_cmd_sync(struct iwl_priv *priv, struct iwl_host_cmd *cmd)
                IWL_ERROR("Error: Response NULL in '%s'\n",
                          get_cmd_string(cmd->id));
                ret = -EIO;
-                goto out;
+                goto cancel;
        }
        ret = 0;
diff --git a/drivers/net/wireless/iwlwifi/iwl-sta.c b/drivers/net/wireless/iwlwifi/iwl-sta.c
index 412f66bac1af..70a8b21ca39b 100644
--- a/drivers/net/wireless/iwlwifi/iwl-sta.c
+++ b/drivers/net/wireless/iwlwifi/iwl-sta.c
@@ -480,6 +480,9 @@ void iwl_clear_stations_table(struct iwl_priv *priv)
        priv->num_stations = 0;
        memset(priv->stations, 0, sizeof(priv->stations));
+        /* clean ucode key table bit map */
+        priv->ucode_key_table = 0;
        spin_unlock_irqrestore(&priv->sta_lock, flags);
 }
 EXPORT_SYMBOL(iwl_clear_stations_table);
diff --git a/drivers/net/wireless/iwlwifi/iwl3945-base.c b/drivers/net/wireless/iwlwifi/iwl3945-base.c
index d64580805d6e..5b44d322b99f 100644
--- a/drivers/net/wireless/iwlwifi/iwl3945-base.c
+++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c
@@ -745,7 +745,7 @@ static int iwl3945_send_cmd_sync(struct iwl3945_priv *priv, struct iwl3945_host_
                IWL_ERROR("Error: Response NULL in '%s'\n",
                          get_cmd_string(cmd->id));
                ret = -EIO;
-                goto out;
+                goto cancel;
        }
        ret = 0;
@@ -6538,7 +6538,7 @@ static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
                dev_kfree_skb_any(skb);
        IWL_DEBUG_MAC80211("leave\n");
-        return 0;
+        return NETDEV_TX_OK;
 }
 static int iwl3945_mac_add_interface(struct ieee80211_hw *hw,
@@ -8143,6 +8143,7 @@ static int iwl3945_pci_suspend(struct pci_dev *pdev, pm_message_t state)
                priv->is_open = 1;
        }
+        pci_save_state(pdev);
        pci_set_power_state(pdev, PCI_D3hot);
        return 0;
@@ -8153,6 +8154,7 @@ static int iwl3945_pci_resume(struct pci_dev *pdev)
        struct iwl3945_priv *priv = pci_get_drvdata(pdev);
        pci_set_power_state(pdev, PCI_D0);
+        pci_restore_state(pdev);
        if (priv->is_open)
                iwl3945_mac_start(priv->hw);
diff --git a/drivers/net/wireless/libertas/hostcmd.h b/drivers/net/wireless/libertas/hostcmd.h
index e173b1b46c23..f6a79a653b7b 100644
--- a/drivers/net/wireless/libertas/hostcmd.h
+++ b/drivers/net/wireless/libertas/hostcmd.h
@@ -32,7 +32,7 @@ struct txpd {
        u8 pktdelay_2ms;
        /* reserved */
        u8 reserved1;
-};
+} __attribute__ ((packed));
 /* RxPD Descriptor */
 struct rxpd {
@@ -63,7 +63,7 @@ struct rxpd {
        /* Pkt Priority */
        u8 priority;
        u8 reserved[3];
-};
+} __attribute__ ((packed));
 struct cmd_header {
        __le16 command;
@@ -97,7 +97,7 @@ struct enc_key {
 struct lbs_offset_value {
        u32 offset;
        u32 value;
-};
+} __attribute__ ((packed));
 /* Define general data structure */
 /* cmd_DS_GEN */
@@ -107,7 +107,7 @@ struct cmd_ds_gen {
        __le16 seqnum;
        __le16 result;
        void *cmdresp[0];
-};
+} __attribute__ ((packed));
 #define S_DS_GEN sizeof(struct cmd_ds_gen)
@@ -163,7 +163,7 @@ struct cmd_ds_802_11_subscribe_event {
         * bump this up a bit.
         */
        uint8_t tlv[128];
-};
+} __attribute__ ((packed));
 /*
 * This scan handle Country Information IE(802.11d compliant)
@@ -180,7 +180,7 @@ struct cmd_ds_802_11_scan {
        mrvlietypes_chanlistparamset_t ChanListParamSet;
        mrvlietypes_ratesparamset_t OpRateSet;
 #endif
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_scan_rsp {
        struct cmd_header hdr;
@@ -188,7 +188,7 @@ struct cmd_ds_802_11_scan_rsp {
        __le16 bssdescriptsize;
        uint8_t nr_sets;
        uint8_t bssdesc_and_tlvbuffer[0];
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_get_log {
        struct cmd_header hdr;
@@ -206,33 +206,33 @@ struct cmd_ds_802_11_get_log {
        __le32 fcserror;
        __le32 txframe;
        __le32 wepundecryptable;
-};
+} __attribute__ ((packed));
 struct cmd_ds_mac_control {
        struct cmd_header hdr;
        __le16 action;
        u16 reserved;
-};
+} __attribute__ ((packed));
 struct cmd_ds_mac_multicast_adr {
        struct cmd_header hdr;
        __le16 action;
        __le16 nr_of_adrs;
        u8 maclist[ETH_ALEN * MRVDRV_MAX_MULTICAST_LIST_SIZE];
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_authenticate {
        u8 macaddr[ETH_ALEN];
        u8 authtype;
        u8 reserved[10];
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_deauthenticate {
        struct cmd_header hdr;
        u8 macaddr[ETH_ALEN];
        __le16 reasoncode;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_associate {
        u8 peerstaaddr[6];
@@ -251,7 +251,7 @@ struct cmd_ds_802_11_associate {
 struct cmd_ds_802_11_associate_rsp {
        struct ieeetypes_assocrsp assocRsp;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_set_wep {
        struct cmd_header hdr;
@@ -265,7 +265,7 @@ struct cmd_ds_802_11_set_wep {
        /* 40, 128bit or TXWEP */
        uint8_t keytype[4];
        uint8_t keymaterial[4][16];
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_3_get_stat {
        __le32 xmitok;
@@ -274,7 +274,7 @@ struct cmd_ds_802_3_get_stat {
        __le32 rcverror;
        __le32 rcvnobuffer;
        __le32 rcvcrcerror;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_get_stat {
        __le32 txfragmentcnt;
@@ -294,7 +294,7 @@ struct cmd_ds_802_11_get_stat {
        __le32 txbeacon;
        __le32 rxbeacon;
        __le32 wepundecryptable;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_snmp_mib {
        struct cmd_header hdr;
@@ -303,58 +303,58 @@ struct cmd_ds_802_11_snmp_mib {
        __le16 oid;
        __le16 bufsize;
        u8 value[128];
-};
+} __attribute__ ((packed));
 struct cmd_ds_mac_reg_map {
        __le16 buffersize;
        u8 regmap[128];
        __le16 reserved;
-};
+} __attribute__ ((packed));
 struct cmd_ds_bbp_reg_map {
        __le16 buffersize;
        u8 regmap[128];
        __le16 reserved;
-};
+} __attribute__ ((packed));
 struct cmd_ds_rf_reg_map {
        __le16 buffersize;
        u8 regmap[64];
        __le16 reserved;
-};
+} __attribute__ ((packed));
 struct cmd_ds_mac_reg_access {
        __le16 action;
        __le16 offset;
        __le32 value;
-};
+} __attribute__ ((packed));
 struct cmd_ds_bbp_reg_access {
        __le16 action;
        __le16 offset;
        u8 value;
        u8 reserved[3];
-};
+} __attribute__ ((packed));
 struct cmd_ds_rf_reg_access {
        __le16 action;
        __le16 offset;
        u8 value;
        u8 reserved[3];
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_radio_control {
        struct cmd_header hdr;
        __le16 action;
        __le16 control;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_beacon_control {
        __le16 action;
        __le16 beacon_enable;
        __le16 beacon_period;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_sleep_params {
        struct cmd_header hdr;
@@ -379,7 +379,7 @@ struct cmd_ds_802_11_sleep_params {
        /* reserved field, should be set to zero */
        __le16 reserved;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_inactivity_timeout {
        struct cmd_header hdr;
@@ -389,7 +389,7 @@ struct cmd_ds_802_11_inactivity_timeout {
        /* Inactivity timeout in msec */
        __le16 timeout;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_rf_channel {
        struct cmd_header hdr;
@@ -399,7 +399,7 @@ struct cmd_ds_802_11_rf_channel {
        __le16 rftype;      /* unused */
        __le16 reserved;    /* unused */
        u8 channellist[32]; /* unused */
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_rssi {
        /* weighting factor */
@@ -408,21 +408,21 @@ struct cmd_ds_802_11_rssi {
        __le16 reserved_0;
        __le16 reserved_1;
        __le16 reserved_2;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_rssi_rsp {
        __le16 SNR;
        __le16 noisefloor;
        __le16 avgSNR;
        __le16 avgnoisefloor;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_mac_address {
        struct cmd_header hdr;
        __le16 action;
        u8 macadd[ETH_ALEN];
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_rf_tx_power {
        struct cmd_header hdr;
@@ -431,7 +431,7 @@ struct cmd_ds_802_11_rf_tx_power {
        __le16 curlevel;
        s8 maxlevel;
        s8 minlevel;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_rf_antenna {
        __le16 action;
@@ -439,33 +439,33 @@ struct cmd_ds_802_11_rf_antenna {
        /* Number of antennas or 0xffff(diversity) */
        __le16 antennamode;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_monitor_mode {
        __le16 action;
        __le16 mode;
-};
+} __attribute__ ((packed));
 struct cmd_ds_set_boot2_ver {
        struct cmd_header hdr;
        __le16 action;
        __le16 version;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_fw_wake_method {
        struct cmd_header hdr;
        __le16 action;
        __le16 method;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_sleep_period {
        struct cmd_header hdr;
        __le16 action;
        __le16 period;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_ps_mode {
        __le16 action;
@@ -473,7 +473,7 @@ struct cmd_ds_802_11_ps_mode {
        __le16 multipledtim;
        __le16 reserved;
        __le16 locallisteninterval;
-};
+} __attribute__ ((packed));
 struct cmd_confirm_sleep {
        struct cmd_header hdr;
@@ -483,7 +483,7 @@ struct cmd_confirm_sleep {
        __le16 multipledtim;
        __le16 reserved;
        __le16 locallisteninterval;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_data_rate {
        struct cmd_header hdr;
@@ -491,14 +491,14 @@ struct cmd_ds_802_11_data_rate {
        __le16 action;
        __le16 reserved;
        u8 rates[MAX_RATES];
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_rate_adapt_rateset {
        struct cmd_header hdr;
        __le16 action;
        __le16 enablehwauto;
        __le16 bitmap;
-};
+} __attribute__ ((packed));
 struct cmd_ds_802_11_ad_hoc_start {
        struct cmd_header hdr;
@@ -520,7 +520,7 @@ struct cmd_ds_802_11_ad_hoc_result {
        u8 pad[3];
        u8 bssid[ETH_ALEN];
-};
+} __attribute__ ((packed));
 struct adhoc_bssdesc {
        u8 bssid[ETH_ALEN];
@@ -578,7 +578,7 @@ struct MrvlIEtype_keyParamSet {
        /* key material of size keylen */
        u8 key[32];
-};
+} __attribute__ ((packed));
 #define MAX_WOL_RULES           16
@@ -590,7 +590,7 @@ struct host_wol_rule {
        __le16 reserve;
        __be32 sig_mask;
        __be32 signature;
-};
+} __attribute__ ((packed));
 struct wol_config {
        uint8_t action;
@@ -598,8 +598,7 @@ struct wol_config {
        uint8_t no_rules_in_cmd;
        uint8_t result;
        struct host_wol_rule rule[MAX_WOL_RULES];
-};
+} __attribute__ ((packed));
 struct cmd_ds_host_sleep {
        struct cmd_header hdr;
diff --git a/drivers/net/wireless/libertas_tf/main.c b/drivers/net/wireless/libertas_tf/main.c
index d1fc305de5fe..e7289e2e7f16 100644
--- a/drivers/net/wireless/libertas_tf/main.c
+++ b/drivers/net/wireless/libertas_tf/main.c
@@ -206,7 +206,7 @@ static int lbtf_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
         * there are no buffered multicast frames to send
         */
        ieee80211_stop_queues(priv->hw);
-        return 0;
+        return NETDEV_TX_OK;
 }
 static void lbtf_tx_work(struct work_struct *work)
diff --git a/drivers/net/wireless/orinoco/orinoco.c b/drivers/net/wireless/orinoco/orinoco.c
index bc84e2792f8a..45a04faa7818 100644
--- a/drivers/net/wireless/orinoco/orinoco.c
+++ b/drivers/net/wireless/orinoco/orinoco.c
@@ -1610,6 +1610,16 @@ static void orinoco_rx_isr_tasklet(unsigned long data)
        struct orinoco_rx_data *rx_data, *temp;
        struct hermes_rx_descriptor *desc;
        struct sk_buff *skb;
+        unsigned long flags;
+        /* orinoco_rx requires the driver lock, and we also need to
+         * protect priv->rx_list, so just hold the lock over the
+         * lot.
+         *
+         * If orinoco_lock fails, we've unplugged the card. In this
+         * case just abort. */
+        if (orinoco_lock(priv, &flags) != 0)
+                return;
        /* extract desc and skb from queue */
        list_for_each_entry_safe(rx_data, temp, &priv->rx_list, list) {
@@ -1622,6 +1632,8 @@ static void orinoco_rx_isr_tasklet(unsigned long data)
                kfree(desc);
        }
+        orinoco_unlock(priv, &flags);
 }
 /********************************************************************/
@@ -1661,7 +1673,7 @@ static void print_linkstatus(struct net_device *dev, u16 status)
                s = "UNKNOWN";
        }
        
-        printk(KERN_INFO "%s: New link status: %s (%04x)\n",
+        printk(KERN_DEBUG "%s: New link status: %s (%04x)\n",
               dev->name, s, status);
 }
@@ -3645,12 +3657,22 @@ struct net_device
 void free_orinocodev(struct net_device *dev)
 {
        struct orinoco_private *priv = netdev_priv(dev);
+        struct orinoco_rx_data *rx_data, *temp;
-        /* No need to empty priv->rx_list: if the tasklet is scheduled
+        /* If the tasklet is scheduled when we call tasklet_kill it
-         * when we call tasklet_kill it will run one final time,
+         * will run one final time. However the tasklet will only
-         * emptying the list */
+         * drain priv->rx_list if the hw is still available. */
        tasklet_kill(&priv->rx_tasklet);
+        /* Explicitly drain priv->rx_list */
+        list_for_each_entry_safe(rx_data, temp, &priv->rx_list, list) {
+                list_del(&rx_data->list);
+                dev_kfree_skb(rx_data->skb);
+                kfree(rx_data->desc);
+                kfree(rx_data);
+        }
        unregister_pm_notifier(&priv->pm_notifier);
        orinoco_uncache_fw(priv);
@@ -5046,33 +5068,30 @@ static int orinoco_ioctl_set_genie(struct net_device *dev,
        struct orinoco_private *priv = netdev_priv(dev);
        u8 *buf;
        unsigned long flags;
-        int err = 0;
        /* cut off at IEEE80211_MAX_DATA_LEN */
        if ((wrqu->data.length > IEEE80211_MAX_DATA_LEN) ||
            (wrqu->data.length && (extra == NULL)))
                return -EINVAL;
-        if (orinoco_lock(priv, &flags) != 0)
-                return -EBUSY;
        if (wrqu->data.length) {
                buf = kmalloc(wrqu->data.length, GFP_KERNEL);
-                if (buf == NULL) {
+                if (buf == NULL)
-                        err = -ENOMEM;
+                        return -ENOMEM;
-                        goto out;
-                }
                memcpy(buf, extra, wrqu->data.length);
-                kfree(priv->wpa_ie);
+        } else
-                priv->wpa_ie = buf;
+                buf = NULL;
-                priv->wpa_ie_len = wrqu->data.length;
-        } else {
+        if (orinoco_lock(priv, &flags) != 0) {
-                kfree(priv->wpa_ie);
+                kfree(buf);
-                priv->wpa_ie = NULL;
+                return -EBUSY;
-                priv->wpa_ie_len = 0;
        }
+        kfree(priv->wpa_ie);
+        priv->wpa_ie = buf;
+        priv->wpa_ie_len = wrqu->data.length;
        if (priv->wpa_ie) {
                /* Looks like wl_lkm wants to check the auth alg, and
                 * somehow pass it to the firmware.
@@ -5081,9 +5100,8 @@ static int orinoco_ioctl_set_genie(struct net_device *dev,
                 */
        }
-out:
        orinoco_unlock(priv, &flags);
-        return err;
+        return 0;
 }
 static int orinoco_ioctl_get_genie(struct net_device *dev,
diff --git a/drivers/net/wireless/orinoco/orinoco_cs.c b/drivers/net/wireless/orinoco/orinoco_cs.c
index f127602670ec..0b32215d3f5d 100644
--- a/drivers/net/wireless/orinoco/orinoco_cs.c
+++ b/drivers/net/wireless/orinoco/orinoco_cs.c
@@ -435,6 +435,7 @@ static struct pcmcia_device_id orinoco_cs_ids[] = {
        PCMCIA_DEVICE_MANF_CARD(0x0250, 0x0002), /* Samsung SWL2000-N 11Mb/s WLAN Card */
        PCMCIA_DEVICE_MANF_CARD(0x0261, 0x0002), /* AirWay 802.11 Adapter (PCMCIA) */
        PCMCIA_DEVICE_MANF_CARD(0x0268, 0x0001), /* ARtem Onair */
+        PCMCIA_DEVICE_MANF_CARD(0x0268, 0x0003), /* ARtem Onair Comcard 11 */
        PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0305), /* Buffalo WLI-PCM-S11 */
        PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1612), /* Linksys WPC11 Version 2.5 */
        PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1613), /* Linksys WPC11 Version 3 */
diff --git a/drivers/net/wireless/p54/p54common.c b/drivers/net/wireless/p54/p54common.c
index 82354b974a04..34561e6e816b 100644
--- a/drivers/net/wireless/p54/p54common.c
+++ b/drivers/net/wireless/p54/p54common.c
@@ -138,6 +138,7 @@ int p54_parse_firmware(struct ieee80211_hw *dev, const struct firmware *fw)
        u8 *fw_version = NULL;
        size_t len;
        int i;
+        int maxlen;
        if (priv->rx_start)
                return 0;
@@ -195,6 +196,16 @@ int p54_parse_firmware(struct ieee80211_hw *dev, const struct firmware *fw)
                        else
                                priv->rx_mtu = (size_t)
                                        0x620 - priv->tx_hdr_len;
+                        maxlen = priv->tx_hdr_len + /* USB devices */
+                                 sizeof(struct p54_rx_data) +
+                                 4 + /* rx alignment */
+                                 IEEE80211_MAX_FRAG_THRESHOLD;
+                        if (priv->rx_mtu > maxlen && PAGE_SIZE == 4096) {
+                                printk(KERN_INFO "p54: rx_mtu reduced from %d "
+                                                 "to %d\n", priv->rx_mtu,
+                                                 maxlen);
+                                priv->rx_mtu = maxlen;
+                        }
                        break;
                        }
                case BR_CODE_EXPOSED_IF:
@@ -440,8 +451,8 @@ static int p54_parse_eeprom(struct ieee80211_hw *dev, void *eeprom, int len)
                        }
                        if (err)
                                goto err;
+                        }
-                }
+                        break;
                case PDR_PRISM_ZIF_TX_IQ_CALIBRATION:
                        priv->iq_autocal = kmalloc(data_len, GFP_KERNEL);
                        if (!priv->iq_autocal) {
@@ -575,6 +586,7 @@ static int p54_rx_data(struct ieee80211_hw *dev, struct sk_buff *skb)
        u16 freq = le16_to_cpu(hdr->freq);
        size_t header_len = sizeof(*hdr);
        u32 tsf32;
+        u8 rate = hdr->rate & 0xf;
        /*
         * If the device is in a unspecified state we have to
@@ -603,8 +615,11 @@ static int p54_rx_data(struct ieee80211_hw *dev, struct sk_buff *skb)
        rx_status.qual = (100 * hdr->rssi) / 127;
        if (hdr->rate & 0x10)
                rx_status.flag |= RX_FLAG_SHORTPRE;
-        rx_status.rate_idx = (dev->conf.channel->band == IEEE80211_BAND_2GHZ ?
+        if (dev->conf.channel->band == IEEE80211_BAND_5GHZ)
-                        hdr->rate : (hdr->rate - 4)) & 0xf;
+                rx_status.rate_idx = (rate < 4) ? 0 : rate - 4;
+        else
+                rx_status.rate_idx = rate;
        rx_status.freq = freq;
        rx_status.band =  dev->conf.channel->band;
        rx_status.antenna = hdr->antenna;
@@ -730,7 +745,7 @@ static void p54_rx_frame_sent(struct ieee80211_hw *dev, struct sk_buff *skb)
                struct ieee80211_tx_info *info = IEEE80211_SKB_CB(entry);
                struct p54_hdr *entry_hdr;
                struct p54_tx_data *entry_data;
-                int pad = 0;
+                unsigned int pad = 0, frame_len;
                range = (void *)info->rate_driver_data;
                if (range->start_addr != addr) {
@@ -753,6 +768,7 @@ static void p54_rx_frame_sent(struct ieee80211_hw *dev, struct sk_buff *skb)
                __skb_unlink(entry, &priv->tx_queue);
                spin_unlock_irqrestore(&priv->tx_queue.lock, flags);
+                frame_len = entry->len;
                entry_hdr = (struct p54_hdr *) entry->data;
                entry_data = (struct p54_tx_data *) entry_hdr->data;
                priv->tx_stats[entry_data->hw_queue].len--;
@@ -798,6 +814,29 @@ static void p54_rx_frame_sent(struct ieee80211_hw *dev, struct sk_buff *skb)
                        info->flags |= IEEE80211_TX_STAT_TX_FILTERED;
                info->status.ack_signal = p54_rssi_to_dbm(dev,
                                (int)payload->ack_rssi);
+                /* Undo all changes to the frame. */
+                switch (entry_data->key_type) {
+                case P54_CRYPTO_TKIPMICHAEL: {
+                        u8 *iv = (u8 *)(entry_data->align + pad +
+                                        entry_data->crypt_offset);
+                        /* Restore the original TKIP IV. */
+                        iv[2] = iv[0];
+                        iv[0] = iv[1];
+                        iv[1] = (iv[0] | 0x20) & 0x7f;  /* WEPSeed - 8.3.2.2 */
+                        frame_len -= 12; /* remove TKIP_MMIC + TKIP_ICV */
+                        break;
+                        }
+                case P54_CRYPTO_AESCCMP:
+                        frame_len -= 8; /* remove CCMP_MIC */
+                        break;
+                case P54_CRYPTO_WEP:
+                        frame_len -= 4; /* remove WEP_ICV */
+                        break;
+                }
+                skb_trim(entry, frame_len);
                skb_pull(entry, sizeof(*hdr) + pad + sizeof(*entry_data));
                ieee80211_tx_status_irqsafe(dev, entry);
                goto out;
@@ -1122,7 +1161,7 @@ static int p54_set_tim(struct ieee80211_hw *dev, struct ieee80211_sta *sta,
        skb = p54_alloc_skb(dev, P54_HDR_FLAG_CONTROL_OPSET,
                      sizeof(struct p54_hdr) + sizeof(*tim),
-                      P54_CONTROL_TYPE_TIM, GFP_KERNEL);
+                      P54_CONTROL_TYPE_TIM, GFP_ATOMIC);
        if (!skb)
                return -ENOMEM;
@@ -1383,7 +1422,6 @@ static int p54_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
        hdr->tries = ridx;
        txhdr->rts_rate_idx = 0;
        if (info->control.hw_key) {
-                crypt_offset += info->control.hw_key->iv_len;
                txhdr->key_type = p54_convert_algo(info->control.hw_key->alg);
                txhdr->key_len = min((u8)16, info->control.hw_key->keylen);
                memcpy(txhdr->key, info->control.hw_key->key, txhdr->key_len);
@@ -1397,6 +1435,8 @@ static int p54_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
                }
                /* reserve some space for ICV */
                len += info->control.hw_key->icv_len;
+                memset(skb_put(skb, info->control.hw_key->icv_len), 0,
+                       info->control.hw_key->icv_len);
        } else {
                txhdr->key_type = 0;
                txhdr->key_len = 0;
@@ -1584,7 +1624,7 @@ static int p54_scan(struct ieee80211_hw *dev, u16 mode, u16 dwell)
 err:
        printk(KERN_ERR "%s: frequency change failed\n", wiphy_name(dev->wiphy));
-        kfree_skb(skb);
+        p54_free_skb(dev, skb);
        return -EINVAL;
 }
@@ -1824,7 +1864,7 @@ static void p54_remove_interface(struct ieee80211_hw *dev,
 static int p54_config(struct ieee80211_hw *dev, u32 changed)
 {
-        int ret;
+        int ret = 0;
        struct p54_common *priv = dev->priv;
        struct ieee80211_conf *conf = &dev->conf;
@@ -2051,7 +2091,7 @@ static int p54_set_key(struct ieee80211_hw *dev, enum set_key_cmd cmd,
                        algo = P54_CRYPTO_AESCCMP;
                        break;
                default:
-                        return -EINVAL;
+                        return -EOPNOTSUPP;
                }
        }
diff --git a/drivers/net/wireless/p54/p54usb.c b/drivers/net/wireless/p54/p54usb.c
index c44a200059d2..5de2ebfb28c7 100644
--- a/drivers/net/wireless/p54/p54usb.c
+++ b/drivers/net/wireless/p54/p54usb.c
@@ -56,6 +56,7 @@ static struct usb_device_id p54u_table[] __devinitdata = {
        {USB_DEVICE(0x050d, 0x7050)},   /* Belkin F5D7050 ver 1000 */
        {USB_DEVICE(0x0572, 0x2000)},   /* Cohiba Proto board */
        {USB_DEVICE(0x0572, 0x2002)},   /* Cohiba Proto board */
+        {USB_DEVICE(0x06b9, 0x0121)},   /* Thomson SpeedTouch 121g */
        {USB_DEVICE(0x0707, 0xee13)},   /* SMC 2862W-G version 2 */
        {USB_DEVICE(0x083a, 0x4521)},   /* Siemens Gigaset USB Adapter 54 version 2 */
        {USB_DEVICE(0x0846, 0x4240)},   /* Netgear WG111 (v2) */
@@ -143,11 +144,8 @@ static void p54u_tx_cb(struct urb *urb)
        struct sk_buff *skb = urb->context;
        struct ieee80211_hw *dev = (struct ieee80211_hw *)
                usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
-        struct p54u_priv *priv = dev->priv;
-        skb_pull(skb, priv->common.tx_hdr_len);
+        p54_free_skb(dev, skb);
-        if (FREE_AFTER_TX(skb))
-                p54_free_skb(dev, skb);
 }
 static void p54u_tx_dummy_cb(struct urb *urb) { }
@@ -229,7 +227,10 @@ static void p54u_tx_3887(struct ieee80211_hw *dev, struct sk_buff *skb)
                          p54u_tx_dummy_cb, dev);
        usb_fill_bulk_urb(data_urb, priv->udev,
                          usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
-                          skb->data, skb->len, p54u_tx_cb, skb);
+                          skb->data, skb->len, FREE_AFTER_TX(skb) ?
+                          p54u_tx_cb : p54u_tx_dummy_cb, skb);
+        addr_urb->transfer_flags |= URB_ZERO_PACKET;
+        data_urb->transfer_flags |= URB_ZERO_PACKET;
        usb_anchor_urb(addr_urb, &priv->submitted);
        err = usb_submit_urb(addr_urb, GFP_ATOMIC);
@@ -238,7 +239,7 @@ static void p54u_tx_3887(struct ieee80211_hw *dev, struct sk_buff *skb)
                goto out;
        }
-        usb_anchor_urb(addr_urb, &priv->submitted);
+        usb_anchor_urb(data_urb, &priv->submitted);
        err = usb_submit_urb(data_urb, GFP_ATOMIC);
        if (err)
                usb_unanchor_urb(data_urb);
@@ -268,27 +269,24 @@ static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb)
 {
        struct p54u_priv *priv = dev->priv;
        struct urb *data_urb;
-        struct lm87_tx_hdr *hdr;
+        struct lm87_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
-        __le32 checksum;
-        __le32 addr = ((struct p54_hdr *)skb->data)->req_id;
        data_urb = usb_alloc_urb(0, GFP_ATOMIC);
        if (!data_urb)
                return;
-        checksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
+        hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
-        hdr = (struct lm87_tx_hdr *)skb_push(skb, sizeof(*hdr));
+        hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
-        hdr->chksum = checksum;
-        hdr->device_addr = addr;
        usb_fill_bulk_urb(data_urb, priv->udev,
                          usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
-                          skb->data, skb->len, p54u_tx_cb, skb);
+                          hdr, skb->len + sizeof(*hdr),  FREE_AFTER_TX(skb) ?
+                          p54u_tx_cb : p54u_tx_dummy_cb, skb);
+        data_urb->transfer_flags |= URB_ZERO_PACKET;
        usb_anchor_urb(data_urb, &priv->submitted);
        if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
                usb_unanchor_urb(data_urb);
-                skb_pull(skb, sizeof(*hdr));
                p54_free_skb(dev, skb);
        }
        usb_free_urb(data_urb);
@@ -298,11 +296,9 @@ static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
 {
        struct p54u_priv *priv = dev->priv;
        struct urb *int_urb, *data_urb;
-        struct net2280_tx_hdr *hdr;
+        struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
        struct net2280_reg_write *reg;
        int err = 0;
-        __le32 addr = ((struct p54_hdr *) skb->data)->req_id;
-        __le16 len = cpu_to_le16(skb->len);
        reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
        if (!reg)
@@ -325,10 +321,9 @@ static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
        reg->addr = cpu_to_le32(P54U_DEV_BASE);
        reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
-        hdr = (void *)skb_push(skb, sizeof(*hdr));
        memset(hdr, 0, sizeof(*hdr));
-        hdr->len = len;
+        hdr->len = cpu_to_le16(skb->len);
-        hdr->device_addr = addr;
+        hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id;
        usb_fill_bulk_urb(int_urb, priv->udev,
                usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
@@ -339,11 +334,13 @@ static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
         * free what's inside the transfer_buffer after the callback routine
         * has completed.
         */
-        int_urb->transfer_flags |= URB_FREE_BUFFER;
+        int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET;
        usb_fill_bulk_urb(data_urb, priv->udev,
                          usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
-                          skb->data, skb->len, p54u_tx_cb, skb);
+                          hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
+                          p54u_tx_cb : p54u_tx_dummy_cb, skb);
+        data_urb->transfer_flags |= URB_ZERO_PACKET;
        usb_anchor_urb(int_urb, &priv->submitted);
        err = usb_submit_urb(int_urb, GFP_ATOMIC);
diff --git a/drivers/net/wireless/rndis_wlan.c b/drivers/net/wireless/rndis_wlan.c
index 607ce9f61b54..ed93ac41297f 100644
--- a/drivers/net/wireless/rndis_wlan.c
+++ b/drivers/net/wireless/rndis_wlan.c
@@ -1649,9 +1649,7 @@ static char *rndis_translate_scan(struct net_device *dev,
                                  char *end_buf,
                                  struct ndis_80211_bssid_ex *bssid)
 {
-#ifdef DEBUG
        struct usbnet *usbdev = netdev_priv(dev);
-#endif
        u8 *ie;
        char *current_val;
        int bssid_len, ie_len, i;
diff --git a/drivers/net/wireless/rt2x00/rt2500usb.c b/drivers/net/wireless/rt2x00/rt2500usb.c
index 30028e2422fc..af6b5847be5c 100644
--- a/drivers/net/wireless/rt2x00/rt2500usb.c
+++ b/drivers/net/wireless/rt2x00/rt2500usb.c
@@ -38,7 +38,7 @@
 /*
 * Allow hardware encryption to be disabled.
 */
-static int modparam_nohwcrypt = 1;
+static int modparam_nohwcrypt = 0;
 module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO);
 MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption.");
@@ -376,11 +376,11 @@ static int rt2500usb_config_key(struct rt2x00_dev *rt2x00dev,
                /*
                 * The driver does not support the IV/EIV generation
-                 * in hardware. However it doesn't support the IV/EIV
+                 * in hardware. However it demands the data to be provided
-                 * inside the ieee80211 frame either, but requires it
+                 * both seperately as well as inside the frame.
-                 * to be provided seperately for the descriptor.
+                 * We already provided the CONFIG_CRYPTO_COPY_IV to rt2x00lib
-                 * rt2x00lib will cut the IV/EIV data out of all frames
+                 * to ensure rt2x00lib will not strip the data from the
-                 * given to us by mac80211, but we must tell mac80211
+                 * frame after the copy, now we must tell mac80211
                 * to generate the IV/EIV data.
                 */
                key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
@@ -1181,7 +1181,7 @@ static void rt2500usb_write_tx_desc(struct rt2x00_dev *rt2x00dev,
                           test_bit(ENTRY_TXD_FIRST_FRAGMENT, &txdesc->flags));
        rt2x00_set_field32(&word, TXD_W0_IFS, txdesc->ifs);
        rt2x00_set_field32(&word, TXD_W0_DATABYTE_COUNT, skb->len);
-        rt2x00_set_field32(&word, TXD_W0_CIPHER, txdesc->cipher);
+        rt2x00_set_field32(&word, TXD_W0_CIPHER, !!txdesc->cipher);
        rt2x00_set_field32(&word, TXD_W0_KEY_ID, txdesc->key_idx);
        rt2x00_desc_write(txd, 0, word);
 }
@@ -1334,14 +1334,7 @@ static void rt2500usb_fill_rxdone(struct queue_entry *entry,
                /* ICV is located at the end of frame */
-                /*
+                rxdesc->flags |= RX_FLAG_MMIC_STRIPPED;
-                 * Hardware has stripped IV/EIV data from 802.11 frame during
-                 * decryption. It has provided the data seperately but rt2x00lib
-                 * should decide if it should be reinserted.
-                 */
-                rxdesc->flags |= RX_FLAG_IV_STRIPPED;
-                if (rxdesc->cipher != CIPHER_TKIP)
-                        rxdesc->flags |= RX_FLAG_MMIC_STRIPPED;
                if (rxdesc->cipher_status == RX_CRYPTO_SUCCESS)
                        rxdesc->flags |= RX_FLAG_DECRYPTED;
                else if (rxdesc->cipher_status == RX_CRYPTO_FAIL_MIC)
diff --git a/drivers/net/wireless/rt2x00/rt2x00dev.c b/drivers/net/wireless/rt2x00/rt2x00dev.c
index 6d92542fcf0d..87c0f2c83077 100644
--- a/drivers/net/wireless/rt2x00/rt2x00dev.c
+++ b/drivers/net/wireless/rt2x00/rt2x00dev.c
@@ -807,13 +807,11 @@ static void rt2x00lib_rate(struct ieee80211_rate *entry,
 {
        entry->flags = 0;
        entry->bitrate = rate->bitrate;
-        entry->hw_value = rt2x00_create_rate_hw_value(index, 0);
+        entry->hw_value =index;
-        entry->hw_value_short = entry->hw_value;
+        entry->hw_value_short = index;
-        if (rate->flags & DEV_RATE_SHORT_PREAMBLE) {
+        if (rate->flags & DEV_RATE_SHORT_PREAMBLE)
                entry->flags |= IEEE80211_RATE_SHORT_PREAMBLE;
-                entry->hw_value_short |= rt2x00_create_rate_hw_value(index, 1);
-        }
 }
 static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
diff --git a/drivers/net/wireless/rt2x00/rt2x00leds.c b/drivers/net/wireless/rt2x00/rt2x00leds.c
index 68f4e0fc35b9..a0cd35b6beb5 100644
--- a/drivers/net/wireless/rt2x00/rt2x00leds.c
+++ b/drivers/net/wireless/rt2x00/rt2x00leds.c
@@ -97,7 +97,7 @@ void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev, bool enabled)
 void rt2x00leds_led_radio(struct rt2x00_dev *rt2x00dev, bool enabled)
 {
-        if (rt2x00dev->led_radio.type == LED_TYPE_ASSOC)
+        if (rt2x00dev->led_radio.type == LED_TYPE_RADIO)
                rt2x00led_led_simple(&rt2x00dev->led_radio, enabled);
 }
diff --git a/drivers/net/wireless/rt2x00/rt2x00lib.h b/drivers/net/wireless/rt2x00/rt2x00lib.h
index 03024327767b..86cd26fbf769 100644
--- a/drivers/net/wireless/rt2x00/rt2x00lib.h
+++ b/drivers/net/wireless/rt2x00/rt2x00lib.h
@@ -52,22 +52,11 @@ struct rt2x00_rate {
 extern const struct rt2x00_rate rt2x00_supported_rates[12];
-static inline u16 rt2x00_create_rate_hw_value(const u16 index,
-                                              const u16 short_preamble)
-{
-        return (short_preamble << 8) | (index & 0xff);
-}
 static inline const struct rt2x00_rate *rt2x00_get_rate(const u16 hw_value)
 {
        return &rt2x00_supported_rates[hw_value & 0xff];
 }
-static inline int rt2x00_get_rate_preamble(const u16 hw_value)
-{
-        return (hw_value & 0xff00);
-}
 /*
 * Radio control handlers.
 */
diff --git a/drivers/net/wireless/rt2x00/rt2x00queue.c b/drivers/net/wireless/rt2x00/rt2x00queue.c
index eaec6bd93ed5..0709decec9c2 100644
--- a/drivers/net/wireless/rt2x00/rt2x00queue.c
+++ b/drivers/net/wireless/rt2x00/rt2x00queue.c
@@ -154,6 +154,7 @@ static void rt2x00queue_create_tx_descriptor(struct queue_entry *entry,
        struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
        struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(entry->skb);
        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)entry->skb->data;
+        struct ieee80211_tx_rate *txrate = &tx_info->control.rates[0];
        struct ieee80211_rate *rate =
            ieee80211_get_tx_rate(rt2x00dev->hw, tx_info);
        const struct rt2x00_rate *hwrate;
@@ -313,7 +314,7 @@ static void rt2x00queue_create_tx_descriptor(struct queue_entry *entry,
                 * When preamble is enabled we should set the
                 * preamble bit for the signal.
                 */
-                if (rt2x00_get_rate_preamble(rate->hw_value))
+                if (txrate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
                        txdesc->signal |= 0x08;
        }
 }
diff --git a/drivers/net/wireless/rt2x00/rt2x00rfkill.c b/drivers/net/wireless/rt2x00/rt2x00rfkill.c
index c3f53a92180a..3298cae1e12d 100644
--- a/drivers/net/wireless/rt2x00/rt2x00rfkill.c
+++ b/drivers/net/wireless/rt2x00/rt2x00rfkill.c
@@ -162,7 +162,7 @@ void rt2x00rfkill_allocate(struct rt2x00_dev *rt2x00dev)
 void rt2x00rfkill_free(struct rt2x00_dev *rt2x00dev)
 {
-        if (!test_bit(RFKILL_STATE_ALLOCATED, &rt2x00dev->flags))
+        if (!test_bit(RFKILL_STATE_ALLOCATED, &rt2x00dev->rfkill_state))
                return;
        cancel_delayed_work_sync(&rt2x00dev->rfkill_work);
diff --git a/drivers/net/wireless/rt2x00/rt2x00usb.c b/drivers/net/wireless/rt2x00/rt2x00usb.c
index 83df312ac56f..0b29d767a258 100644
--- a/drivers/net/wireless/rt2x00/rt2x00usb.c
+++ b/drivers/net/wireless/rt2x00/rt2x00usb.c
@@ -434,11 +434,11 @@ static int rt2x00usb_find_endpoints(struct rt2x00_dev *rt2x00dev)
                if (usb_endpoint_is_bulk_in(ep_desc)) {
                        rt2x00usb_assign_endpoint(rt2x00dev->rx, ep_desc);
-                } else if (usb_endpoint_is_bulk_out(ep_desc)) {
+                } else if (usb_endpoint_is_bulk_out(ep_desc) &&
+                           (queue != queue_end(rt2x00dev))) {
                        rt2x00usb_assign_endpoint(queue, ep_desc);
+                        queue = queue_next(queue);
-                        if (queue != queue_end(rt2x00dev))
-                                queue = queue_next(queue);
                        tx_ep_desc = ep_desc;
                }
        }
diff --git a/drivers/net/wireless/rt2x00/rt73usb.c b/drivers/net/wireless/rt2x00/rt73usb.c
index d638a8a59370..96a8d69f8790 100644
--- a/drivers/net/wireless/rt2x00/rt73usb.c
+++ b/drivers/net/wireless/rt2x00/rt73usb.c
@@ -2321,6 +2321,7 @@ static struct usb_device_id rt73usb_device_table[] = {
        /* Linksys */
        { USB_DEVICE(0x13b1, 0x0020), USB_DEVICE_DATA(&rt73usb_ops) },
        { USB_DEVICE(0x13b1, 0x0023), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x13b1, 0x0028), USB_DEVICE_DATA(&rt73usb_ops) },
        /* MSI */
        { USB_DEVICE(0x0db0, 0x6877), USB_DEVICE_DATA(&rt73usb_ops) },
        { USB_DEVICE(0x0db0, 0x6874), USB_DEVICE_DATA(&rt73usb_ops) },
diff --git a/drivers/net/wireless/rtl818x/rtl8180_dev.c b/drivers/net/wireless/rtl818x/rtl8180_dev.c
index 5f887fb137a9..387c133ec0f2 100644
--- a/drivers/net/wireless/rtl818x/rtl8180_dev.c
+++ b/drivers/net/wireless/rtl818x/rtl8180_dev.c
@@ -897,6 +897,7 @@ static int __devinit rtl8180_probe(struct pci_dev *pdev,
        dev->flags = IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING |
                     IEEE80211_HW_RX_INCLUDES_FCS |
                     IEEE80211_HW_SIGNAL_UNSPEC;
+        dev->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
        dev->queues = 1;
        dev->max_signal = 65;
diff --git a/drivers/net/wireless/rtl818x/rtl8187_dev.c b/drivers/net/wireless/rtl818x/rtl8187_dev.c
index 00ce3ef39abe..22bc07ef2f37 100644
--- a/drivers/net/wireless/rtl818x/rtl8187_dev.c
+++ b/drivers/net/wireless/rtl818x/rtl8187_dev.c
@@ -213,7 +213,7 @@ static int rtl8187_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
        urb = usb_alloc_urb(0, GFP_ATOMIC);
        if (!urb) {
                kfree_skb(skb);
-                return -ENOMEM;
+                return NETDEV_TX_OK;
        }
        flags = skb->len;
@@ -273,6 +273,7 @@ static int rtl8187_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
        usb_fill_bulk_urb(urb, priv->udev, usb_sndbulkpipe(priv->udev, ep),
                          buf, skb->len, rtl8187_tx_cb, skb);
+        urb->transfer_flags |= URB_ZERO_PACKET;
        usb_anchor_urb(urb, &priv->anchored);
        rc = usb_submit_urb(urb, GFP_ATOMIC);
        if (rc < 0) {
@@ -281,7 +282,7 @@ static int rtl8187_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
        }
        usb_free_urb(urb);
-        return rc;
+        return NETDEV_TX_OK;
 }
 static void rtl8187_rx_cb(struct urb *urb)
@@ -1471,6 +1472,7 @@ static void __devexit rtl8187_disconnect(struct usb_interface *intf)
        ieee80211_unregister_hw(dev);
        priv = dev->priv;
+        usb_reset_device(priv->udev);
        usb_put_dev(interface_to_usbdev(intf));
        ieee80211_free_hw(dev);
 }
diff --git a/drivers/net/wireless/rtl818x/rtl8187_rtl8225.c b/drivers/net/wireless/rtl818x/rtl8187_rtl8225.c
index 4e75e8e7fa90..78df281b297a 100644
--- a/drivers/net/wireless/rtl818x/rtl8187_rtl8225.c
+++ b/drivers/net/wireless/rtl818x/rtl8187_rtl8225.c
@@ -285,7 +285,10 @@ static void rtl8225_rf_set_tx_power(struct ieee80211_hw *dev, int channel)
        ofdm_power = priv->channels[channel - 1].hw_value >> 4;
        cck_power = min(cck_power, (u8)11);
-        ofdm_power = min(ofdm_power, (u8)35);
+        if (ofdm_power > (u8)15)
+                ofdm_power = 25;
+        else
+                ofdm_power += 10;
        rtl818x_iowrite8(priv, &priv->map->TX_GAIN_CCK,
                         rtl8225_tx_gain_cck_ofdm[cck_power / 6] >> 1);
@@ -536,7 +539,10 @@ static void rtl8225z2_rf_set_tx_power(struct ieee80211_hw *dev, int channel)
        cck_power += priv->txpwr_base & 0xF;
        cck_power = min(cck_power, (u8)35);
-        ofdm_power = min(ofdm_power, (u8)15);
+        if (ofdm_power > (u8)15)
+                ofdm_power = 25;
+        else
+                ofdm_power += 10;
        ofdm_power += priv->txpwr_base >> 4;
        ofdm_power = min(ofdm_power, (u8)35);
diff --git a/drivers/net/wireless/zd1211rw/zd_usb.c b/drivers/net/wireless/zd1211rw/zd_usb.c
index b5db57d2fcf5..17527f765b39 100644
--- a/drivers/net/wireless/zd1211rw/zd_usb.c
+++ b/drivers/net/wireless/zd1211rw/zd_usb.c
@@ -84,6 +84,7 @@ static struct usb_device_id usb_ids[] = {
        { USB_DEVICE(0x0586, 0x340a), .driver_info = DEVICE_ZD1211B },
        { USB_DEVICE(0x0471, 0x1237), .driver_info = DEVICE_ZD1211B },
        { USB_DEVICE(0x07fa, 0x1196), .driver_info = DEVICE_ZD1211B },
+        { USB_DEVICE(0x0df6, 0x0036), .driver_info = DEVICE_ZD1211B },
        /* "Driverless" devices that need ejecting */
        { USB_DEVICE(0x0ace, 0x2011), .driver_info = DEVICE_INSTALLER },
        { USB_DEVICE(0x0ace, 0x20ff), .driver_info = DEVICE_INSTALLER },