70 files changed, 1028 insertions, 522 deletions
diff --git a/drivers/isdn/hardware/mISDN/hfcmulti.c b/drivers/isdn/hardware/mISDN/hfcmulti.c
index a6624ad252c5..1a1420d7a828 100644
--- a/drivers/isdn/hardware/mISDN/hfcmulti.c
+++ b/drivers/isdn/hardware/mISDN/hfcmulti.c
@@ -3152,7 +3152,7 @@ static void
 hfcmulti_pcm(struct hfc_multi *hc, int ch, int slot_tx, int bank_tx,
    int slot_rx, int bank_rx)
 {
-        if (slot_rx < 0 || slot_rx < 0 || bank_tx < 0 || bank_rx < 0) {
+        if (slot_tx < 0 || slot_rx < 0 || bank_tx < 0 || bank_rx < 0) {
                /* disable PCM */
                mode_hfcmulti(hc, ch, hc->chan[ch].protocol, -1, 0, -1, 0);
                return;
diff --git a/drivers/net/3c507.c b/drivers/net/3c507.c
index fbc231153e55..77cf0901a441 100644
--- a/drivers/net/3c507.c
+++ b/drivers/net/3c507.c
@@ -56,6 +56,7 @@ static const char version[] =
 #include <linux/errno.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
+#include <linux/if_ether.h>
 #include <linux/skbuff.h>
 #include <linux/slab.h>
 #include <linux/init.h>
@@ -734,8 +735,7 @@ static void init_82586_mem(struct net_device *dev)
        memcpy_toio(lp->base, init_words + 5, sizeof(init_words) - 10);
        /* Fill in the station address. */
-        memcpy_toio(lp->base+SA_OFFSET, dev->dev_addr,
+        memcpy_toio(lp->base+SA_OFFSET, dev->dev_addr, ETH_ALEN);
-                   sizeof(dev->dev_addr));
        /* The Tx-block list is written as needed.  We just set up the values. */
        lp->tx_cmd_link = IDLELOOP + 4;
diff --git a/drivers/net/atarilance.c b/drivers/net/atarilance.c
index c5721cb38265..cc9ed8643910 100644
--- a/drivers/net/atarilance.c
+++ b/drivers/net/atarilance.c
@@ -663,7 +663,7 @@ static int lance_open( struct net_device *dev )
        while (--i > 0)
                if (DREG & CSR0_IDON)
                        break;
-        if (i < 0 || (DREG & CSR0_ERR)) {
+        if (i <= 0 || (DREG & CSR0_ERR)) {
                DPRINTK( 2, ( "lance_open(): opening %s failed, i=%d, csr0=%04x\n",
                                          dev->name, i, DREG ));
                DREG = CSR0_STOP;
diff --git a/drivers/net/atlx/atl2.c b/drivers/net/atlx/atl2.c
index 255e4e7ea0ee..40cf9e5cb9e2 100644
--- a/drivers/net/atlx/atl2.c
+++ b/drivers/net/atlx/atl2.c
@@ -1959,12 +1959,15 @@ static int atl2_get_eeprom(struct net_device *netdev,
                return -ENOMEM;
        for (i = first_dword; i < last_dword; i++) {
-                if (!atl2_read_eeprom(hw, i*4, &(eeprom_buff[i-first_dword])))
+                if (!atl2_read_eeprom(hw, i*4, &(eeprom_buff[i-first_dword]))) {
-                        return -EIO;
+                        ret_val = -EIO;
+                        goto free;
+                }
        }
        memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 3),
                eeprom->len);
+free:
        kfree(eeprom_buff);
        return ret_val;
diff --git a/drivers/net/benet/be.h b/drivers/net/benet/be.h
index 9e56014d27ed..9fd8e5ecd5d7 100644
--- a/drivers/net/benet/be.h
+++ b/drivers/net/benet/be.h
@@ -275,6 +275,7 @@ struct be_adapter {
        u32 tx_fc;              /* Tx flow control */
        int link_speed;
        u8 port_type;
+        u8 transceiver;
 };
 extern const struct ethtool_ops be_ethtool_ops;
diff --git a/drivers/net/benet/be_cmds.c b/drivers/net/benet/be_cmds.c
index b748c197408f..7f64d562ccaa 100644
--- a/drivers/net/benet/be_cmds.c
+++ b/drivers/net/benet/be_cmds.c
@@ -1479,6 +1479,41 @@ err:
        return status;
 }
+int be_cmd_set_loopback(struct be_adapter *adapter, u8 port_num,
+                        u8 loopback_type, u8 enable)
+{
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_req_set_lmode *req;
+        int status;
+        spin_lock_bh(&adapter->mcc_lock);
+        wrb = wrb_from_mccq(adapter);
+        if (!wrb) {
+                status = -EBUSY;
+                goto err;
+        }
+        req = embedded_payload(wrb);
+        be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0,
+                                OPCODE_LOWLEVEL_SET_LOOPBACK_MODE);
+        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_LOWLEVEL,
+                        OPCODE_LOWLEVEL_SET_LOOPBACK_MODE,
+                        sizeof(*req));
+        req->src_port = port_num;
+        req->dest_port = port_num;
+        req->loopback_type = loopback_type;
+        req->loopback_state = enable;
+        status = be_mcc_notify_wait(adapter);
+err:
+        spin_unlock_bh(&adapter->mcc_lock);
+        return status;
+}
 int be_cmd_loopback_test(struct be_adapter *adapter, u32 port_num,
                u32 loopback_type, u32 pkt_size, u32 num_pkts, u64 pattern)
 {
@@ -1501,6 +1536,7 @@ int be_cmd_loopback_test(struct be_adapter *adapter, u32 port_num,
        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_LOWLEVEL,
                        OPCODE_LOWLEVEL_LOOPBACK_TEST, sizeof(*req));
+        req->hdr.timeout = 4;
        req->pattern = cpu_to_le64(pattern);
        req->src_port = cpu_to_le32(port_num);
diff --git a/drivers/net/benet/be_cmds.h b/drivers/net/benet/be_cmds.h
index 6eed512bb6d4..cb3188f8708d 100644
--- a/drivers/net/benet/be_cmds.h
+++ b/drivers/net/benet/be_cmds.h
@@ -156,6 +156,7 @@ struct be_mcc_mailbox {
 #define OPCODE_LOWLEVEL_HOST_DDR_DMA                    17
 #define OPCODE_LOWLEVEL_LOOPBACK_TEST                   18
+#define OPCODE_LOWLEVEL_SET_LOOPBACK_MODE               19
 struct be_cmd_req_hdr {
        u8 opcode;              /* dword 0 */
@@ -822,6 +823,19 @@ struct be_cmd_resp_loopback_test {
        u32    ticks_compl;
 };
+struct be_cmd_req_set_lmode {
+        struct be_cmd_req_hdr hdr;
+        u8 src_port;
+        u8 dest_port;
+        u8 loopback_type;
+        u8 loopback_state;
+};
+struct be_cmd_resp_set_lmode {
+        struct be_cmd_resp_hdr resp_hdr;
+        u8 rsvd0[4];
+};
 /********************** DDR DMA test *********************/
 struct be_cmd_req_ddrdma_test {
        struct be_cmd_req_hdr hdr;
@@ -928,3 +942,6 @@ extern int be_cmd_ddr_dma_test(struct be_adapter *adapter, u64 pattern,
                        u32 byte_cnt, struct be_dma_mem *cmd);
 extern int be_cmd_get_seeprom_data(struct be_adapter *adapter,
                                struct be_dma_mem *nonemb_cmd);
+extern int be_cmd_set_loopback(struct be_adapter *adapter, u8 port_num,
+                                u8 loopback_type, u8 enable);
diff --git a/drivers/net/benet/be_ethtool.c b/drivers/net/benet/be_ethtool.c
index c5afc0286d4d..f18c02f3a5e4 100644
--- a/drivers/net/benet/be_ethtool.c
+++ b/drivers/net/benet/be_ethtool.c
@@ -118,6 +118,7 @@ static const char et_self_tests[][ETH_GSTRING_LEN] = {
 #define BE_MAC_LOOPBACK 0x0
 #define BE_PHY_LOOPBACK 0x1
 #define BE_ONE_PORT_EXT_LOOPBACK 0x2
+#define BE_NO_LOOPBACK 0xff
 static void
 be_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *drvinfo)
@@ -339,28 +340,50 @@ static int be_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
                status = be_cmd_read_port_type(adapter, adapter->port_num,
                                                &connector);
-                switch (connector) {
+                if (!status) {
-                case 7:
+                        switch (connector) {
-                        ecmd->port = PORT_FIBRE;
+                        case 7:
-                        break;
+                                ecmd->port = PORT_FIBRE;
-                default:
+                                ecmd->transceiver = XCVR_EXTERNAL;
-                        ecmd->port = PORT_TP;
+                                break;
-                        break;
+                        case 0:
+                                ecmd->port = PORT_TP;
+                                ecmd->transceiver = XCVR_EXTERNAL;
+                                break;
+                        default:
+                                ecmd->port = PORT_TP;
+                                ecmd->transceiver = XCVR_INTERNAL;
+                                break;
+                        }
+                } else {
+                        ecmd->port = PORT_AUI;
+                        ecmd->transceiver = XCVR_INTERNAL;
                }
                /* Save for future use */
                adapter->link_speed = ecmd->speed;
                adapter->port_type = ecmd->port;
+                adapter->transceiver = ecmd->transceiver;
        } else {
                ecmd->speed = adapter->link_speed;
                ecmd->port = adapter->port_type;
+                ecmd->transceiver = adapter->transceiver;
        }
        ecmd->duplex = DUPLEX_FULL;
        ecmd->autoneg = AUTONEG_DISABLE;
-        ecmd->supported = (SUPPORTED_10000baseT_Full | SUPPORTED_TP);
        ecmd->phy_address = adapter->port_num;
-        ecmd->transceiver = XCVR_INTERNAL;
+        switch (ecmd->port) {
+        case PORT_FIBRE:
+                ecmd->supported = (SUPPORTED_10000baseT_Full | SUPPORTED_FIBRE);
+                break;
+        case PORT_TP:
+                ecmd->supported = (SUPPORTED_10000baseT_Full | SUPPORTED_TP);
+                break;
+        case PORT_AUI:
+                ecmd->supported = (SUPPORTED_10000baseT_Full | SUPPORTED_AUI);
+                break;
+        }
        return 0;
 }
@@ -489,6 +512,19 @@ err:
        return ret;
 }
+static u64 be_loopback_test(struct be_adapter *adapter, u8 loopback_type,
+                                u64 *status)
+{
+        be_cmd_set_loopback(adapter, adapter->port_num,
+                                loopback_type, 1);
+        *status = be_cmd_loopback_test(adapter, adapter->port_num,
+                                loopback_type, 1500,
+                                2, 0xabc);
+        be_cmd_set_loopback(adapter, adapter->port_num,
+                                BE_NO_LOOPBACK, 1);
+        return *status;
+}
 static void
 be_self_test(struct net_device *netdev, struct ethtool_test *test, u64 *data)
 {
@@ -497,23 +533,18 @@ be_self_test(struct net_device *netdev, struct ethtool_test *test, u64 *data)
        memset(data, 0, sizeof(u64) * ETHTOOL_TESTS_NUM);
        if (test->flags & ETH_TEST_FL_OFFLINE) {
-                data[0] = be_cmd_loopback_test(adapter, adapter->port_num,
+                if (be_loopback_test(adapter, BE_MAC_LOOPBACK,
-                                                BE_MAC_LOOPBACK, 1500,
+                                                &data[0]) != 0) {
-                                                2, 0xabc);
-                if (data[0] != 0)
                        test->flags |= ETH_TEST_FL_FAILED;
+                }
-                data[1] = be_cmd_loopback_test(adapter, adapter->port_num,
+                if (be_loopback_test(adapter, BE_PHY_LOOPBACK,
-                                                BE_PHY_LOOPBACK, 1500,
+                                                &data[1]) != 0) {
-                                                2, 0xabc);
-                if (data[1] != 0)
                        test->flags |= ETH_TEST_FL_FAILED;
+                }
-                data[2] = be_cmd_loopback_test(adapter, adapter->port_num,
+                if (be_loopback_test(adapter, BE_ONE_PORT_EXT_LOOPBACK,
-                                                BE_ONE_PORT_EXT_LOOPBACK,
+                                                &data[2]) != 0) {
-                                                1500, 2, 0xabc);
-                if (data[2] != 0)
                        test->flags |= ETH_TEST_FL_FAILED;
+                }
                data[3] = be_test_ddr_dma(adapter);
                if (data[3] != 0)
diff --git a/drivers/net/bnx2x_main.c b/drivers/net/bnx2x_main.c
index 0bfdf30ea4d1..ca4ed634d55e 100644
--- a/drivers/net/bnx2x_main.c
+++ b/drivers/net/bnx2x_main.c
@@ -7593,6 +7593,8 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                if (bp->cnic_eth_dev.drv_state & CNIC_DRV_STATE_REGD) {
                        bnx2x_set_iscsi_eth_mac_addr(bp, 1);
                        bp->cnic_flags |= BNX2X_CNIC_FLAG_MAC_SET;
+                        bnx2x_init_sb(bp, bp->cnic_sb, bp->cnic_sb_mapping,
+                                      CNIC_SB_ID(bp));
                }
                mutex_unlock(&bp->cnic_mutex);
 #endif
diff --git a/drivers/net/bonding/bond_3ad.c b/drivers/net/bonding/bond_3ad.c
index 0fb7a4964e75..822f586d72af 100644
--- a/drivers/net/bonding/bond_3ad.c
+++ b/drivers/net/bonding/bond_3ad.c
@@ -1580,7 +1580,7 @@ static void ad_agg_selection_logic(struct aggregator *agg)
                // check if any partner replys
                if (best->is_individual) {
                        pr_warning("%s: Warning: No 802.3ad response from the link partner for any adapters in the bond\n",
-                                   best->slave->dev->master->name);
+                                   best->slave ? best->slave->dev->master->name : "NULL");
                }
                best->is_active = 1;
diff --git a/drivers/net/can/mcp251x.c b/drivers/net/can/mcp251x.c
index 9c5a1537939c..1a72ca066a17 100644
--- a/drivers/net/can/mcp251x.c
+++ b/drivers/net/can/mcp251x.c
@@ -990,7 +990,7 @@ static int __devinit mcp251x_can_probe(struct spi_device *spi)
                        goto error_tx_buf;
                }
                priv->spi_rx_buf = kmalloc(SPI_TRANSFER_BUF_LEN, GFP_KERNEL);
-                if (!priv->spi_tx_buf) {
+                if (!priv->spi_rx_buf) {
                        ret = -ENOMEM;
                        goto error_rx_buf;
                }
diff --git a/drivers/net/cs89x0.c b/drivers/net/cs89x0.c
index af9321617ce4..0e79cef95c0a 100644
--- a/drivers/net/cs89x0.c
+++ b/drivers/net/cs89x0.c
@@ -1325,8 +1325,7 @@ net_open(struct net_device *dev)
                write_irq(dev, lp->chip_type, dev->irq);
                ret = request_irq(dev->irq, net_interrupt, 0, dev->name, dev);
                if (ret) {
-                        if (net_debug)
+                        printk(KERN_ERR "cs89x0: request_irq(%d) failed\n", dev->irq);
-                                printk(KERN_DEBUG "cs89x0: request_irq(%d) failed\n", dev->irq);
                        goto bad_out;
                }
        }
diff --git a/drivers/net/davinci_emac.c b/drivers/net/davinci_emac.c
index 34e03104c3c1..33c4fe26178c 100644
--- a/drivers/net/davinci_emac.c
+++ b/drivers/net/davinci_emac.c
@@ -2711,6 +2711,8 @@ static int __devinit davinci_emac_probe(struct platform_device *pdev)
        SET_ETHTOOL_OPS(ndev, &ethtool_ops);
        netif_napi_add(ndev, &priv->napi, emac_poll, EMAC_POLL_WEIGHT);
+        clk_enable(emac_clk);
        /* register the network device */
        SET_NETDEV_DEV(ndev, &pdev->dev);
        rc = register_netdev(ndev);
@@ -2720,7 +2722,6 @@ static int __devinit davinci_emac_probe(struct platform_device *pdev)
                goto netdev_reg_err;
        }
-        clk_enable(emac_clk);
        /* MII/Phy intialisation, mdio bus registration */
        emac_mii = mdiobus_alloc();
@@ -2760,6 +2761,7 @@ mdiobus_quit:
 netdev_reg_err:
 mdio_alloc_err:
+        clk_disable(emac_clk);
 no_irq_res:
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        release_mem_region(res->start, res->end - res->start + 1);
diff --git a/drivers/net/e1000e/82571.c b/drivers/net/e1000e/82571.c
index b979464091bb..02d67d047d96 100644
--- a/drivers/net/e1000e/82571.c
+++ b/drivers/net/e1000e/82571.c
@@ -237,6 +237,8 @@ static s32 e1000_init_mac_params_82571(struct e1000_adapter *adapter)
        /* Set if manageability features are enabled. */
        mac->arc_subsystem_valid = (er32(FWSM) & E1000_FWSM_MODE_MASK)
                        ? true : false;
+        /* Adaptive IFS supported */
+        mac->adaptive_ifs = true;
        /* check for link */
        switch (hw->phy.media_type) {
diff --git a/drivers/net/e1000e/es2lan.c b/drivers/net/e1000e/es2lan.c
index 3028f23da891..e2aa3b788564 100644
--- a/drivers/net/e1000e/es2lan.c
+++ b/drivers/net/e1000e/es2lan.c
@@ -224,6 +224,8 @@ static s32 e1000_init_mac_params_80003es2lan(struct e1000_adapter *adapter)
        /* Set if manageability features are enabled. */
        mac->arc_subsystem_valid = (er32(FWSM) & E1000_FWSM_MODE_MASK)
                        ? true : false;
+        /* Adaptive IFS not supported */
+        mac->adaptive_ifs = false;
        /* check for link */
        switch (hw->phy.media_type) {
diff --git a/drivers/net/e1000e/hw.h b/drivers/net/e1000e/hw.h
index 2784cf44a6f3..eccf29b75c41 100644
--- a/drivers/net/e1000e/hw.h
+++ b/drivers/net/e1000e/hw.h
@@ -818,6 +818,7 @@ struct e1000_mac_info {
        u8  forced_speed_duplex;
+        bool adaptive_ifs;
        bool arc_subsystem_valid;
        bool autoneg;
        bool autoneg_failed;
diff --git a/drivers/net/e1000e/ich8lan.c b/drivers/net/e1000e/ich8lan.c
index 9b09246af064..ad08cf3f40c0 100644
--- a/drivers/net/e1000e/ich8lan.c
+++ b/drivers/net/e1000e/ich8lan.c
@@ -454,6 +454,8 @@ static s32 e1000_init_mac_params_ich8lan(struct e1000_adapter *adapter)
                mac->rar_entry_count--;
        /* Set if manageability features are enabled. */
        mac->arc_subsystem_valid = true;
+        /* Adaptive IFS supported */
+        mac->adaptive_ifs = true;
        /* LED operations */
        switch (mac->type) {
diff --git a/drivers/net/e1000e/lib.c b/drivers/net/e1000e/lib.c
index a86c17548c1e..2fa9b36a2c5a 100644
--- a/drivers/net/e1000e/lib.c
+++ b/drivers/net/e1000e/lib.c
@@ -125,6 +125,7 @@ void e1000_write_vfta_generic(struct e1000_hw *hw, u32 offset, u32 value)
 void e1000e_init_rx_addrs(struct e1000_hw *hw, u16 rar_count)
 {
        u32 i;
+        u8 mac_addr[ETH_ALEN] = {0};
        /* Setup the receive address */
        e_dbg("Programming MAC Address into RAR[0]\n");
@@ -133,12 +134,8 @@ void e1000e_init_rx_addrs(struct e1000_hw *hw, u16 rar_count)
        /* Zero out the other (rar_entry_count - 1) receive addresses */
        e_dbg("Clearing RAR[1-%u]\n", rar_count-1);
-        for (i = 1; i < rar_count; i++) {
+        for (i = 1; i < rar_count; i++)
-                E1000_WRITE_REG_ARRAY(hw, E1000_RA, (i << 1), 0);
+                e1000e_rar_set(hw, mac_addr, i);
-                e1e_flush();
-                E1000_WRITE_REG_ARRAY(hw, E1000_RA, ((i << 1) + 1), 0);
-                e1e_flush();
-        }
 }
 /**
@@ -164,10 +161,19 @@ void e1000e_rar_set(struct e1000_hw *hw, u8 *addr, u32 index)
        rar_high = ((u32) addr[4] | ((u32) addr[5] << 8));
-        rar_high |= E1000_RAH_AV;
+        /* If MAC address zero, no need to set the AV bit */
+        if (rar_low || rar_high)
+                rar_high |= E1000_RAH_AV;
-        E1000_WRITE_REG_ARRAY(hw, E1000_RA, (index << 1), rar_low);
+        /*
-        E1000_WRITE_REG_ARRAY(hw, E1000_RA, ((index << 1) + 1), rar_high);
+         * Some bridges will combine consecutive 32-bit writes into
+         * a single burst write, which will malfunction on some parts.
+         * The flushes avoid this.
+         */
+        ew32(RAL(index), rar_low);
+        e1e_flush();
+        ew32(RAH(index), rar_high);
+        e1e_flush();
 }
 /**
@@ -1609,6 +1615,11 @@ void e1000e_reset_adaptive(struct e1000_hw *hw)
 {
        struct e1000_mac_info *mac = &hw->mac;
+        if (!mac->adaptive_ifs) {
+                e_dbg("Not in Adaptive IFS mode!\n");
+                goto out;
+        }
        mac->current_ifs_val = 0;
        mac->ifs_min_val = IFS_MIN;
        mac->ifs_max_val = IFS_MAX;
@@ -1617,6 +1628,8 @@ void e1000e_reset_adaptive(struct e1000_hw *hw)
        mac->in_ifs_mode = false;
        ew32(AIT, 0);
+out:
+        return;
 }
 /**
@@ -1630,6 +1643,11 @@ void e1000e_update_adaptive(struct e1000_hw *hw)
 {
        struct e1000_mac_info *mac = &hw->mac;
+        if (!mac->adaptive_ifs) {
+                e_dbg("Not in Adaptive IFS mode!\n");
+                goto out;
+        }
        if ((mac->collision_delta * mac->ifs_ratio) > mac->tx_packet_delta) {
                if (mac->tx_packet_delta > MIN_NUM_XMITS) {
                        mac->in_ifs_mode = true;
@@ -1650,6 +1668,8 @@ void e1000e_update_adaptive(struct e1000_hw *hw)
                        ew32(AIT, 0);
                }
        }
+out:
+        return;
 }
 /**
@@ -2287,10 +2307,12 @@ bool e1000e_enable_tx_pkt_filtering(struct e1000_hw *hw)
        s32 ret_val, hdr_csum, csum;
        u8 i, len;
+        hw->mac.tx_pkt_filtering = true;
        /* No manageability, no filtering */
        if (!e1000e_check_mng_mode(hw)) {
                hw->mac.tx_pkt_filtering = false;
-                return 0;
+                goto out;
        }
        /*
@@ -2298,9 +2320,9 @@ bool e1000e_enable_tx_pkt_filtering(struct e1000_hw *hw)
         * reason, disable filtering.
         */
        ret_val = e1000_mng_enable_host_if(hw);
-        if (ret_val != 0) {
+        if (ret_val) {
                hw->mac.tx_pkt_filtering = false;
-                return ret_val;
+                goto out;
        }
        /* Read in the header.  Length and offset are in dwords. */
@@ -2319,17 +2341,17 @@ bool e1000e_enable_tx_pkt_filtering(struct e1000_hw *hw)
         */
        if ((hdr_csum != csum) || (hdr->signature != E1000_IAMT_SIGNATURE)) {
                hw->mac.tx_pkt_filtering = true;
-                return 1;
+                goto out;
        }
        /* Cookie area is valid, make the final check for filtering. */
        if (!(hdr->status & E1000_MNG_DHCP_COOKIE_STATUS_PARSING)) {
                hw->mac.tx_pkt_filtering = false;
-                return 0;
+                goto out;
        }
-        hw->mac.tx_pkt_filtering = true;
+out:
-        return 1;
+        return hw->mac.tx_pkt_filtering;
 }
 /**
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index 9ccb9010dc5b..c3745c9d21aa 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -3315,24 +3315,24 @@ void e1000e_update_stats(struct e1000_adapter *adapter)
        if ((hw->phy.type == e1000_phy_82578) ||
            (hw->phy.type == e1000_phy_82577)) {
                e1e_rphy(hw, HV_SCC_UPPER, &phy_data);
-                e1e_rphy(hw, HV_SCC_LOWER, &phy_data);
+                if (!e1e_rphy(hw, HV_SCC_LOWER, &phy_data))
-                adapter->stats.scc += phy_data;
+                        adapter->stats.scc += phy_data;
                e1e_rphy(hw, HV_ECOL_UPPER, &phy_data);
-                e1e_rphy(hw, HV_ECOL_LOWER, &phy_data);
+                if (!e1e_rphy(hw, HV_ECOL_LOWER, &phy_data))
-                adapter->stats.ecol += phy_data;
+                        adapter->stats.ecol += phy_data;
                e1e_rphy(hw, HV_MCC_UPPER, &phy_data);
-                e1e_rphy(hw, HV_MCC_LOWER, &phy_data);
+                if (!e1e_rphy(hw, HV_MCC_LOWER, &phy_data))
-                adapter->stats.mcc += phy_data;
+                        adapter->stats.mcc += phy_data;
                e1e_rphy(hw, HV_LATECOL_UPPER, &phy_data);
-                e1e_rphy(hw, HV_LATECOL_LOWER, &phy_data);
+                if (!e1e_rphy(hw, HV_LATECOL_LOWER, &phy_data))
-                adapter->stats.latecol += phy_data;
+                        adapter->stats.latecol += phy_data;
                e1e_rphy(hw, HV_DC_UPPER, &phy_data);
-                e1e_rphy(hw, HV_DC_LOWER, &phy_data);
+                if (!e1e_rphy(hw, HV_DC_LOWER, &phy_data))
-                adapter->stats.dc += phy_data;
+                        adapter->stats.dc += phy_data;
        } else {
                adapter->stats.scc += er32(SCC);
                adapter->stats.ecol += er32(ECOL);
@@ -3360,8 +3360,8 @@ void e1000e_update_stats(struct e1000_adapter *adapter)
        if ((hw->phy.type == e1000_phy_82578) ||
            (hw->phy.type == e1000_phy_82577)) {
                e1e_rphy(hw, HV_COLC_UPPER, &phy_data);
-                e1e_rphy(hw, HV_COLC_LOWER, &phy_data);
+                if (!e1e_rphy(hw, HV_COLC_LOWER, &phy_data))
-                hw->mac.collision_delta = phy_data;
+                        hw->mac.collision_delta = phy_data;
        } else {
                hw->mac.collision_delta = er32(COLC);
        }
@@ -3372,8 +3372,8 @@ void e1000e_update_stats(struct e1000_adapter *adapter)
        if ((hw->phy.type == e1000_phy_82578) ||
            (hw->phy.type == e1000_phy_82577)) {
                e1e_rphy(hw, HV_TNCRS_UPPER, &phy_data);
-                e1e_rphy(hw, HV_TNCRS_LOWER, &phy_data);
+                if (!e1e_rphy(hw, HV_TNCRS_LOWER, &phy_data))
-                adapter->stats.tncrs += phy_data;
+                        adapter->stats.tncrs += phy_data;
        } else {
                if ((hw->mac.type != e1000_82574) &&
                    (hw->mac.type != e1000_82583))
@@ -4674,6 +4674,7 @@ static int e1000_resume(struct pci_dev *pdev)
        pci_set_power_state(pdev, PCI_D0);
        pci_restore_state(pdev);
+        pci_save_state(pdev);
        e1000e_disable_l1aspm(pdev);
        err = pci_enable_device_mem(pdev);
@@ -4825,6 +4826,7 @@ static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev)
        } else {
                pci_set_master(pdev);
                pci_restore_state(pdev);
+                pci_save_state(pdev);
                pci_enable_wake(pdev, PCI_D3hot, 0);
                pci_enable_wake(pdev, PCI_D3cold, 0);
diff --git a/drivers/net/fsl_pq_mdio.c b/drivers/net/fsl_pq_mdio.c
index 25fabb3eedc5..d5160edf2fcf 100644
--- a/drivers/net/fsl_pq_mdio.c
+++ b/drivers/net/fsl_pq_mdio.c
@@ -46,6 +46,11 @@
 #include "gianfar.h"
 #include "fsl_pq_mdio.h"
+struct fsl_pq_mdio_priv {
+        void __iomem *map;
+        struct fsl_pq_mdio __iomem *regs;
+};
 /*
 * Write value to the PHY at mii_id at register regnum,
 * on the bus attached to the local interface, which may be different from the
@@ -105,7 +110,9 @@ int fsl_pq_local_mdio_read(struct fsl_pq_mdio __iomem *regs,
 static struct fsl_pq_mdio __iomem *fsl_pq_mdio_get_regs(struct mii_bus *bus)
 {
-        return (void __iomem __force *)bus->priv;
+        struct fsl_pq_mdio_priv *priv = bus->priv;
+        return priv->regs;
 }
 /*
@@ -266,6 +273,7 @@ static int fsl_pq_mdio_probe(struct of_device *ofdev,
 {
        struct device_node *np = ofdev->node;
        struct device_node *tbi;
+        struct fsl_pq_mdio_priv *priv;
        struct fsl_pq_mdio __iomem *regs = NULL;
        void __iomem *map;
        u32 __iomem *tbipa;
@@ -274,14 +282,19 @@ static int fsl_pq_mdio_probe(struct of_device *ofdev,
        u64 addr = 0, size = 0;
        int err = 0;
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
        new_bus = mdiobus_alloc();
        if (NULL == new_bus)
-                return -ENOMEM;
+                goto err_free_priv;
        new_bus->name = "Freescale PowerQUICC MII Bus",
        new_bus->read = &fsl_pq_mdio_read,
        new_bus->write = &fsl_pq_mdio_write,
        new_bus->reset = &fsl_pq_mdio_reset,
+        new_bus->priv = priv;
        fsl_pq_mdio_bus_name(new_bus->id, np);
        /* Set the PHY base address */
@@ -291,6 +304,7 @@ static int fsl_pq_mdio_probe(struct of_device *ofdev,
                err = -ENOMEM;
                goto err_free_bus;
        }
+        priv->map = map;
        if (of_device_is_compatible(np, "fsl,gianfar-mdio") ||
                        of_device_is_compatible(np, "fsl,gianfar-tbi") ||
@@ -298,8 +312,7 @@ static int fsl_pq_mdio_probe(struct of_device *ofdev,
                        of_device_is_compatible(np, "ucc_geth_phy"))
                map -= offsetof(struct fsl_pq_mdio, miimcfg);
        regs = map;
+        priv->regs = regs;
-        new_bus->priv = (void __force *)regs;
        new_bus->irq = kcalloc(PHY_MAX_ADDR, sizeof(int), GFP_KERNEL);
@@ -392,10 +405,11 @@ static int fsl_pq_mdio_probe(struct of_device *ofdev,
 err_free_irqs:
        kfree(new_bus->irq);
 err_unmap_regs:
-        iounmap(regs);
+        iounmap(priv->map);
 err_free_bus:
        kfree(new_bus);
+err_free_priv:
+        kfree(priv);
        return err;
 }
@@ -404,14 +418,16 @@ static int fsl_pq_mdio_remove(struct of_device *ofdev)
 {
        struct device *device = &ofdev->dev;
        struct mii_bus *bus = dev_get_drvdata(device);
+        struct fsl_pq_mdio_priv *priv = bus->priv;
        mdiobus_unregister(bus);
        dev_set_drvdata(device, NULL);
-        iounmap(fsl_pq_mdio_get_regs(bus));
+        iounmap(priv->map);
        bus->priv = NULL;
        mdiobus_free(bus);
+        kfree(priv);
        return 0;
 }
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index e0620d084644..8bd3c9f17532 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -143,7 +143,6 @@ void gfar_start(struct net_device *dev);
 static void gfar_clear_exact_match(struct net_device *dev);
 static void gfar_set_mac_for_addr(struct net_device *dev, int num, u8 *addr);
 static int gfar_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
-u16 gfar_select_queue(struct net_device *dev, struct sk_buff *skb);
 MODULE_AUTHOR("Freescale Semiconductor, Inc");
 MODULE_DESCRIPTION("Gianfar Ethernet Driver");
@@ -455,7 +454,6 @@ static const struct net_device_ops gfar_netdev_ops = {
        .ndo_set_multicast_list = gfar_set_multi,
        .ndo_tx_timeout = gfar_timeout,
        .ndo_do_ioctl = gfar_ioctl,
-        .ndo_select_queue = gfar_select_queue,
        .ndo_get_stats = gfar_get_stats,
        .ndo_vlan_rx_register = gfar_vlan_rx_register,
        .ndo_set_mac_address = eth_mac_addr,
@@ -506,10 +504,6 @@ static inline int gfar_uses_fcb(struct gfar_private *priv)
        return priv->vlgrp || priv->rx_csum_enable;
 }
-u16 gfar_select_queue(struct net_device *dev, struct sk_buff *skb)
-{
-        return skb_get_queue_mapping(skb);
-}
 static void free_tx_pointers(struct gfar_private *priv)
 {
        int i = 0;
@@ -2470,10 +2464,11 @@ static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
        fcb = (struct rxfcb *)skb->data;
        /* Remove the FCB from the skb */
-        skb_set_queue_mapping(skb, fcb->rq);
        /* Remove the padded bytes, if there are any */
-        if (amount_pull)
+        if (amount_pull) {
+                skb_record_rx_queue(skb, fcb->rq);
                skb_pull(skb, amount_pull);
+        }
        if (priv->rx_csum_enable)
                gfar_rx_checksum(skb, fcb);
@@ -2554,7 +2549,7 @@ int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit)
                                /* Remove the FCS from the packet length */
                                skb_put(skb, pkt_len);
                                rx_queue->stats.rx_bytes += pkt_len;
+                                skb_record_rx_queue(skb, rx_queue->qindex);
                                gfar_process_frame(dev, skb, amount_pull);
                        } else {
diff --git a/drivers/net/hamradio/bpqether.c b/drivers/net/hamradio/bpqether.c
index ae5f11c8fc13..bdadf3e23c94 100644
--- a/drivers/net/hamradio/bpqether.c
+++ b/drivers/net/hamradio/bpqether.c
@@ -248,6 +248,7 @@ static netdev_tx_t bpq_xmit(struct sk_buff *skb, struct net_device *dev)
 {
        unsigned char *ptr;
        struct bpqdev *bpq;
+        struct net_device *orig_dev;
        int size;
        /*
@@ -282,8 +283,9 @@ static netdev_tx_t bpq_xmit(struct sk_buff *skb, struct net_device *dev)
        bpq = netdev_priv(dev);
+        orig_dev = dev;
        if ((dev = bpq_get_ether_dev(dev)) == NULL) {
-                dev->stats.tx_dropped++;
+                orig_dev->stats.tx_dropped++;
                kfree_skb(skb);
                return NETDEV_TX_OK;
        }
diff --git a/drivers/net/ibmlana.c b/drivers/net/ibmlana.c
index 090a6d3af112..052c74091d91 100644
--- a/drivers/net/ibmlana.c
+++ b/drivers/net/ibmlana.c
@@ -87,6 +87,7 @@ History:
 #include <linux/module.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
+#include <linux/if_ether.h>
 #include <linux/skbuff.h>
 #include <linux/bitops.h>
@@ -988,7 +989,7 @@ static int __devinit ibmlana_init_one(struct device *kdev)
        /* copy out MAC address */
-        for (z = 0; z < sizeof(dev->dev_addr); z++)
+        for (z = 0; z < ETH_ALEN; z++)
                dev->dev_addr[z] = inb(dev->base_addr + MACADDRPROM + z);
        /* print config */
diff --git a/drivers/net/igb/e1000_82575.c b/drivers/net/igb/e1000_82575.c
index e8e9e9194a88..c505b50d1fa3 100644
--- a/drivers/net/igb/e1000_82575.c
+++ b/drivers/net/igb/e1000_82575.c
@@ -1096,9 +1096,7 @@ static s32 igb_setup_serdes_link_82575(struct e1000_hw *hw)
                hw_dbg("Configuring Autoneg:PCS_LCTL=0x%08X\n", reg);
        } else {
                /* Set PCS register for forced link */
-                reg |= E1000_PCS_LCTL_FSD |        /* Force Speed */
+                reg |= E1000_PCS_LCTL_FSD;        /* Force Speed */
-                       E1000_PCS_LCTL_FORCE_LINK | /* Force Link */
-                       E1000_PCS_LCTL_FLV_LINK_UP; /* Force link value up */
                hw_dbg("Configuring Forced Link:PCS_LCTL=0x%08X\n", reg);
        }
diff --git a/drivers/net/igb/e1000_phy.c b/drivers/net/igb/e1000_phy.c
index 5c9d73e9bb8d..3670a66401b8 100644
--- a/drivers/net/igb/e1000_phy.c
+++ b/drivers/net/igb/e1000_phy.c
@@ -457,15 +457,6 @@ s32 igb_copper_link_setup_82580(struct e1000_hw *hw)
        phy_data |= I82580_CFG_ENABLE_DOWNSHIFT;
        ret_val = phy->ops.write_reg(hw, I82580_CFG_REG, phy_data);
-        if (ret_val)
-                goto out;
-        /* Set number of link attempts before downshift */
-        ret_val = phy->ops.read_reg(hw, I82580_CTRL_REG, &phy_data);
-        if (ret_val)
-                goto out;
-        phy_data &= ~I82580_CTRL_DOWNSHIFT_MASK;
-        ret_val = phy->ops.write_reg(hw, I82580_CTRL_REG, phy_data);
 out:
        return ret_val;
diff --git a/drivers/net/igb/igb_ethtool.c b/drivers/net/igb/igb_ethtool.c
index ac9d5272650d..f771a6c08777 100644
--- a/drivers/net/igb/igb_ethtool.c
+++ b/drivers/net/igb/igb_ethtool.c
@@ -1795,7 +1795,7 @@ static int igb_wol_exclusion(struct igb_adapter *adapter,
                /* dual port cards only support WoL on port A from now on
                 * unless it was enabled in the eeprom for port B
                 * so exclude FUNC_1 ports from having WoL enabled */
-                if (rd32(E1000_STATUS) & E1000_STATUS_FUNC_1 &&
+                if ((rd32(E1000_STATUS) & E1000_STATUS_FUNC_MASK) &&
                    !adapter->eeprom_wol) {
                        wol->supported = 0;
                        break;
diff --git a/drivers/net/igb/igb_main.c b/drivers/net/igb/igb_main.c
index e959b88be314..d9679493c635 100644
--- a/drivers/net/igb/igb_main.c
+++ b/drivers/net/igb/igb_main.c
@@ -1306,13 +1306,8 @@ void igb_reset(struct igb_adapter *adapter)
        hwm = min(((pba << 10) * 9 / 10),
                        ((pba << 10) - 2 * adapter->max_frame_size));
-        if (mac->type < e1000_82576) {
+        fc->high_water = hwm & 0xFFF0;  /* 16-byte granularity */
-                fc->high_water = hwm & 0xFFF8;  /* 8-byte granularity */
+        fc->low_water = fc->high_water - 16;
-                fc->low_water = fc->high_water - 8;
-        } else {
-                fc->high_water = hwm & 0xFFF0;  /* 16-byte granularity */
-                fc->low_water = fc->high_water - 16;
-        }
        fc->pause_time = 0xFFFF;
        fc->send_xon = 1;
        fc->current_mode = fc->requested_mode;
diff --git a/drivers/net/igbvf/netdev.c b/drivers/net/igbvf/netdev.c
index ca0d1906e83e..a6c39209f66f 100644
--- a/drivers/net/igbvf/netdev.c
+++ b/drivers/net/igbvf/netdev.c
@@ -2759,7 +2759,8 @@ static int __devinit igbvf_probe(struct pci_dev *pdev,
        err = hw->mac.ops.reset_hw(hw);
        if (err) {
                dev_info(&pdev->dev,
-                         "PF still in reset state, assigning new address\n");
+                         "PF still in reset state, assigning new address."
+                         " Is the PF interface up?\n");
                random_ether_addr(hw->mac.addr);
        } else {
                err = hw->mac.ops.read_mac_addr(hw);
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index a938dba7bdfe..81971ed607eb 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -305,10 +305,12 @@ static inline bool ixgbe_tx_is_paused(struct ixgbe_adapter *adapter,
                int reg_idx = tx_ring->reg_idx;
                int dcb_i = adapter->ring_feature[RING_F_DCB].indices;
-                if (adapter->hw.mac.type == ixgbe_mac_82598EB) {
+                switch (adapter->hw.mac.type) {
+                case ixgbe_mac_82598EB:
                        tc = reg_idx >> 2;
                        txoff = IXGBE_TFCS_TXOFF0;
-                } else if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
+                        break;
+                case ixgbe_mac_82599EB:
                        tc = 0;
                        txoff = IXGBE_TFCS_TXOFF;
                        if (dcb_i == 8) {
@@ -327,6 +329,9 @@ static inline bool ixgbe_tx_is_paused(struct ixgbe_adapter *adapter,
                                                tc += (reg_idx - 96) >> 4;
                                }
                        }
+                        break;
+                default:
+                        tc = 0;
                }
                txoff <<= tc;
        }
@@ -4558,6 +4563,11 @@ static int ixgbe_resume(struct pci_dev *pdev)
        pci_set_power_state(pdev, PCI_D0);
        pci_restore_state(pdev);
+        /*
+         * pci_restore_state clears dev->state_saved so call
+         * pci_save_state to restore it.
+         */
+        pci_save_state(pdev);
        err = pci_enable_device_mem(pdev);
        if (err) {
diff --git a/drivers/net/ll_temac_main.c b/drivers/net/ll_temac_main.c
index 336e7c7a9275..a8522bd73ae7 100644
--- a/drivers/net/ll_temac_main.c
+++ b/drivers/net/ll_temac_main.c
@@ -134,7 +134,7 @@ static int temac_dma_bd_init(struct net_device *ndev)
        struct sk_buff *skb;
        int i;
-        lp->rx_skb = kzalloc(sizeof(struct sk_buff)*RX_BD_NUM, GFP_KERNEL);
+        lp->rx_skb = kzalloc(sizeof(*lp->rx_skb) * RX_BD_NUM, GFP_KERNEL);
        /* allocate the tx and rx ring buffer descriptors. */
        /* returns a virtual addres and a physical address. */
        lp->tx_bd_v = dma_alloc_coherent(ndev->dev.parent,
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index 1405a170bb43..af67af55efe7 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -656,6 +656,7 @@ static int rxq_refill(struct rx_queue *rxq, int budget)
                struct sk_buff *skb;
                int rx;
                struct rx_desc *rx_desc;
+                int size;
                skb = __skb_dequeue(&mp->rx_recycle);
                if (skb == NULL)
@@ -678,10 +679,11 @@ static int rxq_refill(struct rx_queue *rxq, int budget)
                rx_desc = rxq->rx_desc_area + rx;
+                size = skb->end - skb->data;
                rx_desc->buf_ptr = dma_map_single(mp->dev->dev.parent,
-                                                  skb->data, mp->skb_size,
+                                                  skb->data, size,
                                                  DMA_FROM_DEVICE);
-                rx_desc->buf_size = mp->skb_size;
+                rx_desc->buf_size = size;
                rxq->rx_skb[rx] = skb;
                wmb();
                rx_desc->cmd_sts = BUFFER_OWNED_BY_DMA | RX_ENABLE_INTERRUPT;
diff --git a/drivers/net/netxen/netxen_nic.h b/drivers/net/netxen/netxen_nic.h
index c1223c92d566..8264ae0cbf1d 100644
--- a/drivers/net/netxen/netxen_nic.h
+++ b/drivers/net/netxen/netxen_nic.h
@@ -53,8 +53,8 @@
 #define _NETXEN_NIC_LINUX_MAJOR 4
 #define _NETXEN_NIC_LINUX_MINOR 0
-#define _NETXEN_NIC_LINUX_SUBVERSION 65
+#define _NETXEN_NIC_LINUX_SUBVERSION 72
-#define NETXEN_NIC_LINUX_VERSIONID  "4.0.65"
+#define NETXEN_NIC_LINUX_VERSIONID  "4.0.72"
 #define NETXEN_VERSION_CODE(a, b, c)    (((a) << 24) + ((b) << 16) + (c))
 #define _major(v)       (((v) >> 24) & 0xff)
diff --git a/drivers/net/netxen/netxen_nic_ethtool.c b/drivers/net/netxen/netxen_nic_ethtool.c
index ddd704ae0188..542f408333ff 100644
--- a/drivers/net/netxen/netxen_nic_ethtool.c
+++ b/drivers/net/netxen/netxen_nic_ethtool.c
@@ -66,7 +66,7 @@ static const char netxen_nic_gstrings_test[][ETH_GSTRING_LEN] = {
 #define NETXEN_NIC_TEST_LEN     ARRAY_SIZE(netxen_nic_gstrings_test)
-#define NETXEN_NIC_REGS_COUNT 42
+#define NETXEN_NIC_REGS_COUNT 30
 #define NETXEN_NIC_REGS_LEN (NETXEN_NIC_REGS_COUNT * sizeof(__le32))
 #define NETXEN_MAX_EEPROM_LEN   1024
@@ -312,150 +312,91 @@ static int netxen_nic_get_regs_len(struct net_device *dev)
        return NETXEN_NIC_REGS_LEN;
 }
-struct netxen_niu_regs {
-        __u32 reg[NETXEN_NIC_REGS_COUNT];
-};
-static struct netxen_niu_regs niu_registers[] = {
-        {
-         /* GB Mode */
-         {
-          NETXEN_NIU_GB_SERDES_RESET,
-          NETXEN_NIU_GB0_MII_MODE,
-          NETXEN_NIU_GB1_MII_MODE,
-          NETXEN_NIU_GB2_MII_MODE,
-          NETXEN_NIU_GB3_MII_MODE,
-          NETXEN_NIU_GB0_GMII_MODE,
-          NETXEN_NIU_GB1_GMII_MODE,
-          NETXEN_NIU_GB2_GMII_MODE,
-          NETXEN_NIU_GB3_GMII_MODE,
-          NETXEN_NIU_REMOTE_LOOPBACK,
-          NETXEN_NIU_GB0_HALF_DUPLEX,
-          NETXEN_NIU_GB1_HALF_DUPLEX,
-          NETXEN_NIU_RESET_SYS_FIFOS,
-          NETXEN_NIU_GB_CRC_DROP,
-          NETXEN_NIU_GB_DROP_WRONGADDR,
-          NETXEN_NIU_TEST_MUX_CTL,
-          NETXEN_NIU_GB_MAC_CONFIG_0(0),
-          NETXEN_NIU_GB_MAC_CONFIG_1(0),
-          NETXEN_NIU_GB_HALF_DUPLEX_CTRL(0),
-          NETXEN_NIU_GB_MAX_FRAME_SIZE(0),
-          NETXEN_NIU_GB_TEST_REG(0),
-          NETXEN_NIU_GB_MII_MGMT_CONFIG(0),
-          NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
-          NETXEN_NIU_GB_MII_MGMT_ADDR(0),
-          NETXEN_NIU_GB_MII_MGMT_CTRL(0),
-          NETXEN_NIU_GB_MII_MGMT_STATUS(0),
-          NETXEN_NIU_GB_MII_MGMT_INDICATE(0),
-          NETXEN_NIU_GB_INTERFACE_CTRL(0),
-          NETXEN_NIU_GB_INTERFACE_STATUS(0),
-          NETXEN_NIU_GB_STATION_ADDR_0(0),
-          NETXEN_NIU_GB_STATION_ADDR_1(0),
-          -1,
-          }
-         },
-        {
-         /* XG Mode */
-         {
-          NETXEN_NIU_XG_SINGLE_TERM,
-          NETXEN_NIU_XG_DRIVE_HI,
-          NETXEN_NIU_XG_DRIVE_LO,
-          NETXEN_NIU_XG_DTX,
-          NETXEN_NIU_XG_DEQ,
-          NETXEN_NIU_XG_WORD_ALIGN,
-          NETXEN_NIU_XG_RESET,
-          NETXEN_NIU_XG_POWER_DOWN,
-          NETXEN_NIU_XG_RESET_PLL,
-          NETXEN_NIU_XG_SERDES_LOOPBACK,
-          NETXEN_NIU_XG_DO_BYTE_ALIGN,
-          NETXEN_NIU_XG_TX_ENABLE,
-          NETXEN_NIU_XG_RX_ENABLE,
-          NETXEN_NIU_XG_STATUS,
-          NETXEN_NIU_XG_PAUSE_THRESHOLD,
-          NETXEN_NIU_XGE_CONFIG_0,
-          NETXEN_NIU_XGE_CONFIG_1,
-          NETXEN_NIU_XGE_IPG,
-          NETXEN_NIU_XGE_STATION_ADDR_0_HI,
-          NETXEN_NIU_XGE_STATION_ADDR_0_1,
-          NETXEN_NIU_XGE_STATION_ADDR_1_LO,
-          NETXEN_NIU_XGE_STATUS,
-          NETXEN_NIU_XGE_MAX_FRAME_SIZE,
-          NETXEN_NIU_XGE_PAUSE_FRAME_VALUE,
-          NETXEN_NIU_XGE_TX_BYTE_CNT,
-          NETXEN_NIU_XGE_TX_FRAME_CNT,
-          NETXEN_NIU_XGE_RX_BYTE_CNT,
-          NETXEN_NIU_XGE_RX_FRAME_CNT,
-          NETXEN_NIU_XGE_AGGR_ERROR_CNT,
-          NETXEN_NIU_XGE_MULTICAST_FRAME_CNT,
-          NETXEN_NIU_XGE_UNICAST_FRAME_CNT,
-          NETXEN_NIU_XGE_CRC_ERROR_CNT,
-          NETXEN_NIU_XGE_OVERSIZE_FRAME_ERR,
-          NETXEN_NIU_XGE_UNDERSIZE_FRAME_ERR,
-          NETXEN_NIU_XGE_LOCAL_ERROR_CNT,
-          NETXEN_NIU_XGE_REMOTE_ERROR_CNT,
-          NETXEN_NIU_XGE_CONTROL_CHAR_CNT,
-          NETXEN_NIU_XGE_PAUSE_FRAME_CNT,
-          -1,
-          }
-         }
-};
 static void
 netxen_nic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
 {
        struct netxen_adapter *adapter = netdev_priv(dev);
-        __u32 mode, *regs_buff = p;
+        struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
-        int i, window;
+        struct nx_host_sds_ring *sds_ring;
+        u32 *regs_buff = p;
+        int ring, i = 0;
+        int port = adapter->physical_port;
        memset(p, 0, NETXEN_NIC_REGS_LEN);
        regs->version = (1 << 24) | (adapter->ahw.revision_id << 16) |
            (adapter->pdev)->device;
-        /* which mode */
-        regs_buff[0] = NXRD32(adapter, NETXEN_NIU_MODE);
-        mode = regs_buff[0];
-        /* Common registers to all the modes */
-        regs_buff[2] = NXRD32(adapter, NETXEN_NIU_STRAP_VALUE_SAVE_HIGHER);
-        /* GB/XGB Mode */
-        mode = (mode / 2) - 1;
-        window = 0;
-        if (mode <= 1) {
-                for (i = 3; niu_registers[mode].reg[i - 3] != -1; i++) {
-                        /* GB: port specific registers */
-                        if (mode == 0 && i >= 19)
-                                window = adapter->physical_port *
-                                        NETXEN_NIC_PORT_WINDOW;
-                        regs_buff[i] = NXRD32(adapter,
-                                niu_registers[mode].reg[i - 3] + window);
-                }
+        if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
+                return;
+        regs_buff[i++] = NXRD32(adapter, CRB_CMDPEG_STATE);
+        regs_buff[i++] = NXRD32(adapter, CRB_RCVPEG_STATE);
+        regs_buff[i++] = NXRD32(adapter, CRB_FW_CAPABILITIES_1);
+        regs_buff[i++] = NXRDIO(adapter, adapter->crb_int_state_reg);
+        regs_buff[i++] = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
+        regs_buff[i++] = NXRD32(adapter, NX_CRB_DEV_STATE);
+        regs_buff[i++] = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);
+        regs_buff[i++] = NXRD32(adapter, NETXEN_PEG_HALT_STATUS1);
+        regs_buff[i++] = NXRD32(adapter, NETXEN_PEG_HALT_STATUS2);
+        regs_buff[i++] = NXRD32(adapter, NETXEN_CRB_PEG_NET_0+0x3c);
+        regs_buff[i++] = NXRD32(adapter, NETXEN_CRB_PEG_NET_1+0x3c);
+        regs_buff[i++] = NXRD32(adapter, NETXEN_CRB_PEG_NET_2+0x3c);
+        regs_buff[i++] = NXRD32(adapter, NETXEN_CRB_PEG_NET_3+0x3c);
+        if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
+                regs_buff[i++] = NXRD32(adapter, NETXEN_CRB_PEG_NET_4+0x3c);
+                i += 2;
+                regs_buff[i++] = NXRD32(adapter, CRB_XG_STATE_P3);
+                regs_buff[i++] = le32_to_cpu(*(adapter->tx_ring->hw_consumer));
+        } else {
+                i++;
+                regs_buff[i++] = NXRD32(adapter,
+                                        NETXEN_NIU_XGE_CONFIG_0+(0x10000*port));
+                regs_buff[i++] = NXRD32(adapter,
+                                        NETXEN_NIU_XGE_CONFIG_1+(0x10000*port));
+                regs_buff[i++] = NXRD32(adapter, CRB_XG_STATE);
+                regs_buff[i++] = NXRDIO(adapter,
+                                 adapter->tx_ring->crb_cmd_consumer);
+        }
+        regs_buff[i++] = NXRDIO(adapter, adapter->tx_ring->crb_cmd_producer);
+        regs_buff[i++] = NXRDIO(adapter,
+                         recv_ctx->rds_rings[0].crb_rcv_producer);
+        regs_buff[i++] = NXRDIO(adapter,
+                         recv_ctx->rds_rings[1].crb_rcv_producer);
+        regs_buff[i++] = adapter->max_sds_rings;
+        for (ring = 0; ring < adapter->max_sds_rings; ring++) {
+                sds_ring = &(recv_ctx->sds_rings[ring]);
+                regs_buff[i++] = NXRDIO(adapter,
+                                        sds_ring->crb_sts_consumer);
        }
 }
 static u32 netxen_nic_test_link(struct net_device *dev)
 {
        struct netxen_adapter *adapter = netdev_priv(dev);
-        __u32 status;
+        u32 val, port;
-        int val;
-        /* read which mode */
+        port = adapter->physical_port;
-        if (adapter->ahw.port_type == NETXEN_NIC_GBE) {
+        if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
-                if (adapter->phy_read &&
+                val = NXRD32(adapter, CRB_XG_STATE_P3);
-                    adapter->phy_read(adapter,
+                val = XG_LINK_STATE_P3(adapter->ahw.pci_func, val);
-                                      NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
+                return (val == XG_LINK_UP_P3) ? 0 : 1;
-                                      &status) != 0)
+        } else {
-                        return -EIO;
-                else {
-                        val = netxen_get_phy_link(status);
-                        return !val;
-                }
-        } else if (adapter->ahw.port_type == NETXEN_NIC_XGBE) {
                val = NXRD32(adapter, CRB_XG_STATE);
+                val = (val >> port*8) & 0xff;
                return (val == XG_LINK_UP) ? 0 : 1;
        }
-        return -EIO;
 }
 static int
diff --git a/drivers/net/netxen/netxen_nic_hw.c b/drivers/net/netxen/netxen_nic_hw.c
index 2e364fee3cbb..85e28e60ecf1 100644
--- a/drivers/net/netxen/netxen_nic_hw.c
+++ b/drivers/net/netxen/netxen_nic_hw.c
@@ -345,8 +345,7 @@ netxen_pcie_sem_lock(struct netxen_adapter *adapter, int sem, u32 id_reg)
 void
 netxen_pcie_sem_unlock(struct netxen_adapter *adapter, int sem)
 {
-        int val;
+        NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM_UNLOCK(sem)));
-        val = NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM_UNLOCK(sem)));
 }
 int netxen_niu_xg_init_port(struct netxen_adapter *adapter, int port)
@@ -691,6 +690,9 @@ void netxen_p3_nic_set_multi(struct net_device *netdev)
        struct list_head *head;
        nx_mac_list_t *cur;
+        if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
+                return;
        list_splice_tail_init(&adapter->mac_list, &del_list);
        nx_p3_nic_add_mac(adapter, adapter->mac_addr, &del_list);
diff --git a/drivers/net/netxen/netxen_nic_init.c b/drivers/net/netxen/netxen_nic_init.c
index ba62411f3532..333bd325f58e 100644
--- a/drivers/net/netxen/netxen_nic_init.c
+++ b/drivers/net/netxen/netxen_nic_init.c
@@ -184,6 +184,8 @@ skip_rds:
        tx_ring = adapter->tx_ring;
        vfree(tx_ring->cmd_buf_arr);
+        kfree(tx_ring);
+        adapter->tx_ring = NULL;
 }
 int netxen_alloc_sw_resources(struct netxen_adapter *adapter)
@@ -785,7 +787,7 @@ netxen_need_fw_reset(struct netxen_adapter *adapter)
        if (NXRD32(adapter, CRB_CMDPEG_STATE) == PHAN_INITIALIZE_FAILED)
                return 1;
-        old_count = count = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);
+        old_count = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);
        for (i = 0; i < 10; i++) {
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index 3fdfc9b7c5b2..def4a07357d6 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -342,7 +342,7 @@ netxen_check_hw_init(struct netxen_adapter *adapter, int first_boot)
                if (!(first_boot & 0x4)) {
                        first_boot |= 0x4;
                        NXWR32(adapter, NETXEN_PCIE_REG(0x4), first_boot);
-                        first_boot = NXRD32(adapter, NETXEN_PCIE_REG(0x4));
+                        NXRD32(adapter, NETXEN_PCIE_REG(0x4));
                }
                /* This is the first boot after power up */
@@ -1952,12 +1952,8 @@ static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
                linkup = (val == XG_LINK_UP_P3);
        } else {
                val = NXRD32(adapter, CRB_XG_STATE);
-                if (adapter->ahw.port_type == NETXEN_NIC_GBE)
+                val = (val >> port*8) & 0xff;
-                        linkup = (val >> port) & 1;
+                linkup = (val == XG_LINK_UP);
-                else {
-                        val = (val >> port*8) & 0xff;
-                        linkup = (val == XG_LINK_UP);
-                }
        }
        netxen_advert_link_change(adapter, linkup);
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index 920f0ecf7a0a..0e260cfbff7b 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -2844,7 +2844,7 @@ static int tcam_wait_bit(struct niu *np, u64 bit)
                        break;
                udelay(1);
        }
-        if (limit < 0)
+        if (limit <= 0)
                return -ENODEV;
        return 0;
diff --git a/drivers/net/pcmcia/nmclan_cs.c b/drivers/net/pcmcia/nmclan_cs.c
index 8a5ae3b182ed..12e3233868e9 100644
--- a/drivers/net/pcmcia/nmclan_cs.c
+++ b/drivers/net/pcmcia/nmclan_cs.c
@@ -1402,7 +1402,6 @@ static void BuildLAF(int *ladrf, int *adr)
  for (i = 0; i < 8; i++)
    printk(KERN_CONT " %02X", ladrf[i]);
  printk(KERN_CONT "\n");
-  }
 #endif
 } /* BuildLAF */
diff --git a/drivers/net/pcmcia/pcnet_cs.c b/drivers/net/pcmcia/pcnet_cs.c
index 92ed3fbf89a5..776cad2f5715 100644
--- a/drivers/net/pcmcia/pcnet_cs.c
+++ b/drivers/net/pcmcia/pcnet_cs.c
@@ -1741,7 +1741,7 @@ static struct pcmcia_device_id pcnet_ids[] = {
        PCMCIA_MFC_DEVICE_CIS_PROD_ID4(0, "NSC MF LAN/Modem", 0x58fc6056, "cis/DP83903.cis"),
        PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0175, 0x0000, "cis/DP83903.cis"),
        PCMCIA_DEVICE_CIS_MANF_CARD(0xc00f, 0x0002, "cis/LA-PCM.cis"),
-        PCMCIA_DEVICE_CIS_PROD_ID12("KTI", "PE520 PLUS", 0xad180345, 0x9d58d392, "PE520.cis"),
+        PCMCIA_DEVICE_CIS_PROD_ID12("KTI", "PE520 PLUS", 0xad180345, 0x9d58d392, "cis/PE520.cis"),
        PCMCIA_DEVICE_CIS_PROD_ID12("NDC", "Ethernet", 0x01c43ae1, 0x00b2e941, "cis/NE2K.cis"),
        PCMCIA_DEVICE_CIS_PROD_ID12("PMX   ", "PE-200", 0x34f3f1c8, 0x10b59f8c, "cis/PE-200.cis"),
        PCMCIA_DEVICE_CIS_PROD_ID12("TAMARACK", "Ethernet", 0xcf434fba, 0x00b2e941, "cis/tamarack.cis"),
@@ -1754,7 +1754,7 @@ MODULE_DEVICE_TABLE(pcmcia, pcnet_ids);
 MODULE_FIRMWARE("cis/PCMLM28.cis");
 MODULE_FIRMWARE("cis/DP83903.cis");
 MODULE_FIRMWARE("cis/LA-PCM.cis");
-MODULE_FIRMWARE("PE520.cis");
+MODULE_FIRMWARE("cis/PE520.cis");
 MODULE_FIRMWARE("cis/NE2K.cis");
 MODULE_FIRMWARE("cis/PE-200.cis");
 MODULE_FIRMWARE("cis/tamarack.cis");
diff --git a/drivers/net/pcnet32.c b/drivers/net/pcnet32.c
index ed62ac6d9c0e..0dc7ff896eeb 100644
--- a/drivers/net/pcnet32.c
+++ b/drivers/net/pcnet32.c
@@ -45,6 +45,7 @@ static const char *const version =
 #include <linux/crc32.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
+#include <linux/if_ether.h>
 #include <linux/skbuff.h>
 #include <linux/spinlock.h>
 #include <linux/moduleparam.h>
@@ -1765,7 +1766,7 @@ pcnet32_probe1(unsigned long ioaddr, int shared, struct pci_dev *pdev)
        /* if the ethernet address is not valid, force to 00:00:00:00:00:00 */
        if (!is_valid_ether_addr(dev->perm_addr))
-                memset(dev->dev_addr, 0, sizeof(dev->dev_addr));
+                memset(dev->dev_addr, 0, ETH_ALEN);
        if (pcnet32_debug & NETIF_MSG_PROBE) {
                printk(" %pM", dev->dev_addr);
diff --git a/drivers/net/phy/broadcom.c b/drivers/net/phy/broadcom.c
index c13cf64095b6..33c4b12a63ba 100644
--- a/drivers/net/phy/broadcom.c
+++ b/drivers/net/phy/broadcom.c
@@ -331,8 +331,8 @@ static void bcm54xx_adjust_rxrefclk(struct phy_device *phydev)
        bool clk125en = true;
        /* Abort if we are using an untested phy. */
-        if (BRCM_PHY_MODEL(phydev) != PHY_ID_BCM57780 ||
+        if (BRCM_PHY_MODEL(phydev) != PHY_ID_BCM57780 &&
-            BRCM_PHY_MODEL(phydev) != PHY_ID_BCM50610 ||
+            BRCM_PHY_MODEL(phydev) != PHY_ID_BCM50610 &&
            BRCM_PHY_MODEL(phydev) != PHY_ID_BCM50610M)
                return;
diff --git a/drivers/net/phy/mdio_bus.c b/drivers/net/phy/mdio_bus.c
index bd4e8d72dc08..e17b70291bbc 100644
--- a/drivers/net/phy/mdio_bus.c
+++ b/drivers/net/phy/mdio_bus.c
@@ -264,6 +264,8 @@ static int mdio_bus_match(struct device *dev, struct device_driver *drv)
                (phydev->phy_id & phydrv->phy_id_mask));
 }
+#ifdef CONFIG_PM
 static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
 {
        struct device_driver *drv = phydev->dev.driver;
@@ -295,34 +297,88 @@ static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
        return true;
 }
-/* Suspend and resume.  Copied from platform_suspend and
+static int mdio_bus_suspend(struct device *dev)
- * platform_resume
- */
-static int mdio_bus_suspend(struct device * dev, pm_message_t state)
 {
        struct phy_driver *phydrv = to_phy_driver(dev->driver);
        struct phy_device *phydev = to_phy_device(dev);
+        /*
+         * We must stop the state machine manually, otherwise it stops out of
+         * control, possibly with the phydev->lock held. Upon resume, netdev
+         * may call phy routines that try to grab the same lock, and that may
+         * lead to a deadlock.
+         */
+        if (phydev->attached_dev)
+                phy_stop_machine(phydev);
        if (!mdio_bus_phy_may_suspend(phydev))
                return 0;
        return phydrv->suspend(phydev);
 }
-static int mdio_bus_resume(struct device * dev)
+static int mdio_bus_resume(struct device *dev)
 {
        struct phy_driver *phydrv = to_phy_driver(dev->driver);
        struct phy_device *phydev = to_phy_device(dev);
+        int ret;
        if (!mdio_bus_phy_may_suspend(phydev))
+                goto no_resume;
+        ret = phydrv->resume(phydev);
+        if (ret < 0)
+                return ret;
+no_resume:
+        if (phydev->attached_dev)
+                phy_start_machine(phydev, NULL);
+        return 0;
+}
+static int mdio_bus_restore(struct device *dev)
+{
+        struct phy_device *phydev = to_phy_device(dev);
+        struct net_device *netdev = phydev->attached_dev;
+        int ret;
+        if (!netdev)
                return 0;
-        return phydrv->resume(phydev);
+        ret = phy_init_hw(phydev);
+        if (ret < 0)
+                return ret;
+        /* The PHY needs to renegotiate. */
+        phydev->link = 0;
+        phydev->state = PHY_UP;
+        phy_start_machine(phydev, NULL);
+        return 0;
 }
+static struct dev_pm_ops mdio_bus_pm_ops = {
+        .suspend = mdio_bus_suspend,
+        .resume = mdio_bus_resume,
+        .freeze = mdio_bus_suspend,
+        .thaw = mdio_bus_resume,
+        .restore = mdio_bus_restore,
+};
+#define MDIO_BUS_PM_OPS (&mdio_bus_pm_ops)
+#else
+#define MDIO_BUS_PM_OPS NULL
+#endif /* CONFIG_PM */
 struct bus_type mdio_bus_type = {
        .name           = "mdio_bus",
        .match          = mdio_bus_match,
-        .suspend        = mdio_bus_suspend,
+        .pm             = MDIO_BUS_PM_OPS,
-        .resume         = mdio_bus_resume,
 };
 EXPORT_SYMBOL(mdio_bus_type);
diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c
index b10fedd82143..8212b2b93422 100644
--- a/drivers/net/phy/phy_device.c
+++ b/drivers/net/phy/phy_device.c
@@ -378,6 +378,20 @@ void phy_disconnect(struct phy_device *phydev)
 }
 EXPORT_SYMBOL(phy_disconnect);
+int phy_init_hw(struct phy_device *phydev)
+{
+        int ret;
+        if (!phydev->drv || !phydev->drv->config_init)
+                return 0;
+        ret = phy_scan_fixups(phydev);
+        if (ret < 0)
+                return ret;
+        return phydev->drv->config_init(phydev);
+}
 /**
 * phy_attach_direct - attach a network device to a given PHY device pointer
 * @dev: network device to attach
@@ -425,21 +439,7 @@ int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
        /* Do initial configuration here, now that
         * we have certain key parameters
         * (dev_flags and interface) */
-        if (phydev->drv->config_init) {
+        return phy_init_hw(phydev);
-                int err;
-                err = phy_scan_fixups(phydev);
-                if (err < 0)
-                        return err;
-                err = phydev->drv->config_init(phydev);
-                if (err < 0)
-                        return err;
-        }
-        return 0;
 }
 EXPORT_SYMBOL(phy_attach_direct);
diff --git a/drivers/net/rrunner.c b/drivers/net/rrunner.c
index 085f4ec896d3..266baf534964 100644
--- a/drivers/net/rrunner.c
+++ b/drivers/net/rrunner.c
@@ -1293,7 +1293,7 @@ static void rr_dump(struct net_device *dev)
        printk("Error code 0x%x\n", readl(&regs->Fail1));
-        index = (((readl(&regs->EvtPrd) >> 8) & 0xff ) - 1) % EVT_RING_ENTRIES;
+        index = (((readl(&regs->EvtPrd) >> 8) & 0xff) - 1) % TX_RING_ENTRIES;
        cons = rrpriv->dirty_tx;
        printk("TX ring index %i, TX consumer %i\n",
               index, cons);
diff --git a/drivers/net/sfc/efx.c b/drivers/net/sfc/efx.c
index 3591cc9c39c8..62d5cd51a9dd 100644
--- a/drivers/net/sfc/efx.c
+++ b/drivers/net/sfc/efx.c
@@ -741,14 +741,14 @@ static int efx_probe_port(struct efx_nic *efx)
        EFX_LOG(efx, "create port\n");
+        if (phy_flash_cfg)
+                efx->phy_mode = PHY_MODE_SPECIAL;
        /* Connect up MAC/PHY operations table */
        rc = efx->type->probe_port(efx);
        if (rc)
                goto err;
-        if (phy_flash_cfg)
-                efx->phy_mode = PHY_MODE_SPECIAL;
        /* Sanity check MAC address */
        if (is_valid_ether_addr(efx->mac_address)) {
                memcpy(efx->net_dev->dev_addr, efx->mac_address, ETH_ALEN);
diff --git a/drivers/net/sfc/falcon.c b/drivers/net/sfc/falcon.c
index 17afcd26e870..9d009c46e962 100644
--- a/drivers/net/sfc/falcon.c
+++ b/drivers/net/sfc/falcon.c
@@ -925,6 +925,7 @@ static int falcon_probe_port(struct efx_nic *efx)
 static void falcon_remove_port(struct efx_nic *efx)
 {
+        efx->phy_op->remove(efx);
        efx_nic_free_buffer(efx, &efx->stats_buffer);
 }
diff --git a/drivers/net/sfc/falcon_xmac.c b/drivers/net/sfc/falcon_xmac.c
index 3da933f8f079..8ccab2c67a20 100644
--- a/drivers/net/sfc/falcon_xmac.c
+++ b/drivers/net/sfc/falcon_xmac.c
@@ -111,16 +111,12 @@ static void falcon_mask_status_intr(struct efx_nic *efx, bool enable)
        efx_writeo(efx, &reg, FR_AB_XM_MGT_INT_MASK);
 }
-/* Get status of XAUI link */
+static bool falcon_xgxs_link_ok(struct efx_nic *efx)
-static bool falcon_xaui_link_ok(struct efx_nic *efx)
 {
        efx_oword_t reg;
        bool align_done, link_ok = false;
        int sync_status;
-        if (LOOPBACK_INTERNAL(efx))
-                return true;
        /* Read link status */
        efx_reado(efx, &reg, FR_AB_XX_CORE_STAT);
@@ -135,14 +131,24 @@ static bool falcon_xaui_link_ok(struct efx_nic *efx)
        EFX_SET_OWORD_FIELD(reg, FRF_AB_XX_DISPERR, FFE_AB_XX_STAT_ALL_LANES);
        efx_writeo(efx, &reg, FR_AB_XX_CORE_STAT);
-        /* If the link is up, then check the phy side of the xaui link */
-        if (efx->link_state.up && link_ok)
-                if (efx->mdio.mmds & (1 << MDIO_MMD_PHYXS))
-                        link_ok = efx_mdio_phyxgxs_lane_sync(efx);
        return link_ok;
 }
+static bool falcon_xmac_link_ok(struct efx_nic *efx)
+{
+        /*
+         * Check MAC's XGXS link status except when using XGMII loopback
+         * which bypasses the XGXS block.
+         * If possible, check PHY's XGXS link status except when using
+         * MAC loopback.
+         */
+        return (efx->loopback_mode == LOOPBACK_XGMII ||
+                falcon_xgxs_link_ok(efx)) &&
+                (!(efx->mdio.mmds & (1 << MDIO_MMD_PHYXS)) ||
+                 LOOPBACK_INTERNAL(efx) || 
+                 efx_mdio_phyxgxs_lane_sync(efx));
+}
 void falcon_reconfigure_xmac_core(struct efx_nic *efx)
 {
        unsigned int max_frame_len;
@@ -245,9 +251,9 @@ static void falcon_reconfigure_xgxs_core(struct efx_nic *efx)
 /* Try to bring up the Falcon side of the Falcon-Phy XAUI link */
-static bool falcon_check_xaui_link_up(struct efx_nic *efx, int tries)
+static bool falcon_xmac_link_ok_retry(struct efx_nic *efx, int tries)
 {
-        bool mac_up = falcon_xaui_link_ok(efx);
+        bool mac_up = falcon_xmac_link_ok(efx);
        if (LOOPBACK_MASK(efx) & LOOPBACKS_EXTERNAL(efx) & LOOPBACKS_WS ||
            efx_phy_mode_disabled(efx->phy_mode))
@@ -261,7 +267,7 @@ static bool falcon_check_xaui_link_up(struct efx_nic *efx, int tries)
                falcon_reset_xaui(efx);
                udelay(200);
-                mac_up = falcon_xaui_link_ok(efx);
+                mac_up = falcon_xmac_link_ok(efx);
                --tries;
        }
@@ -272,7 +278,7 @@ static bool falcon_check_xaui_link_up(struct efx_nic *efx, int tries)
 static bool falcon_xmac_check_fault(struct efx_nic *efx)
 {
-        return !falcon_check_xaui_link_up(efx, 5);
+        return !falcon_xmac_link_ok_retry(efx, 5);
 }
 static int falcon_reconfigure_xmac(struct efx_nic *efx)
@@ -284,7 +290,7 @@ static int falcon_reconfigure_xmac(struct efx_nic *efx)
        falcon_reconfigure_mac_wrapper(efx);
-        efx->xmac_poll_required = !falcon_check_xaui_link_up(efx, 5);
+        efx->xmac_poll_required = !falcon_xmac_link_ok_retry(efx, 5);
        falcon_mask_status_intr(efx, true);
        return 0;
@@ -357,7 +363,7 @@ void falcon_poll_xmac(struct efx_nic *efx)
                return;
        falcon_mask_status_intr(efx, false);
-        efx->xmac_poll_required = !falcon_check_xaui_link_up(efx, 1);
+        efx->xmac_poll_required = !falcon_xmac_link_ok_retry(efx, 1);
        falcon_mask_status_intr(efx, true);
 }
diff --git a/drivers/net/sfc/mcdi_phy.c b/drivers/net/sfc/mcdi_phy.c
index 0e1bcc5a0d52..eb694af7a473 100644
--- a/drivers/net/sfc/mcdi_phy.c
+++ b/drivers/net/sfc/mcdi_phy.c
@@ -304,31 +304,47 @@ static u32 mcdi_to_ethtool_media(u32 media)
 static int efx_mcdi_phy_probe(struct efx_nic *efx)
 {
-        struct efx_mcdi_phy_cfg *phy_cfg;
+        struct efx_mcdi_phy_cfg *phy_data;
+        u8 outbuf[MC_CMD_GET_LINK_OUT_LEN];
+        u32 caps;
        int rc;
-        /* TODO: Move phy_data initialisation to
+        /* Initialise and populate phy_data */
-         * phy_op->probe/remove, rather than init/fini */
+        phy_data = kzalloc(sizeof(*phy_data), GFP_KERNEL);
-        phy_cfg = kzalloc(sizeof(*phy_cfg), GFP_KERNEL);
+        if (phy_data == NULL)
-        if (phy_cfg == NULL) {
+                return -ENOMEM;
-                rc = -ENOMEM;
-                goto fail_alloc;
+        rc = efx_mcdi_get_phy_cfg(efx, phy_data);
-        }
-        rc = efx_mcdi_get_phy_cfg(efx, phy_cfg);
        if (rc != 0)
                goto fail;
-        efx->phy_type = phy_cfg->type;
+        /* Read initial link advertisement */
+        BUILD_BUG_ON(MC_CMD_GET_LINK_IN_LEN != 0);
+        rc = efx_mcdi_rpc(efx, MC_CMD_GET_LINK, NULL, 0,
+                          outbuf, sizeof(outbuf), NULL);
+        if (rc)
+                goto fail;
+        /* Fill out nic state */
+        efx->phy_data = phy_data;
+        efx->phy_type = phy_data->type;
-        efx->mdio_bus = phy_cfg->channel;
+        efx->mdio_bus = phy_data->channel;
-        efx->mdio.prtad = phy_cfg->port;
+        efx->mdio.prtad = phy_data->port;
-        efx->mdio.mmds = phy_cfg->mmd_mask & ~(1 << MC_CMD_MMD_CLAUSE22);
+        efx->mdio.mmds = phy_data->mmd_mask & ~(1 << MC_CMD_MMD_CLAUSE22);
        efx->mdio.mode_support = 0;
-        if (phy_cfg->mmd_mask & (1 << MC_CMD_MMD_CLAUSE22))
+        if (phy_data->mmd_mask & (1 << MC_CMD_MMD_CLAUSE22))
                efx->mdio.mode_support |= MDIO_SUPPORTS_C22;
-        if (phy_cfg->mmd_mask & ~(1 << MC_CMD_MMD_CLAUSE22))
+        if (phy_data->mmd_mask & ~(1 << MC_CMD_MMD_CLAUSE22))
                efx->mdio.mode_support |= MDIO_SUPPORTS_C45 | MDIO_EMULATE_C22;
+        caps = MCDI_DWORD(outbuf, GET_LINK_OUT_CAP);
+        if (caps & (1 << MC_CMD_PHY_CAP_AN_LBN))
+                efx->link_advertising =
+                        mcdi_to_ethtool_cap(phy_data->media, caps);
+        else
+                phy_data->forced_cap = caps;
        /* Assert that we can map efx -> mcdi loopback modes */
        BUILD_BUG_ON(LOOPBACK_NONE != MC_CMD_LOOPBACK_NONE);
        BUILD_BUG_ON(LOOPBACK_DATA != MC_CMD_LOOPBACK_DATA);
@@ -365,46 +381,6 @@ static int efx_mcdi_phy_probe(struct efx_nic *efx)
         * but by convention we don't */
        efx->loopback_modes &= ~(1 << LOOPBACK_NONE);
-        kfree(phy_cfg);
-        return 0;
-fail:
-        kfree(phy_cfg);
-fail_alloc:
-        return rc;
-}
-static int efx_mcdi_phy_init(struct efx_nic *efx)
-{
-        struct efx_mcdi_phy_cfg *phy_data;
-        u8 outbuf[MC_CMD_GET_LINK_OUT_LEN];
-        u32 caps;
-        int rc;
-        phy_data = kzalloc(sizeof(*phy_data), GFP_KERNEL);
-        if (phy_data == NULL)
-                return -ENOMEM;
-        rc = efx_mcdi_get_phy_cfg(efx, phy_data);
-        if (rc != 0)
-                goto fail;
-        efx->phy_data = phy_data;
-        BUILD_BUG_ON(MC_CMD_GET_LINK_IN_LEN != 0);
-        rc = efx_mcdi_rpc(efx, MC_CMD_GET_LINK, NULL, 0,
-                          outbuf, sizeof(outbuf), NULL);
-        if (rc)
-                goto fail;
-        caps = MCDI_DWORD(outbuf, GET_LINK_OUT_CAP);
-        if (caps & (1 << MC_CMD_PHY_CAP_AN_LBN))
-                efx->link_advertising =
-                        mcdi_to_ethtool_cap(phy_data->media, caps);
-        else
-                phy_data->forced_cap = caps;
        return 0;
 fail:
@@ -504,7 +480,7 @@ static bool efx_mcdi_phy_poll(struct efx_nic *efx)
        return !efx_link_state_equal(&efx->link_state, &old_state);
 }
-static void efx_mcdi_phy_fini(struct efx_nic *efx)
+static void efx_mcdi_phy_remove(struct efx_nic *efx)
 {
        struct efx_mcdi_phy_data *phy_data = efx->phy_data;
@@ -586,10 +562,11 @@ static int efx_mcdi_phy_set_settings(struct efx_nic *efx, struct ethtool_cmd *ec
 struct efx_phy_operations efx_mcdi_phy_ops = {
        .probe          = efx_mcdi_phy_probe,
-        .init           = efx_mcdi_phy_init,
+        .init           = efx_port_dummy_op_int,
        .reconfigure    = efx_mcdi_phy_reconfigure,
        .poll           = efx_mcdi_phy_poll,
-        .fini           = efx_mcdi_phy_fini,
+        .fini           = efx_port_dummy_op_void,
+        .remove         = efx_mcdi_phy_remove,
        .get_settings   = efx_mcdi_phy_get_settings,
        .set_settings   = efx_mcdi_phy_set_settings,
        .run_tests      = NULL,
diff --git a/drivers/net/sfc/net_driver.h b/drivers/net/sfc/net_driver.h
index 34c381f009b7..d5aab5b3fa06 100644
--- a/drivers/net/sfc/net_driver.h
+++ b/drivers/net/sfc/net_driver.h
@@ -524,6 +524,7 @@ struct efx_phy_operations {
        int (*probe) (struct efx_nic *efx);
        int (*init) (struct efx_nic *efx);
        void (*fini) (struct efx_nic *efx);
+        void (*remove) (struct efx_nic *efx);
        int (*reconfigure) (struct efx_nic *efx);
        bool (*poll) (struct efx_nic *efx);
        void (*get_settings) (struct efx_nic *efx,
diff --git a/drivers/net/sfc/nic.c b/drivers/net/sfc/nic.c
index a577be227862..db44224ed2ca 100644
--- a/drivers/net/sfc/nic.c
+++ b/drivers/net/sfc/nic.c
@@ -1576,6 +1576,8 @@ void efx_nic_init_common(struct efx_nic *efx)
        EFX_SET_OWORD_FIELD(temp, FRF_AZ_TX_SOFT_EVT_EN, 1);
        /* Prefetch threshold 2 => fetch when descriptor cache half empty */
        EFX_SET_OWORD_FIELD(temp, FRF_AZ_TX_PREF_THRESHOLD, 2);
+        /* Disable hardware watchdog which can misfire */
+        EFX_SET_OWORD_FIELD(temp, FRF_AZ_TX_PREF_WD_TMR, 0x3fffff);
        /* Squash TX of packets of 16 bytes or less */
        if (efx_nic_rev(efx) >= EFX_REV_FALCON_B0)
                EFX_SET_OWORD_FIELD(temp, FRF_BZ_TX_FLUSH_MIN_LEN_EN, 1);
diff --git a/drivers/net/sfc/qt202x_phy.c b/drivers/net/sfc/qt202x_phy.c
index 3800fc791b2f..ff8f0a417fa3 100644
--- a/drivers/net/sfc/qt202x_phy.c
+++ b/drivers/net/sfc/qt202x_phy.c
@@ -33,6 +33,9 @@
 #define PCS_FW_HEARTBEAT_REG    0xd7ee
 #define PCS_FW_HEARTB_LBN       0
 #define PCS_FW_HEARTB_WIDTH     8
+#define PCS_FW_PRODUCT_CODE_1   0xd7f0
+#define PCS_FW_VERSION_1        0xd7f3
+#define PCS_FW_BUILD_1          0xd7f6
 #define PCS_UC8051_STATUS_REG   0xd7fd
 #define PCS_UC_STATUS_LBN       0
 #define PCS_UC_STATUS_WIDTH     8
@@ -52,14 +55,24 @@ void falcon_qt202x_set_led(struct efx_nic *p, int led, int mode)
 struct qt202x_phy_data {
        enum efx_phy_mode phy_mode;
+        bool bug17190_in_bad_state;
+        unsigned long bug17190_timer;
+        u32 firmware_ver;
 };
 #define QT2022C2_MAX_RESET_TIME 500
 #define QT2022C2_RESET_WAIT 10
-static int qt2025c_wait_reset(struct efx_nic *efx)
+#define QT2025C_MAX_HEARTB_TIME (5 * HZ)
+#define QT2025C_HEARTB_WAIT 100
+#define QT2025C_MAX_FWSTART_TIME (25 * HZ / 10)
+#define QT2025C_FWSTART_WAIT 100
+#define BUG17190_INTERVAL (2 * HZ)
+static int qt2025c_wait_heartbeat(struct efx_nic *efx)
 {
-        unsigned long timeout = jiffies + 10 * HZ;
+        unsigned long timeout = jiffies + QT2025C_MAX_HEARTB_TIME;
        int reg, old_counter = 0;
        /* Wait for firmware heartbeat to start */
@@ -74,11 +87,25 @@ static int qt2025c_wait_reset(struct efx_nic *efx)
                        old_counter = counter;
                else if (counter != old_counter)
                        break;
-                if (time_after(jiffies, timeout))
+                if (time_after(jiffies, timeout)) {
+                        /* Some cables have EEPROMs that conflict with the
+                         * PHY's on-board EEPROM so it cannot load firmware */
+                        EFX_ERR(efx, "If an SFP+ direct attach cable is"
+                                " connected, please check that it complies"
+                                " with the SFP+ specification\n");
                        return -ETIMEDOUT;
-                msleep(10);
+                }
+                msleep(QT2025C_HEARTB_WAIT);
        }
+        return 0;
+}
+static int qt2025c_wait_fw_status_good(struct efx_nic *efx)
+{
+        unsigned long timeout = jiffies + QT2025C_MAX_FWSTART_TIME;
+        int reg;
        /* Wait for firmware status to look good */
        for (;;) {
                reg = efx_mdio_read(efx, MDIO_MMD_PCS, PCS_UC8051_STATUS_REG);
@@ -90,7 +117,178 @@ static int qt2025c_wait_reset(struct efx_nic *efx)
                        break;
                if (time_after(jiffies, timeout))
                        return -ETIMEDOUT;
+                msleep(QT2025C_FWSTART_WAIT);
+        }
+        return 0;
+}
+static void qt2025c_restart_firmware(struct efx_nic *efx)
+{
+        /* Restart microcontroller execution of firmware from RAM */
+        efx_mdio_write(efx, 3, 0xe854, 0x00c0);
+        efx_mdio_write(efx, 3, 0xe854, 0x0040);
+        msleep(50);
+}
+static int qt2025c_wait_reset(struct efx_nic *efx)
+{
+        int rc;
+        rc = qt2025c_wait_heartbeat(efx);
+        if (rc != 0)
+                return rc;
+        rc = qt2025c_wait_fw_status_good(efx);
+        if (rc == -ETIMEDOUT) {
+                /* Bug 17689: occasionally heartbeat starts but firmware status
+                 * code never progresses beyond 0x00.  Try again, once, after
+                 * restarting execution of the firmware image. */
+                EFX_LOG(efx, "bashing QT2025C microcontroller\n");
+                qt2025c_restart_firmware(efx);
+                rc = qt2025c_wait_heartbeat(efx);
+                if (rc != 0)
+                        return rc;
+                rc = qt2025c_wait_fw_status_good(efx);
+        }
+        return rc;
+}
+static void qt2025c_firmware_id(struct efx_nic *efx)
+{
+        struct qt202x_phy_data *phy_data = efx->phy_data;
+        u8 firmware_id[9];
+        size_t i;
+        for (i = 0; i < sizeof(firmware_id); i++)
+                firmware_id[i] = efx_mdio_read(efx, MDIO_MMD_PCS,
+                                               PCS_FW_PRODUCT_CODE_1 + i);
+        EFX_INFO(efx, "QT2025C firmware %xr%d v%d.%d.%d.%d [20%02d-%02d-%02d]\n",
+                 (firmware_id[0] << 8) | firmware_id[1], firmware_id[2],
+                 firmware_id[3] >> 4, firmware_id[3] & 0xf,
+                 firmware_id[4], firmware_id[5],
+                 firmware_id[6], firmware_id[7], firmware_id[8]);
+        phy_data->firmware_ver = ((firmware_id[3] & 0xf0) << 20) |
+                                 ((firmware_id[3] & 0x0f) << 16) |
+                                 (firmware_id[4] << 8) | firmware_id[5];
+}
+static void qt2025c_bug17190_workaround(struct efx_nic *efx)
+{
+        struct qt202x_phy_data *phy_data = efx->phy_data;
+        /* The PHY can get stuck in a state where it reports PHY_XS and PMA/PMD
+         * layers up, but PCS down (no block_lock).  If we notice this state
+         * persisting for a couple of seconds, we switch PMA/PMD loopback
+         * briefly on and then off again, which is normally sufficient to
+         * recover it.
+         */
+        if (efx->link_state.up ||
+            !efx_mdio_links_ok(efx, MDIO_DEVS_PMAPMD | MDIO_DEVS_PHYXS)) {
+                phy_data->bug17190_in_bad_state = false;
+                return;
+        }
+        if (!phy_data->bug17190_in_bad_state) {
+                phy_data->bug17190_in_bad_state = true;
+                phy_data->bug17190_timer = jiffies + BUG17190_INTERVAL;
+                return;
+        }
+        if (time_after_eq(jiffies, phy_data->bug17190_timer)) {
+                EFX_LOG(efx, "bashing QT2025C PMA/PMD\n");
+                efx_mdio_set_flag(efx, MDIO_MMD_PMAPMD, MDIO_CTRL1,
+                                  MDIO_PMA_CTRL1_LOOPBACK, true);
                msleep(100);
+                efx_mdio_set_flag(efx, MDIO_MMD_PMAPMD, MDIO_CTRL1,
+                                  MDIO_PMA_CTRL1_LOOPBACK, false);
+                phy_data->bug17190_timer = jiffies + BUG17190_INTERVAL;
+        }
+}
+static int qt2025c_select_phy_mode(struct efx_nic *efx)
+{
+        struct qt202x_phy_data *phy_data = efx->phy_data;
+        struct falcon_board *board = falcon_board(efx);
+        int reg, rc, i;
+        uint16_t phy_op_mode;
+        /* Only 2.0.1.0+ PHY firmware supports the more optimal SFP+
+         * Self-Configure mode.  Don't attempt any switching if we encounter
+         * older firmware. */
+        if (phy_data->firmware_ver < 0x02000100)
+                return 0;
+        /* In general we will get optimal behaviour in "SFP+ Self-Configure"
+         * mode; however, that powers down most of the PHY when no module is
+         * present, so we must use a different mode (any fixed mode will do)
+         * to be sure that loopbacks will work. */
+        phy_op_mode = (efx->loopback_mode == LOOPBACK_NONE) ? 0x0038 : 0x0020;
+        /* Only change mode if really necessary */
+        reg = efx_mdio_read(efx, 1, 0xc319);
+        if ((reg & 0x0038) == phy_op_mode)
+                return 0;
+        EFX_LOG(efx, "Switching PHY to mode 0x%04x\n", phy_op_mode);
+        /* This sequence replicates the register writes configured in the boot
+         * EEPROM (including the differences between board revisions), except
+         * that the operating mode is changed, and the PHY is prevented from
+         * unnecessarily reloading the main firmware image again. */
+        efx_mdio_write(efx, 1, 0xc300, 0x0000);
+        /* (Note: this portion of the boot EEPROM sequence, which bit-bashes 9
+         * STOPs onto the firmware/module I2C bus to reset it, varies across
+         * board revisions, as the bus is connected to different GPIO/LED
+         * outputs on the PHY.) */
+        if (board->major == 0 && board->minor < 2) {
+                efx_mdio_write(efx, 1, 0xc303, 0x4498);
+                for (i = 0; i < 9; i++) {
+                        efx_mdio_write(efx, 1, 0xc303, 0x4488);
+                        efx_mdio_write(efx, 1, 0xc303, 0x4480);
+                        efx_mdio_write(efx, 1, 0xc303, 0x4490);
+                        efx_mdio_write(efx, 1, 0xc303, 0x4498);
+                }
+        } else {
+                efx_mdio_write(efx, 1, 0xc303, 0x0920);
+                efx_mdio_write(efx, 1, 0xd008, 0x0004);
+                for (i = 0; i < 9; i++) {
+                        efx_mdio_write(efx, 1, 0xc303, 0x0900);
+                        efx_mdio_write(efx, 1, 0xd008, 0x0005);
+                        efx_mdio_write(efx, 1, 0xc303, 0x0920);
+                        efx_mdio_write(efx, 1, 0xd008, 0x0004);
+                }
+                efx_mdio_write(efx, 1, 0xc303, 0x4900);
+        }
+        efx_mdio_write(efx, 1, 0xc303, 0x4900);
+        efx_mdio_write(efx, 1, 0xc302, 0x0004);
+        efx_mdio_write(efx, 1, 0xc316, 0x0013);
+        efx_mdio_write(efx, 1, 0xc318, 0x0054);
+        efx_mdio_write(efx, 1, 0xc319, phy_op_mode);
+        efx_mdio_write(efx, 1, 0xc31a, 0x0098);
+        efx_mdio_write(efx, 3, 0x0026, 0x0e00);
+        efx_mdio_write(efx, 3, 0x0027, 0x0013);
+        efx_mdio_write(efx, 3, 0x0028, 0xa528);
+        efx_mdio_write(efx, 1, 0xd006, 0x000a);
+        efx_mdio_write(efx, 1, 0xd007, 0x0009);
+        efx_mdio_write(efx, 1, 0xd008, 0x0004);
+        /* This additional write is not present in the boot EEPROM.  It
+         * prevents the PHY's internal boot ROM doing another pointless (and
+         * slow) reload of the firmware image (the microcontroller's code
+         * memory is not affected by the microcontroller reset). */
+        efx_mdio_write(efx, 1, 0xc317, 0x00ff);
+        efx_mdio_write(efx, 1, 0xc300, 0x0002);
+        msleep(20);
+        /* Restart microcontroller execution of firmware from RAM */
+        qt2025c_restart_firmware(efx);
+        /* Wait for the microcontroller to be ready again */
+        rc = qt2025c_wait_reset(efx);
+        if (rc < 0) {
+                EFX_ERR(efx, "PHY microcontroller reset during mode switch "
+                                "timed out\n");
+                return rc;
        }
        return 0;
@@ -137,6 +335,16 @@ static int qt202x_reset_phy(struct efx_nic *efx)
 static int qt202x_phy_probe(struct efx_nic *efx)
 {
+        struct qt202x_phy_data *phy_data;
+        phy_data = kzalloc(sizeof(struct qt202x_phy_data), GFP_KERNEL);
+        if (!phy_data)
+                return -ENOMEM;
+        efx->phy_data = phy_data;
+        phy_data->phy_mode = efx->phy_mode;
+        phy_data->bug17190_in_bad_state = false;
+        phy_data->bug17190_timer = 0;
        efx->mdio.mmds = QT202X_REQUIRED_DEVS;
        efx->mdio.mode_support = MDIO_SUPPORTS_C45 | MDIO_EMULATE_C22;
        efx->loopback_modes = QT202X_LOOPBACKS | FALCON_XMAC_LOOPBACKS;
@@ -145,7 +353,6 @@ static int qt202x_phy_probe(struct efx_nic *efx)
 static int qt202x_phy_init(struct efx_nic *efx)
 {
-        struct qt202x_phy_data *phy_data;
        u32 devid;
        int rc;
@@ -155,17 +362,14 @@ static int qt202x_phy_init(struct efx_nic *efx)
                return rc;
        }
-        phy_data = kzalloc(sizeof(struct qt202x_phy_data), GFP_KERNEL);
-        if (!phy_data)
-                return -ENOMEM;
-        efx->phy_data = phy_data;
        devid = efx_mdio_read_id(efx, MDIO_MMD_PHYXS);
        EFX_INFO(efx, "PHY ID reg %x (OUI %06x model %02x revision %x)\n",
                 devid, efx_mdio_id_oui(devid), efx_mdio_id_model(devid),
                 efx_mdio_id_rev(devid));
-        phy_data->phy_mode = efx->phy_mode;
+        if (efx->phy_type == PHY_TYPE_QT2025C)
+                qt2025c_firmware_id(efx);
        return 0;
 }
@@ -183,6 +387,9 @@ static bool qt202x_phy_poll(struct efx_nic *efx)
        efx->link_state.fd = true;
        efx->link_state.fc = efx->wanted_fc;
+        if (efx->phy_type == PHY_TYPE_QT2025C)
+                qt2025c_bug17190_workaround(efx);
        return efx->link_state.up != was_up;
 }
@@ -191,6 +398,10 @@ static int qt202x_phy_reconfigure(struct efx_nic *efx)
        struct qt202x_phy_data *phy_data = efx->phy_data;
        if (efx->phy_type == PHY_TYPE_QT2025C) {
+                int rc = qt2025c_select_phy_mode(efx);
+                if (rc)
+                        return rc;
                /* There are several different register bits which can
                 * disable TX (and save power) on direct-attach cables
                 * or optical transceivers, varying somewhat between
@@ -224,7 +435,7 @@ static void qt202x_phy_get_settings(struct efx_nic *efx, struct ethtool_cmd *ecm
        mdio45_ethtool_gset(&efx->mdio, ecmd);
 }
-static void qt202x_phy_fini(struct efx_nic *efx)
+static void qt202x_phy_remove(struct efx_nic *efx)
 {
        /* Free the context block */
        kfree(efx->phy_data);
@@ -236,7 +447,8 @@ struct efx_phy_operations falcon_qt202x_phy_ops = {
        .init            = qt202x_phy_init,
        .reconfigure     = qt202x_phy_reconfigure,
        .poll            = qt202x_phy_poll,
-        .fini            = qt202x_phy_fini,
+        .fini            = efx_port_dummy_op_void,
+        .remove          = qt202x_phy_remove,
        .get_settings    = qt202x_phy_get_settings,
        .set_settings    = efx_mdio_set_settings,
 };
diff --git a/drivers/net/sfc/siena.c b/drivers/net/sfc/siena.c
index de07a4f031b2..f8c6771e66d8 100644
--- a/drivers/net/sfc/siena.c
+++ b/drivers/net/sfc/siena.c
@@ -133,6 +133,7 @@ static int siena_probe_port(struct efx_nic *efx)
 void siena_remove_port(struct efx_nic *efx)
 {
+        efx->phy_op->remove(efx);
        efx_nic_free_buffer(efx, &efx->stats_buffer);
 }
diff --git a/drivers/net/sfc/tenxpress.c b/drivers/net/sfc/tenxpress.c
index ca11572a49a9..3009c297c135 100644
--- a/drivers/net/sfc/tenxpress.c
+++ b/drivers/net/sfc/tenxpress.c
@@ -202,10 +202,14 @@ static ssize_t set_phy_short_reach(struct device *dev,
        int rc;
        rtnl_lock();
-        efx_mdio_set_flag(efx, MDIO_MMD_PMAPMD, MDIO_PMA_10GBT_TXPWR,
+        if (efx->state != STATE_RUNNING) {
-                          MDIO_PMA_10GBT_TXPWR_SHORT,
+                rc = -EBUSY;
-                          count != 0 && *buf != '0');
+        } else {
-        rc = efx_reconfigure_port(efx);
+                efx_mdio_set_flag(efx, MDIO_MMD_PMAPMD, MDIO_PMA_10GBT_TXPWR,
+                                  MDIO_PMA_10GBT_TXPWR_SHORT,
+                                  count != 0 && *buf != '0');
+                rc = efx_reconfigure_port(efx);
+        }
        rtnl_unlock();
        return rc < 0 ? rc : (ssize_t)count;
@@ -298,36 +302,62 @@ static int tenxpress_init(struct efx_nic *efx)
        return 0;
 }
-static int sfx7101_phy_probe(struct efx_nic *efx)
+static int tenxpress_phy_probe(struct efx_nic *efx)
 {
-        efx->mdio.mmds = TENXPRESS_REQUIRED_DEVS;
+        struct tenxpress_phy_data *phy_data;
-        efx->mdio.mode_support = MDIO_SUPPORTS_C45 | MDIO_EMULATE_C22;
+        int rc;
-        efx->loopback_modes = SFX7101_LOOPBACKS | FALCON_XMAC_LOOPBACKS;
-        return 0;
+        /* Allocate phy private storage */
-}
+        phy_data = kzalloc(sizeof(*phy_data), GFP_KERNEL);
+        if (!phy_data)
+                return -ENOMEM;
+        efx->phy_data = phy_data;
+        phy_data->phy_mode = efx->phy_mode;
+        /* Create any special files */
+        if (efx->phy_type == PHY_TYPE_SFT9001B) {
+                rc = device_create_file(&efx->pci_dev->dev,
+                                        &dev_attr_phy_short_reach);
+                if (rc)
+                        goto fail;
+        }
+        if (efx->phy_type == PHY_TYPE_SFX7101) {
+                efx->mdio.mmds = TENXPRESS_REQUIRED_DEVS;
+                efx->mdio.mode_support = MDIO_SUPPORTS_C45;
+                efx->loopback_modes = SFX7101_LOOPBACKS | FALCON_XMAC_LOOPBACKS;
+                efx->link_advertising = (ADVERTISED_TP | ADVERTISED_Autoneg |
+                                         ADVERTISED_10000baseT_Full);
+        } else {
+                efx->mdio.mmds = TENXPRESS_REQUIRED_DEVS;
+                efx->mdio.mode_support = MDIO_SUPPORTS_C45 | MDIO_EMULATE_C22;
+                efx->loopback_modes = (SFT9001_LOOPBACKS |
+                                       FALCON_XMAC_LOOPBACKS | 
+                                       FALCON_GMAC_LOOPBACKS);
+                efx->link_advertising = (ADVERTISED_TP | ADVERTISED_Autoneg |
+                                         ADVERTISED_10000baseT_Full |
+                                         ADVERTISED_1000baseT_Full |
+                                         ADVERTISED_100baseT_Full);
+        }
-static int sft9001_phy_probe(struct efx_nic *efx)
-{
-        efx->mdio.mmds = TENXPRESS_REQUIRED_DEVS;
-        efx->mdio.mode_support = MDIO_SUPPORTS_C45 | MDIO_EMULATE_C22;
-        efx->loopback_modes = (SFT9001_LOOPBACKS | FALCON_XMAC_LOOPBACKS |
-                               FALCON_GMAC_LOOPBACKS);
        return 0;
+fail:
+        kfree(efx->phy_data);
+        efx->phy_data = NULL;
+        return rc;
 }
 static int tenxpress_phy_init(struct efx_nic *efx)
 {
-        struct tenxpress_phy_data *phy_data;
+        int rc;
-        int rc = 0;
        falcon_board(efx)->type->init_phy(efx);
-        phy_data = kzalloc(sizeof(*phy_data), GFP_KERNEL);
-        if (!phy_data)
-                return -ENOMEM;
-        efx->phy_data = phy_data;
-        phy_data->phy_mode = efx->phy_mode;
        if (!(efx->phy_mode & PHY_MODE_SPECIAL)) {
                if (efx->phy_type == PHY_TYPE_SFT9001A) {
                        int reg;
@@ -341,44 +371,27 @@ static int tenxpress_phy_init(struct efx_nic *efx)
                rc = efx_mdio_wait_reset_mmds(efx, TENXPRESS_REQUIRED_DEVS);
                if (rc < 0)
-                        goto fail;
+                        return rc;
                rc = efx_mdio_check_mmds(efx, TENXPRESS_REQUIRED_DEVS, 0);
                if (rc < 0)
-                        goto fail;
+                        return rc;
        }
        rc = tenxpress_init(efx);
        if (rc < 0)
-                goto fail;
+                return rc;
-        /* Initialise advertising flags */
+        /* Reinitialise flow control settings */
-        efx->link_advertising = (ADVERTISED_TP | ADVERTISED_Autoneg |
-                                  ADVERTISED_10000baseT_Full);
-        if (efx->phy_type != PHY_TYPE_SFX7101)
-                efx->link_advertising |= (ADVERTISED_1000baseT_Full |
-                                           ADVERTISED_100baseT_Full);
        efx_link_set_wanted_fc(efx, efx->wanted_fc);
        efx_mdio_an_reconfigure(efx);
-        if (efx->phy_type == PHY_TYPE_SFT9001B) {
-                rc = device_create_file(&efx->pci_dev->dev,
-                                        &dev_attr_phy_short_reach);
-                if (rc)
-                        goto fail;
-        }
        schedule_timeout_uninterruptible(HZ / 5); /* 200ms */
        /* Let XGXS and SerDes out of reset */
        falcon_reset_xaui(efx);
        return 0;
- fail:
-        kfree(efx->phy_data);
-        efx->phy_data = NULL;
-        return rc;
 }
 /* Perform a "special software reset" on the PHY. The caller is
@@ -589,25 +602,26 @@ static bool tenxpress_phy_poll(struct efx_nic *efx)
        return !efx_link_state_equal(&efx->link_state, &old_state);
 }
-static void tenxpress_phy_fini(struct efx_nic *efx)
+static void sfx7101_phy_fini(struct efx_nic *efx)
 {
        int reg;
+        /* Power down the LNPGA */
+        reg = (1 << PMA_PMD_LNPGA_POWERDOWN_LBN);
+        efx_mdio_write(efx, MDIO_MMD_PMAPMD, PMA_PMD_XCONTROL_REG, reg);
+        /* Waiting here ensures that the board fini, which can turn
+         * off the power to the PHY, won't get run until the LNPGA
+         * powerdown has been given long enough to complete. */
+        schedule_timeout_uninterruptible(LNPGA_PDOWN_WAIT); /* 200 ms */
+}
+static void tenxpress_phy_remove(struct efx_nic *efx)
+{
        if (efx->phy_type == PHY_TYPE_SFT9001B)
                device_remove_file(&efx->pci_dev->dev,
                                   &dev_attr_phy_short_reach);
-        if (efx->phy_type == PHY_TYPE_SFX7101) {
-                /* Power down the LNPGA */
-                reg = (1 << PMA_PMD_LNPGA_POWERDOWN_LBN);
-                efx_mdio_write(efx, MDIO_MMD_PMAPMD, PMA_PMD_XCONTROL_REG, reg);
-                /* Waiting here ensures that the board fini, which can turn
-                 * off the power to the PHY, won't get run until the LNPGA
-                 * powerdown has been given long enough to complete. */
-                schedule_timeout_uninterruptible(LNPGA_PDOWN_WAIT); /* 200 ms */
-        }
        kfree(efx->phy_data);
        efx->phy_data = NULL;
 }
@@ -819,11 +833,12 @@ static void sft9001_set_npage_adv(struct efx_nic *efx, u32 advertising)
 }
 struct efx_phy_operations falcon_sfx7101_phy_ops = {
-        .probe            = sfx7101_phy_probe,
+        .probe            = tenxpress_phy_probe,
        .init             = tenxpress_phy_init,
        .reconfigure      = tenxpress_phy_reconfigure,
        .poll             = tenxpress_phy_poll,
-        .fini             = tenxpress_phy_fini,
+        .fini             = sfx7101_phy_fini,
+        .remove           = tenxpress_phy_remove,
        .get_settings     = tenxpress_get_settings,
        .set_settings     = tenxpress_set_settings,
        .set_npage_adv    = sfx7101_set_npage_adv,
@@ -832,11 +847,12 @@ struct efx_phy_operations falcon_sfx7101_phy_ops = {
 };
 struct efx_phy_operations falcon_sft9001_phy_ops = {
-        .probe            = sft9001_phy_probe,
+        .probe            = tenxpress_phy_probe,
        .init             = tenxpress_phy_init,
        .reconfigure      = tenxpress_phy_reconfigure,
        .poll             = tenxpress_phy_poll,
-        .fini             = tenxpress_phy_fini,
+        .fini             = efx_port_dummy_op_void,
+        .remove           = tenxpress_phy_remove,
        .get_settings     = tenxpress_get_settings,
        .set_settings     = tenxpress_set_settings,
        .set_npage_adv    = sft9001_set_npage_adv,
diff --git a/drivers/net/sfc/tx.c b/drivers/net/sfc/tx.c
index e669f94e821b..a8b70ef6d817 100644
--- a/drivers/net/sfc/tx.c
+++ b/drivers/net/sfc/tx.c
@@ -821,8 +821,6 @@ static void efx_enqueue_unwind(struct efx_tx_queue *tx_queue)
                                           EFX_TXQ_MASK];
                efx_tsoh_free(tx_queue, buffer);
                EFX_BUG_ON_PARANOID(buffer->skb);
-                buffer->len = 0;
-                buffer->continuation = true;
                if (buffer->unmap_len) {
                        unmap_addr = (buffer->dma_addr + buffer->len -
                                      buffer->unmap_len);
@@ -836,6 +834,8 @@ static void efx_enqueue_unwind(struct efx_tx_queue *tx_queue)
                                               PCI_DMA_TODEVICE);
                        buffer->unmap_len = 0;
                }
+                buffer->len = 0;
+                buffer->continuation = true;
        }
 }
diff --git a/drivers/net/sh_eth.c b/drivers/net/sh_eth.c
index ed52c0063a65..42a35f086a9f 100644
--- a/drivers/net/sh_eth.c
+++ b/drivers/net/sh_eth.c
@@ -110,7 +110,7 @@ static void sh_eth_reset(struct net_device *ndev)
                mdelay(1);
                cnt--;
        }
-        if (cnt < 0)
+        if (cnt == 0)
                printk(KERN_ERR "Device reset fail\n");
        /* Table Init */
diff --git a/drivers/net/tulip/Kconfig b/drivers/net/tulip/Kconfig
index 1cc8cf4425d1..516713fa0a05 100644
--- a/drivers/net/tulip/Kconfig
+++ b/drivers/net/tulip/Kconfig
@@ -101,6 +101,10 @@ config TULIP_NAPI_HW_MITIGATION
          If in doubt, say Y.
+config TULIP_DM910X
+        def_bool y
+        depends on TULIP && SPARC
 config DE4X5
        tristate "Generic DECchip & DIGITAL EtherWORKS PCI/EISA"
        depends on PCI || EISA
diff --git a/drivers/net/tulip/dmfe.c b/drivers/net/tulip/dmfe.c
index 8153fdd0af91..2d9f09c6189e 100644
--- a/drivers/net/tulip/dmfe.c
+++ b/drivers/net/tulip/dmfe.c
@@ -92,6 +92,10 @@
 #include <asm/uaccess.h>
 #include <asm/irq.h>
+#ifdef CONFIG_TULIP_DM910X
+#include <linux/of.h>
+#endif
 /* Board/System/Debug information/definition ---------------- */
 #define PCI_DM9132_ID   0x91321282      /* Davicom DM9132 ID */
@@ -377,6 +381,23 @@ static int __devinit dmfe_init_one (struct pci_dev *pdev,
        if (!printed_version++)
                printk(version);
+        /*
+         *      SPARC on-board DM910x chips should be handled by the main
+         *      tulip driver, except for early DM9100s.
+         */
+#ifdef CONFIG_TULIP_DM910X
+        if ((ent->driver_data == PCI_DM9100_ID && pdev->revision >= 0x30) ||
+            ent->driver_data == PCI_DM9102_ID) {
+                struct device_node *dp = pci_device_to_OF_node(pdev);
+                if (dp && of_get_property(dp, "local-mac-address", NULL)) {
+                        printk(KERN_INFO DRV_NAME
+                               ": skipping on-board DM910x (use tulip)\n");
+                        return -ENODEV;
+                }
+        }
+#endif
        /* Init network device */
        dev = alloc_etherdev(sizeof(*db));
        if (dev == NULL)
diff --git a/drivers/net/tulip/tulip_core.c b/drivers/net/tulip/tulip_core.c
index 64aa2d6af08b..cbfdd9fbe005 100644
--- a/drivers/net/tulip/tulip_core.c
+++ b/drivers/net/tulip/tulip_core.c
@@ -196,9 +196,13 @@ struct tulip_chip_table tulip_tbl[] = {
        | HAS_NWAY | HAS_PCI_MWI, tulip_timer, tulip_media_task },
  /* DM910X */
+#ifdef CONFIG_TULIP_DM910X
  { "Davicom DM9102/DM9102A", 128, 0x0001ebef,
        HAS_MII | HAS_MEDIA_TABLE | CSR12_IN_SROM | HAS_ACPI,
        tulip_timer, tulip_media_task },
+#else
+  { NULL },
+#endif
  /* RS7112 */
  { "Conexant LANfinity", 256, 0x0001ebef,
@@ -228,8 +232,10 @@ static DEFINE_PCI_DEVICE_TABLE(tulip_pci_tbl) = {
        { 0x1259, 0xa120, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
        { 0x11F6, 0x9881, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMPEX9881 },
        { 0x8086, 0x0039, PCI_ANY_ID, PCI_ANY_ID, 0, 0, I21145 },
+#ifdef CONFIG_TULIP_DM910X
        { 0x1282, 0x9100, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DM910X },
        { 0x1282, 0x9102, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DM910X },
+#endif
        { 0x1113, 0x1216, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
        { 0x1113, 0x1217, PCI_ANY_ID, PCI_ANY_ID, 0, 0, MX98715 },
        { 0x1113, 0x9511, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
@@ -1299,18 +1305,30 @@ static int __devinit tulip_init_one (struct pci_dev *pdev,
        }
        /*
-         *      Early DM9100's need software CRC and the DMFE driver
+         *      DM910x chips should be handled by the dmfe driver, except
+         *      on-board chips on SPARC systems.  Also, early DM9100s need
+         *      software CRC which only the dmfe driver supports.
         */
-        if (pdev->vendor == 0x1282 && pdev->device == 0x9100)
+#ifdef CONFIG_TULIP_DM910X
-        {
+        if (chip_idx == DM910X) {
-                /* Read Chip revision */
+                struct device_node *dp;
-                if (pdev->revision < 0x30)
-                {
+                if (pdev->vendor == 0x1282 && pdev->device == 0x9100 &&
-                        printk(KERN_ERR PFX "skipping early DM9100 with Crc bug (use dmfe)\n");
+                    pdev->revision < 0x30) {
+                        printk(KERN_INFO PFX
+                               "skipping early DM9100 with Crc bug (use dmfe)\n");
+                        return -ENODEV;
+                }
+                dp = pci_device_to_OF_node(pdev);
+                if (!(dp && of_get_property(dp, "local-mac-address", NULL))) {
+                        printk(KERN_INFO PFX
+                               "skipping DM910x expansion card (use dmfe)\n");
                        return -ENODEV;
                }
        }
+#endif
        /*
         *      Looks for early PCI chipsets where people report hangs
diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index 01e99f22210e..2834a01bae24 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -849,13 +849,13 @@ static void tun_sock_write_space(struct sock *sk)
        if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
                wake_up_interruptible_sync(sk->sk_sleep);
-        tun = container_of(sk, struct tun_sock, sk)->tun;
+        tun = tun_sk(sk)->tun;
        kill_fasync(&tun->fasync, SIGIO, POLL_OUT);
 }
 static void tun_sock_destruct(struct sock *sk)
 {
-        free_netdev(container_of(sk, struct tun_sock, sk)->tun->dev);
+        free_netdev(tun_sk(sk)->tun->dev);
 }
 static struct proto tun_proto = {
@@ -990,7 +990,7 @@ static int tun_set_iff(struct net *net, struct file *file, struct ifreq *ifr)
                sk->sk_write_space = tun_sock_write_space;
                sk->sk_sndbuf = INT_MAX;
-                container_of(sk, struct tun_sock, sk)->tun = tun;
+                tun_sk(sk)->tun = tun;
                security_tun_dev_post_create(sk);
diff --git a/drivers/net/ucc_geth.c b/drivers/net/ucc_geth.c
index afaf088b72ea..96bdc0b43889 100644
--- a/drivers/net/ucc_geth.c
+++ b/drivers/net/ucc_geth.c
@@ -1563,7 +1563,10 @@ static int ugeth_disable(struct ucc_geth_private *ugeth, enum comm_dir mode)
 static void ugeth_quiesce(struct ucc_geth_private *ugeth)
 {
-        /* Wait for and prevent any further xmits. */
+        /* Prevent any further xmits, plus detach the device. */
+        netif_device_detach(ugeth->ndev);
+        /* Wait for any current xmits to finish. */
        netif_tx_disable(ugeth->ndev);
        /* Disable the interrupt to avoid NAPI rescheduling. */
@@ -1577,7 +1580,7 @@ static void ugeth_activate(struct ucc_geth_private *ugeth)
 {
        napi_enable(&ugeth->napi);
        enable_irq(ugeth->ug_info->uf_info.irq);
-        netif_tx_wake_all_queues(ugeth->ndev);
+        netif_device_attach(ugeth->ndev);
 }
 /* Called every time the controller might need to be made
@@ -1648,25 +1651,28 @@ static void adjust_link(struct net_device *dev)
                        ugeth->oldspeed = phydev->speed;
                }
-                /*
-                 * To change the MAC configuration we need to disable the
-                 * controller. To do so, we have to either grab ugeth->lock,
-                 * which is a bad idea since 'graceful stop' commands might
-                 * take quite a while, or we can quiesce driver's activity.
-                 */
-                ugeth_quiesce(ugeth);
-                ugeth_disable(ugeth, COMM_DIR_RX_AND_TX);
-                out_be32(&ug_regs->maccfg2, tempval);
-                out_be32(&uf_regs->upsmr, upsmr);
-                ugeth_enable(ugeth, COMM_DIR_RX_AND_TX);
-                ugeth_activate(ugeth);
                if (!ugeth->oldlink) {
                        new_state = 1;
                        ugeth->oldlink = 1;
                }
+                if (new_state) {
+                        /*
+                         * To change the MAC configuration we need to disable
+                         * the controller. To do so, we have to either grab
+                         * ugeth->lock, which is a bad idea since 'graceful
+                         * stop' commands might take quite a while, or we can
+                         * quiesce driver's activity.
+                         */
+                        ugeth_quiesce(ugeth);
+                        ugeth_disable(ugeth, COMM_DIR_RX_AND_TX);
+                        out_be32(&ug_regs->maccfg2, tempval);
+                        out_be32(&uf_regs->upsmr, upsmr);
+                        ugeth_enable(ugeth, COMM_DIR_RX_AND_TX);
+                        ugeth_activate(ugeth);
+                }
        } else if (ugeth->oldlink) {
                        new_state = 1;
                        ugeth->oldlink = 0;
@@ -3273,7 +3279,7 @@ static int ucc_geth_tx(struct net_device *dev, u8 txQ)
                /* Handle the transmitted buffer and release */
                /* the BD to be used with the current frame  */
-                if ((bd == ugeth->txBd[txQ]) && (netif_queue_stopped(dev) == 0))
+                if (bd == ugeth->txBd[txQ]) /* queue empty? */
                        break;
                dev->stats.tx_packets++;
@@ -3601,6 +3607,7 @@ static int ucc_geth_suspend(struct of_device *ofdev, pm_message_t state)
        if (!netif_running(ndev))
                return 0;
+        netif_device_detach(ndev);
        napi_disable(&ugeth->napi);
        /*
@@ -3659,7 +3666,7 @@ static int ucc_geth_resume(struct of_device *ofdev)
        phy_start(ugeth->phydev);
        napi_enable(&ugeth->napi);
-        netif_start_queue(ndev);
+        netif_device_attach(ndev);
        return 0;
 }
diff --git a/drivers/net/ucc_geth.h b/drivers/net/ucc_geth.h
index a007e2acf651..ef1fbeb11c6e 100644
--- a/drivers/net/ucc_geth.h
+++ b/drivers/net/ucc_geth.h
@@ -838,13 +838,13 @@ struct ucc_geth_hardware_statistics {
                                                           using the maximum is
                                                           easier */
 #define UCC_GETH_SEND_QUEUE_QUEUE_DESCRIPTOR_ALIGNMENT  32
-#define UCC_GETH_SCHEDULER_ALIGNMENT            4       /* This is a guess */
+#define UCC_GETH_SCHEDULER_ALIGNMENT            8       /* This is a guess */
 #define UCC_GETH_TX_STATISTICS_ALIGNMENT        4       /* This is a guess */
 #define UCC_GETH_RX_STATISTICS_ALIGNMENT        4       /* This is a guess */
 #define UCC_GETH_RX_INTERRUPT_COALESCING_ALIGNMENT      64
 #define UCC_GETH_RX_BD_QUEUES_ALIGNMENT         8       /* This is a guess */
 #define UCC_GETH_RX_PREFETCHED_BDS_ALIGNMENT    128     /* This is a guess */
-#define UCC_GETH_RX_EXTENDED_FILTERING_GLOBAL_PARAMETERS_ALIGNMENT 4    /* This
+#define UCC_GETH_RX_EXTENDED_FILTERING_GLOBAL_PARAMETERS_ALIGNMENT 8    /* This
                                                                           is a
                                                                           guess
                                                                         */
@@ -899,16 +899,17 @@ struct ucc_geth_hardware_statistics {
 #define UCC_GETH_UTFS_INIT                      512     /* Tx virtual FIFO size
                                                         */
 #define UCC_GETH_UTFET_INIT                     256     /* 1/2 utfs */
-#define UCC_GETH_UTFTT_INIT                     128
+#define UCC_GETH_UTFTT_INIT                     512
 /* Gigabit Ethernet (1000 Mbps) */
 #define UCC_GETH_URFS_GIGA_INIT                 4096/*2048*/    /* Rx virtual
                                                                   FIFO size */
 #define UCC_GETH_URFET_GIGA_INIT                2048/*1024*/    /* 1/2 urfs */
 #define UCC_GETH_URFSET_GIGA_INIT               3072/*1536*/    /* 3/4 urfs */
-#define UCC_GETH_UTFS_GIGA_INIT                 8192/*2048*/    /* Tx virtual
+#define UCC_GETH_UTFS_GIGA_INIT                 4096/*2048*/    /* Tx virtual
+                                                                   FIFO size */
+#define UCC_GETH_UTFET_GIGA_INIT                2048/*1024*/    /* 1/2 utfs */
+#define UCC_GETH_UTFTT_GIGA_INIT                4096/*0x40*/    /* Tx virtual
                                                                   FIFO size */
-#define UCC_GETH_UTFET_GIGA_INIT                4096/*1024*/    /* 1/2 utfs */
-#define UCC_GETH_UTFTT_GIGA_INIT                0x400/*0x40*/   /* */
 #define UCC_GETH_REMODER_INIT                   0       /* bits that must be
                                                           set */
diff --git a/drivers/net/usb/hso.c b/drivers/net/usb/hso.c
index f78f0903b073..6895f1531238 100644
--- a/drivers/net/usb/hso.c
+++ b/drivers/net/usb/hso.c
@@ -286,6 +286,7 @@ struct hso_device {
        u8 usb_gone;
        struct work_struct async_get_intf;
        struct work_struct async_put_intf;
+        struct work_struct reset_device;
        struct usb_device *usb;
        struct usb_interface *interface;
@@ -332,7 +333,8 @@ static void hso_kick_transmit(struct hso_serial *serial);
 /* Helper functions */
 static int hso_mux_submit_intr_urb(struct hso_shared_int *mux_int,
                                   struct usb_device *usb, gfp_t gfp);
-static void log_usb_status(int status, const char *function);
+static void handle_usb_error(int status, const char *function,
+                             struct hso_device *hso_dev);
 static struct usb_endpoint_descriptor *hso_get_ep(struct usb_interface *intf,
                                                  int type, int dir);
 static int hso_get_mux_ports(struct usb_interface *intf, unsigned char *ports);
@@ -350,6 +352,7 @@ static void async_put_intf(struct work_struct *data);
 static int hso_put_activity(struct hso_device *hso_dev);
 static int hso_get_activity(struct hso_device *hso_dev);
 static void tiocmget_intr_callback(struct urb *urb);
+static void reset_device(struct work_struct *data);
 /*****************************************************************************/
 /* Helping functions                                                         */
 /*****************************************************************************/
@@ -461,10 +464,17 @@ static const struct usb_device_id hso_ids[] = {
        {USB_DEVICE(0x0af0, 0x7501)},           /* GTM 382 */
        {USB_DEVICE(0x0af0, 0x7601)},           /* GE40x */
        {USB_DEVICE(0x0af0, 0x7701)},
+        {USB_DEVICE(0x0af0, 0x7706)},
        {USB_DEVICE(0x0af0, 0x7801)},
        {USB_DEVICE(0x0af0, 0x7901)},
+        {USB_DEVICE(0x0af0, 0x7A01)},
+        {USB_DEVICE(0x0af0, 0x7A05)},
        {USB_DEVICE(0x0af0, 0x8200)},
        {USB_DEVICE(0x0af0, 0x8201)},
+        {USB_DEVICE(0x0af0, 0x8300)},
+        {USB_DEVICE(0x0af0, 0x8302)},
+        {USB_DEVICE(0x0af0, 0x8304)},
+        {USB_DEVICE(0x0af0, 0x8400)},
        {USB_DEVICE(0x0af0, 0xd035)},
        {USB_DEVICE(0x0af0, 0xd055)},
        {USB_DEVICE(0x0af0, 0xd155)},
@@ -473,6 +483,8 @@ static const struct usb_device_id hso_ids[] = {
        {USB_DEVICE(0x0af0, 0xd157)},
        {USB_DEVICE(0x0af0, 0xd257)},
        {USB_DEVICE(0x0af0, 0xd357)},
+        {USB_DEVICE(0x0af0, 0xd058)},
+        {USB_DEVICE(0x0af0, 0xc100)},
        {}
 };
 MODULE_DEVICE_TABLE(usb, hso_ids);
@@ -655,8 +667,8 @@ static void set_serial_by_index(unsigned index, struct hso_serial *serial)
        spin_unlock_irqrestore(&serial_table_lock, flags);
 }
-/* log a meaningful explanation of an USB status */
+static void handle_usb_error(int status, const char *function,
-static void log_usb_status(int status, const char *function)
+                             struct hso_device *hso_dev)
 {
        char *explanation;
@@ -685,10 +697,20 @@ static void log_usb_status(int status, const char *function)
        case -EMSGSIZE:
                explanation = "internal error";
                break;
+        case -EILSEQ:
+        case -EPROTO:
+        case -ETIME:
+        case -ETIMEDOUT:
+                explanation = "protocol error";
+                if (hso_dev)
+                        schedule_work(&hso_dev->reset_device);
+                break;
        default:
                explanation = "unknown status";
                break;
        }
+        /* log a meaningful explanation of an USB status */
        D1("%s: received USB status - %s (%d)", function, explanation, status);
 }
@@ -762,7 +784,7 @@ static void write_bulk_callback(struct urb *urb)
        /* log status, but don't act on it, we don't need to resubmit anything
         * anyhow */
        if (status)
-                log_usb_status(status, __func__);
+                handle_usb_error(status, __func__, odev->parent);
        hso_put_activity(odev->parent);
@@ -806,7 +828,7 @@ static netdev_tx_t hso_net_start_xmit(struct sk_buff *skb,
        result = usb_submit_urb(odev->mux_bulk_tx_urb, GFP_ATOMIC);
        if (result) {
                dev_warn(&odev->parent->interface->dev,
-                        "failed mux_bulk_tx_urb %d", result);
+                        "failed mux_bulk_tx_urb %d\n", result);
                net->stats.tx_errors++;
                netif_start_queue(net);
        } else {
@@ -998,7 +1020,7 @@ static void read_bulk_callback(struct urb *urb)
        /* is al ok?  (Filip: Who's Al ?) */
        if (status) {
-                log_usb_status(status, __func__);
+                handle_usb_error(status, __func__, odev->parent);
                return;
        }
@@ -1019,7 +1041,8 @@ static void read_bulk_callback(struct urb *urb)
        if (odev->parent->port_spec & HSO_INFO_CRC_BUG) {
                u32 rest;
                u8 crc_check[4] = { 0xDE, 0xAD, 0xBE, 0xEF };
-                rest = urb->actual_length % odev->in_endp->wMaxPacketSize;
+                rest = urb->actual_length %
+                        le16_to_cpu(odev->in_endp->wMaxPacketSize);
                if (((rest == 5) || (rest == 6)) &&
                    !memcmp(((u8 *) urb->transfer_buffer) +
                            urb->actual_length - 4, crc_check, 4)) {
@@ -1053,7 +1076,7 @@ static void read_bulk_callback(struct urb *urb)
        result = usb_submit_urb(urb, GFP_ATOMIC);
        if (result)
                dev_warn(&odev->parent->interface->dev,
-                         "%s failed submit mux_bulk_rx_urb %d", __func__,
+                         "%s failed submit mux_bulk_rx_urb %d\n", __func__,
                         result);
 }
@@ -1207,7 +1230,7 @@ static void hso_std_serial_read_bulk_callback(struct urb *urb)
                D1("serial == NULL");
                return;
        } else if (status) {
-                log_usb_status(status, __func__);
+                handle_usb_error(status, __func__, serial->parent);
                return;
        }
@@ -1225,7 +1248,7 @@ static void hso_std_serial_read_bulk_callback(struct urb *urb)
                        u8 crc_check[4] = { 0xDE, 0xAD, 0xBE, 0xEF };
                        rest =
                            urb->actual_length %
-                            serial->in_endp->wMaxPacketSize;
+                            le16_to_cpu(serial->in_endp->wMaxPacketSize);
                        if (((rest == 5) || (rest == 6)) &&
                            !memcmp(((u8 *) urb->transfer_buffer) +
                                    urb->actual_length - 4, crc_check, 4)) {
@@ -1513,7 +1536,7 @@ static void tiocmget_intr_callback(struct urb *urb)
        if (!serial)
                return;
        if (status) {
-                log_usb_status(status, __func__);
+                handle_usb_error(status, __func__, serial->parent);
                return;
        }
        tiocmget = serial->tiocmget;
@@ -1700,6 +1723,10 @@ static int hso_serial_tiocmset(struct tty_struct *tty, struct file *file,
                D1("no tty structures");
                return -EINVAL;
        }
+        if ((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM)
+                return -EINVAL;
        if_num = serial->parent->interface->altsetting->desc.bInterfaceNumber;
        spin_lock_irqsave(&serial->serial_lock, flags);
@@ -1838,7 +1865,7 @@ static int mux_device_request(struct hso_serial *serial, u8 type, u16 port,
        result = usb_submit_urb(ctrl_urb, GFP_ATOMIC);
        if (result) {
                dev_err(&ctrl_urb->dev->dev,
-                        "%s failed submit ctrl_urb %d type %d", __func__,
+                        "%s failed submit ctrl_urb %d type %d\n", __func__,
                        result, type);
                return result;
        }
@@ -1888,7 +1915,7 @@ static void intr_callback(struct urb *urb)
        /* status check */
        if (status) {
-                log_usb_status(status, __func__);
+                handle_usb_error(status, __func__, NULL);
                return;
        }
        D4("\n--- Got intr callback 0x%02X ---", status);
@@ -1905,18 +1932,18 @@ static void intr_callback(struct urb *urb)
                        if (serial != NULL) {
                                D1("Pending read interrupt on port %d\n", i);
                                spin_lock(&serial->serial_lock);
-                                if (serial->rx_state == RX_IDLE) {
+                                if (serial->rx_state == RX_IDLE &&
+                                        serial->open_count > 0) {
                                        /* Setup and send a ctrl req read on
                                         * port i */
-                                if (!serial->rx_urb_filled[0]) {
+                                        if (!serial->rx_urb_filled[0]) {
                                                serial->rx_state = RX_SENT;
                                                hso_mux_serial_read(serial);
                                        } else
                                                serial->rx_state = RX_PENDING;
                                } else {
-                                        D1("Already pending a read on "
+                                        D1("Already a read pending on "
-                                           "port %d\n", i);
+                                           "port %d or port not open\n", i);
                                }
                                spin_unlock(&serial->serial_lock);
                        }
@@ -1958,7 +1985,7 @@ static void hso_std_serial_write_bulk_callback(struct urb *urb)
        tty = tty_kref_get(serial->tty);
        spin_unlock(&serial->serial_lock);
        if (status) {
-                log_usb_status(status, __func__);
+                handle_usb_error(status, __func__, serial->parent);
                tty_kref_put(tty);
                return;
        }
@@ -2014,7 +2041,7 @@ static void ctrl_callback(struct urb *urb)
        tty = tty_kref_get(serial->tty);
        spin_unlock(&serial->serial_lock);
        if (status) {
-                log_usb_status(status, __func__);
+                handle_usb_error(status, __func__, serial->parent);
                tty_kref_put(tty);
                return;
        }
@@ -2358,12 +2385,12 @@ static int hso_serial_common_create(struct hso_serial *serial, int num_urbs,
        serial->tx_data_length = tx_size;
        serial->tx_data = kzalloc(serial->tx_data_length, GFP_KERNEL);
        if (!serial->tx_data) {
-                dev_err(dev, "%s - Out of memory", __func__);
+                dev_err(dev, "%s - Out of memory\n", __func__);
                goto exit;
        }
        serial->tx_buffer = kzalloc(serial->tx_data_length, GFP_KERNEL);
        if (!serial->tx_buffer) {
-                dev_err(dev, "%s - Out of memory", __func__);
+                dev_err(dev, "%s - Out of memory\n", __func__);
                goto exit;
        }
@@ -2391,6 +2418,7 @@ static struct hso_device *hso_create_device(struct usb_interface *intf,
        INIT_WORK(&hso_dev->async_get_intf, async_get_intf);
        INIT_WORK(&hso_dev->async_put_intf, async_put_intf);
+        INIT_WORK(&hso_dev->reset_device, reset_device);
        return hso_dev;
 }
@@ -2831,13 +2859,14 @@ struct hso_shared_int *hso_create_shared_int(struct usb_interface *interface)
        mux->shared_intr_urb = usb_alloc_urb(0, GFP_KERNEL);
        if (!mux->shared_intr_urb) {
-                dev_err(&interface->dev, "Could not allocate intr urb?");
+                dev_err(&interface->dev, "Could not allocate intr urb?\n");
                goto exit;
        }
-        mux->shared_intr_buf = kzalloc(mux->intr_endp->wMaxPacketSize,
+        mux->shared_intr_buf =
-                                       GFP_KERNEL);
+                kzalloc(le16_to_cpu(mux->intr_endp->wMaxPacketSize),
+                        GFP_KERNEL);
        if (!mux->shared_intr_buf) {
-                dev_err(&interface->dev, "Could not allocate intr buf?");
+                dev_err(&interface->dev, "Could not allocate intr buf?\n");
                goto exit;
        }
@@ -3132,6 +3161,26 @@ out:
        return result;
 }
+static void reset_device(struct work_struct *data)
+{
+        struct hso_device *hso_dev =
+            container_of(data, struct hso_device, reset_device);
+        struct usb_device *usb = hso_dev->usb;
+        int result;
+        if (hso_dev->usb_gone) {
+                D1("No reset during disconnect\n");
+        } else {
+                result = usb_lock_device_for_reset(usb, hso_dev->interface);
+                if (result < 0)
+                        D1("unable to lock device for reset: %d\n", result);
+                else {
+                        usb_reset_device(usb);
+                        usb_unlock_device(usb);
+                }
+        }
+}
 static void hso_serial_ref_free(struct kref *ref)
 {
        struct hso_device *hso_dev = container_of(ref, struct hso_device, ref);
@@ -3232,13 +3281,13 @@ static int hso_mux_submit_intr_urb(struct hso_shared_int *shared_int,
                         usb_rcvintpipe(usb,
                                shared_int->intr_endp->bEndpointAddress & 0x7F),
                         shared_int->shared_intr_buf,
-                         shared_int->intr_endp->wMaxPacketSize,
+                         1,
                         intr_callback, shared_int,
                         shared_int->intr_endp->bInterval);
        result = usb_submit_urb(shared_int->shared_intr_urb, gfp);
        if (result)
-                dev_warn(&usb->dev, "%s failed mux_intr_urb %d", __func__,
+                dev_warn(&usb->dev, "%s failed mux_intr_urb %d\n", __func__,
                        result);
        return result;
diff --git a/drivers/net/usb/rtl8150.c b/drivers/net/usb/rtl8150.c
index dfc7e9fec3ea..21ac103fbb71 100644
--- a/drivers/net/usb/rtl8150.c
+++ b/drivers/net/usb/rtl8150.c
@@ -270,7 +270,7 @@ static int read_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 * reg)
                get_registers(dev, PHYCNT, 1, data);
        } while ((data[0] & PHY_GO) && (i++ < MII_TIMEOUT));
-        if (i < MII_TIMEOUT) {
+        if (i <= MII_TIMEOUT) {
                get_registers(dev, PHYDAT, 2, data);
                *reg = data[0] | (data[1] << 8);
                return 0;
@@ -295,7 +295,7 @@ static int write_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 reg)
                get_registers(dev, PHYCNT, 1, data);
        } while ((data[0] & PHY_GO) && (i++ < MII_TIMEOUT));
-        if (i < MII_TIMEOUT)
+        if (i <= MII_TIMEOUT)
                return 0;
        else
                return 1;
diff --git a/drivers/net/via-rhine.c b/drivers/net/via-rhine.c
index 6bc924cd4583..a7e0c84426ea 100644
--- a/drivers/net/via-rhine.c
+++ b/drivers/net/via-rhine.c
@@ -102,6 +102,7 @@ static const int multicast_filter_limit = 32;
 #include <linux/ethtool.h>
 #include <linux/crc32.h>
 #include <linux/bitops.h>
+#include <linux/workqueue.h>
 #include <asm/processor.h>      /* Processor type for cache alignment. */
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -389,6 +390,7 @@ struct rhine_private {
        struct net_device *dev;
        struct napi_struct napi;
        spinlock_t lock;
+        struct work_struct reset_task;
        /* Frequently used values: keep some adjacent for cache effect. */
        u32 quirks;
@@ -407,6 +409,7 @@ struct rhine_private {
 static int  mdio_read(struct net_device *dev, int phy_id, int location);
 static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
 static int  rhine_open(struct net_device *dev);
+static void rhine_reset_task(struct work_struct *work);
 static void rhine_tx_timeout(struct net_device *dev);
 static netdev_tx_t rhine_start_tx(struct sk_buff *skb,
                                  struct net_device *dev);
@@ -775,6 +778,8 @@ static int __devinit rhine_init_one(struct pci_dev *pdev,
        dev->irq = pdev->irq;
        spin_lock_init(&rp->lock);
+        INIT_WORK(&rp->reset_task, rhine_reset_task);
        rp->mii_if.dev = dev;
        rp->mii_if.mdio_read = mdio_read;
        rp->mii_if.mdio_write = mdio_write;
@@ -1179,22 +1184,18 @@ static int rhine_open(struct net_device *dev)
        return 0;
 }
-static void rhine_tx_timeout(struct net_device *dev)
+static void rhine_reset_task(struct work_struct *work)
 {
-        struct rhine_private *rp = netdev_priv(dev);
+        struct rhine_private *rp = container_of(work, struct rhine_private,
-        void __iomem *ioaddr = rp->base;
+                                                reset_task);
+        struct net_device *dev = rp->dev;
-        printk(KERN_WARNING "%s: Transmit timed out, status %4.4x, PHY status "
-               "%4.4x, resetting...\n",
-               dev->name, ioread16(ioaddr + IntrStatus),
-               mdio_read(dev, rp->mii_if.phy_id, MII_BMSR));
        /* protect against concurrent rx interrupts */
        disable_irq(rp->pdev->irq);
        napi_disable(&rp->napi);
-        spin_lock(&rp->lock);
+        spin_lock_bh(&rp->lock);
        /* clear all descriptors */
        free_tbufs(dev);
@@ -1206,7 +1207,7 @@ static void rhine_tx_timeout(struct net_device *dev)
        rhine_chip_reset(dev);
        init_registers(dev);
-        spin_unlock(&rp->lock);
+        spin_unlock_bh(&rp->lock);
        enable_irq(rp->pdev->irq);
        dev->trans_start = jiffies;
@@ -1214,6 +1215,19 @@ static void rhine_tx_timeout(struct net_device *dev)
        netif_wake_queue(dev);
 }
+static void rhine_tx_timeout(struct net_device *dev)
+{
+        struct rhine_private *rp = netdev_priv(dev);
+        void __iomem *ioaddr = rp->base;
+        printk(KERN_WARNING "%s: Transmit timed out, status %4.4x, PHY status "
+               "%4.4x, resetting...\n",
+               dev->name, ioread16(ioaddr + IntrStatus),
+               mdio_read(dev, rp->mii_if.phy_id, MII_BMSR));
+        schedule_work(&rp->reset_task);
+}
 static netdev_tx_t rhine_start_tx(struct sk_buff *skb,
                                  struct net_device *dev)
 {
@@ -1830,10 +1844,11 @@ static int rhine_close(struct net_device *dev)
        struct rhine_private *rp = netdev_priv(dev);
        void __iomem *ioaddr = rp->base;
-        spin_lock_irq(&rp->lock);
-        netif_stop_queue(dev);
        napi_disable(&rp->napi);
+        cancel_work_sync(&rp->reset_task);
+        netif_stop_queue(dev);
+        spin_lock_irq(&rp->lock);
        if (debug > 1)
                printk(KERN_DEBUG "%s: Shutting down ethercard, "
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index 83fc3a8dd254..f15485efe40e 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -2237,8 +2237,6 @@ static int velocity_open(struct net_device *dev)
        /* Ensure chip is running */
        pci_set_power_state(vptr->pdev, PCI_D0);
-        velocity_give_many_rx_descs(vptr);
        velocity_init_registers(vptr, VELOCITY_INIT_COLD);
        ret = request_irq(vptr->pdev->irq, velocity_intr, IRQF_SHARED,
@@ -2250,6 +2248,8 @@ static int velocity_open(struct net_device *dev)
                goto out;
        }
+        velocity_give_many_rx_descs(vptr);
        mac_enable_int(vptr->mac_regs);
        netif_start_queue(dev);
        napi_enable(&vptr->napi);
@@ -2339,10 +2339,10 @@ static int velocity_change_mtu(struct net_device *dev, int new_mtu)
                dev->mtu = new_mtu;
-                velocity_give_many_rx_descs(vptr);
                velocity_init_registers(vptr, VELOCITY_INIT_COLD);
+                velocity_give_many_rx_descs(vptr);
                mac_enable_int(vptr->mac_regs);
                netif_start_queue(dev);
diff --git a/drivers/net/vxge/vxge-main.c b/drivers/net/vxge/vxge-main.c
index 6466bc840e6d..a6606b8948e9 100644
--- a/drivers/net/vxge/vxge-main.c
+++ b/drivers/net/vxge/vxge-main.c
@@ -310,7 +310,7 @@ static int vxge_rx_map(void *dtrh, struct vxge_ring *ring)
        dma_addr = pci_map_single(ring->pdev, rx_priv->skb_data,
                                rx_priv->data_size, PCI_DMA_FROMDEVICE);
-        if (dma_addr == 0) {
+        if (unlikely(pci_dma_mapping_error(ring->pdev, dma_addr))) {
                ring->stats.pci_map_fail++;
                return -EIO;
        }
@@ -4087,21 +4087,21 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
                goto _exit0;
        }
-        if (!pci_set_dma_mask(pdev, 0xffffffffffffffffULL)) {
+        if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                vxge_debug_ll_config(VXGE_TRACE,
                        "%s : using 64bit DMA", __func__);
                high_dma = 1;
                if (pci_set_consistent_dma_mask(pdev,
-                                                0xffffffffffffffffULL)) {
+                                                DMA_BIT_MASK(64))) {
                        vxge_debug_init(VXGE_ERR,
                                "%s : unable to obtain 64bit DMA for "
                                "consistent allocations", __func__);
                        ret = -ENOMEM;
                        goto _exit1;
                }
-        } else if (!pci_set_dma_mask(pdev, 0xffffffffUL)) {
+        } else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
                vxge_debug_ll_config(VXGE_TRACE,
                        "%s : using 32bit DMA", __func__);
        } else {
diff --git a/drivers/net/wireless/libertas/mesh.c b/drivers/net/wireless/libertas/mesh.c
index 954cd00f7452..e385af1f4583 100644
--- a/drivers/net/wireless/libertas/mesh.c
+++ b/drivers/net/wireless/libertas/mesh.c
@@ -1,6 +1,7 @@
 #include <linux/delay.h>
 #include <linux/etherdevice.h>
 #include <linux/netdevice.h>
+#include <linux/if_ether.h>
 #include <linux/if_arp.h>
 #include <linux/kthread.h>
 #include <linux/kfifo.h>
@@ -364,8 +365,7 @@ int lbs_add_mesh(struct lbs_private *priv)
        mesh_dev->netdev_ops = &mesh_netdev_ops;
        mesh_dev->ethtool_ops = &lbs_ethtool_ops;
-        memcpy(mesh_dev->dev_addr, priv->dev->dev_addr,
+        memcpy(mesh_dev->dev_addr, priv->dev->dev_addr, ETH_ALEN);
-                        sizeof(priv->dev->dev_addr));
        SET_NETDEV_DEV(priv->mesh_dev, priv->dev->dev.parent);
diff --git a/drivers/s390/net/claw.c b/drivers/s390/net/claw.c
index 3c77bfe0764c..147bb1a69aba 100644
--- a/drivers/s390/net/claw.c
+++ b/drivers/s390/net/claw.c
@@ -3398,7 +3398,7 @@ claw_init(void)
                goto out_err;
        }
        CLAW_DBF_TEXT(2, setup, "init_mod");
-        claw_root_dev = root_device_register("qeth");
+        claw_root_dev = root_device_register("claw");
        ret = IS_ERR(claw_root_dev) ? PTR_ERR(claw_root_dev) : 0;
        if (ret)
                goto register_err;
diff --git a/drivers/scsi/cxgb3i/cxgb3i_offload.c b/drivers/scsi/cxgb3i/cxgb3i_offload.c
index 26ffdcd5a437..2a3cf823d68d 100644
--- a/drivers/scsi/cxgb3i/cxgb3i_offload.c
+++ b/drivers/scsi/cxgb3i/cxgb3i_offload.c
@@ -1440,6 +1440,10 @@ void cxgb3i_c3cn_release(struct s3_conn *c3cn)
 static int is_cxgb3_dev(struct net_device *dev)
 {
        struct cxgb3i_sdev_data *cdata;
+        struct net_device *ndev = dev;
+        if (dev->priv_flags & IFF_802_1Q_VLAN)
+                ndev = vlan_dev_real_dev(dev);
        write_lock(&cdata_rwlock);
        list_for_each_entry(cdata, &cdata_list, list) {
@@ -1447,7 +1451,7 @@ static int is_cxgb3_dev(struct net_device *dev)
                int i;
                for (i = 0; i < ports->nports; i++)
-                        if (dev == ports->lldevs[i]) {
+                        if (ndev == ports->lldevs[i]) {
                                write_unlock(&cdata_rwlock);
                                return 1;
                        }
@@ -1566,6 +1570,26 @@ out_err:
        return -EINVAL;
 }
+/* *
+ * cxgb3i_find_dev - find the interface associated with the given address
+ * @ipaddr: ip address
+ */
+static struct net_device *
+cxgb3i_find_dev(struct net_device *dev, __be32 ipaddr)
+{
+        struct flowi fl;
+        int err;
+        struct rtable *rt;
+        memset(&fl, 0, sizeof(fl));
+        fl.nl_u.ip4_u.daddr = ipaddr;
+        err = ip_route_output_key(dev ? dev_net(dev) : &init_net, &rt, &fl);
+        if (!err)
+                return (&rt->u.dst)->dev;
+        return NULL;
+}
 /**
 * cxgb3i_c3cn_connect - initiates an iscsi tcp connection to a given address
@@ -1581,6 +1605,7 @@ int cxgb3i_c3cn_connect(struct net_device *dev, struct s3_conn *c3cn,
        struct cxgb3i_sdev_data *cdata;
        struct t3cdev *cdev;
        __be32 sipv4;
+        struct net_device *dstdev;
        int err;
        c3cn_conn_debug("c3cn 0x%p, dev 0x%p.\n", c3cn, dev);
@@ -1591,6 +1616,13 @@ int cxgb3i_c3cn_connect(struct net_device *dev, struct s3_conn *c3cn,
        c3cn->daddr.sin_port = usin->sin_port;
        c3cn->daddr.sin_addr.s_addr = usin->sin_addr.s_addr;
+        dstdev = cxgb3i_find_dev(dev, usin->sin_addr.s_addr);
+        if (!dstdev || !is_cxgb3_dev(dstdev))
+                return -ENETUNREACH;
+        if (dstdev->priv_flags & IFF_802_1Q_VLAN)
+                dev = dstdev;
        rt = find_route(dev, c3cn->saddr.sin_addr.s_addr,
                        c3cn->daddr.sin_addr.s_addr,
                        c3cn->saddr.sin_port,
diff --git a/drivers/serial/serial_cs.c b/drivers/serial/serial_cs.c
index fc413f0f8dd2..0ee7239c5d69 100644
--- a/drivers/serial/serial_cs.c
+++ b/drivers/serial/serial_cs.c
@@ -819,6 +819,7 @@ static struct pcmcia_device_id serial_ids[] = {
        PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0035, "cis/3CXEM556.cis"),
        PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x003d, "cis/3CXEM556.cis"),
        PCMCIA_DEVICE_CIS_PROD_ID12("Sierra Wireless", "AC850", 0xd85f6206, 0x42a2c018, "cis/SW_8xx_SER.cis"), /* Sierra Wireless AC850 3G Network Adapter R1 */
+        PCMCIA_DEVICE_CIS_PROD_ID12("Sierra Wireless", "AC860", 0xd85f6206, 0x698f93db, "cis/SW_8xx_SER.cis"), /* Sierra Wireless AC860 3G Network Adapter R1 */
        PCMCIA_DEVICE_CIS_PROD_ID12("Sierra Wireless", "AC710/AC750", 0xd85f6206, 0x761b11e0, "cis/SW_7xx_SER.cis"),  /* Sierra Wireless AC710/AC750 GPRS Network Adapter R1 */
        PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0xa555, "cis/SW_555_SER.cis"),  /* Sierra Aircard 555 CDMA 1xrtt Modem -- pre update */
        PCMCIA_DEVICE_CIS_MANF_CARD(0x013f, 0xa555, "cis/SW_555_SER.cis"),  /* Sierra Aircard 555 CDMA 1xrtt Modem -- post update */
@@ -827,7 +828,7 @@ static struct pcmcia_device_id serial_ids[] = {
        PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-4", 0x96913a85, 0xcec8f102, "cis/COMpad4.cis"),
        PCMCIA_DEVICE_CIS_PROD_ID123("ADVANTECH", "COMpad-32/85", "1.0", 0x96913a85, 0x8fbe92ae, 0x0877b627, "cis/COMpad2.cis"),
        PCMCIA_DEVICE_CIS_PROD_ID2("RS-COM 2P", 0xad20b156, "cis/RS-COM-2P.cis"),
-        PCMCIA_DEVICE_CIS_MANF_CARD(0x0013, 0x0000, "GLOBETROTTER.cis"),
+        PCMCIA_DEVICE_CIS_MANF_CARD(0x0013, 0x0000, "cis/GLOBETROTTER.cis"),
        PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL100  1.00.",0x19ca78af,0xf964f42b),
        PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL100",0x19ca78af,0x71d98e83),
        PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL232  1.00.",0x19ca78af,0x69fb7490),
@@ -861,6 +862,18 @@ static struct pcmcia_device_id serial_ids[] = {
 };
 MODULE_DEVICE_TABLE(pcmcia, serial_ids);
+MODULE_FIRMWARE("cis/PCMLM28.cis");
+MODULE_FIRMWARE("cis/DP83903.cis");
+MODULE_FIRMWARE("cis/3CCFEM556.cis");
+MODULE_FIRMWARE("cis/3CXEM556.cis");
+MODULE_FIRMWARE("cis/SW_8xx_SER.cis");
+MODULE_FIRMWARE("cis/SW_7xx_SER.cis");
+MODULE_FIRMWARE("cis/SW_555_SER.cis");
+MODULE_FIRMWARE("cis/MT5634ZLX.cis");
+MODULE_FIRMWARE("cis/COMpad2.cis");
+MODULE_FIRMWARE("cis/COMpad4.cis");
+MODULE_FIRMWARE("cis/RS-COM-2P.cis");
 static struct pcmcia_driver serial_cs_driver = {
        .owner          = THIS_MODULE,
        .drv            = {