17 files changed, 757 insertions, 133 deletions

diff --git a/drivers/block/viodasd.c b/drivers/block/viodasd.c
index 41ca721d2523..ebfe038d859e 100644
--- a/drivers/block/viodasd.c
+++ b/drivers/block/viodasd.c
@@ -69,7 +69,7 @@ MODULE_LICENSE("GPL");
 enum {
         PARTITION_SHIFT = 3,
         MAX_DISKNO = HVMAXARCHITECTEDVIRTUALDISKS,
-        MAX_DISK_NAME = sizeof(((struct gendisk *)0)->disk_name)
+        MAX_DISK_NAME = FIELD_SIZEOF(struct gendisk, disk_name)
 };
 
 static DEFINE_SPINLOCK(viodasd_spinlock);
diff --git a/drivers/char/xilinx_hwicap/buffer_icap.c b/drivers/char/xilinx_hwicap/buffer_icap.c
index f577daedb630..aa7f7962a9a0 100644
--- a/drivers/char/xilinx_hwicap/buffer_icap.c
+++ b/drivers/char/xilinx_hwicap/buffer_icap.c
@@ -74,7 +74,7 @@
 
 /**
  * buffer_icap_get_status - Get the contents of the status register.
- * @base_address: is the base address of the device
+ * @drvdata: a pointer to the drvdata.
  *
  * The status register contains the ICAP status and the done bit.
  *
@@ -88,9 +88,9 @@
  * D1 - Always 1
  * D0 - Done bit
  **/
-static inline u32 buffer_icap_get_status(void __iomem *base_address)
+u32 buffer_icap_get_status(struct hwicap_drvdata *drvdata)
 {
-        return in_be32(base_address + XHI_STATUS_REG_OFFSET);
+        return in_be32(drvdata->base_address + XHI_STATUS_REG_OFFSET);
 }
 
 /**
@@ -117,20 +117,8 @@ static inline u32 buffer_icap_get_bram(void __iomem *base_address,
  **/
 static inline bool buffer_icap_busy(void __iomem *base_address)
 {
-        return (buffer_icap_get_status(base_address) & 1) == XHI_NOT_FINISHED;
-}
-
-/**
- * buffer_icap_busy - Return true if the icap device is not busy
- * @base_address: is the base address of the device
- *
- * The queries the low order bit of the status register, which
- * indicates whether the current configuration or readback operation
- * has completed.
- **/
-static inline bool buffer_icap_done(void __iomem *base_address)
-{
-        return (buffer_icap_get_status(base_address) & 1) == XHI_FINISHED;
+        u32 status = in_be32(base_address + XHI_STATUS_REG_OFFSET);
+        return (status & 1) == XHI_NOT_FINISHED;
 }
 
 /**
diff --git a/drivers/char/xilinx_hwicap/buffer_icap.h b/drivers/char/xilinx_hwicap/buffer_icap.h
index 03184959fa00..c5b1840906b2 100644
--- a/drivers/char/xilinx_hwicap/buffer_icap.h
+++ b/drivers/char/xilinx_hwicap/buffer_icap.h
@@ -44,8 +44,6 @@
 #include <asm/io.h>
 #include "xilinx_hwicap.h"
 
-void buffer_icap_reset(struct hwicap_drvdata *drvdata);
-
 /* Loads a partial bitstream from system memory. */
 int buffer_icap_set_configuration(struct hwicap_drvdata *drvdata, u32 *data,
                              u32 Size);
@@ -54,4 +52,7 @@ int buffer_icap_set_configuration(struct hwicap_drvdata *drvdata, u32 *data,
 int buffer_icap_get_configuration(struct hwicap_drvdata *drvdata, u32 *data,
                              u32 Size);
 
+u32 buffer_icap_get_status(struct hwicap_drvdata *drvdata);
+void buffer_icap_reset(struct hwicap_drvdata *drvdata);
+
 #endif
diff --git a/drivers/char/xilinx_hwicap/fifo_icap.c b/drivers/char/xilinx_hwicap/fifo_icap.c
index 6f45dbd47125..776b50528478 100644
--- a/drivers/char/xilinx_hwicap/fifo_icap.c
+++ b/drivers/char/xilinx_hwicap/fifo_icap.c
@@ -78,13 +78,6 @@
 #define XHI_CR_READ_MASK 0x00000002 /* Read from ICAP to FIFO */
 #define XHI_CR_WRITE_MASK 0x00000001 /* Write from FIFO to ICAP */
 
-/* Status Register (SR) */
-#define XHI_SR_CFGERR_N_MASK 0x00000100 /* Config Error Mask */
-#define XHI_SR_DALIGN_MASK 0x00000080 /* Data Alignment Mask */
-#define XHI_SR_RIP_MASK 0x00000040 /* Read back Mask */
-#define XHI_SR_IN_ABORT_N_MASK 0x00000020 /* Select Map Abort Mask */
-#define XHI_SR_DONE_MASK 0x00000001 /* Done bit Mask  */
-
 
 #define XHI_WFO_MAX_VACANCY 1024 /* Max Write FIFO Vacancy, in words */
 #define XHI_RFO_MAX_OCCUPANCY 256 /* Max Read FIFO Occupancy, in words */
@@ -152,13 +145,35 @@ static inline void fifo_icap_start_readback(struct hwicap_drvdata *drvdata)
 }
 
 /**
+ * fifo_icap_get_status - Get the contents of the status register.
+ * @drvdata: a pointer to the drvdata.
+ *
+ * The status register contains the ICAP status and the done bit.
+ *
+ * D8 - cfgerr
+ * D7 - dalign
+ * D6 - rip
+ * D5 - in_abort_l
+ * D4 - Always 1
+ * D3 - Always 1
+ * D2 - Always 1
+ * D1 - Always 1
+ * D0 - Done bit
+ **/
+u32 fifo_icap_get_status(struct hwicap_drvdata *drvdata)
+{
+        u32 status = in_be32(drvdata->base_address + XHI_SR_OFFSET);
+        dev_dbg(drvdata->dev, "Getting status = %x\n", status);
+        return status;
+}
+
+/**
  * fifo_icap_busy - Return true if the ICAP is still processing a transaction.
  * @drvdata: a pointer to the drvdata.
  **/
 static inline u32 fifo_icap_busy(struct hwicap_drvdata *drvdata)
 {
         u32 status = in_be32(drvdata->base_address + XHI_SR_OFFSET);
-        dev_dbg(drvdata->dev, "Getting status = %x\n", status);
         return (status & XHI_SR_DONE_MASK) ? 0 : 1;
 }
 
diff --git a/drivers/char/xilinx_hwicap/fifo_icap.h b/drivers/char/xilinx_hwicap/fifo_icap.h
index 4d3068dd0405..ffabd3ba2bd8 100644
--- a/drivers/char/xilinx_hwicap/fifo_icap.h
+++ b/drivers/char/xilinx_hwicap/fifo_icap.h
@@ -56,6 +56,7 @@ int fifo_icap_set_configuration(
                 u32 *FrameBuffer,
                 u32 NumWords);
 
+u32 fifo_icap_get_status(struct hwicap_drvdata *drvdata);
 void fifo_icap_reset(struct hwicap_drvdata *drvdata);
 void fifo_icap_flush_fifo(struct hwicap_drvdata *drvdata);
 
diff --git a/drivers/char/xilinx_hwicap/xilinx_hwicap.c b/drivers/char/xilinx_hwicap/xilinx_hwicap.c
index 2284fa2a5a57..016f90567a52 100644
--- a/drivers/char/xilinx_hwicap/xilinx_hwicap.c
+++ b/drivers/char/xilinx_hwicap/xilinx_hwicap.c
@@ -36,7 +36,7 @@
  *****************************************************************************/
 
 /*
- * This is the code behind /dev/xilinx_icap -- it allows a user-space
+ * This is the code behind /dev/icap* -- it allows a user-space
  * application to use the Xilinx ICAP subsystem.
  *
  * The following operations are possible:
@@ -67,7 +67,7 @@
  * user-space application code that uses this device.  The simplest
  * way to use this interface is simply:
  *
- * cp foo.bit /dev/xilinx_icap
+ * cp foo.bit /dev/icap0
  *
  * Note that unless foo.bit is an appropriately constructed partial
  * bitstream, this has a high likelyhood of overwriting the design
@@ -105,18 +105,14 @@
 #include "buffer_icap.h"
 #include "fifo_icap.h"
 
-#define DRIVER_NAME "xilinx_icap"
+#define DRIVER_NAME "icap"
 
 #define HWICAP_REGS   (0x10000)
 
-/* dynamically allocate device number */
-static int xhwicap_major;
-static int xhwicap_minor;
+#define XHWICAP_MAJOR 259
+#define XHWICAP_MINOR 0
 #define HWICAP_DEVICES 1
 
-module_param(xhwicap_major, int, S_IRUGO);
-module_param(xhwicap_minor, int, S_IRUGO);
-
 /* An array, which is set to true when the device is registered. */
 static bool probed_devices[HWICAP_DEVICES];
 static struct mutex icap_sem;
@@ -250,8 +246,26 @@ static int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata,
          * Create the data to be written to the ICAP.
          */
         buffer[index++] = XHI_DUMMY_PACKET;
+        buffer[index++] = XHI_NOOP_PACKET;
         buffer[index++] = XHI_SYNC_PACKET;
         buffer[index++] = XHI_NOOP_PACKET;
+        buffer[index++] = XHI_NOOP_PACKET;
+
+        /*
+         * Write the data to the FIFO and initiate the transfer of data present
+         * in the FIFO to the ICAP device.
+         */
+        status = drvdata->config->set_configuration(drvdata,
+                                                    &buffer[0], index);
+        if (status)
+                return status;
+
+        /* If the syncword was not found, then we need to start over. */
+        status = drvdata->config->get_status(drvdata);
+        if ((status & XHI_SR_DALIGN_MASK) != XHI_SR_DALIGN_MASK)
+                return -EIO;
+
+        index = 0;
         buffer[index++] = hwicap_type_1_read(reg) | 1;
         buffer[index++] = XHI_NOOP_PACKET;
         buffer[index++] = XHI_NOOP_PACKET;
@@ -587,7 +601,7 @@ static int __devinit hwicap_setup(struct device *dev, int id,
         probed_devices[id] = 1;
         mutex_unlock(&icap_sem);
 
-        devt = MKDEV(xhwicap_major, xhwicap_minor + id);
+        devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR + id);
 
         drvdata = kzalloc(sizeof(struct hwicap_drvdata), GFP_KERNEL);
         if (!drvdata) {
@@ -664,12 +678,14 @@ static int __devinit hwicap_setup(struct device *dev, int id,
 static struct hwicap_driver_config buffer_icap_config = {
         .get_configuration = buffer_icap_get_configuration,
         .set_configuration = buffer_icap_set_configuration,
+        .get_status = buffer_icap_get_status,
         .reset = buffer_icap_reset,
 };
 
 static struct hwicap_driver_config fifo_icap_config = {
         .get_configuration = fifo_icap_get_configuration,
         .set_configuration = fifo_icap_set_configuration,
+        .get_status = fifo_icap_get_status,
         .reset = fifo_icap_reset,
 };
 
@@ -690,7 +706,7 @@ static int __devexit hwicap_remove(struct device *dev)
         dev_set_drvdata(dev, NULL);
 
         mutex_lock(&icap_sem);
-        probed_devices[MINOR(dev->devt)-xhwicap_minor] = 0;
+        probed_devices[MINOR(dev->devt)-XHWICAP_MINOR] = 0;
         mutex_unlock(&icap_sem);
         return 0;               /* success */
 }
@@ -830,23 +846,12 @@ static int __init hwicap_module_init(void)
         icap_class = class_create(THIS_MODULE, "xilinx_config");
         mutex_init(&icap_sem);
 
-        if (xhwicap_major) {
-                devt = MKDEV(xhwicap_major, xhwicap_minor);
-                retval = register_chrdev_region(
-                                devt,
-                                HWICAP_DEVICES,
-                                DRIVER_NAME);
-                if (retval < 0)
-                        return retval;
-        } else {
-                retval = alloc_chrdev_region(&devt,
-                                xhwicap_minor,
-                                HWICAP_DEVICES,
-                                DRIVER_NAME);
-                if (retval < 0)
-                        return retval;
-                xhwicap_major = MAJOR(devt);
-        }
+        devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR);
+        retval = register_chrdev_region(devt,
+                                        HWICAP_DEVICES,
+                                        DRIVER_NAME);
+        if (retval < 0)
+                return retval;
 
         retval = platform_driver_register(&hwicap_platform_driver);
 
@@ -871,7 +876,7 @@ static int __init hwicap_module_init(void)
 
 static void __exit hwicap_module_cleanup(void)
 {
-        dev_t devt = MKDEV(xhwicap_major, xhwicap_minor);
+        dev_t devt = MKDEV(XHWICAP_MAJOR, XHWICAP_MINOR);
 
         class_destroy(icap_class);
 
diff --git a/drivers/char/xilinx_hwicap/xilinx_hwicap.h b/drivers/char/xilinx_hwicap/xilinx_hwicap.h
index 405fee7e189b..1f9c8b082dbe 100644
--- a/drivers/char/xilinx_hwicap/xilinx_hwicap.h
+++ b/drivers/char/xilinx_hwicap/xilinx_hwicap.h
@@ -65,10 +65,27 @@ struct hwicap_drvdata {
 };
 
 struct hwicap_driver_config {
+        /* Read configuration data given by size into the data buffer.
+           Return 0 if successful. */
         int (*get_configuration)(struct hwicap_drvdata *drvdata, u32 *data,
                         u32 size);
+        /* Write configuration data given by size from the data buffer.
+           Return 0 if successful. */
         int (*set_configuration)(struct hwicap_drvdata *drvdata, u32 *data,
                         u32 size);
+        /* Get the status register, bit pattern given by:
+         * D8 - 0 = configuration error
+         * D7 - 1 = alignment found
+         * D6 - 1 = readback in progress
+         * D5 - 0 = abort in progress
+         * D4 - Always 1
+         * D3 - Always 1
+         * D2 - Always 1
+         * D1 - Always 1
+         * D0 - 1 = operation completed
+         */
+        u32 (*get_status)(struct hwicap_drvdata *drvdata);
+        /* Reset the hw */
         void (*reset)(struct hwicap_drvdata *drvdata);
 };
 
@@ -163,6 +180,13 @@ struct config_registers {
 /* Constant to use for CRC check when CRC has been disabled */
 #define XHI_DISABLED_AUTO_CRC       0x0000DEFCUL
 
+/* Meanings of the bits returned by get_status */
+#define XHI_SR_CFGERR_N_MASK 0x00000100 /* Config Error Mask */
+#define XHI_SR_DALIGN_MASK 0x00000080 /* Data Alignment Mask */
+#define XHI_SR_RIP_MASK 0x00000040 /* Read back Mask */
+#define XHI_SR_IN_ABORT_N_MASK 0x00000020 /* Select Map Abort Mask */
+#define XHI_SR_DONE_MASK 0x00000001 /* Done bit Mask  */
+
 /**
  * hwicap_type_1_read - Generates a Type 1 read packet header.
  * @reg: is the address of the register to be read back.
diff --git a/drivers/net/Makefile b/drivers/net/Makefile
index 3b1ea321dc05..4b442739e7bf 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/pasemi_mac.c b/drivers/net/pasemi_mac.c
index 2e39e0285d8f..c50f0f4de6d8 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,103 @@ 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);
+}
+
 static int pasemi_mac_setup_rx_resources(const struct net_device *dev)
 {
         struct pasemi_mac_rxring *ring;
@@ -445,7 +529,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 +894,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 +1133,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 +1150,16 @@ static int pasemi_mac_open(struct net_device *dev)
         if (!mac->tx)
                 goto out_tx_ring;
 
+        if (dev->mtu > 1500) {
+                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 +1343,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 +1388,9 @@ 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]);
+
         /* Free resources */
         pasemi_mac_free_rx_resources(mac);
         pasemi_mac_free_tx_resources(mac);
@@ -1299,35 +1398,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 +1527,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++;
@@ -1445,8 +1644,9 @@ 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 +1668,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 +1692,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 +1705,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 +1739,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;
@@ -1590,6 +1801,7 @@ pasemi_mac_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         mac->bufsz = dev->mtu + ETH_HLEN + ETH_FCS_LEN + LOCAL_SKB_ALIGN + 128;
 
         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/of/base.c b/drivers/of/base.c
index 80c9deca5f35..9bd7c4a31253 100644
--- a/drivers/of/base.c
+++ b/drivers/of/base.c
@@ -117,6 +117,32 @@ int of_device_is_compatible(const struct device_node *device,
 EXPORT_SYMBOL(of_device_is_compatible);
 
 /**
+ *  of_device_is_available - check if a device is available for use
+ *
+ *  @device: Node to check for availability
+ *
+ *  Returns 1 if the status property is absent or set to "okay" or "ok",
+ *  0 otherwise
+ */
+int of_device_is_available(const struct device_node *device)
+{
+        const char *status;
+        int statlen;
+
+        status = of_get_property(device, "status", &statlen);
+        if (status == NULL)
+                return 1;
+
+        if (statlen > 0) {
+                if (!strcmp(status, "okay") || !strcmp(status, "ok"))
+                        return 1;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(of_device_is_available);
+
+/**
  *      of_get_parent - Get a node's parent if any
  *      @node:  Node to get parent
  *
diff --git a/drivers/ps3/ps3-sys-manager.c b/drivers/ps3/ps3-sys-manager.c
index d4f6f960dd18..7605453b74fd 100644
--- a/drivers/ps3/ps3-sys-manager.c
+++ b/drivers/ps3/ps3-sys-manager.c
@@ -24,6 +24,7 @@
 #include <linux/reboot.h>
 
 #include <asm/firmware.h>
+#include <asm/lv1call.h>
 #include <asm/ps3.h>
 
 #include "vuart.h"
@@ -187,6 +188,7 @@ enum ps3_sys_manager_next_op {
  * controller, and bluetooth controller.
  * @PS3_SM_WAKE_RTC:
  * @PS3_SM_WAKE_RTC_ERROR:
+ * @PS3_SM_WAKE_W_O_L: Ether or wireless LAN.
  * @PS3_SM_WAKE_P_O_R: Power on reset.
  *
  * Additional wakeup sources when specifying PS3_SM_NEXT_OP_SYS_SHUTDOWN.
@@ -200,10 +202,19 @@ enum ps3_sys_manager_wake_source {
         PS3_SM_WAKE_DEFAULT   = 0,
         PS3_SM_WAKE_RTC       = 0x00000040,
         PS3_SM_WAKE_RTC_ERROR = 0x00000080,
+        PS3_SM_WAKE_W_O_L     = 0x00000400,
         PS3_SM_WAKE_P_O_R     = 0x80000000,
 };
 
 /**
+ * user_wake_sources - User specified wakeup sources.
+ *
+ * Logical OR of enum ps3_sys_manager_wake_source types.
+ */
+
+static u32 user_wake_sources = PS3_SM_WAKE_DEFAULT;
+
+/**
  * enum ps3_sys_manager_cmd - Command from system manager to guest.
  *
  * The guest completes the actions needed, then acks or naks the command via
@@ -581,6 +592,23 @@ fail_id:
         return -EIO;
 }
 
+static void ps3_sys_manager_fin(struct ps3_system_bus_device *dev)
+{
+        ps3_sys_manager_send_request_shutdown(dev);
+
+        pr_emerg("System Halted, OK to turn off power\n");
+
+        while (ps3_sys_manager_handle_msg(dev)) {
+                /* pause until next DEC interrupt */
+                lv1_pause(0);
+        }
+
+        while (1) {
+                /* pause, ignoring DEC interrupt */
+                lv1_pause(1);
+        }
+}
+
 /**
  * ps3_sys_manager_final_power_off - The final platform machine_power_off routine.
  *
@@ -601,13 +629,9 @@ static void ps3_sys_manager_final_power_off(struct ps3_system_bus_device *dev)
         ps3_vuart_cancel_async(dev);
 
         ps3_sys_manager_send_next_op(dev, PS3_SM_NEXT_OP_SYS_SHUTDOWN,
-                PS3_SM_WAKE_DEFAULT);
-        ps3_sys_manager_send_request_shutdown(dev);
-
-        pr_emerg("System Halted, OK to turn off power\n");
+                user_wake_sources);
 
-        while (1)
-                ps3_sys_manager_handle_msg(dev);
+        ps3_sys_manager_fin(dev);
 }
 
 /**
@@ -638,14 +662,42 @@ static void ps3_sys_manager_final_restart(struct ps3_system_bus_device *dev)
 
         ps3_sys_manager_send_attr(dev, 0);
         ps3_sys_manager_send_next_op(dev, PS3_SM_NEXT_OP_SYS_REBOOT,
-                PS3_SM_WAKE_DEFAULT);
-        ps3_sys_manager_send_request_shutdown(dev);
+                user_wake_sources);
 
-        pr_emerg("System Halted, OK to turn off power\n");
+        ps3_sys_manager_fin(dev);
+}
+
+/**
+ * ps3_sys_manager_get_wol - Get wake-on-lan setting.
+ */
+
+int ps3_sys_manager_get_wol(void)
+{
+        pr_debug("%s:%d\n", __func__, __LINE__);
+
+        return (user_wake_sources & PS3_SM_WAKE_W_O_L) != 0;
+}
+EXPORT_SYMBOL_GPL(ps3_sys_manager_get_wol);
+
+/**
+ * ps3_sys_manager_set_wol - Set wake-on-lan setting.
+ */
+
+void ps3_sys_manager_set_wol(int state)
+{
+        static DEFINE_MUTEX(mutex);
+
+        mutex_lock(&mutex);
+
+        pr_debug("%s:%d: %d\n", __func__, __LINE__, state);
 
-        while (1)
-                ps3_sys_manager_handle_msg(dev);
+        if (state)
+                user_wake_sources |= PS3_SM_WAKE_W_O_L;
+        else
+                user_wake_sources &= ~PS3_SM_WAKE_W_O_L;
+        mutex_unlock(&mutex);
 }
+EXPORT_SYMBOL_GPL(ps3_sys_manager_set_wol);
 
 /**
  * ps3_sys_manager_work - Asynchronous read handler.
diff --git a/drivers/ps3/sys-manager-core.c b/drivers/ps3/sys-manager-core.c
index 31648f7d9ae1..474225852b63 100644
--- a/drivers/ps3/sys-manager-core.c
+++ b/drivers/ps3/sys-manager-core.c
@@ -19,6 +19,7 @@
  */
 
 #include <linux/kernel.h>
+#include <asm/lv1call.h>
 #include <asm/ps3.h>
 
 /**
@@ -50,10 +51,7 @@ void ps3_sys_manager_power_off(void)
         if (ps3_sys_manager_ops.power_off)
                 ps3_sys_manager_ops.power_off(ps3_sys_manager_ops.dev);
 
-        printk(KERN_EMERG "System Halted, OK to turn off power\n");
-        local_irq_disable();
-        while (1)
-                (void)0;
+        ps3_sys_manager_halt();
 }
 
 void ps3_sys_manager_restart(void)
@@ -61,8 +59,14 @@ void ps3_sys_manager_restart(void)
         if (ps3_sys_manager_ops.restart)
                 ps3_sys_manager_ops.restart(ps3_sys_manager_ops.dev);
 
-        printk(KERN_EMERG "System Halted, OK to turn off power\n");
+        ps3_sys_manager_halt();
+}
+
+void ps3_sys_manager_halt(void)
+{
+        pr_emerg("System Halted, OK to turn off power\n");
         local_irq_disable();
         while (1)
-                (void)0;
+                lv1_pause(1);
 }
+
diff --git a/drivers/serial/of_serial.c b/drivers/serial/of_serial.c
index c0e50a461055..8aacfb78deab 100644
--- a/drivers/serial/of_serial.c
+++ b/drivers/serial/of_serial.c
@@ -56,7 +56,9 @@ static int __devinit of_platform_serial_setup(struct of_device *ofdev,
         port->flags = UPF_SHARE_IRQ | UPF_BOOT_AUTOCONF | UPF_IOREMAP
                 | UPF_FIXED_PORT;
         port->dev = &ofdev->dev;
-        port->custom_divisor = *clk / (16 * (*spd));
+        /* If current-speed was set, then try not to change it. */
+        if (spd)
+                port->custom_divisor = *clk / (16 * (*spd));
 
         return 0;
 }