34 files changed, 408 insertions, 396 deletions

diff --git a/drivers/net/82596.c b/drivers/net/82596.c
index 8236f26ffd46..640d7ca2ebcf 100644
--- a/drivers/net/82596.c
+++ b/drivers/net/82596.c
@@ -1066,8 +1066,8 @@ static int i596_start_xmit(struct sk_buff *skb, struct net_device *dev)
         short length = skb->len;
         dev->trans_start = jiffies;
 
-        DEB(DEB_STARTTX,printk(KERN_DEBUG "%s: i596_start_xmit(%x,%x) called\n", dev->name,
-                                skb->len, (unsigned int)skb->data));
+        DEB(DEB_STARTTX,printk(KERN_DEBUG "%s: i596_start_xmit(%x,%p) called\n",
+                                dev->name, skb->len, skb->data));
 
         if (skb->len < ETH_ZLEN) {
                 if (skb_padto(skb, ETH_ZLEN))
@@ -1246,7 +1246,8 @@ struct net_device * __init i82596_probe(int unit)
         dev->priv = (void *)(dev->mem_start);
 
         lp = dev->priv;
-        DEB(DEB_INIT,printk(KERN_DEBUG "%s: lp at 0x%08lx (%d bytes), lp->scb at 0x%08lx\n",
+        DEB(DEB_INIT,printk(KERN_DEBUG "%s: lp at 0x%08lx (%zd bytes), "
+                        "lp->scb at 0x%08lx\n",
                         dev->name, (unsigned long)lp,
                         sizeof(struct i596_private), (unsigned long)&lp->scb));
         memset((void *) lp, 0, sizeof(struct i596_private));
diff --git a/drivers/net/b44.c b/drivers/net/b44.c
index 5eb2ec68393f..303a8d94ad4b 100644
--- a/drivers/net/b44.c
+++ b/drivers/net/b44.c
@@ -110,6 +110,11 @@ MODULE_DEVICE_TABLE(pci, b44_pci_tbl);
 
 static void b44_halt(struct b44 *);
 static void b44_init_rings(struct b44 *);
+
+#define B44_FULL_RESET          1
+#define B44_FULL_RESET_SKIP_PHY 2
+#define B44_PARTIAL_RESET       3
+
 static void b44_init_hw(struct b44 *, int);
 
 static int dma_desc_align_mask;
@@ -752,7 +757,7 @@ static void b44_recycle_rx(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
                                              dest_idx * sizeof(dest_desc),
                                              DMA_BIDIRECTIONAL);
 
-        pci_dma_sync_single_for_device(bp->pdev, src_desc->addr,
+        pci_dma_sync_single_for_device(bp->pdev, le32_to_cpu(src_desc->addr),
                                        RX_PKT_BUF_SZ,
                                        PCI_DMA_FROMDEVICE);
 }
@@ -884,7 +889,7 @@ static int b44_poll(struct net_device *netdev, int *budget)
                 spin_lock_irqsave(&bp->lock, flags);
                 b44_halt(bp);
                 b44_init_rings(bp);
-                b44_init_hw(bp, 1);
+                b44_init_hw(bp, B44_FULL_RESET_SKIP_PHY);
                 netif_wake_queue(bp->dev);
                 spin_unlock_irqrestore(&bp->lock, flags);
                 done = 1;
@@ -954,7 +959,7 @@ static void b44_tx_timeout(struct net_device *dev)
 
         b44_halt(bp);
         b44_init_rings(bp);
-        b44_init_hw(bp, 1);
+        b44_init_hw(bp, B44_FULL_RESET);
 
         spin_unlock_irq(&bp->lock);
 
@@ -1071,7 +1076,7 @@ static int b44_change_mtu(struct net_device *dev, int new_mtu)
         b44_halt(bp);
         dev->mtu = new_mtu;
         b44_init_rings(bp);
-        b44_init_hw(bp, 1);
+        b44_init_hw(bp, B44_FULL_RESET);
         spin_unlock_irq(&bp->lock);
 
         b44_enable_ints(bp);
@@ -1368,12 +1373,12 @@ static int b44_set_mac_addr(struct net_device *dev, void *p)
  * packet processing.  Invoked with bp->lock held.
  */
 static void __b44_set_rx_mode(struct net_device *);
-static void b44_init_hw(struct b44 *bp, int full_reset)
+static void b44_init_hw(struct b44 *bp, int reset_kind)
 {
         u32 val;
 
         b44_chip_reset(bp);
-        if (full_reset) {
+        if (reset_kind == B44_FULL_RESET) {
                 b44_phy_reset(bp);
                 b44_setup_phy(bp);
         }
@@ -1390,7 +1395,10 @@ static void b44_init_hw(struct b44 *bp, int full_reset)
         bw32(bp, B44_TXMAXLEN, bp->dev->mtu + ETH_HLEN + 8 + RX_HEADER_LEN);
 
         bw32(bp, B44_TX_WMARK, 56); /* XXX magic */
-        if (full_reset) {
+        if (reset_kind == B44_PARTIAL_RESET) {
+                bw32(bp, B44_DMARX_CTRL, (DMARX_CTRL_ENABLE |
+                                      (bp->rx_offset << DMARX_CTRL_ROSHIFT)));
+        } else {
                 bw32(bp, B44_DMATX_CTRL, DMATX_CTRL_ENABLE);
                 bw32(bp, B44_DMATX_ADDR, bp->tx_ring_dma + bp->dma_offset);
                 bw32(bp, B44_DMARX_CTRL, (DMARX_CTRL_ENABLE |
@@ -1401,9 +1409,6 @@ static void b44_init_hw(struct b44 *bp, int full_reset)
                 bp->rx_prod = bp->rx_pending;
 
                 bw32(bp, B44_MIB_CTRL, MIB_CTRL_CLR_ON_READ);
-        } else {
-                bw32(bp, B44_DMARX_CTRL, (DMARX_CTRL_ENABLE |
-                                      (bp->rx_offset << DMARX_CTRL_ROSHIFT)));
         }
 
         val = br32(bp, B44_ENET_CTRL);
@@ -1420,7 +1425,7 @@ static int b44_open(struct net_device *dev)
                 goto out;
 
         b44_init_rings(bp);
-        b44_init_hw(bp, 1);
+        b44_init_hw(bp, B44_FULL_RESET);
 
         b44_check_phy(bp);
 
@@ -1629,7 +1634,7 @@ static int b44_close(struct net_device *dev)
         netif_poll_enable(dev);
 
         if (bp->flags & B44_FLAG_WOL_ENABLE) {
-                b44_init_hw(bp, 0);
+                b44_init_hw(bp, B44_PARTIAL_RESET);
                 b44_setup_wol(bp);
         }
 
@@ -1905,7 +1910,7 @@ static int b44_set_ringparam(struct net_device *dev,
 
         b44_halt(bp);
         b44_init_rings(bp);
-        b44_init_hw(bp, 1);
+        b44_init_hw(bp, B44_FULL_RESET);
         netif_wake_queue(bp->dev);
         spin_unlock_irq(&bp->lock);
 
@@ -1948,7 +1953,7 @@ static int b44_set_pauseparam(struct net_device *dev,
         if (bp->flags & B44_FLAG_PAUSE_AUTO) {
                 b44_halt(bp);
                 b44_init_rings(bp);
-                b44_init_hw(bp, 1);
+                b44_init_hw(bp, B44_FULL_RESET);
         } else {
                 __b44_set_flow_ctrl(bp, bp->flags);
         }
@@ -2304,7 +2309,7 @@ static int b44_suspend(struct pci_dev *pdev, pm_message_t state)
 
         free_irq(dev->irq, dev);
         if (bp->flags & B44_FLAG_WOL_ENABLE) {
-                b44_init_hw(bp, 0);
+                b44_init_hw(bp, B44_PARTIAL_RESET);
                 b44_setup_wol(bp);
         }
         pci_disable_device(pdev);
@@ -2315,21 +2320,32 @@ static int b44_resume(struct pci_dev *pdev)
 {
         struct net_device *dev = pci_get_drvdata(pdev);
         struct b44 *bp = netdev_priv(dev);
+        int rc = 0;
 
         pci_restore_state(pdev);
-        pci_enable_device(pdev);
+        rc = pci_enable_device(pdev);
+        if (rc) {
+                printk(KERN_ERR PFX "%s: pci_enable_device failed\n",
+                        dev->name);
+                return rc;
+        }
+
         pci_set_master(pdev);
 
         if (!netif_running(dev))
                 return 0;
 
-        if (request_irq(dev->irq, b44_interrupt, IRQF_SHARED, dev->name, dev))
+        rc = request_irq(dev->irq, b44_interrupt, IRQF_SHARED, dev->name, dev);
+        if (rc) {
                 printk(KERN_ERR PFX "%s: request_irq failed\n", dev->name);
+                pci_disable_device(pdev);
+                return rc;
+        }
 
         spin_lock_irq(&bp->lock);
 
         b44_init_rings(bp);
-        b44_init_hw(bp, 1);
+        b44_init_hw(bp, B44_FULL_RESET);
         netif_device_attach(bp->dev);
         spin_unlock_irq(&bp->lock);
 
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index ca5acc4736df..ee7b75b976b5 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -57,8 +57,8 @@
 
 #define DRV_MODULE_NAME         "bnx2"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "1.5.3"
-#define DRV_MODULE_RELDATE      "January 8, 2007"
+#define DRV_MODULE_VERSION      "1.5.5"
+#define DRV_MODULE_RELDATE      "February 1, 2007"
 
 #define RUN_AT(x) (jiffies + (x))
 
@@ -1356,6 +1356,14 @@ bnx2_init_copper_phy(struct bnx2 *bp)
                 bnx2_write_phy(bp, 0x18, 0x0400);
         }
 
+        if (bp->phy_flags & PHY_DIS_EARLY_DAC_FLAG) {
+                bnx2_write_phy(bp, MII_BNX2_DSP_ADDRESS,
+                               MII_BNX2_DSP_EXPAND_REG | 0x8);
+                bnx2_read_phy(bp, MII_BNX2_DSP_RW_PORT, &val);
+                val &= ~(1 << 8);
+                bnx2_write_phy(bp, MII_BNX2_DSP_RW_PORT, val);
+        }
+
         if (bp->dev->mtu > 1500) {
                 /* Set extended packet length bit */
                 bnx2_write_phy(bp, 0x18, 0x7);
@@ -5845,9 +5853,11 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
         reg = REG_RD_IND(bp, BNX2_SHM_HDR_SIGNATURE);
 
         if ((reg & BNX2_SHM_HDR_SIGNATURE_SIG_MASK) ==
-            BNX2_SHM_HDR_SIGNATURE_SIG)
-                bp->shmem_base = REG_RD_IND(bp, BNX2_SHM_HDR_ADDR_0);
-        else
+            BNX2_SHM_HDR_SIGNATURE_SIG) {
+                u32 off = PCI_FUNC(pdev->devfn) << 2;
+
+                bp->shmem_base = REG_RD_IND(bp, BNX2_SHM_HDR_ADDR_0 + off);
+        } else
                 bp->shmem_base = HOST_VIEW_SHMEM_BASE;
 
         /* Get the permanent MAC address.  First we need to make sure the
@@ -5916,6 +5926,8 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
         } else if (CHIP_NUM(bp) == CHIP_NUM_5706 ||
                    CHIP_NUM(bp) == CHIP_NUM_5708)
                 bp->phy_flags |= PHY_CRC_FIX_FLAG;
+        else if (CHIP_ID(bp) == CHIP_ID_5709_A0)
+                bp->phy_flags |= PHY_DIS_EARLY_DAC_FLAG;
 
         if ((CHIP_ID(bp) == CHIP_ID_5708_A0) ||
             (CHIP_ID(bp) == CHIP_ID_5708_B0) ||
diff --git a/drivers/net/bnx2.h b/drivers/net/bnx2.h
index 13b6f9b11e01..ccbdf81c6599 100644
--- a/drivers/net/bnx2.h
+++ b/drivers/net/bnx2.h
@@ -6288,6 +6288,10 @@ struct l2_fhdr {
 
 #define BCM5708S_TX_ACTL3                       0x17
 
+#define MII_BNX2_DSP_RW_PORT                    0x15
+#define MII_BNX2_DSP_ADDRESS                    0x17
+#define MII_BNX2_DSP_EXPAND_REG                  0x0f00
+
 #define MIN_ETHERNET_PACKET_SIZE        60
 #define MAX_ETHERNET_PACKET_SIZE        1514
 #define MAX_ETHERNET_JUMBO_PACKET_SIZE  9014
@@ -6489,6 +6493,7 @@ struct bnx2 {
 #define PHY_INT_MODE_MASK_FLAG          0x300
 #define PHY_INT_MODE_AUTO_POLLING_FLAG  0x100
 #define PHY_INT_MODE_LINK_READY_FLAG    0x200
+#define PHY_DIS_EARLY_DAC_FLAG          0x400
 
         u32                     chip_id;
         /* chip num:16-31, rev:12-15, metal:4-11, bond_id:0-3 */
@@ -6512,6 +6517,7 @@ struct bnx2 {
 #define CHIP_ID_5708_A0                 0x57080000
 #define CHIP_ID_5708_B0                 0x57081000
 #define CHIP_ID_5708_B1                 0x57081010
+#define CHIP_ID_5709_A0                 0x57090000
 
 #define CHIP_BOND_ID(bp)                (((bp)->chip_id) & 0xf)
 
diff --git a/drivers/net/bonding/bonding.h b/drivers/net/bonding/bonding.h
index dc434fb6da85..0978c9ac6d2b 100644
--- a/drivers/net/bonding/bonding.h
+++ b/drivers/net/bonding/bonding.h
@@ -151,8 +151,8 @@ struct slave {
         struct slave *next;
         struct slave *prev;
         int    delay;
-        u32    jiffies;
-        u32    last_arp_rx;
+        unsigned long jiffies;
+        unsigned long last_arp_rx;
         s8     link;    /* one of BOND_LINK_XXXX */
         s8     state;   /* one of BOND_STATE_XXXX */
         u32    original_flags;
@@ -242,7 +242,8 @@ extern inline int slave_do_arp_validate(struct bonding *bond, struct slave *slav
         return bond->params.arp_validate & (1 << slave->state);
 }
 
-extern inline u32 slave_last_rx(struct bonding *bond, struct slave *slave)
+extern inline unsigned long slave_last_rx(struct bonding *bond,
+                                        struct slave *slave)
 {
         if (slave_do_arp_validate(bond, slave))
                 return slave->last_arp_rx;
diff --git a/drivers/net/e100.c b/drivers/net/e100.c
index c2ae2a24629b..0cefef5e3f06 100644
--- a/drivers/net/e100.c
+++ b/drivers/net/e100.c
@@ -2718,12 +2718,11 @@ static int e100_suspend(struct pci_dev *pdev, pm_message_t state)
         struct net_device *netdev = pci_get_drvdata(pdev);
         struct nic *nic = netdev_priv(netdev);
 
-#ifdef CONFIG_E100_NAPI
         if (netif_running(netdev))
                 netif_poll_disable(nic->netdev);
-#endif
         del_timer_sync(&nic->watchdog);
         netif_carrier_off(nic->netdev);
+        netif_device_detach(netdev);
 
         pci_save_state(pdev);
 
@@ -2736,6 +2735,7 @@ static int e100_suspend(struct pci_dev *pdev, pm_message_t state)
         }
 
         pci_disable_device(pdev);
+        free_irq(pdev->irq, netdev);
         pci_set_power_state(pdev, PCI_D3hot);
 
         return 0;
@@ -2759,16 +2759,13 @@ static int e100_resume(struct pci_dev *pdev)
 }
 #endif /* CONFIG_PM */
 
-
 static void e100_shutdown(struct pci_dev *pdev)
 {
         struct net_device *netdev = pci_get_drvdata(pdev);
         struct nic *nic = netdev_priv(netdev);
 
-#ifdef CONFIG_E100_NAPI
         if (netif_running(netdev))
                 netif_poll_disable(nic->netdev);
-#endif
         del_timer_sync(&nic->watchdog);
         netif_carrier_off(nic->netdev);
 
diff --git a/drivers/net/ehea/ehea.h b/drivers/net/ehea/ehea.h
index 39ad9f73d1ec..272e1ec51aa2 100644
--- a/drivers/net/ehea/ehea.h
+++ b/drivers/net/ehea/ehea.h
@@ -39,7 +39,7 @@
 #include <asm/io.h>
 
 #define DRV_NAME        "ehea"
-#define DRV_VERSION     "EHEA_0043"
+#define DRV_VERSION     "EHEA_0045"
 
 #define EHEA_MSG_DEFAULT (NETIF_MSG_LINK | NETIF_MSG_TIMER \
         | NETIF_MSG_RX_ERR | NETIF_MSG_TX_ERR)
diff --git a/drivers/net/ehea/ehea_main.c b/drivers/net/ehea/ehea_main.c
index 83fa32f72398..9de2d38a5321 100644
--- a/drivers/net/ehea/ehea_main.c
+++ b/drivers/net/ehea/ehea_main.c
@@ -558,12 +558,12 @@ static irqreturn_t ehea_qp_aff_irq_handler(int irq, void *param)
         u32 qp_token;
 
         eqe = ehea_poll_eq(port->qp_eq);
-        ehea_debug("eqe=%p", eqe);
+
         while (eqe) {
-                ehea_debug("*eqe=%lx", *(u64*)eqe);
-                eqe = ehea_poll_eq(port->qp_eq);
                 qp_token = EHEA_BMASK_GET(EHEA_EQE_QP_TOKEN, eqe->entry);
-                ehea_debug("next eqe=%p", eqe);
+                ehea_error("QP aff_err: entry=0x%lx, token=0x%x",
+                           eqe->entry, qp_token);
+                eqe = ehea_poll_eq(port->qp_eq);
         }
 
         return IRQ_HANDLED;
@@ -575,8 +575,9 @@ static struct ehea_port *ehea_get_port(struct ehea_adapter *adapter,
         int i;
 
         for (i = 0; i < adapter->num_ports; i++)
-                if (adapter->port[i]->logical_port_id == logical_port)
-                        return adapter->port[i];
+                if (adapter->port[i])
+                        if (adapter->port[i]->logical_port_id == logical_port)
+                                return adapter->port[i];
         return NULL;
 }
 
@@ -642,6 +643,8 @@ int ehea_sense_port_attr(struct ehea_port *port)
                 break;
         }
 
+        port->autoneg = 1;
+
         /* Number of default QPs */
         port->num_def_qps = cb0->num_default_qps;
 
@@ -728,10 +731,7 @@ int ehea_set_portspeed(struct ehea_port *port, u32 port_speed)
                 }
         } else {
                 if (hret == H_AUTHORITY) {
-                        ehea_info("Hypervisor denied setting port speed. Either"
-                                  " this partition is not authorized to set "
-                                  "port speed or another partition has modified"
-                                  " port speed first.");
+                        ehea_info("Hypervisor denied setting port speed");
                         ret = -EPERM;
                 } else {
                         ret = -EIO;
@@ -998,7 +998,7 @@ static int ehea_configure_port(struct ehea_port *port)
                      | EHEA_BMASK_SET(PXLY_RC_JUMBO_FRAME, 1);
 
         for (i = 0; i < port->num_def_qps; i++)
-                cb0->default_qpn_arr[i] = port->port_res[i].qp->init_attr.qp_nr;
+                cb0->default_qpn_arr[i] = port->port_res[0].qp->init_attr.qp_nr;
 
         if (netif_msg_ifup(port))
                 ehea_dump(cb0, sizeof(*cb0), "ehea_configure_port");
@@ -1485,11 +1485,12 @@ out:
 
 static void ehea_promiscuous_error(u64 hret, int enable)
 {
-        ehea_info("Hypervisor denied %sabling promiscuous mode.%s",
-                  enable == 1 ? "en" : "dis",
-                  hret != H_AUTHORITY ? "" : " Another partition owning a "
-                  "logical port on the same physical port might have altered "
-                  "promiscuous mode first.");
+        if (hret == H_AUTHORITY)
+                ehea_info("Hypervisor denied %sabling promiscuous mode",
+                          enable == 1 ? "en" : "dis");
+        else
+                ehea_error("failed %sabling promiscuous mode",
+                           enable == 1 ? "en" : "dis");
 }
 
 static void ehea_promiscuous(struct net_device *dev, int enable)
@@ -2267,6 +2268,8 @@ static void ehea_tx_watchdog(struct net_device *dev)
 int ehea_sense_adapter_attr(struct ehea_adapter *adapter)
 {
         struct hcp_query_ehea *cb;
+        struct device_node *lhea_dn = NULL;
+        struct device_node *eth_dn = NULL;
         u64 hret;
         int ret;
 
@@ -2283,7 +2286,18 @@ int ehea_sense_adapter_attr(struct ehea_adapter *adapter)
                 goto out_herr;
         }
 
-        adapter->num_ports = cb->num_ports;
+        /* Determine the number of available logical ports
+         * by counting the child nodes of the lhea OFDT entry
+         */
+        adapter->num_ports = 0;
+        lhea_dn = of_find_node_by_name(lhea_dn, "lhea");
+        do {
+                eth_dn = of_get_next_child(lhea_dn, eth_dn);
+                if (eth_dn)
+                        adapter->num_ports++;
+        } while ( eth_dn );
+        of_node_put(lhea_dn);
+
         adapter->max_mc_mac = cb->max_mc_mac - 1;
         ret = 0;
 
@@ -2302,6 +2316,7 @@ static int ehea_setup_single_port(struct ehea_port *port,
         struct ehea_adapter *adapter = port->adapter;
         struct hcp_ehea_port_cb4 *cb4;
         u32 *dn_log_port_id;
+        int jumbo = 0;
 
         sema_init(&port->port_lock, 1);
         port->state = EHEA_PORT_DOWN;
@@ -2334,8 +2349,6 @@ static int ehea_setup_single_port(struct ehea_port *port,
 
         INIT_LIST_HEAD(&port->mc_list->list);
 
-        ehea_set_portspeed(port, EHEA_SPEED_AUTONEG);
-
         ret = ehea_sense_port_attr(port);
         if (ret)
                 goto out;
@@ -2345,13 +2358,25 @@ static int ehea_setup_single_port(struct ehea_port *port,
         if (!cb4) {
                 ehea_error("no mem for cb4");
         } else {
-                cb4->jumbo_frame = 1;
-                hret = ehea_h_modify_ehea_port(adapter->handle,
-                                               port->logical_port_id,
-                                               H_PORT_CB4, H_PORT_CB4_JUMBO,
-                                               cb4);
-                if (hret != H_SUCCESS) {
-                        ehea_info("Jumbo frames not activated");
+                hret = ehea_h_query_ehea_port(adapter->handle,
+                                              port->logical_port_id,
+                                              H_PORT_CB4,
+                                              H_PORT_CB4_JUMBO, cb4);
+
+                if (hret == H_SUCCESS) {
+                        if (cb4->jumbo_frame)
+                                jumbo = 1;
+                        else {
+                                cb4->jumbo_frame = 1;
+                                hret = ehea_h_modify_ehea_port(adapter->handle,
+                                                               port->
+                                                                logical_port_id,
+                                                               H_PORT_CB4,
+                                                               H_PORT_CB4_JUMBO,
+                                                               cb4);
+                                if (hret == H_SUCCESS)
+                                        jumbo = 1;
+                        }
                 }
                 kfree(cb4);
         }
@@ -2390,6 +2415,9 @@ static int ehea_setup_single_port(struct ehea_port *port,
                 goto out_free;
         }
 
+        ehea_info("%s: Jumbo frames are %sabled", dev->name,
+                  jumbo == 1 ? "en" : "dis");
+
         port->netdev = dev;
         ret = 0;
         goto out;
@@ -2471,14 +2499,16 @@ static int __devinit ehea_probe(struct ibmebus_dev *dev,
 
         adapter_handle = (u64*)get_property(dev->ofdev.node, "ibm,hea-handle",
                                             NULL);
-        if (!adapter_handle) {
+        if (adapter_handle)
+                adapter->handle = *adapter_handle;
+
+        if (!adapter->handle) {
                 dev_err(&dev->ofdev.dev, "failed getting handle for adapter"
                         " '%s'\n", dev->ofdev.node->full_name);
                 ret = -ENODEV;
                 goto out_free_ad;
         }
 
-        adapter->handle = *adapter_handle;
         adapter->pd = EHEA_PD_ID;
 
         dev->ofdev.dev.driver_data = adapter;
@@ -2568,6 +2598,7 @@ static int __devexit ehea_remove(struct ibmebus_dev *dev)
         destroy_workqueue(adapter->ehea_wq);
 
         ibmebus_free_irq(NULL, adapter->neq->attr.ist1, adapter);
+        tasklet_kill(&adapter->neq_tasklet);
 
         ehea_destroy_eq(adapter->neq);
 
diff --git a/drivers/net/ehea/ehea_phyp.c b/drivers/net/ehea/ehea_phyp.c
index 0cfc2bc1a27b..37716e05e808 100644
--- a/drivers/net/ehea/ehea_phyp.c
+++ b/drivers/net/ehea/ehea_phyp.c
@@ -94,6 +94,7 @@ static long ehea_plpar_hcall9(unsigned long opcode,
 {
         long ret;
         int i, sleep_msecs;
+        u8 cb_cat;
 
         for (i = 0; i < 5; i++) {
                 ret = plpar_hcall9(opcode, outs,
@@ -106,7 +107,13 @@ static long ehea_plpar_hcall9(unsigned long opcode,
                         continue;
                 }
 
-                if (ret < H_SUCCESS)
+                cb_cat = EHEA_BMASK_GET(H_MEHEAPORT_CAT, arg2);
+
+                if ((ret < H_SUCCESS) && !(((ret == H_AUTHORITY)
+                    && (opcode == H_MODIFY_HEA_PORT))
+                    && (((cb_cat == H_PORT_CB4) && ((arg3 == H_PORT_CB4_JUMBO)
+                    || (arg3 == H_PORT_CB4_SPEED))) || ((cb_cat == H_PORT_CB7)
+                    && (arg3 == H_PORT_CB7_DUCQPN)))))
                         ehea_error("opcode=%lx ret=%lx"
                                    " arg1=%lx arg2=%lx arg3=%lx arg4=%lx"
                                    " arg5=%lx arg6=%lx arg7=%lx arg8=%lx"
@@ -120,7 +127,6 @@ static long ehea_plpar_hcall9(unsigned long opcode,
                                    outs[0], outs[1], outs[2], outs[3],
                                    outs[4], outs[5], outs[6], outs[7],
                                    outs[8]);
-
                 return ret;
         }
 
diff --git a/drivers/net/fs_enet/mac-fec.c b/drivers/net/fs_enet/mac-fec.c
index c2c5fd419bd0..ff6839477306 100644
--- a/drivers/net/fs_enet/mac-fec.c
+++ b/drivers/net/fs_enet/mac-fec.c
@@ -104,9 +104,9 @@ static int do_pd_setup(struct fs_enet_private *fep)
         fep->interrupt = platform_get_irq_byname(pdev,"interrupt");
         if (fep->interrupt < 0)
                 return -EINVAL;
-        
+
         r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs");
-        fep->fec.fecp =(void*)r->start;
+        fep->fec.fecp = ioremap(r->start, r->end - r->start + 1);
 
         if(fep->fec.fecp == NULL)
                 return -EINVAL;
@@ -319,11 +319,14 @@ static void restart(struct net_device *dev)
          * Clear any outstanding interrupt.
          */
         FW(fecp, ievent, 0xffc0);
+#ifndef CONFIG_PPC_MERGE
         FW(fecp, ivec, (fep->interrupt / 2) << 29);
-        
+#else
+        FW(fecp, ivec, (virq_to_hw(fep->interrupt) / 2) << 29);
+#endif
 
         /*
-         * adjust to speed (only for DUET & RMII) 
+         * adjust to speed (only for DUET & RMII)
          */
 #ifdef CONFIG_DUET
         if (fpi->use_rmii) {
@@ -418,6 +421,7 @@ static void stop(struct net_device *dev)
 
 static void pre_request_irq(struct net_device *dev, int irq)
 {
+#ifndef CONFIG_PPC_MERGE
         immap_t *immap = fs_enet_immap;
         u32 siel;
 
@@ -431,6 +435,7 @@ static void pre_request_irq(struct net_device *dev, int irq)
                         siel &= ~(0x80000000 >> (irq & ~1));
                 out_be32(&immap->im_siu_conf.sc_siel, siel);
         }
+#endif
 }
 
 static void post_free_irq(struct net_device *dev, int irq)
diff --git a/drivers/net/fs_enet/mac-scc.c b/drivers/net/fs_enet/mac-scc.c
index 95ec5872c507..afd7fca7c6c4 100644
--- a/drivers/net/fs_enet/mac-scc.c
+++ b/drivers/net/fs_enet/mac-scc.c
@@ -121,13 +121,13 @@ static int do_pd_setup(struct fs_enet_private *fep)
                 return -EINVAL;
 
         r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs");
-        fep->scc.sccp = (void *)r->start;
+        fep->scc.sccp = ioremap(r->start, r->end - r->start + 1);
 
         if (fep->scc.sccp == NULL)
                 return -EINVAL;
 
         r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pram");
-        fep->scc.ep = (void *)r->start;
+        fep->scc.ep = ioremap(r->start, r->end - r->start + 1);
 
         if (fep->scc.ep == NULL)
                 return -EINVAL;
@@ -397,6 +397,7 @@ static void stop(struct net_device *dev)
 
 static void pre_request_irq(struct net_device *dev, int irq)
 {
+#ifndef CONFIG_PPC_MERGE
         immap_t *immap = fs_enet_immap;
         u32 siel;
 
@@ -410,6 +411,7 @@ static void pre_request_irq(struct net_device *dev, int irq)
                         siel &= ~(0x80000000 >> (irq & ~1));
                 out_be32(&immap->im_siu_conf.sc_siel, siel);
         }
+#endif
 }
 
 static void post_free_irq(struct net_device *dev, int irq)
diff --git a/drivers/net/hamradio/Kconfig b/drivers/net/hamradio/Kconfig
index 896aa02000d7..feb0ada7a025 100644
--- a/drivers/net/hamradio/Kconfig
+++ b/drivers/net/hamradio/Kconfig
@@ -113,7 +113,7 @@ config SCC_TRXECHO
 
 config BAYCOM_SER_FDX
         tristate "BAYCOM ser12 fullduplex driver for AX.25"
-        depends on AX25
+        depends on AX25 && !S390
         select CRC_CCITT
         ---help---
           This is one of two drivers for Baycom style simple amateur radio
@@ -133,7 +133,7 @@ config BAYCOM_SER_FDX
 
 config BAYCOM_SER_HDX
         tristate "BAYCOM ser12 halfduplex driver for AX.25"
-        depends on AX25
+        depends on AX25 && !S390
         select CRC_CCITT
         ---help---
           This is one of two drivers for Baycom style simple amateur radio
@@ -181,7 +181,7 @@ config BAYCOM_EPP
 
 config YAM
         tristate "YAM driver for AX.25"
-        depends on AX25
+        depends on AX25 && !S390
         help
           The YAM is a modem for packet radio which connects to the serial
           port and includes some of the functions of a Terminal Node
diff --git a/drivers/net/irda/irda-usb.c b/drivers/net/irda/irda-usb.c
index 3ca1082ec776..340ee99652eb 100644
--- a/drivers/net/irda/irda-usb.c
+++ b/drivers/net/irda/irda-usb.c
@@ -441,25 +441,13 @@ static int irda_usb_hard_xmit(struct sk_buff *skb, struct net_device *netdev)
                 goto drop;
         }
 
-        /* Make sure there is room for IrDA-USB header. The actual
-         * allocation will be done lower in skb_push().
-         * Also, we don't use directly skb_cow(), because it require
-         * headroom >= 16, which force unnecessary copies - Jean II */
-        if (skb_headroom(skb) < self->header_length) {
-                IRDA_DEBUG(0, "%s(), Insuficient skb headroom.\n", __FUNCTION__);
-                if (skb_cow(skb, self->header_length)) {
-                        IRDA_WARNING("%s(), failed skb_cow() !!!\n", __FUNCTION__);
-                        goto drop;
-                }
-        }
+        memcpy(self->tx_buff + self->header_length, skb->data, skb->len);
 
         /* Change setting for next frame */
-
         if (self->capability & IUC_STIR421X) {
                 __u8 turnaround_time;
-                __u8* frame;
+                __u8* frame = self->tx_buff;
                 turnaround_time = get_turnaround_time( skb );
-                frame= skb_push(skb, self->header_length);
                 irda_usb_build_header(self, frame, 0);
                 frame[2] = turnaround_time;
                 if ((skb->len != 0) &&
@@ -472,17 +460,17 @@ static int irda_usb_hard_xmit(struct sk_buff *skb, struct net_device *netdev)
                         frame[1] = 0;
                 }
         } else {
-                irda_usb_build_header(self, skb_push(skb, self->header_length), 0);
+                irda_usb_build_header(self, self->tx_buff, 0);
         }
 
         /* FIXME: Make macro out of this one */
         ((struct irda_skb_cb *)skb->cb)->context = self;
 
-        usb_fill_bulk_urb(urb, self->usbdev, 
+        usb_fill_bulk_urb(urb, self->usbdev,
                       usb_sndbulkpipe(self->usbdev, self->bulk_out_ep),
-                      skb->data, IRDA_SKB_MAX_MTU,
+                      self->tx_buff, skb->len + self->header_length,
                       write_bulk_callback, skb);
-        urb->transfer_buffer_length = skb->len;
+
         /* This flag (URB_ZERO_PACKET) indicates that what we send is not
          * a continuous stream of data but separate packets.
          * In this case, the USB layer will insert an empty USB frame (TD)
@@ -1455,6 +1443,9 @@ static inline void irda_usb_close(struct irda_usb_cb *self)
         /* Remove the speed buffer */
         kfree(self->speed_buff);
         self->speed_buff = NULL;
+
+        kfree(self->tx_buff);
+        self->tx_buff = NULL;
 }
 
 /********************** USB CONFIG SUBROUTINES **********************/
@@ -1524,8 +1515,6 @@ static inline int irda_usb_parse_endpoints(struct irda_usb_cb *self, struct usb_
 
         IRDA_DEBUG(0, "%s(), And our endpoints are : in=%02X, out=%02X (%d), int=%02X\n",
                 __FUNCTION__, self->bulk_in_ep, self->bulk_out_ep, self->bulk_out_mtu, self->bulk_int_ep);
-        /* Should be 8, 16, 32 or 64 bytes */
-        IRDA_ASSERT(self->bulk_out_mtu == 64, ;);
 
         return((self->bulk_in_ep != 0) && (self->bulk_out_ep != 0));
 }
@@ -1753,9 +1742,14 @@ static int irda_usb_probe(struct usb_interface *intf,
 
         memset(self->speed_buff, 0, IRDA_USB_SPEED_MTU);
 
+        self->tx_buff = kzalloc(IRDA_SKB_MAX_MTU + self->header_length,
+                                GFP_KERNEL);
+        if (self->tx_buff == NULL)
+                goto err_out_4;
+
         ret = irda_usb_open(self);
         if (ret) 
-                goto err_out_4;
+                goto err_out_5;
 
         IRDA_MESSAGE("IrDA: Registered device %s\n", net->name);
         usb_set_intfdata(intf, self);
@@ -1766,14 +1760,14 @@ static int irda_usb_probe(struct usb_interface *intf,
                 self->needspatch = (ret < 0);
                 if (self->needspatch) {
                         IRDA_ERROR("STIR421X: Couldn't upload patch\n");
-                        goto err_out_5;
+                        goto err_out_6;
                 }
 
                 /* replace IrDA class descriptor with what patched device is now reporting */
                 irda_desc = irda_usb_find_class_desc (self->usbintf);
                 if (irda_desc == NULL) {
                         ret = -ENODEV;
-                        goto err_out_5;
+                        goto err_out_6;
                 }
                 if (self->irda_desc)
                         kfree (self->irda_desc);
@@ -1782,9 +1776,10 @@ static int irda_usb_probe(struct usb_interface *intf,
         }
 
         return 0;
-
-err_out_5:
+err_out_6:
         unregister_netdev(self->netdev);
+err_out_5:
+        kfree(self->tx_buff);
 err_out_4:
         kfree(self->speed_buff);
 err_out_3:
diff --git a/drivers/net/irda/irda-usb.h b/drivers/net/irda/irda-usb.h
index 6b2271f18e77..e846c38224a3 100644
--- a/drivers/net/irda/irda-usb.h
+++ b/drivers/net/irda/irda-usb.h
@@ -156,6 +156,7 @@ struct irda_usb_cb {
         struct irlap_cb   *irlap;       /* The link layer we are binded to */
         struct qos_info qos;
         char *speed_buff;               /* Buffer for speed changes */
+        char *tx_buff;
 
         struct timeval stamp;
         struct timeval now;
diff --git a/drivers/net/irda/stir4200.c b/drivers/net/irda/stir4200.c
index c14a74634fd5..20d306fea4cb 100644
--- a/drivers/net/irda/stir4200.c
+++ b/drivers/net/irda/stir4200.c
@@ -59,7 +59,7 @@
 #include <asm/byteorder.h>
 #include <asm/unaligned.h>
 
-MODULE_AUTHOR("Stephen Hemminger <shemminger@osdl.org>");
+MODULE_AUTHOR("Stephen Hemminger <shemminger@linux-foundation.org>");
 MODULE_DESCRIPTION("IrDA-USB Dongle Driver for SigmaTel STIr4200");
 MODULE_LICENSE("GPL");
 
diff --git a/drivers/net/irda/vlsi_ir.c b/drivers/net/irda/vlsi_ir.c
index 18c68193bf14..e2b1af618450 100644
--- a/drivers/net/irda/vlsi_ir.c
+++ b/drivers/net/irda/vlsi_ir.c
@@ -166,7 +166,7 @@ static void vlsi_proc_pdev(struct seq_file *seq, struct pci_dev *pdev)
         unsigned i;
 
         seq_printf(seq, "\n%s (vid/did: %04x/%04x)\n",
-                   PCIDEV_NAME(pdev), (int)pdev->vendor, (int)pdev->device);
+                   pci_name(pdev), (int)pdev->vendor, (int)pdev->device);
         seq_printf(seq, "pci-power-state: %u\n", (unsigned) pdev->current_state);
         seq_printf(seq, "resources: irq=%u / io=0x%04x / dma_mask=0x%016Lx\n",
                    pdev->irq, (unsigned)pci_resource_start(pdev, 0), (unsigned long long)pdev->dma_mask);
@@ -1401,7 +1401,7 @@ static void vlsi_tx_timeout(struct net_device *ndev)
 
         if (vlsi_start_hw(idev))
                 IRDA_ERROR("%s: failed to restart hw - %s(%s) unusable!\n",
-                           __FUNCTION__, PCIDEV_NAME(idev->pdev), ndev->name);
+                           __FUNCTION__, pci_name(idev->pdev), ndev->name);
         else
                 netif_start_queue(ndev);
 }
@@ -1643,7 +1643,7 @@ vlsi_irda_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                 pdev->current_state = 0; /* hw must be running now */
 
         IRDA_MESSAGE("%s: IrDA PCI controller %s detected\n",
-                     drivername, PCIDEV_NAME(pdev));
+                     drivername, pci_name(pdev));
 
         if ( !pci_resource_start(pdev,0)
              || !(pci_resource_flags(pdev,0) & IORESOURCE_IO) ) {
@@ -1728,7 +1728,7 @@ static void __devexit vlsi_irda_remove(struct pci_dev *pdev)
 
         pci_set_drvdata(pdev, NULL);
 
-        IRDA_MESSAGE("%s: %s removed\n", drivername, PCIDEV_NAME(pdev));
+        IRDA_MESSAGE("%s: %s removed\n", drivername, pci_name(pdev));
 }
 
 #ifdef CONFIG_PM
@@ -1748,7 +1748,7 @@ static int vlsi_irda_suspend(struct pci_dev *pdev, pm_message_t state)
 
         if (!ndev) {
                 IRDA_ERROR("%s - %s: no netdevice \n",
-                           __FUNCTION__, PCIDEV_NAME(pdev));
+                           __FUNCTION__, pci_name(pdev));
                 return 0;
         }
         idev = ndev->priv;      
@@ -1759,7 +1759,7 @@ static int vlsi_irda_suspend(struct pci_dev *pdev, pm_message_t state)
                         pdev->current_state = state.event;
                 }
                 else
-                        IRDA_ERROR("%s - %s: invalid suspend request %u -> %u\n", __FUNCTION__, PCIDEV_NAME(pdev), pdev->current_state, state.event);
+                        IRDA_ERROR("%s - %s: invalid suspend request %u -> %u\n", __FUNCTION__, pci_name(pdev), pdev->current_state, state.event);
                 up(&idev->sem);
                 return 0;
         }
@@ -1787,7 +1787,7 @@ static int vlsi_irda_resume(struct pci_dev *pdev)
 
         if (!ndev) {
                 IRDA_ERROR("%s - %s: no netdevice \n",
-                           __FUNCTION__, PCIDEV_NAME(pdev));
+                           __FUNCTION__, pci_name(pdev));
                 return 0;
         }
         idev = ndev->priv;      
@@ -1795,7 +1795,7 @@ static int vlsi_irda_resume(struct pci_dev *pdev)
         if (pdev->current_state == 0) {
                 up(&idev->sem);
                 IRDA_WARNING("%s - %s: already resumed\n",
-                             __FUNCTION__, PCIDEV_NAME(pdev));
+                             __FUNCTION__, pci_name(pdev));
                 return 0;
         }
         
diff --git a/drivers/net/irda/vlsi_ir.h b/drivers/net/irda/vlsi_ir.h
index c37f0bc4c7f9..2d3b773d8e35 100644
--- a/drivers/net/irda/vlsi_ir.h
+++ b/drivers/net/irda/vlsi_ir.h
@@ -41,39 +41,6 @@
 #define PCI_CLASS_SUBCLASS_MASK         0xffff
 #endif
 
-/* in recent 2.5 interrupt handlers have non-void return value */
-#ifndef IRQ_RETVAL
-typedef void irqreturn_t;
-#define IRQ_NONE
-#define IRQ_HANDLED
-#define IRQ_RETVAL(x)
-#endif
-
-/* some stuff need to check kernelversion. Not all 2.5 stuff was present
- * in early 2.5.x - the test is merely to separate 2.4 from 2.5
- */
-#include <linux/version.h>
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
-
-/* PDE() introduced in 2.5.4 */
-#ifdef CONFIG_PROC_FS
-#define PDE(inode) ((inode)->i_private)
-#endif
-
-/* irda crc16 calculation exported in 2.5.42 */
-#define irda_calc_crc16(fcs,buf,len)    (GOOD_FCS)
-
-/* we use this for unified pci device name access */
-#define PCIDEV_NAME(pdev)       ((pdev)->name)
-
-#else /* 2.5 or later */
-
-/* whatever we get from the associated struct device - bus:slot:dev.fn id */
-#define PCIDEV_NAME(pdev)       (pci_name(pdev))
-
-#endif
-
 /* ================================================================ */
 
 /* non-standard PCI registers */
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index c41ae4286eea..b3bf86422734 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -314,6 +314,13 @@ int mv643xx_eth_free_tx_descs(struct net_device *dev, int force)
 
         while (mp->tx_desc_count > 0) {
                 spin_lock_irqsave(&mp->lock, flags);
+
+                /* tx_desc_count might have changed before acquiring the lock */
+                if (mp->tx_desc_count <= 0) {
+                        spin_unlock_irqrestore(&mp->lock, flags);
+                        return released;
+                }
+
                 tx_index = mp->tx_used_desc_q;
                 desc = &mp->p_tx_desc_area[tx_index];
                 cmd_sts = desc->cmd_sts;
@@ -332,13 +339,13 @@ int mv643xx_eth_free_tx_descs(struct net_device *dev, int force)
                 if (skb)
                         mp->tx_skb[tx_index] = NULL;
 
-                spin_unlock_irqrestore(&mp->lock, flags);
-
                 if (cmd_sts & ETH_ERROR_SUMMARY) {
                         printk("%s: Error in TX\n", dev->name);
                         mp->stats.tx_errors++;
                 }
 
+                spin_unlock_irqrestore(&mp->lock, flags);
+
                 if (cmd_sts & ETH_TX_FIRST_DESC)
                         dma_unmap_single(NULL, addr, count, DMA_TO_DEVICE);
                 else
diff --git a/drivers/net/netxen/netxen_nic.h b/drivers/net/netxen/netxen_nic.h
index 6490acf05305..e8598b809228 100644
--- a/drivers/net/netxen/netxen_nic.h
+++ b/drivers/net/netxen/netxen_nic.h
@@ -63,12 +63,11 @@
 
 #include "netxen_nic_hw.h"
 
-#define NETXEN_NIC_BUILD_NO     "4"
+#define NETXEN_NIC_BUILD_NO     "2"
 #define _NETXEN_NIC_LINUX_MAJOR 3
 #define _NETXEN_NIC_LINUX_MINOR 3
-#define _NETXEN_NIC_LINUX_SUBVERSION 2
-#define NETXEN_NIC_LINUX_VERSIONID  "3.3.2" "-" NETXEN_NIC_BUILD_NO
-#define NETXEN_NIC_FW_VERSIONID "3.3.2"
+#define _NETXEN_NIC_LINUX_SUBVERSION 3
+#define NETXEN_NIC_LINUX_VERSIONID  "3.3.3" "-" NETXEN_NIC_BUILD_NO
 
 #define RCV_DESC_RINGSIZE       \
         (sizeof(struct rcv_desc) * adapter->max_rx_desc_count)
@@ -240,49 +239,39 @@ extern unsigned long long netxen_dma_mask;
 
 typedef u32 netxen_ctx_msg;
 
-#define _netxen_set_bits(config_word, start, bits, val) {\
-        unsigned long long mask = (((1ULL << (bits)) - 1) << (start));  \
-        unsigned long long value = (val);       \
-        (config_word) &= ~mask; \
-        (config_word) |= (((value) << (start)) & mask); \
-}
-
 #define netxen_set_msg_peg_id(config_word, val) \
-        _netxen_set_bits(config_word, 0, 2, val)
+        ((config_word) &= ~3, (config_word) |= val & 3)
 #define netxen_set_msg_privid(config_word)      \
-        set_bit(2, (unsigned long*)&config_word)
+        ((config_word) |= 1 << 2)
 #define netxen_set_msg_count(config_word, val)  \
-        _netxen_set_bits(config_word, 3, 15, val)
+        ((config_word) &= ~(0x7fff<<3), (config_word) |= (val & 0x7fff) << 3)
 #define netxen_set_msg_ctxid(config_word, val)  \
-        _netxen_set_bits(config_word, 18, 10, val)
+        ((config_word) &= ~(0x3ff<<18), (config_word) |= (val & 0x3ff) << 18)
 #define netxen_set_msg_opcode(config_word, val) \
-        _netxen_set_bits(config_word, 28, 4, val)
+        ((config_word) &= ~(0xf<<24), (config_word) |= (val & 0xf) << 24)
 
 struct netxen_rcv_context {
-        u32 rcv_ring_addr_lo;
-        u32 rcv_ring_addr_hi;
-        u32 rcv_ring_size;
-        u32 rsrvd;
+        __le64 rcv_ring_addr;
+        __le32 rcv_ring_size;
+        __le32 rsrvd;
 };
 
 struct netxen_ring_ctx {
 
         /* one command ring */
-        u64 cmd_consumer_offset;
-        u32 cmd_ring_addr_lo;
-        u32 cmd_ring_addr_hi;
-        u32 cmd_ring_size;
-        u32 rsrvd;
+        __le64 cmd_consumer_offset;
+        __le64 cmd_ring_addr;
+        __le32 cmd_ring_size;
+        __le32 rsrvd;
 
         /* three receive rings */
         struct netxen_rcv_context rcv_ctx[3];
 
         /* one status ring */
-        u32 sts_ring_addr_lo;
-        u32 sts_ring_addr_hi;
-        u32 sts_ring_size;
+        __le64 sts_ring_addr;
+        __le32 sts_ring_size;
 
-        u32 ctx_id;
+        __le32 ctx_id;
 } __attribute__ ((aligned(64)));
 
 /*
@@ -306,81 +295,85 @@ struct netxen_ring_ctx {
         ((cmd_desc)->port_ctxid |= ((var) & 0x0F))
 
 #define netxen_set_cmd_desc_flags(cmd_desc, val)        \
-        _netxen_set_bits((cmd_desc)->flags_opcode, 0, 7, val)
+        ((cmd_desc)->flags_opcode &= ~cpu_to_le16(0x7f), \
+        (cmd_desc)->flags_opcode |= cpu_to_le16((val) & 0x7f))
 #define netxen_set_cmd_desc_opcode(cmd_desc, val)       \
-        _netxen_set_bits((cmd_desc)->flags_opcode, 7, 6, val)
+        ((cmd_desc)->flags_opcode &= ~cpu_to_le16(0x3f<<7), \
+        (cmd_desc)->flags_opcode |= cpu_to_le16((val) & (0x3f<<7)))
 
 #define netxen_set_cmd_desc_num_of_buff(cmd_desc, val)  \
-        _netxen_set_bits((cmd_desc)->num_of_buffers_total_length, 0, 8, val);
+        ((cmd_desc)->num_of_buffers_total_length &= ~cpu_to_le32(0xff), \
+        (cmd_desc)->num_of_buffers_total_length |= cpu_to_le32((val) & 0xff))
 #define netxen_set_cmd_desc_totallength(cmd_desc, val)  \
-        _netxen_set_bits((cmd_desc)->num_of_buffers_total_length, 8, 24, val);
+        ((cmd_desc)->num_of_buffers_total_length &= cpu_to_le32(0xff), \
+        (cmd_desc)->num_of_buffers_total_length |= cpu_to_le32(val << 24))
 
 #define netxen_get_cmd_desc_opcode(cmd_desc)    \
-        (((cmd_desc)->flags_opcode >> 7) & 0x003F)
+        ((le16_to_cpu((cmd_desc)->flags_opcode) >> 7) & 0x003F)
 #define netxen_get_cmd_desc_totallength(cmd_desc)       \
-        (((cmd_desc)->num_of_buffers_total_length >> 8) & 0x0FFFFFF)
+        (le32_to_cpu((cmd_desc)->num_of_buffers_total_length) >> 8)
 
 struct cmd_desc_type0 {
         u8 tcp_hdr_offset;      /* For LSO only */
         u8 ip_hdr_offset;       /* For LSO only */
         /* Bit pattern: 0-6 flags, 7-12 opcode, 13-15 unused */
-        u16 flags_opcode;
+        __le16 flags_opcode;
         /* Bit pattern: 0-7 total number of segments,
            8-31 Total size of the packet */
-        u32 num_of_buffers_total_length;
+        __le32 num_of_buffers_total_length;
         union {
                 struct {
-                        u32 addr_low_part2;
-                        u32 addr_high_part2;
+                        __le32 addr_low_part2;
+                        __le32 addr_high_part2;
                 };
-                u64 addr_buffer2;
+                __le64 addr_buffer2;
         };
 
-        u16 reference_handle;   /* changed to u16 to add mss */
-        u16 mss;                /* passed by NDIS_PACKET for LSO */
+        __le16 reference_handle;        /* changed to u16 to add mss */
+        __le16 mss;             /* passed by NDIS_PACKET for LSO */
         /* Bit pattern 0-3 port, 0-3 ctx id */
         u8 port_ctxid;
         u8 total_hdr_length;    /* LSO only : MAC+IP+TCP Hdr size */
-        u16 conn_id;            /* IPSec offoad only */
+        __le16 conn_id;         /* IPSec offoad only */
 
         union {
                 struct {
-                        u32 addr_low_part3;
-                        u32 addr_high_part3;
+                        __le32 addr_low_part3;
+                        __le32 addr_high_part3;
                 };
-                u64 addr_buffer3;
+                __le64 addr_buffer3;
         };
         union {
                 struct {
-                        u32 addr_low_part1;
-                        u32 addr_high_part1;
+                        __le32 addr_low_part1;
+                        __le32 addr_high_part1;
                 };
-                u64 addr_buffer1;
+                __le64 addr_buffer1;
         };
 
-        u16 buffer1_length;
-        u16 buffer2_length;
-        u16 buffer3_length;
-        u16 buffer4_length;
+        __le16 buffer1_length;
+        __le16 buffer2_length;
+        __le16 buffer3_length;
+        __le16 buffer4_length;
 
         union {
                 struct {
-                        u32 addr_low_part4;
-                        u32 addr_high_part4;
+                        __le32 addr_low_part4;
+                        __le32 addr_high_part4;
                 };
-                u64 addr_buffer4;
+                __le64 addr_buffer4;
         };
 
-        u64 unused;
+        __le64 unused;
 
 } __attribute__ ((aligned(64)));
 
 /* Note: sizeof(rcv_desc) should always be a mutliple of 2 */
 struct rcv_desc {
-        u16 reference_handle;
-        u16 reserved;
-        u32 buffer_length;      /* allocated buffer length (usually 2K) */
-        u64 addr_buffer;
+        __le16 reference_handle;
+        __le16 reserved;
+        __le32 buffer_length;   /* allocated buffer length (usually 2K) */
+        __le64 addr_buffer;
 };
 
 /* opcode field in status_desc */
@@ -406,36 +399,36 @@ struct rcv_desc {
         (((status_desc)->lro & 0x80) >> 7)
 
 #define netxen_get_sts_port(status_desc)        \
-        ((status_desc)->status_desc_data & 0x0F)
+        (le64_to_cpu((status_desc)->status_desc_data) & 0x0F)
 #define netxen_get_sts_status(status_desc)      \
-        (((status_desc)->status_desc_data >> 4) & 0x0F)
+        ((le64_to_cpu((status_desc)->status_desc_data) >> 4) & 0x0F)
 #define netxen_get_sts_type(status_desc)        \
-        (((status_desc)->status_desc_data >> 8) & 0x0F)
+        ((le64_to_cpu((status_desc)->status_desc_data) >> 8) & 0x0F)
 #define netxen_get_sts_totallength(status_desc) \
-        (((status_desc)->status_desc_data >> 12) & 0xFFFF)
+        ((le64_to_cpu((status_desc)->status_desc_data) >> 12) & 0xFFFF)
 #define netxen_get_sts_refhandle(status_desc)   \
-        (((status_desc)->status_desc_data >> 28) & 0xFFFF)
+        ((le64_to_cpu((status_desc)->status_desc_data) >> 28) & 0xFFFF)
 #define netxen_get_sts_prot(status_desc)        \
-        (((status_desc)->status_desc_data >> 44) & 0x0F)
+        ((le64_to_cpu((status_desc)->status_desc_data) >> 44) & 0x0F)
 #define netxen_get_sts_owner(status_desc)       \
-        (((status_desc)->status_desc_data >> 56) & 0x03)
+        ((le64_to_cpu((status_desc)->status_desc_data) >> 56) & 0x03)
 #define netxen_get_sts_opcode(status_desc)      \
-        (((status_desc)->status_desc_data >> 58) & 0x03F)
+        ((le64_to_cpu((status_desc)->status_desc_data) >> 58) & 0x03F)
 
 #define netxen_clear_sts_owner(status_desc)     \
         ((status_desc)->status_desc_data &=     \
-        ~(((unsigned long long)3) << 56 ))
+        ~cpu_to_le64(((unsigned long long)3) << 56 ))
 #define netxen_set_sts_owner(status_desc, val)  \
         ((status_desc)->status_desc_data |=     \
-        (((unsigned long long)((val) & 0x3)) << 56 ))
+        cpu_to_le64(((unsigned long long)((val) & 0x3)) << 56 ))
 
 struct status_desc {
         /* Bit pattern: 0-3 port, 4-7 status, 8-11 type, 12-27 total_length
            28-43 reference_handle, 44-47 protocol, 48-52 unused
            53-55 desc_cnt, 56-57 owner, 58-63 opcode
          */
-        u64 status_desc_data;
-        u32 hash_value;
+        __le64 status_desc_data;
+        __le32 hash_value;
         u8 hash_type;
         u8 msg_type;
         u8 unused;
@@ -1006,9 +999,9 @@ void netxen_niu_gbe_set_mii_mode(struct netxen_adapter *adapter, int port,
 void netxen_niu_gbe_set_gmii_mode(struct netxen_adapter *adapter, int port,
                                   long enable);
 int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long phy, long reg,
-                            __le32 * readval);
+                            __u32 * readval);
 int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long phy,
-                             long reg, __le32 val);
+                             long reg, __u32 val);
 
 /* Functions available from netxen_nic_hw.c */
 int netxen_nic_set_mtu_xgb(struct netxen_port *port, int new_mtu);
diff --git a/drivers/net/netxen/netxen_nic_ethtool.c b/drivers/net/netxen/netxen_nic_ethtool.c
index 34044616b3c8..c381d77a7336 100644
--- a/drivers/net/netxen/netxen_nic_ethtool.c
+++ b/drivers/net/netxen/netxen_nic_ethtool.c
@@ -218,7 +218,7 @@ netxen_nic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
 {
         struct netxen_port *port = netdev_priv(dev);
         struct netxen_adapter *adapter = port->adapter;
-        __le32 status;
+        __u32 status;
 
         /* read which mode */
         if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
@@ -226,7 +226,7 @@ netxen_nic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
                 if (adapter->phy_write
                     && adapter->phy_write(adapter, port->portnum,
                                           NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
-                                          (__le32) ecmd->autoneg) != 0)
+                                          ecmd->autoneg) != 0)
                         return -EIO;
                 else
                         port->link_autoneg = ecmd->autoneg;
@@ -279,7 +279,7 @@ static int netxen_nic_get_regs_len(struct net_device *dev)
 }
 
 struct netxen_niu_regs {
-        __le32 reg[NETXEN_NIC_REGS_COUNT];
+        __u32 reg[NETXEN_NIC_REGS_COUNT];
 };
 
 static struct netxen_niu_regs niu_registers[] = {
@@ -372,7 +372,7 @@ netxen_nic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
 {
         struct netxen_port *port = netdev_priv(dev);
         struct netxen_adapter *adapter = port->adapter;
-        __le32 mode, *regs_buff = p;
+        __u32 mode, *regs_buff = p;
         void __iomem *addr;
         int i, window;
 
@@ -415,7 +415,7 @@ static u32 netxen_nic_get_link(struct net_device *dev)
 {
         struct netxen_port *port = netdev_priv(dev);
         struct netxen_adapter *adapter = port->adapter;
-        __le32 status;
+        __u32 status;
 
         /* read which mode */
         if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
@@ -482,13 +482,13 @@ netxen_nic_get_pauseparam(struct net_device *dev,
 {
         struct netxen_port *port = netdev_priv(dev);
         struct netxen_adapter *adapter = port->adapter;
-        __le32 val;
+        __u32 val;
 
         if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
                 /* get flow control settings */
                 netxen_nic_read_w0(adapter,
                                    NETXEN_NIU_GB_MAC_CONFIG_0(port->portnum),
-                                   (u32 *) & val);
+                                   &val);
                 pause->rx_pause = netxen_gb_get_rx_flowctl(val);
                 pause->tx_pause = netxen_gb_get_tx_flowctl(val);
                 /* get autoneg settings */
@@ -502,7 +502,7 @@ netxen_nic_set_pauseparam(struct net_device *dev,
 {
         struct netxen_port *port = netdev_priv(dev);
         struct netxen_adapter *adapter = port->adapter;
-        __le32 val;
+        __u32 val;
         unsigned int autoneg;
 
         /* read mode */
@@ -522,13 +522,13 @@ netxen_nic_set_pauseparam(struct net_device *dev,
 
                 netxen_nic_write_w0(adapter,
                                     NETXEN_NIU_GB_MAC_CONFIG_0(port->portnum),
-                                    *(u32 *) (&val));
+                                    *&val);
                 /* set autoneg */
                 autoneg = pause->autoneg;
                 if (adapter->phy_write
                     && adapter->phy_write(adapter, port->portnum,
                                           NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
-                                          (__le32) autoneg) != 0)
+                                          autoneg) != 0)
                         return -EIO;
                 else {
                         port->link_autoneg = pause->autoneg;
@@ -543,7 +543,7 @@ static int netxen_nic_reg_test(struct net_device *dev)
         struct netxen_port *port = netdev_priv(dev);
         struct netxen_adapter *adapter = port->adapter;
         u32 data_read, data_written, save;
-        __le32 mode;
+        __u32 mode;
 
         /* 
          * first test the "Read Only" registers by writing which mode
diff --git a/drivers/net/netxen/netxen_nic_hw.c b/drivers/net/netxen/netxen_nic_hw.c
index c0c31d1914a7..f263232f499f 100644
--- a/drivers/net/netxen/netxen_nic_hw.c
+++ b/drivers/net/netxen/netxen_nic_hw.c
@@ -95,7 +95,7 @@ void netxen_nic_set_multi(struct net_device *netdev)
         struct netxen_port *port = netdev_priv(netdev);
         struct netxen_adapter *adapter = port->adapter;
         struct dev_mc_list *mc_ptr;
-        __le32 netxen_mac_addr_cntl_data = 0;
+        __u32 netxen_mac_addr_cntl_data = 0;
 
         mc_ptr = netdev->mc_list;
         if (netdev->flags & IFF_PROMISC) {
@@ -236,8 +236,9 @@ int netxen_nic_hw_resources(struct netxen_adapter *adapter)
         }
         memset(addr, 0, sizeof(struct netxen_ring_ctx));
         adapter->ctx_desc = (struct netxen_ring_ctx *)addr;
-        adapter->ctx_desc->cmd_consumer_offset = adapter->ctx_desc_phys_addr
-            + sizeof(struct netxen_ring_ctx);
+        adapter->ctx_desc->cmd_consumer_offset =
+            cpu_to_le64(adapter->ctx_desc_phys_addr +
+                        sizeof(struct netxen_ring_ctx));
         adapter->cmd_consumer = (uint32_t *) (((char *)addr) +
                                               sizeof(struct netxen_ring_ctx));
 
@@ -253,11 +254,10 @@ int netxen_nic_hw_resources(struct netxen_adapter *adapter)
                 return -ENOMEM;
         }
 
-        adapter->ctx_desc->cmd_ring_addr_lo =
-            hw->cmd_desc_phys_addr & 0xffffffffUL;
-        adapter->ctx_desc->cmd_ring_addr_hi =
-            ((u64) hw->cmd_desc_phys_addr >> 32);
-        adapter->ctx_desc->cmd_ring_size = adapter->max_tx_desc_count;
+        adapter->ctx_desc->cmd_ring_addr =
+                cpu_to_le64(hw->cmd_desc_phys_addr);
+        adapter->ctx_desc->cmd_ring_size =
+                cpu_to_le32(adapter->max_tx_desc_count);
 
         hw->cmd_desc_head = (struct cmd_desc_type0 *)addr;
 
@@ -278,12 +278,10 @@ int netxen_nic_hw_resources(struct netxen_adapter *adapter)
                                 return err;
                         }
                         rcv_desc->desc_head = (struct rcv_desc *)addr;
-                        adapter->ctx_desc->rcv_ctx[ring].rcv_ring_addr_lo =
-                            rcv_desc->phys_addr & 0xffffffffUL;
-                        adapter->ctx_desc->rcv_ctx[ring].rcv_ring_addr_hi =
-                            ((u64) rcv_desc->phys_addr >> 32);
+                        adapter->ctx_desc->rcv_ctx[ring].rcv_ring_addr =
+                            cpu_to_le64(rcv_desc->phys_addr);
                         adapter->ctx_desc->rcv_ctx[ring].rcv_ring_size =
-                            rcv_desc->max_rx_desc_count;
+                            cpu_to_le32(rcv_desc->max_rx_desc_count);
                 }
 
                 addr = netxen_alloc(adapter->ahw.pdev, STATUS_DESC_RINGSIZE,
@@ -297,11 +295,10 @@ int netxen_nic_hw_resources(struct netxen_adapter *adapter)
                         return err;
                 }
                 recv_ctx->rcv_status_desc_head = (struct status_desc *)addr;
-                adapter->ctx_desc->sts_ring_addr_lo =
-                    recv_ctx->rcv_status_desc_phys_addr & 0xffffffffUL;
-                adapter->ctx_desc->sts_ring_addr_hi =
-                    ((u64) recv_ctx->rcv_status_desc_phys_addr >> 32);
-                adapter->ctx_desc->sts_ring_size = adapter->max_rx_desc_count;
+                adapter->ctx_desc->sts_ring_addr =
+                    cpu_to_le64(recv_ctx->rcv_status_desc_phys_addr);
+                adapter->ctx_desc->sts_ring_size =
+                    cpu_to_le32(adapter->max_rx_desc_count);
 
         }
         /* Window = 1 */
@@ -387,10 +384,6 @@ void netxen_tso_check(struct netxen_adapter *adapter,
         }
         adapter->stats.xmitcsummed++;
         desc->tcp_hdr_offset = skb->h.raw - skb->data;
-        netxen_set_cmd_desc_totallength(desc,
-                                        cpu_to_le32
-                                        (netxen_get_cmd_desc_totallength
-                                         (desc)));
         desc->ip_hdr_offset = skb->nh.raw - skb->data;
 }
 
@@ -867,9 +860,9 @@ netxen_crb_writelit_adapter(struct netxen_adapter *adapter, unsigned long off,
 void netxen_nic_set_link_parameters(struct netxen_port *port)
 {
         struct netxen_adapter *adapter = port->adapter;
-        __le32 status;
-        __le32 autoneg;
-        __le32 mode;
+        __u32 status;
+        __u32 autoneg;
+        __u32 mode;
 
         netxen_nic_read_w0(adapter, NETXEN_NIU_MODE, &mode);
         if (netxen_get_niu_enable_ge(mode)) {   /* Gb 10/100/1000 Mbps mode */
@@ -984,7 +977,8 @@ void netxen_nic_flash_print(struct netxen_adapter *adapter)
                        _NETXEN_NIC_LINUX_MAJOR, fw_major);
                 adapter->driver_mismatch = 1;
         }
-        if (fw_minor != _NETXEN_NIC_LINUX_MINOR) {
+        if (fw_minor != _NETXEN_NIC_LINUX_MINOR &&
+                        fw_minor != (_NETXEN_NIC_LINUX_MINOR + 1)) {
                 printk(KERN_ERR "The mismatch in driver version and firmware "
                        "version minor number\n"
                        "Driver version minor number = %d \t"
diff --git a/drivers/net/netxen/netxen_nic_hw.h b/drivers/net/netxen/netxen_nic_hw.h
index 0685633a9c1e..ab1112eb1b0d 100644
--- a/drivers/net/netxen/netxen_nic_hw.h
+++ b/drivers/net/netxen/netxen_nic_hw.h
@@ -124,28 +124,28 @@ typedef enum {
  */
 
 #define netxen_gb_enable_tx(config_word)        \
-        set_bit(0, (unsigned long*)(&config_word))
+        ((config_word) |= 1 << 0)
 #define netxen_gb_enable_rx(config_word)        \
-        set_bit(2, (unsigned long*)(&config_word))
+        ((config_word) |= 1 << 2)
 #define netxen_gb_tx_flowctl(config_word)       \
-        set_bit(4, (unsigned long*)(&config_word))
+        ((config_word) |= 1 << 4)
 #define netxen_gb_rx_flowctl(config_word)       \
-        set_bit(5, (unsigned long*)(&config_word))
+        ((config_word) |= 1 << 5)
 #define netxen_gb_tx_reset_pb(config_word)      \
-                set_bit(16, (unsigned long*)(&config_word))
+        ((config_word) |= 1 << 16)
 #define netxen_gb_rx_reset_pb(config_word)      \
-                set_bit(17, (unsigned long*)(&config_word))
+        ((config_word) |= 1 << 17)
 #define netxen_gb_tx_reset_mac(config_word)     \
-                set_bit(18, (unsigned long*)(&config_word))
+        ((config_word) |= 1 << 18)
 #define netxen_gb_rx_reset_mac(config_word)     \
-                set_bit(19, (unsigned long*)(&config_word))
+        ((config_word) |= 1 << 19)
 #define netxen_gb_soft_reset(config_word)       \
-                set_bit(31, (unsigned long*)(&config_word))
+        ((config_word) |= 1 << 31)
 
 #define netxen_gb_unset_tx_flowctl(config_word) \
-                clear_bit(4, (unsigned long *)(&config_word))
+        ((config_word) &= ~(1 << 4))
 #define netxen_gb_unset_rx_flowctl(config_word) \
-                clear_bit(5, (unsigned long*)(&config_word))
+        ((config_word) &= ~(1 << 5))
 
 #define netxen_gb_get_tx_synced(config_word)    \
                 _netxen_crb_get_bit((config_word), 1)
@@ -171,15 +171,15 @@ typedef enum {
  */
 
 #define netxen_gb_set_duplex(config_word)       \
-                set_bit(0, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 0)
 #define netxen_gb_set_crc_enable(config_word)   \
-                set_bit(1, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 1)
 #define netxen_gb_set_padshort(config_word)     \
-                set_bit(2, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 2)
 #define netxen_gb_set_checklength(config_word)  \
-                set_bit(4, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 4)
 #define netxen_gb_set_hugeframes(config_word)   \
-                set_bit(5, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 5)
 #define netxen_gb_set_preamblelen(config_word, val)     \
                 ((config_word) |= ((val) << 12) & 0xF000)
 #define netxen_gb_set_intfmode(config_word, val)                \
@@ -190,9 +190,9 @@ typedef enum {
 #define netxen_gb_set_mii_mgmt_clockselect(config_word, val)    \
                 ((config_word) |= ((val) & 0x07))
 #define netxen_gb_mii_mgmt_reset(config_word)   \
-                set_bit(31, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 31)
 #define netxen_gb_mii_mgmt_unset(config_word)   \
-                clear_bit(31, (unsigned long*)&config_word)
+                ((config_word) &= ~(1 << 31))
 
 /*
  * NIU GB MII Mgmt Command Register (applies to GB0, GB1, GB2, GB3)
@@ -201,7 +201,7 @@ typedef enum {
  */
 
 #define netxen_gb_mii_mgmt_set_read_cycle(config_word)  \
-                set_bit(0, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 0)
 #define netxen_gb_mii_mgmt_reg_addr(config_word, val)   \
                 ((config_word) |= ((val) & 0x1F))
 #define netxen_gb_mii_mgmt_phy_addr(config_word, val)   \
@@ -274,9 +274,9 @@ typedef enum {
 #define netxen_set_phy_speed(config_word, val)  \
                 ((config_word) |= ((val & 0x03) << 14))
 #define netxen_set_phy_duplex(config_word)      \
-                set_bit(13, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 13)
 #define netxen_clear_phy_duplex(config_word)    \
-                clear_bit(13, (unsigned long*)&config_word)
+                ((config_word) &= ~(1 << 13))
 
 #define netxen_get_phy_jabber(config_word)      \
                 _netxen_crb_get_bit(config_word, 0)
@@ -350,11 +350,11 @@ typedef enum {
                 _netxen_crb_get_bit(config_word, 15)
 
 #define netxen_set_phy_int_link_status_changed(config_word)     \
-                set_bit(10, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 10)
 #define netxen_set_phy_int_autoneg_completed(config_word)       \
-                set_bit(11, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 11)
 #define netxen_set_phy_int_speed_changed(config_word)   \
-                set_bit(14, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 14)
 
 /*
  * NIU Mode Register.
@@ -382,22 +382,22 @@ typedef enum {
  */
 
 #define netxen_set_gb_drop_gb0(config_word)     \
-                set_bit(0, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 0)
 #define netxen_set_gb_drop_gb1(config_word)     \
-                set_bit(1, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 1)
 #define netxen_set_gb_drop_gb2(config_word)     \
-                set_bit(2, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 2)
 #define netxen_set_gb_drop_gb3(config_word)     \
-                set_bit(3, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 3)
 
 #define netxen_clear_gb_drop_gb0(config_word)   \
-                clear_bit(0, (unsigned long*)&config_word)
+                ((config_word) &= ~(1 << 0))
 #define netxen_clear_gb_drop_gb1(config_word)   \
-                clear_bit(1, (unsigned long*)&config_word)
+                ((config_word) &= ~(1 << 1))
 #define netxen_clear_gb_drop_gb2(config_word)   \
-                clear_bit(2, (unsigned long*)&config_word)
+                ((config_word) &= ~(1 << 2))
 #define netxen_clear_gb_drop_gb3(config_word)   \
-                clear_bit(3, (unsigned long*)&config_word)
+                ((config_word) &= ~(1 << 3))
 
 /*
  * NIU XG MAC Config Register
@@ -413,7 +413,7 @@ typedef enum {
  */
 
 #define netxen_xg_soft_reset(config_word)       \
-                set_bit(4, (unsigned long*)&config_word)
+                ((config_word) |= 1 << 4)
 
 /*
  * MAC Control Register
@@ -433,19 +433,19 @@ typedef enum {
 #define netxen_nic_mcr_set_id_pool0(config, val)        \
                 ((config) |= ((val) &0x03))
 #define netxen_nic_mcr_set_enable_xtnd0(config) \
-                (set_bit(3, (unsigned long *)&(config)))
+                ((config) |= 1 << 3)
 #define netxen_nic_mcr_set_id_pool1(config, val)        \
                 ((config) |= (((val) & 0x03) << 4))
 #define netxen_nic_mcr_set_enable_xtnd1(config) \
-                (set_bit(6, (unsigned long *)&(config)))
+                ((config) |= 1 << 6)
 #define netxen_nic_mcr_set_id_pool2(config, val)        \
                 ((config) |= (((val) & 0x03) << 8))
 #define netxen_nic_mcr_set_enable_xtnd2(config) \
-                (set_bit(10, (unsigned long *)&(config)))
+                ((config) |= 1 << 10)
 #define netxen_nic_mcr_set_id_pool3(config, val)        \
                 ((config) |= (((val) & 0x03) << 12))
 #define netxen_nic_mcr_set_enable_xtnd3(config) \
-                (set_bit(14, (unsigned long *)&(config)))
+                ((config) |= 1 << 14)
 #define netxen_nic_mcr_set_mode_select(config, val)     \
                 ((config) |= (((val) & 0x03) << 24))
 #define netxen_nic_mcr_set_enable_pool(config, val)     \
diff --git a/drivers/net/netxen/netxen_nic_init.c b/drivers/net/netxen/netxen_nic_init.c
index c3e41f368554..973af96337a9 100644
--- a/drivers/net/netxen/netxen_nic_init.c
+++ b/drivers/net/netxen/netxen_nic_init.c
@@ -690,8 +690,7 @@ int netxen_nic_rx_has_work(struct netxen_adapter *adapter)
                 desc_head = recv_ctx->rcv_status_desc_head;
                 desc = &desc_head[consumer];
 
-                if (((le16_to_cpu(netxen_get_sts_owner(desc)))
-                     & STATUS_OWNER_HOST))
+                if (netxen_get_sts_owner(desc) & STATUS_OWNER_HOST)
                         return 1;
         }
 
@@ -787,11 +786,11 @@ netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
         struct netxen_port *port = adapter->port[netxen_get_sts_port(desc)];
         struct pci_dev *pdev = port->pdev;
         struct net_device *netdev = port->netdev;
-        int index = le16_to_cpu(netxen_get_sts_refhandle(desc));
+        int index = netxen_get_sts_refhandle(desc);
         struct netxen_recv_context *recv_ctx = &(adapter->recv_ctx[ctxid]);
         struct netxen_rx_buffer *buffer;
         struct sk_buff *skb;
-        u32 length = le16_to_cpu(netxen_get_sts_totallength(desc));
+        u32 length = netxen_get_sts_totallength(desc);
         u32 desc_ctx;
         struct netxen_rcv_desc_ctx *rcv_desc;
         int ret;
@@ -918,16 +917,14 @@ u32 netxen_process_rcv_ring(struct netxen_adapter *adapter, int ctxid, int max)
          */
         while (count < max) {
                 desc = &desc_head[consumer];
-                if (!
-                    (le16_to_cpu(netxen_get_sts_owner(desc)) &
-                     STATUS_OWNER_HOST)) {
+                if (!(netxen_get_sts_owner(desc) & STATUS_OWNER_HOST)) {
                         DPRINTK(ERR, "desc %p ownedby %x\n", desc,
                                 netxen_get_sts_owner(desc));
                         break;
                 }
                 netxen_process_rcv(adapter, ctxid, desc);
                 netxen_clear_sts_owner(desc);
-                netxen_set_sts_owner(desc, cpu_to_le16(STATUS_OWNER_PHANTOM));
+                netxen_set_sts_owner(desc, STATUS_OWNER_PHANTOM);
                 consumer = (consumer + 1) & (adapter->max_rx_desc_count - 1);
                 count++;
         }
@@ -1232,7 +1229,7 @@ void netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter, uint32_t ctx,
 
                 /* make a rcv descriptor  */
                 pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
-                pdesc->buffer_length = cpu_to_le16(rcv_desc->dma_size);
+                pdesc->buffer_length = cpu_to_le32(rcv_desc->dma_size);
                 pdesc->addr_buffer = cpu_to_le64(buffer->dma);
                 DPRINTK(INFO, "done writing descripter\n");
                 producer =
diff --git a/drivers/net/netxen/netxen_nic_isr.c b/drivers/net/netxen/netxen_nic_isr.c
index 06847d4252c3..be366e48007c 100644
--- a/drivers/net/netxen/netxen_nic_isr.c
+++ b/drivers/net/netxen/netxen_nic_isr.c
@@ -79,7 +79,7 @@ void netxen_indicate_link_status(struct netxen_adapter *adapter, u32 portno,
 void netxen_handle_port_int(struct netxen_adapter *adapter, u32 portno,
                             u32 enable)
 {
-        __le32 int_src;
+        __u32 int_src;
         struct netxen_port *port;
 
         /*  This should clear the interrupt source */
@@ -110,7 +110,7 @@ void netxen_handle_port_int(struct netxen_adapter *adapter, u32 portno,
         /* write it down later.. */
         if ((netxen_get_phy_int_speed_changed(int_src))
             || (netxen_get_phy_int_link_status_changed(int_src))) {
-                __le32 status;
+                __u32 status;
 
                 DPRINTK(INFO, "SPEED CHANGED OR LINK STATUS CHANGED \n");
 
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index 8a5792fea774..69c1b9d23a1a 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -117,7 +117,7 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         void __iomem *mem_ptr1 = NULL;
         void __iomem *mem_ptr2 = NULL;
 
-        u8 *db_ptr = NULL;
+        u8 __iomem *db_ptr = NULL;
         unsigned long mem_base, mem_len, db_base, db_len;
         int pci_using_dac, i, err;
         int ring;
@@ -191,7 +191,7 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 db_len);
 
         db_ptr = ioremap(db_base, NETXEN_DB_MAPSIZE_BYTES);
-        if (db_ptr == 0UL) {
+        if (!db_ptr) {
                 printk(KERN_ERR "%s: Failed to allocate doorbell map.",
                        netxen_nic_driver_name);
                 err = -EIO;
@@ -818,7 +818,7 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         /* Take skb->data itself */
         pbuf = &adapter->cmd_buf_arr[producer];
         if ((netdev->features & NETIF_F_TSO) && skb_shinfo(skb)->gso_size > 0) {
-                pbuf->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
+                pbuf->mss = skb_shinfo(skb)->gso_size;
                 hwdesc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
         } else {
                 pbuf->mss = 0;
@@ -882,7 +882,7 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                         hwdesc->addr_buffer3 = cpu_to_le64(temp_dma);
                         break;
                 case 3:
-                        hwdesc->buffer4_length = temp_len;
+                        hwdesc->buffer4_length = cpu_to_le16(temp_len);
                         hwdesc->addr_buffer4 = cpu_to_le64(temp_dma);
                         break;
                 }
@@ -1144,7 +1144,7 @@ static int __init netxen_init_module(void)
         if ((netxen_workq = create_singlethread_workqueue("netxen")) == 0)
                 return -ENOMEM;
 
-        return pci_module_init(&netxen_driver);
+        return pci_register_driver(&netxen_driver);
 }
 
 module_init(netxen_init_module);
diff --git a/drivers/net/netxen/netxen_nic_niu.c b/drivers/net/netxen/netxen_nic_niu.c
index 4987dc765d99..40d7003a371c 100644
--- a/drivers/net/netxen/netxen_nic_niu.c
+++ b/drivers/net/netxen/netxen_nic_niu.c
@@ -89,15 +89,15 @@ static inline int phy_unlock(struct netxen_adapter *adapter)
  *
  */
 int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long phy,
-                            long reg, __le32 * readval)
+                            long reg, __u32 * readval)
 {
         long timeout = 0;
         long result = 0;
         long restore = 0;
-        __le32 address;
-        __le32 command;
-        __le32 status;
-        __le32 mac_cfg0;
+        __u32 address;
+        __u32 command;
+        __u32 status;
+        __u32 mac_cfg0;
 
         if (phy_lock(adapter) != 0) {
                 return -1;
@@ -112,7 +112,7 @@ int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long phy,
                                   &mac_cfg0, 4))
                 return -EIO;
         if (netxen_gb_get_soft_reset(mac_cfg0)) {
-                __le32 temp;
+                __u32 temp;
                 temp = 0;
                 netxen_gb_tx_reset_pb(temp);
                 netxen_gb_rx_reset_pb(temp);
@@ -184,15 +184,15 @@ int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long phy,
  *
  */
 int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter,
-                             long phy, long reg, __le32 val)
+                             long phy, long reg, __u32 val)
 {
         long timeout = 0;
         long result = 0;
         long restore = 0;
-        __le32 address;
-        __le32 command;
-        __le32 status;
-        __le32 mac_cfg0;
+        __u32 address;
+        __u32 command;
+        __u32 status;
+        __u32 mac_cfg0;
 
         /*
          * MII mgmt all goes through port 0 MAC interface, so it
@@ -203,7 +203,7 @@ int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter,
                                   &mac_cfg0, 4))
                 return -EIO;
         if (netxen_gb_get_soft_reset(mac_cfg0)) {
-                __le32 temp;
+                __u32 temp;
                 temp = 0;
                 netxen_gb_tx_reset_pb(temp);
                 netxen_gb_rx_reset_pb(temp);
@@ -269,7 +269,7 @@ int netxen_niu_gbe_enable_phy_interrupts(struct netxen_adapter *adapter,
                                          int port)
 {
         int result = 0;
-        __le32 enable = 0;
+        __u32 enable = 0;
         netxen_set_phy_int_link_status_changed(enable);
         netxen_set_phy_int_autoneg_completed(enable);
         netxen_set_phy_int_speed_changed(enable);
@@ -402,7 +402,7 @@ void netxen_niu_gbe_set_gmii_mode(struct netxen_adapter *adapter,
 int netxen_niu_gbe_init_port(struct netxen_adapter *adapter, int port)
 {
         int result = 0;
-        __le32 status;
+        __u32 status;
         if (adapter->disable_phy_interrupts)
                 adapter->disable_phy_interrupts(adapter, port);
         mdelay(2);
@@ -410,7 +410,7 @@ int netxen_niu_gbe_init_port(struct netxen_adapter *adapter, int port)
         if (0 ==
             netxen_niu_gbe_phy_read(adapter, port,
                                     NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
-                                    (__le32 *) & status)) {
+                                    &status)) {
                 if (netxen_get_phy_link(status)) {
                         if (netxen_get_phy_speed(status) == 2) {
                                 netxen_niu_gbe_set_gmii_mode(adapter, port, 1);
@@ -489,7 +489,7 @@ int netxen_niu_gbe_handle_phy_interrupt(struct netxen_adapter *adapter,
                                         int port, long enable)
 {
         int result = 0;
-        __le32 int_src;
+        __u32 int_src;
 
         printk(KERN_INFO PFX "NETXEN: Handling PHY interrupt on port %d"
                " (device enable = %d)\n", (int)port, (int)enable);
@@ -530,7 +530,7 @@ int netxen_niu_gbe_handle_phy_interrupt(struct netxen_adapter *adapter,
                         printk(KERN_INFO PFX "autoneg_error ");
                 if ((netxen_get_phy_int_speed_changed(int_src))
                     || (netxen_get_phy_int_link_status_changed(int_src))) {
-                        __le32 status;
+                        __u32 status;
 
                         printk(KERN_INFO PFX
                                "speed_changed or link status changed");
@@ -583,9 +583,9 @@ int netxen_niu_gbe_handle_phy_interrupt(struct netxen_adapter *adapter,
 int netxen_niu_macaddr_get(struct netxen_adapter *adapter,
                            int phy, netxen_ethernet_macaddr_t * addr)
 {
-        u64 result = 0;
-        __le32 stationhigh;
-        __le32 stationlow;
+        u32 stationhigh;
+        u32 stationlow;
+        u8 val[8];
 
         if (addr == NULL)
                 return -EINVAL;
@@ -598,10 +598,10 @@ int netxen_niu_macaddr_get(struct netxen_adapter *adapter,
         if (netxen_nic_hw_read_wx(adapter, NETXEN_NIU_GB_STATION_ADDR_1(phy),
                                   &stationlow, 4))
                 return -EIO;
+        ((__le32 *)val)[1] = cpu_to_le32(stationhigh);
+        ((__le32 *)val)[0] = cpu_to_le32(stationlow);
 
-        result = (u64) netxen_gb_get_stationaddress_low(stationlow);
-        result |= (u64) stationhigh << 16;
-        memcpy(*addr, &result, sizeof(netxen_ethernet_macaddr_t));
+        memcpy(addr, val + 2, 6);
 
         return 0;
 }
@@ -613,24 +613,25 @@ int netxen_niu_macaddr_get(struct netxen_adapter *adapter,
 int netxen_niu_macaddr_set(struct netxen_port *port,
                            netxen_ethernet_macaddr_t addr)
 {
-        __le32 temp = 0;
+        u8 temp[4];
+        u32 val;
         struct netxen_adapter *adapter = port->adapter;
         int phy = port->portnum;
         unsigned char mac_addr[6];
         int i;
 
         for (i = 0; i < 10; i++) {
-                memcpy(&temp, addr, 2);
-                temp <<= 16;
+                temp[0] = temp[1] = 0;
+                memcpy(temp + 2, addr, 2);
+                val = le32_to_cpu(*(__le32 *)temp);
                 if (netxen_nic_hw_write_wx
-                    (adapter, NETXEN_NIU_GB_STATION_ADDR_1(phy), &temp, 4))
+                    (adapter, NETXEN_NIU_GB_STATION_ADDR_1(phy), &val, 4))
                         return -EIO;
 
-                temp = 0;
-
-                memcpy(&temp, ((u8 *) addr) + 2, sizeof(__le32));
+                memcpy(temp, ((u8 *) addr) + 2, sizeof(__le32));
+                val = le32_to_cpu(*(__le32 *)temp);
                 if (netxen_nic_hw_write_wx
-                    (adapter, NETXEN_NIU_GB_STATION_ADDR_0(phy), &temp, 4))
+                    (adapter, NETXEN_NIU_GB_STATION_ADDR_0(phy), &val, 4))
                         return -2;
 
                 netxen_niu_macaddr_get(adapter, phy,
@@ -659,9 +660,9 @@ int netxen_niu_macaddr_set(struct netxen_port *port,
 int netxen_niu_enable_gbe_port(struct netxen_adapter *adapter,
                                int port, netxen_niu_gbe_ifmode_t mode)
 {
-        __le32 mac_cfg0;
-        __le32 mac_cfg1;
-        __le32 mii_cfg;
+        __u32 mac_cfg0;
+        __u32 mac_cfg1;
+        __u32 mii_cfg;
 
         if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
                 return -EINVAL;
@@ -736,7 +737,7 @@ int netxen_niu_enable_gbe_port(struct netxen_adapter *adapter,
 /* Disable a GbE interface */
 int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter, int port)
 {
-        __le32 mac_cfg0;
+        __u32 mac_cfg0;
 
         if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
                 return -EINVAL;
@@ -752,7 +753,7 @@ int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter, int port)
 /* Disable an XG interface */
 int netxen_niu_disable_xg_port(struct netxen_adapter *adapter, int port)
 {
-        __le32 mac_cfg;
+        __u32 mac_cfg;
 
         if (port != 0)
                 return -EINVAL;
@@ -769,7 +770,7 @@ int netxen_niu_disable_xg_port(struct netxen_adapter *adapter, int port)
 int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter, int port,
                                     netxen_niu_prom_mode_t mode)
 {
-        __le32 reg;
+        __u32 reg;
 
         if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
                 return -EINVAL;
@@ -826,22 +827,21 @@ int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter, int port,
 int netxen_niu_xg_macaddr_set(struct netxen_port *port,
                               netxen_ethernet_macaddr_t addr)
 {
-        __le32 temp = 0;
+        u8 temp[4];
+        u32 val;
         struct netxen_adapter *adapter = port->adapter;
 
-        memcpy(&temp, addr, 2);
-        temp = cpu_to_le32(temp);
-        temp <<= 16;
+        temp[0] = temp[1] = 0;
+        memcpy(temp + 2, addr, 2);
+        val = le32_to_cpu(*(__le32 *)temp);
         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_1,
-                                   &temp, 4))
+                                   &val, 4))
                 return -EIO;
 
-        temp = 0;
-
         memcpy(&temp, ((u8 *) addr) + 2, sizeof(__le32));
-        temp = cpu_to_le32(temp);
+        val = le32_to_cpu(*(__le32 *)temp);
         if (netxen_nic_hw_write_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_HI,
-                                   &temp, 4))
+                                   &val, 4))
                 return -EIO;
 
         return 0;
@@ -854,9 +854,9 @@ int netxen_niu_xg_macaddr_set(struct netxen_port *port,
 int netxen_niu_xg_macaddr_get(struct netxen_adapter *adapter, int phy,
                               netxen_ethernet_macaddr_t * addr)
 {
-        __le32 stationhigh;
-        __le32 stationlow;
-        u64 result;
+        u32 stationhigh;
+        u32 stationlow;
+        u8 val[8];
 
         if (addr == NULL)
                 return -EINVAL;
@@ -869,10 +869,10 @@ int netxen_niu_xg_macaddr_get(struct netxen_adapter *adapter, int phy,
         if (netxen_nic_hw_read_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_1,
                                   &stationlow, 4))
                 return -EIO;
+        ((__le32 *)val)[1] = cpu_to_le32(stationhigh);
+        ((__le32 *)val)[0] = cpu_to_le32(stationlow);
 
-        result = ((u64) stationlow) >> 16;
-        result |= (u64) stationhigh << 16;
-        memcpy(*addr, &result, sizeof(netxen_ethernet_macaddr_t));
+        memcpy(addr, val + 2, 6);
 
         return 0;
 }
@@ -880,7 +880,7 @@ int netxen_niu_xg_macaddr_get(struct netxen_adapter *adapter, int phy,
 int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter,
                                        int port, netxen_niu_prom_mode_t mode)
 {
-        __le32 reg;
+        __u32 reg;
 
         if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
                 return -EINVAL;
diff --git a/drivers/net/pcmcia/3c589_cs.c b/drivers/net/pcmcia/3c589_cs.c
index 342f4062de0b..461e8274ef69 100644
--- a/drivers/net/pcmcia/3c589_cs.c
+++ b/drivers/net/pcmcia/3c589_cs.c
@@ -606,11 +606,14 @@ static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
     kio_addr_t ioaddr = dev->base_addr;
     struct el3_private *priv = netdev_priv(dev);
+    unsigned long flags;
 
     DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
           "status %4.4x.\n", dev->name, (long)skb->len,
           inw(ioaddr + EL3_STATUS));
 
+    spin_lock_irqsave(&priv->lock, flags);    
+
     priv->stats.tx_bytes += skb->len;
 
     /* Put out the doubleword header... */
@@ -628,6 +631,7 @@ static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
     dev_kfree_skb(skb);
     pop_tx_status(dev);
+    spin_unlock_irqrestore(&priv->lock, flags);    
     
     return 0;
 }
@@ -729,14 +733,13 @@ static void media_check(unsigned long arg)
 
     if (!netif_device_present(dev)) goto reschedule;
 
-    EL3WINDOW(1);
     /* Check for pending interrupt with expired latency timer: with
        this, we can limp along even if the interrupt is blocked */
     if ((inw(ioaddr + EL3_STATUS) & IntLatch) &&
         (inb(ioaddr + EL3_TIMER) == 0xff)) {
         if (!lp->fast_poll)
             printk(KERN_WARNING "%s: interrupt(s) dropped!\n", dev->name);
-        el3_interrupt(dev->irq, lp);
+        el3_interrupt(dev->irq, dev);
         lp->fast_poll = HZ;
     }
     if (lp->fast_poll) {
diff --git a/drivers/net/phy/fixed.c b/drivers/net/phy/fixed.c
index 096d4a100bf2..86135397f430 100644
--- a/drivers/net/phy/fixed.c
+++ b/drivers/net/phy/fixed.c
@@ -349,7 +349,7 @@ static int __init fixed_init(void)
         fixed_mdio_register_device(0, 100, 1);
 #endif
 
-#ifdef CONFIX_FIXED_MII_10_FDX
+#ifdef CONFIG_FIXED_MII_10_FDX
         fixed_mdio_register_device(0, 10, 1);
 #endif
         return 0;
diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c
index e175f3910b18..9765fa661467 100644
--- a/drivers/net/phy/phy.c
+++ b/drivers/net/phy/phy.c
@@ -286,6 +286,7 @@ int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd)
 
         return 0;
 }
+EXPORT_SYMBOL(phy_ethtool_sset);
 
 int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd)
 {
@@ -302,7 +303,7 @@ int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd)
 
         return 0;
 }
-
+EXPORT_SYMBOL(phy_ethtool_gset);
 
 /* Note that this function is currently incompatible with the
  * PHYCONTROL layer.  It changes registers without regard to
diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c
index 250cdbeefdfd..1dd66b8ea0fa 100644
--- a/drivers/net/s2io.c
+++ b/drivers/net/s2io.c
@@ -556,10 +556,9 @@ static int init_shared_mem(struct s2io_nic *nic)
                 }
         }
 
-        nic->ufo_in_band_v = kmalloc((sizeof(u64) * size), GFP_KERNEL);
+        nic->ufo_in_band_v = kcalloc(size, sizeof(u64), GFP_KERNEL);
         if (!nic->ufo_in_band_v)
                 return -ENOMEM;
-        memset(nic->ufo_in_band_v, 0, size);
 
         /* Allocation and initialization of RXDs in Rings */
         size = 0;
diff --git a/drivers/net/skge.c b/drivers/net/skge.c
index deedfd5f8226..45283f3f95e4 100644
--- a/drivers/net/skge.c
+++ b/drivers/net/skge.c
@@ -60,7 +60,7 @@
 #define LINK_HZ                 (HZ/2)
 
 MODULE_DESCRIPTION("SysKonnect Gigabit Ethernet driver");
-MODULE_AUTHOR("Stephen Hemminger <shemminger@osdl.org>");
+MODULE_AUTHOR("Stephen Hemminger <shemminger@linux-foundation.org>");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index a6601e8d423c..822dd0b13133 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -3639,29 +3639,6 @@ static int sky2_resume(struct pci_dev *pdev)
 out:
         return err;
 }
-
-/* BIOS resume runs after device (it's a bug in PM)
- * as a temporary workaround on suspend/resume leave MSI disabled
- */
-static int sky2_suspend_late(struct pci_dev *pdev, pm_message_t state)
-{
-        struct sky2_hw *hw = pci_get_drvdata(pdev);
-
-        free_irq(pdev->irq, hw);
-        if (hw->msi) {
-                pci_disable_msi(pdev);
-                hw->msi = 0;
-        }
-        return 0;
-}
-
-static int sky2_resume_early(struct pci_dev *pdev)
-{
-        struct sky2_hw *hw = pci_get_drvdata(pdev);
-        struct net_device *dev = hw->dev[0];
-
-        return request_irq(pdev->irq, sky2_intr, IRQF_SHARED, dev->name, hw);
-}
 #endif
 
 static struct pci_driver sky2_driver = {
@@ -3672,8 +3649,6 @@ static struct pci_driver sky2_driver = {
 #ifdef CONFIG_PM
         .suspend = sky2_suspend,
         .resume = sky2_resume,
-        .suspend_late = sky2_suspend_late,
-        .resume_early = sky2_resume_early,
 #endif
 };
 
@@ -3691,6 +3666,6 @@ module_init(sky2_init_module);
 module_exit(sky2_cleanup_module);
 
 MODULE_DESCRIPTION("Marvell Yukon 2 Gigabit Ethernet driver");
-MODULE_AUTHOR("Stephen Hemminger <shemminger@osdl.org>");
+MODULE_AUTHOR("Stephen Hemminger <shemminger@linux-foundation.org>");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/net/smc911x.c b/drivers/net/smc911x.c
index 880d9fdd7c67..43af61438449 100644
--- a/drivers/net/smc911x.c
+++ b/drivers/net/smc911x.c
@@ -968,11 +968,11 @@ static void smc911x_phy_configure(struct work_struct *work)
          * We should not be called if phy_type is zero.
          */
         if (lp->phy_type == 0)
-                 goto smc911x_phy_configure_exit;
+                 goto smc911x_phy_configure_exit_nolock;
 
         if (smc911x_phy_reset(dev, phyaddr)) {
                 printk("%s: PHY reset timed out\n", dev->name);
-                goto smc911x_phy_configure_exit;
+                goto smc911x_phy_configure_exit_nolock;
         }
         spin_lock_irqsave(&lp->lock, flags);
 
@@ -1041,6 +1041,7 @@ static void smc911x_phy_configure(struct work_struct *work)
 
 smc911x_phy_configure_exit:
         spin_unlock_irqrestore(&lp->lock, flags);
+smc911x_phy_configure_exit_nolock:
         lp->work_pending = 0;
 }
 
diff --git a/drivers/net/spider_net.c b/drivers/net/spider_net.c
index ebb6aa39f9c7..8ea2fc1b96cb 100644
--- a/drivers/net/spider_net.c
+++ b/drivers/net/spider_net.c
@@ -1925,6 +1925,8 @@ spider_net_stop(struct net_device *netdev)
         /* release chains */
         spider_net_release_tx_chain(card, 1);
 
+        spider_net_free_rx_chain_contents(card);
+
         spider_net_free_chain(card, &card->tx_chain);
         spider_net_free_chain(card, &card->rx_chain);