21 files changed, 635 insertions, 81 deletions

diff --git a/drivers/net/3c527.c b/drivers/net/3c527.c
index b72b89d53ec8..fae295b6809c 100644
--- a/drivers/net/3c527.c
+++ b/drivers/net/3c527.c
@@ -103,8 +103,8 @@ DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Richard Procter <rnp@paradise.net.
 #include <linux/ethtool.h>
 #include <linux/completion.h>
 #include <linux/bitops.h>
+#include <linux/semaphore.h>
 
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/io.h>
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 45c3a208d93f..015e16325973 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -827,7 +827,7 @@ config ULTRA32
 
 config BFIN_MAC
         tristate "Blackfin 527/536/537 on-chip mac support"
-        depends on NET_ETHERNET && (BF527 || BF537 || BF536) && (!BF537_PORT_H)
+        depends on NET_ETHERNET && (BF527 || BF537 || BF536)
         select CRC32
         select MII
         select PHYLIB
@@ -2335,7 +2335,7 @@ config UGETH_TX_ON_DEMAND
 
 config MV643XX_ETH
         tristate "Marvell Discovery (643XX) and Orion ethernet support"
-        depends on MV64360 || MV64X60 || (PPC_MULTIPLATFORM && PPC32) || ARCH_ORION
+        depends on MV64360 || MV64X60 || (PPC_MULTIPLATFORM && PPC32) || PLAT_ORION
         select MII
         help
           This driver supports the gigabit ethernet MACs in the
diff --git a/drivers/net/Makefile b/drivers/net/Makefile
index 4d71729e85e5..2f1f3f2739fd 100644
--- a/drivers/net/Makefile
+++ b/drivers/net/Makefile
@@ -218,7 +218,8 @@ obj-$(CONFIG_SMC911X) += smc911x.o
 obj-$(CONFIG_BFIN_MAC) += bfin_mac.o
 obj-$(CONFIG_DM9000) += dm9000.o
 obj-$(CONFIG_FEC_8XX) += fec_8xx/
-obj-$(CONFIG_PASEMI_MAC) += pasemi_mac.o
+obj-$(CONFIG_PASEMI_MAC) += pasemi_mac_driver.o
+pasemi_mac_driver-objs := pasemi_mac.o pasemi_mac_ethtool.o
 obj-$(CONFIG_MLX4_CORE) += mlx4/
 obj-$(CONFIG_ENC28J60) += enc28j60.o
 
diff --git a/drivers/net/arm/at91_ether.c b/drivers/net/arm/at91_ether.c
index 770226d904d4..1e39e78f1778 100644
--- a/drivers/net/arm/at91_ether.c
+++ b/drivers/net/arm/at91_ether.c
@@ -1043,7 +1043,9 @@ static int __init at91ether_setup(unsigned long phy_type, unsigned short phy_add
         } else if (machine_is_csb337()) {
                 /* mix link activity status into LED2 link state */
                 write_phy(phy_address, MII_LEDCTRL_REG, 0x0d22);
-        }
+        } else if (machine_is_ecbat91())
+                write_phy(phy_address, MII_LEDCTRL_REG, 0x156A);
+
         disable_mdi();
         spin_unlock_irq(&lp->lock);
 
diff --git a/drivers/net/cxgb3/adapter.h b/drivers/net/cxgb3/adapter.h
index eb305a0895fc..4fdb13f8447b 100644
--- a/drivers/net/cxgb3/adapter.h
+++ b/drivers/net/cxgb3/adapter.h
@@ -43,7 +43,6 @@
 #include <linux/mutex.h>
 #include <linux/bitops.h>
 #include "t3cdev.h"
-#include <asm/semaphore.h>
 #include <asm/io.h>
 
 struct vlan_group;
diff --git a/drivers/net/cxgb3/t3cdev.h b/drivers/net/cxgb3/t3cdev.h
index 77fcc1a4984e..a18c8a140424 100644
--- a/drivers/net/cxgb3/t3cdev.h
+++ b/drivers/net/cxgb3/t3cdev.h
@@ -34,7 +34,6 @@
 
 #include <linux/list.h>
 #include <asm/atomic.h>
-#include <asm/semaphore.h>
 #include <linux/netdevice.h>
 #include <linux/proc_fs.h>
 #include <linux/skbuff.h>
diff --git a/drivers/net/hamradio/6pack.c b/drivers/net/hamradio/6pack.c
index 0a9b75139e0f..1da55dd2a5a0 100644
--- a/drivers/net/hamradio/6pack.c
+++ b/drivers/net/hamradio/6pack.c
@@ -33,7 +33,7 @@
 #include <linux/init.h>
 #include <linux/ip.h>
 #include <linux/tcp.h>
-#include <asm/semaphore.h>
+#include <linux/semaphore.h>
 #include <asm/atomic.h>
 
 #define SIXPACK_VERSION    "Revision: 0.3.0"
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index bb31e09899fc..ce4fc2ec2fe4 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -49,7 +49,6 @@
 #include <linux/in.h>
 #include <linux/ip.h>
 #include <net/net_namespace.h>
-#include <asm/semaphore.h>
 #include <asm/hvcall.h>
 #include <asm/atomic.h>
 #include <asm/vio.h>
diff --git a/drivers/net/irda/pxaficp_ir.c b/drivers/net/irda/pxaficp_ir.c
index 60b94bb4d25e..d5c2d27f3ea4 100644
--- a/drivers/net/irda/pxaficp_ir.c
+++ b/drivers/net/irda/pxaficp_ir.c
@@ -36,6 +36,7 @@
 #include <asm/hardware.h>
 #include <asm/arch/irda.h>
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/pxa2xx-gpio.h>
 
 #ifdef CONFIG_MACH_MAINSTONE
 #include <asm/arch/mainstone.h>
@@ -831,6 +832,11 @@ static int pxa_irda_probe(struct platform_device *pdev)
         if (err)
                 goto err_mem_5;
 
+        if (si->pdata->startup)
+                err = si->pdata->startup(si->dev);
+        if (err)
+                goto err_startup;
+
         dev->hard_start_xmit    = pxa_irda_hard_xmit;
         dev->open               = pxa_irda_start;
         dev->stop               = pxa_irda_stop;
@@ -856,6 +862,9 @@ static int pxa_irda_probe(struct platform_device *pdev)
                 dev_set_drvdata(&pdev->dev, dev);
 
         if (err) {
+                if (si->pdata->shutdown)
+                        si->pdata->shutdown(si->dev);
+err_startup:
                 kfree(si->tx_buff.head);
 err_mem_5:
                 kfree(si->rx_buff.head);
@@ -881,6 +890,8 @@ static int pxa_irda_remove(struct platform_device *_dev)
         if (dev) {
                 struct pxa_irda *si = netdev_priv(dev);
                 unregister_netdev(dev);
+                if (si->pdata->shutdown)
+                        si->pdata->shutdown(si->dev);
                 kfree(si->tx_buff.head);
                 kfree(si->rx_buff.head);
                 clk_put(si->fir_clk);
diff --git a/drivers/net/iseries_veth.c b/drivers/net/iseries_veth.c
index 58d3bb622da6..b8d0639c1cdf 100644
--- a/drivers/net/iseries_veth.c
+++ b/drivers/net/iseries_veth.c
@@ -308,7 +308,8 @@ static void veth_complete_allocation(void *parm, int number)
 
 static int veth_allocate_events(HvLpIndex rlp, int number)
 {
-        struct veth_allocation vc = { COMPLETION_INITIALIZER(vc.c), 0 };
+        struct veth_allocation vc =
+                { COMPLETION_INITIALIZER_ONSTACK(vc.c), 0 };
 
         mf_allocate_lp_events(rlp, HvLpEvent_Type_VirtualLan,
                             sizeof(struct veth_lpevent), number,
diff --git a/drivers/net/netxen/netxen_nic_hdr.h b/drivers/net/netxen/netxen_nic_hdr.h
index 160f605e58db..24d027e29c45 100644
--- a/drivers/net/netxen/netxen_nic_hdr.h
+++ b/drivers/net/netxen/netxen_nic_hdr.h
@@ -34,7 +34,6 @@
 #include <linux/kernel.h>
 #include <linux/version.h>
 
-#include <asm/semaphore.h>
 #include <linux/spinlock.h>
 #include <asm/irq.h>
 #include <linux/init.h>
diff --git a/drivers/net/pasemi_mac.c b/drivers/net/pasemi_mac.c
index bcd7f9814ed8..3b2a6c598088 100644
--- a/drivers/net/pasemi_mac.c
+++ b/drivers/net/pasemi_mac.c
@@ -55,15 +55,10 @@
  * - Multiqueue RX/TX
  */
 
-
-/* Must be a power of two */
-#define RX_RING_SIZE 2048
-#define TX_RING_SIZE 4096
-
 #define LRO_MAX_AGGR 64
 
 #define PE_MIN_MTU      64
-#define PE_MAX_MTU      1500
+#define PE_MAX_MTU      9000
 #define PE_DEF_MTU      ETH_DATA_LEN
 
 #define DEFAULT_MSG_ENABLE        \
@@ -76,16 +71,6 @@
          NETIF_MSG_RX_ERR       | \
          NETIF_MSG_TX_ERR)
 
-#define TX_DESC(tx, num)        ((tx)->chan.ring_virt[(num) & (TX_RING_SIZE-1)])
-#define TX_DESC_INFO(tx, num)   ((tx)->ring_info[(num) & (TX_RING_SIZE-1)])
-#define RX_DESC(rx, num)        ((rx)->chan.ring_virt[(num) & (RX_RING_SIZE-1)])
-#define RX_DESC_INFO(rx, num)   ((rx)->ring_info[(num) & (RX_RING_SIZE-1)])
-#define RX_BUFF(rx, num)        ((rx)->buffers[(num) & (RX_RING_SIZE-1)])
-
-#define RING_USED(ring)         (((ring)->next_to_fill - (ring)->next_to_clean) \
-                                 & ((ring)->size - 1))
-#define RING_AVAIL(ring)        ((ring->size) - RING_USED(ring))
-
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR ("Olof Johansson <olof@lixom.net>");
 MODULE_DESCRIPTION("PA Semi PWRficient Ethernet driver");
@@ -94,6 +79,8 @@ static int debug = -1;	/* -1 == use DEFAULT_MSG_ENABLE as value */
 module_param(debug, int, 0);
 MODULE_PARM_DESC(debug, "PA Semi MAC bitmapped debugging message enable value");
 
+extern const struct ethtool_ops pasemi_mac_ethtool_ops;
+
 static int translation_enabled(void)
 {
 #if defined(CONFIG_PPC_PASEMI_IOMMU_DMA_FORCE)
@@ -322,6 +309,104 @@ static int pasemi_mac_unmap_tx_skb(struct pasemi_mac *mac,
         return (nfrags + 3) & ~1;
 }
 
+static struct pasemi_mac_csring *pasemi_mac_setup_csring(struct pasemi_mac *mac)
+{
+        struct pasemi_mac_csring *ring;
+        u32 val;
+        unsigned int cfg;
+        int chno;
+
+        ring = pasemi_dma_alloc_chan(TXCHAN, sizeof(struct pasemi_mac_csring),
+                                       offsetof(struct pasemi_mac_csring, chan));
+
+        if (!ring) {
+                dev_err(&mac->pdev->dev, "Can't allocate checksum channel\n");
+                goto out_chan;
+        }
+
+        chno = ring->chan.chno;
+
+        ring->size = CS_RING_SIZE;
+        ring->next_to_fill = 0;
+
+        /* Allocate descriptors */
+        if (pasemi_dma_alloc_ring(&ring->chan, CS_RING_SIZE))
+                goto out_ring_desc;
+
+        write_dma_reg(PAS_DMA_TXCHAN_BASEL(chno),
+                      PAS_DMA_TXCHAN_BASEL_BRBL(ring->chan.ring_dma));
+        val = PAS_DMA_TXCHAN_BASEU_BRBH(ring->chan.ring_dma >> 32);
+        val |= PAS_DMA_TXCHAN_BASEU_SIZ(CS_RING_SIZE >> 3);
+
+        write_dma_reg(PAS_DMA_TXCHAN_BASEU(chno), val);
+
+        ring->events[0] = pasemi_dma_alloc_flag();
+        ring->events[1] = pasemi_dma_alloc_flag();
+        if (ring->events[0] < 0 || ring->events[1] < 0)
+                goto out_flags;
+
+        pasemi_dma_clear_flag(ring->events[0]);
+        pasemi_dma_clear_flag(ring->events[1]);
+
+        ring->fun = pasemi_dma_alloc_fun();
+        if (ring->fun < 0)
+                goto out_fun;
+
+        cfg = PAS_DMA_TXCHAN_CFG_TY_FUNC | PAS_DMA_TXCHAN_CFG_UP |
+              PAS_DMA_TXCHAN_CFG_TATTR(ring->fun) |
+              PAS_DMA_TXCHAN_CFG_LPSQ | PAS_DMA_TXCHAN_CFG_LPDQ;
+
+        if (translation_enabled())
+                cfg |= PAS_DMA_TXCHAN_CFG_TRD | PAS_DMA_TXCHAN_CFG_TRR;
+
+        write_dma_reg(PAS_DMA_TXCHAN_CFG(chno), cfg);
+
+        /* enable channel */
+        pasemi_dma_start_chan(&ring->chan, PAS_DMA_TXCHAN_TCMDSTA_SZ |
+                                           PAS_DMA_TXCHAN_TCMDSTA_DB |
+                                           PAS_DMA_TXCHAN_TCMDSTA_DE |
+                                           PAS_DMA_TXCHAN_TCMDSTA_DA);
+
+        return ring;
+
+out_fun:
+out_flags:
+        if (ring->events[0] >= 0)
+                pasemi_dma_free_flag(ring->events[0]);
+        if (ring->events[1] >= 0)
+                pasemi_dma_free_flag(ring->events[1]);
+        pasemi_dma_free_ring(&ring->chan);
+out_ring_desc:
+        pasemi_dma_free_chan(&ring->chan);
+out_chan:
+
+        return NULL;
+}
+
+static void pasemi_mac_setup_csrings(struct pasemi_mac *mac)
+{
+        int i;
+        mac->cs[0] = pasemi_mac_setup_csring(mac);
+        if (mac->type == MAC_TYPE_XAUI)
+                mac->cs[1] = pasemi_mac_setup_csring(mac);
+        else
+                mac->cs[1] = 0;
+
+        for (i = 0; i < MAX_CS; i++)
+                if (mac->cs[i])
+                        mac->num_cs++;
+}
+
+static void pasemi_mac_free_csring(struct pasemi_mac_csring *csring)
+{
+        pasemi_dma_stop_chan(&csring->chan);
+        pasemi_dma_free_flag(csring->events[0]);
+        pasemi_dma_free_flag(csring->events[1]);
+        pasemi_dma_free_ring(&csring->chan);
+        pasemi_dma_free_chan(&csring->chan);
+        pasemi_dma_free_fun(csring->fun);
+}
+
 static int pasemi_mac_setup_rx_resources(const struct net_device *dev)
 {
         struct pasemi_mac_rxring *ring;
@@ -445,7 +530,7 @@ pasemi_mac_setup_tx_resources(const struct net_device *dev)
         cfg = PAS_DMA_TXCHAN_CFG_TY_IFACE |
               PAS_DMA_TXCHAN_CFG_TATTR(mac->dma_if) |
               PAS_DMA_TXCHAN_CFG_UP |
-              PAS_DMA_TXCHAN_CFG_WT(2);
+              PAS_DMA_TXCHAN_CFG_WT(4);
 
         if (translation_enabled())
                 cfg |= PAS_DMA_TXCHAN_CFG_TRD | PAS_DMA_TXCHAN_CFG_TRR;
@@ -810,13 +895,21 @@ restart:
                 u64 mactx = TX_DESC(txring, i);
                 struct sk_buff *skb;
 
-                skb = TX_DESC_INFO(txring, i+1).skb;
-                nr_frags = TX_DESC_INFO(txring, i).dma;
-
                 if ((mactx  & XCT_MACTX_E) ||
                     (*chan->status & PAS_STATUS_ERROR))
                         pasemi_mac_tx_error(mac, mactx);
 
+                /* Skip over control descriptors */
+                if (!(mactx & XCT_MACTX_LLEN_M)) {
+                        TX_DESC(txring, i) = 0;
+                        TX_DESC(txring, i+1) = 0;
+                        buf_count = 2;
+                        continue;
+                }
+
+                skb = TX_DESC_INFO(txring, i+1).skb;
+                nr_frags = TX_DESC_INFO(txring, i).dma;
+
                 if (unlikely(mactx & XCT_MACTX_O))
                         /* Not yet transmitted */
                         break;
@@ -1041,13 +1134,7 @@ static int pasemi_mac_open(struct net_device *dev)
 {
         struct pasemi_mac *mac = netdev_priv(dev);
         unsigned int flags;
-        int ret;
-
-        /* enable rx section */
-        write_dma_reg(PAS_DMA_COM_RXCMD, PAS_DMA_COM_RXCMD_EN);
-
-        /* enable tx section */
-        write_dma_reg(PAS_DMA_COM_TXCMD, PAS_DMA_COM_TXCMD_EN);
+        int i, ret;
 
         flags = PAS_MAC_CFG_TXP_FCE | PAS_MAC_CFG_TXP_FPC(3) |
                 PAS_MAC_CFG_TXP_SL(3) | PAS_MAC_CFG_TXP_COB(0xf) |
@@ -1064,6 +1151,19 @@ static int pasemi_mac_open(struct net_device *dev)
         if (!mac->tx)
                 goto out_tx_ring;
 
+        /* We might already have allocated rings in case mtu was changed
+         * before interface was brought up.
+         */
+        if (dev->mtu > 1500 && !mac->num_cs) {
+                pasemi_mac_setup_csrings(mac);
+                if (!mac->num_cs)
+                        goto out_tx_ring;
+        }
+
+        /* Zero out rmon counters */
+        for (i = 0; i < 32; i++)
+                write_mac_reg(mac, PAS_MAC_RMON(i), 0);
+
         /* 0x3ff with 33MHz clock is about 31us */
         write_iob_reg(PAS_IOB_DMA_COM_TIMEOUTCFG,
                       PAS_IOB_DMA_COM_TIMEOUTCFG_TCNT(0x3ff));
@@ -1247,7 +1347,7 @@ static int pasemi_mac_close(struct net_device *dev)
 {
         struct pasemi_mac *mac = netdev_priv(dev);
         unsigned int sta;
-        int rxch, txch;
+        int rxch, txch, i;
 
         rxch = rx_ring(mac)->chan.chno;
         txch = tx_ring(mac)->chan.chno;
@@ -1292,6 +1392,13 @@ static int pasemi_mac_close(struct net_device *dev)
         free_irq(mac->tx->chan.irq, mac->tx);
         free_irq(mac->rx->chan.irq, mac->rx);
 
+        for (i = 0; i < mac->num_cs; i++) {
+                pasemi_mac_free_csring(mac->cs[i]);
+                mac->cs[i] = NULL;
+        }
+
+        mac->num_cs = 0;
+
         /* Free resources */
         pasemi_mac_free_rx_resources(mac);
         pasemi_mac_free_tx_resources(mac);
@@ -1299,35 +1406,113 @@ static int pasemi_mac_close(struct net_device *dev)
         return 0;
 }
 
+static void pasemi_mac_queue_csdesc(const struct sk_buff *skb,
+                                    const dma_addr_t *map,
+                                    const unsigned int *map_size,
+                                    struct pasemi_mac_txring *txring,
+                                    struct pasemi_mac_csring *csring)
+{
+        u64 fund;
+        dma_addr_t cs_dest;
+        const int nh_off = skb_network_offset(skb);
+        const int nh_len = skb_network_header_len(skb);
+        const int nfrags = skb_shinfo(skb)->nr_frags;
+        int cs_size, i, fill, hdr, cpyhdr, evt;
+        dma_addr_t csdma;
+
+        fund = XCT_FUN_ST | XCT_FUN_RR_8BRES |
+               XCT_FUN_O | XCT_FUN_FUN(csring->fun) |
+               XCT_FUN_CRM_SIG | XCT_FUN_LLEN(skb->len - nh_off) |
+               XCT_FUN_SHL(nh_len >> 2) | XCT_FUN_SE;
+
+        switch (ip_hdr(skb)->protocol) {
+        case IPPROTO_TCP:
+                fund |= XCT_FUN_SIG_TCP4;
+                /* TCP checksum is 16 bytes into the header */
+                cs_dest = map[0] + skb_transport_offset(skb) + 16;
+                break;
+        case IPPROTO_UDP:
+                fund |= XCT_FUN_SIG_UDP4;
+                /* UDP checksum is 6 bytes into the header */
+                cs_dest = map[0] + skb_transport_offset(skb) + 6;
+                break;
+        default:
+                BUG();
+        }
+
+        /* Do the checksum offloaded */
+        fill = csring->next_to_fill;
+        hdr = fill;
+
+        CS_DESC(csring, fill++) = fund;
+        /* Room for 8BRES. Checksum result is really 2 bytes into it */
+        csdma = csring->chan.ring_dma + (fill & (CS_RING_SIZE-1)) * 8 + 2;
+        CS_DESC(csring, fill++) = 0;
+
+        CS_DESC(csring, fill) = XCT_PTR_LEN(map_size[0]-nh_off) | XCT_PTR_ADDR(map[0]+nh_off);
+        for (i = 1; i <= nfrags; i++)
+                CS_DESC(csring, fill+i) = XCT_PTR_LEN(map_size[i]) | XCT_PTR_ADDR(map[i]);
+
+        fill += i;
+        if (fill & 1)
+                fill++;
+
+        /* Copy the result into the TCP packet */
+        cpyhdr = fill;
+        CS_DESC(csring, fill++) = XCT_FUN_O | XCT_FUN_FUN(csring->fun) |
+                                  XCT_FUN_LLEN(2) | XCT_FUN_SE;
+        CS_DESC(csring, fill++) = XCT_PTR_LEN(2) | XCT_PTR_ADDR(cs_dest) | XCT_PTR_T;
+        CS_DESC(csring, fill++) = XCT_PTR_LEN(2) | XCT_PTR_ADDR(csdma);
+        fill++;
+
+        evt = !csring->last_event;
+        csring->last_event = evt;
+
+        /* Event handshaking with MAC TX */
+        CS_DESC(csring, fill++) = CTRL_CMD_T | CTRL_CMD_META_EVT | CTRL_CMD_O |
+                                  CTRL_CMD_ETYPE_SET | CTRL_CMD_REG(csring->events[evt]);
+        CS_DESC(csring, fill++) = 0;
+        CS_DESC(csring, fill++) = CTRL_CMD_T | CTRL_CMD_META_EVT | CTRL_CMD_O |
+                                  CTRL_CMD_ETYPE_WCLR | CTRL_CMD_REG(csring->events[!evt]);
+        CS_DESC(csring, fill++) = 0;
+        csring->next_to_fill = fill & (CS_RING_SIZE-1);
+
+        cs_size = fill - hdr;
+        write_dma_reg(PAS_DMA_TXCHAN_INCR(csring->chan.chno), (cs_size) >> 1);
+
+        /* TX-side event handshaking */
+        fill = txring->next_to_fill;
+        TX_DESC(txring, fill++) = CTRL_CMD_T | CTRL_CMD_META_EVT | CTRL_CMD_O |
+                                  CTRL_CMD_ETYPE_WSET | CTRL_CMD_REG(csring->events[evt]);
+        TX_DESC(txring, fill++) = 0;
+        TX_DESC(txring, fill++) = CTRL_CMD_T | CTRL_CMD_META_EVT | CTRL_CMD_O |
+                                  CTRL_CMD_ETYPE_CLR | CTRL_CMD_REG(csring->events[!evt]);
+        TX_DESC(txring, fill++) = 0;
+        txring->next_to_fill = fill;
+
+        write_dma_reg(PAS_DMA_TXCHAN_INCR(txring->chan.chno), 2);
+
+        return;
+}
+
 static int pasemi_mac_start_tx(struct sk_buff *skb, struct net_device *dev)
 {
-        struct pasemi_mac *mac = netdev_priv(dev);
-        struct pasemi_mac_txring *txring;
-        u64 dflags, mactx;
+        struct pasemi_mac * const mac = netdev_priv(dev);
+        struct pasemi_mac_txring * const txring = tx_ring(mac);
+        struct pasemi_mac_csring *csring;
+        u64 dflags = 0;
+        u64 mactx;
         dma_addr_t map[MAX_SKB_FRAGS+1];
         unsigned int map_size[MAX_SKB_FRAGS+1];
         unsigned long flags;
         int i, nfrags;
         int fill;
+        const int nh_off = skb_network_offset(skb);
+        const int nh_len = skb_network_header_len(skb);
 
-        dflags = XCT_MACTX_O | XCT_MACTX_ST | XCT_MACTX_CRC_PAD;
-
-        if (skb->ip_summed == CHECKSUM_PARTIAL) {
-                const unsigned char *nh = skb_network_header(skb);
+        prefetch(&txring->ring_info);
 
-                switch (ip_hdr(skb)->protocol) {
-                case IPPROTO_TCP:
-                        dflags |= XCT_MACTX_CSUM_TCP;
-                        dflags |= XCT_MACTX_IPH(skb_network_header_len(skb) >> 2);
-                        dflags |= XCT_MACTX_IPO(nh - skb->data);
-                        break;
-                case IPPROTO_UDP:
-                        dflags |= XCT_MACTX_CSUM_UDP;
-                        dflags |= XCT_MACTX_IPH(skb_network_header_len(skb) >> 2);
-                        dflags |= XCT_MACTX_IPO(nh - skb->data);
-                        break;
-                }
-        }
+        dflags = XCT_MACTX_O | XCT_MACTX_ST | XCT_MACTX_CRC_PAD;
 
         nfrags = skb_shinfo(skb)->nr_frags;
 
@@ -1350,24 +1535,46 @@ static int pasemi_mac_start_tx(struct sk_buff *skb, struct net_device *dev)
                 }
         }
 
-        mactx = dflags | XCT_MACTX_LLEN(skb->len);
+        if (skb->ip_summed == CHECKSUM_PARTIAL && skb->len <= 1540) {
+                switch (ip_hdr(skb)->protocol) {
+                case IPPROTO_TCP:
+                        dflags |= XCT_MACTX_CSUM_TCP;
+                        dflags |= XCT_MACTX_IPH(nh_len >> 2);
+                        dflags |= XCT_MACTX_IPO(nh_off);
+                        break;
+                case IPPROTO_UDP:
+                        dflags |= XCT_MACTX_CSUM_UDP;
+                        dflags |= XCT_MACTX_IPH(nh_len >> 2);
+                        dflags |= XCT_MACTX_IPO(nh_off);
+                        break;
+                default:
+                        WARN_ON(1);
+                }
+        }
 
-        txring = tx_ring(mac);
+        mactx = dflags | XCT_MACTX_LLEN(skb->len);
 
         spin_lock_irqsave(&txring->lock, flags);
 
-        fill = txring->next_to_fill;
-
         /* Avoid stepping on the same cache line that the DMA controller
          * is currently about to send, so leave at least 8 words available.
          * Total free space needed is mactx + fragments + 8
          */
-        if (RING_AVAIL(txring) < nfrags + 10) {
+        if (RING_AVAIL(txring) < nfrags + 14) {
                 /* no room -- stop the queue and wait for tx intr */
                 netif_stop_queue(dev);
                 goto out_err;
         }
 
+        /* Queue up checksum + event descriptors, if needed */
+        if (mac->num_cs && skb->ip_summed == CHECKSUM_PARTIAL && skb->len > 1540) {
+                csring = mac->cs[mac->last_cs];
+                mac->last_cs = (mac->last_cs + 1) % mac->num_cs;
+
+                pasemi_mac_queue_csdesc(skb, map, map_size, txring, csring);
+        }
+
+        fill = txring->next_to_fill;
         TX_DESC(txring, fill) = mactx;
         TX_DESC_INFO(txring, fill).dma = nfrags;
         fill++;
@@ -1441,12 +1648,33 @@ static int pasemi_mac_poll(struct napi_struct *napi, int budget)
         return pkts;
 }
 
+#ifdef CONFIG_NET_POLL_CONTROLLER
+/*
+ * Polling 'interrupt' - used by things like netconsole to send skbs
+ * without having to re-enable interrupts. It's not called while
+ * the interrupt routine is executing.
+ */
+static void pasemi_mac_netpoll(struct net_device *dev)
+{
+        const struct pasemi_mac *mac = netdev_priv(dev);
+
+        disable_irq(mac->tx->chan.irq);
+        pasemi_mac_tx_intr(mac->tx->chan.irq, mac->tx);
+        enable_irq(mac->tx->chan.irq);
+
+        disable_irq(mac->rx->chan.irq);
+        pasemi_mac_rx_intr(mac->rx->chan.irq, mac->rx);
+        enable_irq(mac->rx->chan.irq);
+}
+#endif
+
 static int pasemi_mac_change_mtu(struct net_device *dev, int new_mtu)
 {
         struct pasemi_mac *mac = netdev_priv(dev);
         unsigned int reg;
-        unsigned int rcmdsta;
+        unsigned int rcmdsta = 0;
         int running;
+        int ret = 0;
 
         if (new_mtu < PE_MIN_MTU || new_mtu > PE_MAX_MTU)
                 return -EINVAL;
@@ -1468,6 +1696,16 @@ static int pasemi_mac_change_mtu(struct net_device *dev, int new_mtu)
                 pasemi_mac_pause_rxint(mac);
                 pasemi_mac_clean_rx(rx_ring(mac), RX_RING_SIZE);
                 pasemi_mac_free_rx_buffers(mac);
+
+        }
+
+        /* Setup checksum channels if large MTU and none already allocated */
+        if (new_mtu > 1500 && !mac->num_cs) {
+                pasemi_mac_setup_csrings(mac);
+                if (!mac->num_cs) {
+                        ret = -ENOMEM;
+                        goto out;
+                }
         }
 
         /* Change maxf, i.e. what size frames are accepted.
@@ -1482,6 +1720,7 @@ static int pasemi_mac_change_mtu(struct net_device *dev, int new_mtu)
         /* MTU + ETH_HLEN + VLAN_HLEN + 2 64B cachelines */
         mac->bufsz = new_mtu + ETH_HLEN + ETH_FCS_LEN + LOCAL_SKB_ALIGN + 128;
 
+out:
         if (running) {
                 write_dma_reg(PAS_DMA_RXINT_RCMDSTA(mac->dma_if),
                               rcmdsta | PAS_DMA_RXINT_RCMDSTA_EN);
@@ -1494,7 +1733,7 @@ static int pasemi_mac_change_mtu(struct net_device *dev, int new_mtu)
                 pasemi_mac_intf_enable(mac);
         }
 
-        return 0;
+        return ret;
 }
 
 static int __devinit
@@ -1528,7 +1767,7 @@ pasemi_mac_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         netif_napi_add(dev, &mac->napi, pasemi_mac_poll, 64);
 
         dev->features = NETIF_F_IP_CSUM | NETIF_F_LLTX | NETIF_F_SG |
-                        NETIF_F_HIGHDMA;
+                        NETIF_F_HIGHDMA | NETIF_F_GSO;
 
         mac->lro_mgr.max_aggr = LRO_MAX_AGGR;
         mac->lro_mgr.max_desc = MAX_LRO_DESCRIPTORS;
@@ -1588,8 +1827,12 @@ pasemi_mac_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         dev->mtu = PE_DEF_MTU;
         /* 1500 MTU + ETH_HLEN + VLAN_HLEN + 2 64B cachelines */
         mac->bufsz = dev->mtu + ETH_HLEN + ETH_FCS_LEN + LOCAL_SKB_ALIGN + 128;
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        dev->poll_controller = pasemi_mac_netpoll;
+#endif
 
         dev->change_mtu = pasemi_mac_change_mtu;
+        dev->ethtool_ops = &pasemi_mac_ethtool_ops;
 
         if (err)
                 goto out;
diff --git a/drivers/net/pasemi_mac.h b/drivers/net/pasemi_mac.h
index 99e7b9329a6f..1a115ec60b53 100644
--- a/drivers/net/pasemi_mac.h
+++ b/drivers/net/pasemi_mac.h
@@ -26,7 +26,14 @@
 #include <linux/spinlock.h>
 #include <linux/phy.h>
 
+/* Must be a power of two */
+#define RX_RING_SIZE 2048
+#define TX_RING_SIZE 4096
+#define CS_RING_SIZE (TX_RING_SIZE*2)
+
+
 #define MAX_LRO_DESCRIPTORS 8
+#define MAX_CS  2
 
 struct pasemi_mac_txring {
         struct pasemi_dmachan chan; /* Must be first */
@@ -51,6 +58,15 @@ struct pasemi_mac_rxring {
         struct pasemi_mac *mac; /* Needed in intr handler */
 };
 
+struct pasemi_mac_csring {
+        struct pasemi_dmachan chan;
+        unsigned int    size;
+        unsigned int    next_to_fill;
+        int             events[2];
+        int             last_event;
+        int             fun;
+};
+
 struct pasemi_mac {
         struct net_device *netdev;
         struct pci_dev *pdev;
@@ -60,10 +76,12 @@ struct pasemi_mac {
         struct napi_struct napi;
 
         int             bufsz; /* RX ring buffer size */
+        int             last_cs;
+        int             num_cs;
+        u32             dma_if;
         u8              type;
 #define MAC_TYPE_GMAC   1
 #define MAC_TYPE_XAUI   2
-        u32     dma_if;
 
         u8              mac_addr[6];
 
@@ -74,6 +92,7 @@ struct pasemi_mac {
 
         struct pasemi_mac_txring *tx;
         struct pasemi_mac_rxring *rx;
+        struct pasemi_mac_csring *cs[MAX_CS];
         char            tx_irq_name[10];                /* "eth%d tx" */
         char            rx_irq_name[10];                /* "eth%d rx" */
         int     link;
@@ -90,6 +109,16 @@ struct pasemi_mac_buffer {
         dma_addr_t      dma;
 };
 
+#define TX_DESC(tx, num)        ((tx)->chan.ring_virt[(num) & (TX_RING_SIZE-1)])
+#define TX_DESC_INFO(tx, num)   ((tx)->ring_info[(num) & (TX_RING_SIZE-1)])
+#define RX_DESC(rx, num)        ((rx)->chan.ring_virt[(num) & (RX_RING_SIZE-1)])
+#define RX_DESC_INFO(rx, num)   ((rx)->ring_info[(num) & (RX_RING_SIZE-1)])
+#define RX_BUFF(rx, num)        ((rx)->buffers[(num) & (RX_RING_SIZE-1)])
+#define CS_DESC(cs, num)        ((cs)->chan.ring_virt[(num) & (CS_RING_SIZE-1)])
+
+#define RING_USED(ring) (((ring)->next_to_fill - (ring)->next_to_clean) \
+                                & ((ring)->size - 1))
+#define RING_AVAIL(ring)        ((ring->size) - RING_USED(ring))
 
 /* PCI register offsets and formats */
 
@@ -101,6 +130,7 @@ enum {
         PAS_MAC_CFG_ADR0 = 0x8c,
         PAS_MAC_CFG_ADR1 = 0x90,
         PAS_MAC_CFG_TXP = 0x98,
+        PAS_MAC_CFG_RMON = 0x100,
         PAS_MAC_IPC_CHNL = 0x208,
 };
 
@@ -172,6 +202,8 @@ enum {
 #define PAS_MAC_CFG_TXP_TIFG(x)         (((x) << PAS_MAC_CFG_TXP_TIFG_S) & \
                                          PAS_MAC_CFG_TXP_TIFG_M)
 
+#define PAS_MAC_RMON(r)                 (0x100+(r)*4)
+
 #define PAS_MAC_IPC_CHNL_DCHNO_M        0x003f0000
 #define PAS_MAC_IPC_CHNL_DCHNO_S        16
 #define PAS_MAC_IPC_CHNL_DCHNO(x)       (((x) << PAS_MAC_IPC_CHNL_DCHNO_S) & \
@@ -181,4 +213,5 @@ enum {
 #define PAS_MAC_IPC_CHNL_BCH(x)         (((x) << PAS_MAC_IPC_CHNL_BCH_S) & \
                                          PAS_MAC_IPC_CHNL_BCH_M)
 
+
 #endif /* PASEMI_MAC_H */
diff --git a/drivers/net/pasemi_mac_ethtool.c b/drivers/net/pasemi_mac_ethtool.c
new file mode 100644
index 000000000000..5e8df3afea64
--- /dev/null
+++ b/drivers/net/pasemi_mac_ethtool.c
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2006-2008 PA Semi, Inc
+ *
+ * Ethtool hooks for the PA Semi PWRficient onchip 1G/10G Ethernet MACs
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+
+#include <linux/netdevice.h>
+#include <linux/ethtool.h>
+#include <linux/pci.h>
+#include <linux/inet_lro.h>
+
+#include <asm/pasemi_dma.h>
+#include "pasemi_mac.h"
+
+static struct {
+        const char str[ETH_GSTRING_LEN];
+} ethtool_stats_keys[] = {
+        { "rx-drops" },
+        { "rx-bytes" },
+        { "rx-packets" },
+        { "rx-broadcast-packets" },
+        { "rx-multicast-packets" },
+        { "rx-crc-errors" },
+        { "rx-undersize-errors" },
+        { "rx-oversize-errors" },
+        { "rx-short-fragment-errors" },
+        { "rx-jabber-errors" },
+        { "rx-64-byte-packets" },
+        { "rx-65-127-byte-packets" },
+        { "rx-128-255-byte-packets" },
+        { "rx-256-511-byte-packets" },
+        { "rx-512-1023-byte-packets" },
+        { "rx-1024-1518-byte-packets" },
+        { "rx-pause-frames" },
+        { "tx-bytes" },
+        { "tx-packets" },
+        { "tx-broadcast-packets" },
+        { "tx-multicast-packets" },
+        { "tx-collisions" },
+        { "tx-late-collisions" },
+        { "tx-excessive-collisions" },
+        { "tx-crc-errors" },
+        { "tx-undersize-errors" },
+        { "tx-oversize-errors" },
+        { "tx-64-byte-packets" },
+        { "tx-65-127-byte-packets" },
+        { "tx-128-255-byte-packets" },
+        { "tx-256-511-byte-packets" },
+        { "tx-512-1023-byte-packets" },
+        { "tx-1024-1518-byte-packets" },
+};
+
+static int
+pasemi_mac_ethtool_get_settings(struct net_device *netdev,
+                               struct ethtool_cmd *cmd)
+{
+        struct pasemi_mac *mac = netdev_priv(netdev);
+        struct phy_device *phydev = mac->phydev;
+
+        return phy_ethtool_gset(phydev, cmd);
+}
+
+static void
+pasemi_mac_ethtool_get_drvinfo(struct net_device *netdev,
+                               struct ethtool_drvinfo *drvinfo)
+{
+        struct pasemi_mac *mac;
+        mac = netdev_priv(netdev);
+
+        /* clear and fill out info */
+        memset(drvinfo, 0, sizeof(struct ethtool_drvinfo));
+        strncpy(drvinfo->driver, "pasemi_mac", 12);
+        strcpy(drvinfo->version, "N/A");
+        strcpy(drvinfo->fw_version, "N/A");
+        strncpy(drvinfo->bus_info, pci_name(mac->pdev), 32);
+}
+
+static u32
+pasemi_mac_ethtool_get_msglevel(struct net_device *netdev)
+{
+        struct pasemi_mac *mac = netdev_priv(netdev);
+        return mac->msg_enable;
+}
+
+static void
+pasemi_mac_ethtool_set_msglevel(struct net_device *netdev,
+                                u32 level)
+{
+        struct pasemi_mac *mac = netdev_priv(netdev);
+        mac->msg_enable = level;
+}
+
+
+static void
+pasemi_mac_ethtool_get_ringparam(struct net_device *netdev,
+                                 struct ethtool_ringparam *ering)
+{
+        struct pasemi_mac *mac = netdev->priv;
+
+        ering->tx_max_pending = TX_RING_SIZE/2;
+        ering->tx_pending = RING_USED(mac->tx)/2;
+        ering->rx_max_pending = RX_RING_SIZE/4;
+        ering->rx_pending = RING_USED(mac->rx)/4;
+}
+
+static int pasemi_mac_get_sset_count(struct net_device *netdev, int sset)
+{
+        switch (sset) {
+        case ETH_SS_STATS:
+                return ARRAY_SIZE(ethtool_stats_keys);
+        default:
+                return -EOPNOTSUPP;
+        }
+}
+
+static void pasemi_mac_get_ethtool_stats(struct net_device *netdev,
+                struct ethtool_stats *stats, u64 *data)
+{
+        struct pasemi_mac *mac = netdev->priv;
+        int i;
+
+        data[0] = pasemi_read_dma_reg(PAS_DMA_RXINT_RCMDSTA(mac->dma_if))
+                        >> PAS_DMA_RXINT_RCMDSTA_DROPS_S;
+        for (i = 0; i < 32; i++)
+                data[1+i] = pasemi_read_mac_reg(mac->dma_if, PAS_MAC_RMON(i));
+}
+
+static void pasemi_mac_get_strings(struct net_device *netdev, u32 stringset,
+                                   u8 *data)
+{
+        memcpy(data, ethtool_stats_keys, sizeof(ethtool_stats_keys));
+}
+
+const struct ethtool_ops pasemi_mac_ethtool_ops = {
+        .get_settings           = pasemi_mac_ethtool_get_settings,
+        .get_drvinfo            = pasemi_mac_ethtool_get_drvinfo,
+        .get_msglevel           = pasemi_mac_ethtool_get_msglevel,
+        .set_msglevel           = pasemi_mac_ethtool_set_msglevel,
+        .get_link               = ethtool_op_get_link,
+        .get_ringparam          = pasemi_mac_ethtool_get_ringparam,
+        .get_strings            = pasemi_mac_get_strings,
+        .get_sset_count         = pasemi_mac_get_sset_count,
+        .get_ethtool_stats      = pasemi_mac_get_ethtool_stats,
+};
+
diff --git a/drivers/net/ps3_gelic_net.c b/drivers/net/ps3_gelic_net.c
index 7eb6e7e848f4..e365efb3c627 100644
--- a/drivers/net/ps3_gelic_net.c
+++ b/drivers/net/ps3_gelic_net.c
@@ -1266,6 +1266,85 @@ int gelic_net_set_rx_csum(struct net_device *netdev, u32 data)
         return 0;
 }
 
+static void gelic_net_get_wol(struct net_device *netdev,
+                              struct ethtool_wolinfo *wol)
+{
+        if (0 <= ps3_compare_firmware_version(2, 2, 0))
+                wol->supported = WAKE_MAGIC;
+        else
+                wol->supported = 0;
+
+        wol->wolopts = ps3_sys_manager_get_wol() ? wol->supported : 0;
+        memset(&wol->sopass, 0, sizeof(wol->sopass));
+}
+static int gelic_net_set_wol(struct net_device *netdev,
+                             struct ethtool_wolinfo *wol)
+{
+        int status;
+        struct gelic_card *card;
+        u64 v1, v2;
+
+        if (ps3_compare_firmware_version(2, 2, 0) < 0 ||
+            !capable(CAP_NET_ADMIN))
+                return -EPERM;
+
+        if (wol->wolopts & ~WAKE_MAGIC)
+                return -EINVAL;
+
+        card = netdev_card(netdev);
+        if (wol->wolopts & WAKE_MAGIC) {
+                status = lv1_net_control(bus_id(card), dev_id(card),
+                                         GELIC_LV1_SET_WOL,
+                                         GELIC_LV1_WOL_MAGIC_PACKET,
+                                         0, GELIC_LV1_WOL_MP_ENABLE,
+                                         &v1, &v2);
+                if (status) {
+                        pr_info("%s: enabling WOL failed %d\n", __func__,
+                                status);
+                        status = -EIO;
+                        goto done;
+                }
+                status = lv1_net_control(bus_id(card), dev_id(card),
+                                         GELIC_LV1_SET_WOL,
+                                         GELIC_LV1_WOL_ADD_MATCH_ADDR,
+                                         0, GELIC_LV1_WOL_MATCH_ALL,
+                                         &v1, &v2);
+                if (!status)
+                        ps3_sys_manager_set_wol(1);
+                else {
+                        pr_info("%s: enabling WOL filter failed %d\n",
+                                __func__, status);
+                        status = -EIO;
+                }
+        } else {
+                status = lv1_net_control(bus_id(card), dev_id(card),
+                                         GELIC_LV1_SET_WOL,
+                                         GELIC_LV1_WOL_MAGIC_PACKET,
+                                         0, GELIC_LV1_WOL_MP_DISABLE,
+                                         &v1, &v2);
+                if (status) {
+                        pr_info("%s: disabling WOL failed %d\n", __func__,
+                                status);
+                        status = -EIO;
+                        goto done;
+                }
+                status = lv1_net_control(bus_id(card), dev_id(card),
+                                         GELIC_LV1_SET_WOL,
+                                         GELIC_LV1_WOL_DELETE_MATCH_ADDR,
+                                         0, GELIC_LV1_WOL_MATCH_ALL,
+                                         &v1, &v2);
+                if (!status)
+                        ps3_sys_manager_set_wol(0);
+                else {
+                        pr_info("%s: removing WOL filter failed %d\n",
+                                __func__, status);
+                        status = -EIO;
+                }
+        }
+done:
+        return status;
+}
+
 static struct ethtool_ops gelic_ether_ethtool_ops = {
         .get_drvinfo    = gelic_net_get_drvinfo,
         .get_settings   = gelic_ether_get_settings,
@@ -1274,6 +1353,8 @@ static struct ethtool_ops gelic_ether_ethtool_ops = {
         .set_tx_csum    = ethtool_op_set_tx_csum,
         .get_rx_csum    = gelic_net_get_rx_csum,
         .set_rx_csum    = gelic_net_set_rx_csum,
+        .get_wol        = gelic_net_get_wol,
+        .set_wol        = gelic_net_set_wol,
 };
 
 /**
diff --git a/drivers/net/ps3_gelic_net.h b/drivers/net/ps3_gelic_net.h
index 1d39d06797e4..520f143c2c09 100644
--- a/drivers/net/ps3_gelic_net.h
+++ b/drivers/net/ps3_gelic_net.h
@@ -182,12 +182,32 @@ enum gelic_lv1_net_control_code {
         GELIC_LV1_GET_ETH_PORT_STATUS   = 2,
         GELIC_LV1_SET_NEGOTIATION_MODE  = 3,
         GELIC_LV1_GET_VLAN_ID           = 4,
+        GELIC_LV1_SET_WOL               = 5,
         GELIC_LV1_GET_CHANNEL           = 6,
         GELIC_LV1_POST_WLAN_CMD         = 9,
         GELIC_LV1_GET_WLAN_CMD_RESULT   = 10,
         GELIC_LV1_GET_WLAN_EVENT        = 11
 };
 
+/* for GELIC_LV1_SET_WOL */
+enum gelic_lv1_wol_command {
+        GELIC_LV1_WOL_MAGIC_PACKET      = 1,
+        GELIC_LV1_WOL_ADD_MATCH_ADDR    = 6,
+        GELIC_LV1_WOL_DELETE_MATCH_ADDR = 7,
+};
+
+/* for GELIC_LV1_WOL_MAGIC_PACKET */
+enum gelic_lv1_wol_mp_arg {
+        GELIC_LV1_WOL_MP_DISABLE        = 0,
+        GELIC_LV1_WOL_MP_ENABLE         = 1,
+};
+
+/* for GELIC_LV1_WOL_{ADD,DELETE}_MATCH_ADDR */
+enum gelic_lv1_wol_match_arg {
+        GELIC_LV1_WOL_MATCH_INDIVIDUAL  = 0,
+        GELIC_LV1_WOL_MATCH_ALL         = 1,
+};
+
 /* status returened from GET_ETH_PORT_STATUS */
 enum gelic_lv1_ether_port_status {
         GELIC_LV1_ETHER_LINK_UP         = 0x0000000000000001L,
diff --git a/drivers/net/ucc_geth.c b/drivers/net/ucc_geth.c
index 0aac91c3e4e4..281ce3d39532 100644
--- a/drivers/net/ucc_geth.c
+++ b/drivers/net/ucc_geth.c
@@ -3853,7 +3853,13 @@ static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *ma
 
         ugeth_vdbg("%s: IN", __FUNCTION__);
 
-        prop = of_get_property(np, "device-id", NULL);
+        prop = of_get_property(np, "cell-index", NULL);
+        if (!prop) {
+                prop = of_get_property(np, "device-id", NULL);
+                if (!prop)
+                        return -ENODEV;
+        }
+
         ucc_num = *prop - 1;
         if ((ucc_num < 0) || (ucc_num > 7))
                 return -ENODEV;
diff --git a/drivers/net/ucc_geth_mii.c b/drivers/net/ucc_geth_mii.c
index e4d3f330bac3..2af490781005 100644
--- a/drivers/net/ucc_geth_mii.c
+++ b/drivers/net/ucc_geth_mii.c
@@ -203,9 +203,14 @@ static int uec_mdio_probe(struct of_device *ofdev, const struct of_device_id *ma
                 if ((res.start >= tempres.start) &&
                     (res.end <= tempres.end)) {
                         /* set this UCC to be the MII master */
-                        const u32 *id = of_get_property(tempnp, "device-id", NULL);
-                        if (id == NULL)
-                                goto bus_register_fail;
+                        const u32 *id;
+
+                        id = of_get_property(tempnp, "cell-index", NULL);
+                        if (!id) {
+                                id = of_get_property(tempnp, "device-id", NULL);
+                                if (!id)
+                                        goto bus_register_fail;
+                        }
 
                         ucc_set_qe_mux_mii_mng(*id - 1);
 
diff --git a/drivers/net/usb/kaweth.c b/drivers/net/usb/kaweth.c
index 569ad8bfd383..0dcfc0310264 100644
--- a/drivers/net/usb/kaweth.c
+++ b/drivers/net/usb/kaweth.c
@@ -58,7 +58,6 @@
 #include <linux/dma-mapping.h>
 #include <linux/wait.h>
 #include <asm/uaccess.h>
-#include <asm/semaphore.h>
 #include <asm/byteorder.h>
 
 #undef DEBUG
diff --git a/drivers/net/wireless/b43/leds.c b/drivers/net/wireless/b43/leds.c
index 0aac1ff511df..36a9c42df835 100644
--- a/drivers/net/wireless/b43/leds.c
+++ b/drivers/net/wireless/b43/leds.c
@@ -116,10 +116,7 @@ static void b43_unregister_led(struct b43_led *led)
 {
         if (!led->dev)
                 return;
-        if (led->dev->suspend_in_progress)
-                led_classdev_unregister_suspended(&led->led_dev);
-        else
-                led_classdev_unregister(&led->led_dev);
+        led_classdev_unregister(&led->led_dev);
         b43_led_turn_off(led->dev, led->index, led->activelow);
         led->dev = NULL;
 }
diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index 94a0cdeb39a8..4bf8a99099fe 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -2808,10 +2808,10 @@ static int b43_rng_read(struct hwrng *rng, u32 * data)
         return (sizeof(u16));
 }
 
-static void b43_rng_exit(struct b43_wl *wl, bool suspended)
+static void b43_rng_exit(struct b43_wl *wl)
 {
         if (wl->rng_initialized)
-                __hwrng_unregister(&wl->rng, suspended);
+                hwrng_unregister(&wl->rng);
 }
 
 static int b43_rng_init(struct b43_wl *wl)
@@ -3832,7 +3832,7 @@ static void b43_wireless_core_exit(struct b43_wldev *dev)
 
         if (!dev->suspend_in_progress) {
                 b43_leds_exit(dev);
-                b43_rng_exit(dev->wl, false);
+                b43_rng_exit(dev->wl);
         }
         b43_dma_free(dev);
         b43_pio_free(dev);
@@ -4613,7 +4613,7 @@ static int b43_resume(struct ssb_device *dev)
                 err = b43_wireless_core_start(wldev);
                 if (err) {
                         b43_leds_exit(wldev);
-                        b43_rng_exit(wldev->wl, true);
+                        b43_rng_exit(wldev->wl);
                         b43_wireless_core_exit(wldev);
                         b43err(wl, "Resume failed at core start\n");
                         goto out;