517 files changed, 8960 insertions, 4307 deletions

diff --git a/drivers/acpi/acpica/acconfig.h b/drivers/acpi/acpica/acconfig.h
index bc533dde16c4..f895a244ca7e 100644
--- a/drivers/acpi/acpica/acconfig.h
+++ b/drivers/acpi/acpica/acconfig.h
@@ -121,7 +121,7 @@
 
 /* Maximum sleep allowed via Sleep() operator */
 
-#define ACPI_MAX_SLEEP                  20000   /* Two seconds */
+#define ACPI_MAX_SLEEP                  2000    /* Two seconds */
 
 /******************************************************************************
  *
diff --git a/drivers/acpi/apei/Kconfig b/drivers/acpi/apei/Kconfig
index c34aa51af4ee..e3f47872ec22 100644
--- a/drivers/acpi/apei/Kconfig
+++ b/drivers/acpi/apei/Kconfig
@@ -13,6 +13,7 @@ config ACPI_APEI_GHES
         bool "APEI Generic Hardware Error Source"
         depends on ACPI_APEI && X86
         select ACPI_HED
+        select IRQ_WORK
         select LLIST
         select GENERIC_ALLOCATOR
         help
diff --git a/drivers/acpi/apei/apei-base.c b/drivers/acpi/apei/apei-base.c
index 8041248fce9b..61540360d5ce 100644
--- a/drivers/acpi/apei/apei-base.c
+++ b/drivers/acpi/apei/apei-base.c
@@ -618,7 +618,7 @@ int apei_osc_setup(void)
         };
 
         capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
-        capbuf[OSC_SUPPORT_TYPE] = 0;
+        capbuf[OSC_SUPPORT_TYPE] = 1;
         capbuf[OSC_CONTROL_TYPE] = 0;
 
         if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle))
diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index ca3e6be44a04..5987e0ba8c2d 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -468,6 +468,15 @@ config PATA_ICSIDE
           interface card.  This is not required for ICS partition support.
           If you are unsure, say N to this.
 
+config PATA_IMX
+        tristate "PATA support for Freescale iMX"
+        depends on ARCH_MXC
+        help
+          This option enables support for the PATA host available on Freescale
+          iMX SoCs.
+
+          If unsure, say N.
+
 config PATA_IT8213
         tristate "IT8213 PATA support (Experimental)"
         depends on PCI && EXPERIMENTAL
diff --git a/drivers/ata/Makefile b/drivers/ata/Makefile
index 8ac64e1aa051..9550d691fd19 100644
--- a/drivers/ata/Makefile
+++ b/drivers/ata/Makefile
@@ -48,6 +48,7 @@ obj-$(CONFIG_PATA_HPT37X)	+= pata_hpt37x.o
 obj-$(CONFIG_PATA_HPT3X2N)      += pata_hpt3x2n.o
 obj-$(CONFIG_PATA_HPT3X3)       += pata_hpt3x3.o
 obj-$(CONFIG_PATA_ICSIDE)       += pata_icside.o
+obj-$(CONFIG_PATA_IMX)          += pata_imx.o
 obj-$(CONFIG_PATA_IT8213)       += pata_it8213.o
 obj-$(CONFIG_PATA_IT821X)       += pata_it821x.o
 obj-$(CONFIG_PATA_JMICRON)      += pata_jmicron.o
diff --git a/drivers/ata/pata_at91.c b/drivers/ata/pata_at91.c
index 960c72571395..3f4c2613b3df 100644
--- a/drivers/ata/pata_at91.c
+++ b/drivers/ata/pata_at91.c
@@ -30,7 +30,7 @@
 
 #include <mach/at91sam9_smc.h>
 #include <mach/board.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 
 #define DRV_NAME                "pata_at91"
 #define DRV_VERSION             "0.3"
diff --git a/drivers/ata/pata_imx.c b/drivers/ata/pata_imx.c
new file mode 100644
index 000000000000..ca9d9caedfa3
--- /dev/null
+++ b/drivers/ata/pata_imx.c
@@ -0,0 +1,253 @@
+/*
+ * Freescale iMX PATA driver
+ *
+ * Copyright (C) 2011 Arnaud Patard <arnaud.patard@rtp-net.org>
+ *
+ * Based on pata_platform - Copyright (C) 2006 - 2007  Paul Mundt
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * TODO:
+ * - dmaengine support
+ * - check if timing stuff needed
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/blkdev.h>
+#include <scsi/scsi_host.h>
+#include <linux/ata.h>
+#include <linux/libata.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+
+#define DRV_NAME "pata_imx"
+
+#define PATA_IMX_ATA_CONTROL            0x24
+#define PATA_IMX_ATA_CTRL_FIFO_RST_B    (1<<7)
+#define PATA_IMX_ATA_CTRL_ATA_RST_B     (1<<6)
+#define PATA_IMX_ATA_CTRL_IORDY_EN      (1<<0)
+#define PATA_IMX_ATA_INT_EN             0x2C
+#define PATA_IMX_ATA_INTR_ATA_INTRQ2    (1<<3)
+#define PATA_IMX_DRIVE_DATA             0xA0
+#define PATA_IMX_DRIVE_CONTROL          0xD8
+
+struct pata_imx_priv {
+        struct clk *clk;
+        /* timings/interrupt/control regs */
+        u8 *host_regs;
+        u32 ata_ctl;
+};
+
+static int pata_imx_set_mode(struct ata_link *link, struct ata_device **unused)
+{
+        struct ata_device *dev;
+        struct ata_port *ap = link->ap;
+        struct pata_imx_priv *priv = ap->host->private_data;
+        u32 val;
+
+        ata_for_each_dev(dev, link, ENABLED) {
+                dev->pio_mode = dev->xfer_mode = XFER_PIO_0;
+                dev->xfer_shift = ATA_SHIFT_PIO;
+                dev->flags |= ATA_DFLAG_PIO;
+
+                val = __raw_readl(priv->host_regs + PATA_IMX_ATA_CONTROL);
+                if (ata_pio_need_iordy(dev))
+                        val |= PATA_IMX_ATA_CTRL_IORDY_EN;
+                else
+                        val &= ~PATA_IMX_ATA_CTRL_IORDY_EN;
+                __raw_writel(val, priv->host_regs + PATA_IMX_ATA_CONTROL);
+
+                ata_dev_printk(dev, KERN_INFO, "configured for PIO\n");
+        }
+        return 0;
+}
+
+static struct scsi_host_template pata_imx_sht = {
+        ATA_PIO_SHT(DRV_NAME),
+};
+
+static struct ata_port_operations pata_imx_port_ops = {
+        .inherits               = &ata_sff_port_ops,
+        .sff_data_xfer          = ata_sff_data_xfer_noirq,
+        .cable_detect           = ata_cable_unknown,
+        .set_mode               = pata_imx_set_mode,
+};
+
+static void pata_imx_setup_port(struct ata_ioports *ioaddr)
+{
+        /* Fixup the port shift for platforms that need it */
+        ioaddr->data_addr       = ioaddr->cmd_addr + (ATA_REG_DATA    << 2);
+        ioaddr->error_addr      = ioaddr->cmd_addr + (ATA_REG_ERR     << 2);
+        ioaddr->feature_addr    = ioaddr->cmd_addr + (ATA_REG_FEATURE << 2);
+        ioaddr->nsect_addr      = ioaddr->cmd_addr + (ATA_REG_NSECT   << 2);
+        ioaddr->lbal_addr       = ioaddr->cmd_addr + (ATA_REG_LBAL    << 2);
+        ioaddr->lbam_addr       = ioaddr->cmd_addr + (ATA_REG_LBAM    << 2);
+        ioaddr->lbah_addr       = ioaddr->cmd_addr + (ATA_REG_LBAH    << 2);
+        ioaddr->device_addr     = ioaddr->cmd_addr + (ATA_REG_DEVICE  << 2);
+        ioaddr->status_addr     = ioaddr->cmd_addr + (ATA_REG_STATUS  << 2);
+        ioaddr->command_addr    = ioaddr->cmd_addr + (ATA_REG_CMD     << 2);
+}
+
+static int __devinit pata_imx_probe(struct platform_device *pdev)
+{
+        struct ata_host *host;
+        struct ata_port *ap;
+        struct pata_imx_priv *priv;
+        int irq = 0;
+        struct resource *io_res;
+
+        io_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (io_res == NULL)
+                return -EINVAL;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq <= 0)
+                return -EINVAL;
+
+        priv = devm_kzalloc(&pdev->dev,
+                                sizeof(struct pata_imx_priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        priv->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(priv->clk)) {
+                dev_err(&pdev->dev, "Failed to get clock\n");
+                return PTR_ERR(priv->clk);
+        }
+
+        clk_enable(priv->clk);
+
+        host = ata_host_alloc(&pdev->dev, 1);
+        if (!host)
+                goto free_priv;
+
+        host->private_data = priv;
+        ap = host->ports[0];
+
+        ap->ops = &pata_imx_port_ops;
+        ap->pio_mask = ATA_PIO0;
+        ap->flags |= ATA_FLAG_SLAVE_POSS;
+
+        priv->host_regs = devm_ioremap(&pdev->dev, io_res->start,
+                resource_size(io_res));
+        if (!priv->host_regs) {
+                dev_err(&pdev->dev, "failed to map IO/CTL base\n");
+                goto free_priv;
+        }
+
+        ap->ioaddr.cmd_addr = priv->host_regs + PATA_IMX_DRIVE_DATA;
+        ap->ioaddr.ctl_addr = priv->host_regs + PATA_IMX_DRIVE_CONTROL;
+
+        ap->ioaddr.altstatus_addr = ap->ioaddr.ctl_addr;
+
+        pata_imx_setup_port(&ap->ioaddr);
+
+        ata_port_desc(ap, "cmd 0x%llx ctl 0x%llx",
+                (unsigned long long)io_res->start + PATA_IMX_DRIVE_DATA,
+                (unsigned long long)io_res->start + PATA_IMX_DRIVE_CONTROL);
+
+        /* deassert resets */
+        __raw_writel(PATA_IMX_ATA_CTRL_FIFO_RST_B |
+                        PATA_IMX_ATA_CTRL_ATA_RST_B,
+                        priv->host_regs + PATA_IMX_ATA_CONTROL);
+        /* enable interrupts */
+        __raw_writel(PATA_IMX_ATA_INTR_ATA_INTRQ2,
+                        priv->host_regs + PATA_IMX_ATA_INT_EN);
+
+        /* activate */
+        return ata_host_activate(host, irq, ata_sff_interrupt, 0,
+                                &pata_imx_sht);
+
+free_priv:
+        clk_disable(priv->clk);
+        clk_put(priv->clk);
+        return -ENOMEM;
+}
+
+static int __devexit pata_imx_remove(struct platform_device *pdev)
+{
+        struct ata_host *host = dev_get_drvdata(&pdev->dev);
+        struct pata_imx_priv *priv = host->private_data;
+
+        ata_host_detach(host);
+
+        __raw_writel(0, priv->host_regs + PATA_IMX_ATA_INT_EN);
+
+        clk_disable(priv->clk);
+        clk_put(priv->clk);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int pata_imx_suspend(struct device *dev)
+{
+        struct ata_host *host = dev_get_drvdata(dev);
+        struct pata_imx_priv *priv = host->private_data;
+        int ret;
+
+        ret = ata_host_suspend(host, PMSG_SUSPEND);
+        if (!ret) {
+                __raw_writel(0, priv->host_regs + PATA_IMX_ATA_INT_EN);
+                priv->ata_ctl =
+                        __raw_readl(priv->host_regs + PATA_IMX_ATA_CONTROL);
+                clk_disable(priv->clk);
+        }
+
+        return ret;
+}
+
+static int pata_imx_resume(struct device *dev)
+{
+        struct ata_host *host = dev_get_drvdata(dev);
+        struct pata_imx_priv *priv = host->private_data;
+
+        clk_enable(priv->clk);
+
+        __raw_writel(priv->ata_ctl, priv->host_regs + PATA_IMX_ATA_CONTROL);
+
+        __raw_writel(PATA_IMX_ATA_INTR_ATA_INTRQ2,
+                        priv->host_regs + PATA_IMX_ATA_INT_EN);
+
+        ata_host_resume(host);
+
+        return 0;
+}
+
+static const struct dev_pm_ops pata_imx_pm_ops = {
+        .suspend        = pata_imx_suspend,
+        .resume         = pata_imx_resume,
+};
+#endif
+
+static struct platform_driver pata_imx_driver = {
+        .probe          = pata_imx_probe,
+        .remove         = __devexit_p(pata_imx_remove),
+        .driver = {
+                .name           = DRV_NAME,
+                .owner          = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm             = &pata_imx_pm_ops,
+#endif
+        },
+};
+
+static int __init pata_imx_init(void)
+{
+        return platform_driver_register(&pata_imx_driver);
+}
+
+static void __exit pata_imx_exit(void)
+{
+        platform_driver_unregister(&pata_imx_driver);
+}
+module_init(pata_imx_init);
+module_exit(pata_imx_exit);
+
+MODULE_AUTHOR("Arnaud Patard <arnaud.patard@rtp-net.org>");
+MODULE_DESCRIPTION("low-level driver for iMX PATA");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/ata/pata_via.c b/drivers/ata/pata_via.c
index 65e4be6be220..8e9f5048a10a 100644
--- a/drivers/ata/pata_via.c
+++ b/drivers/ata/pata_via.c
@@ -124,6 +124,17 @@ static const struct via_isa_bridge {
         { NULL }
 };
 
+static const struct dmi_system_id no_atapi_dma_dmi_table[] = {
+        {
+                .ident = "AVERATEC 3200",
+                .matches = {
+                        DMI_MATCH(DMI_BOARD_VENDOR, "AVERATEC"),
+                        DMI_MATCH(DMI_BOARD_NAME, "3200"),
+                },
+        },
+        { }
+};
+
 struct via_port {
         u8 cached_device;
 };
@@ -355,6 +366,13 @@ static unsigned long via_mode_filter(struct ata_device *dev, unsigned long mask)
                         mask &= ~ ATA_MASK_UDMA;
                 }
         }
+
+        if (dev->class == ATA_DEV_ATAPI &&
+            dmi_check_system(no_atapi_dma_dmi_table)) {
+                ata_dev_warn(dev, "controller locks up on ATAPI DMA, forcing PIO\n");
+                mask &= ATA_MASK_PIO;
+        }
+
         return mask;
 }
 
diff --git a/drivers/ata/sata_dwc_460ex.c b/drivers/ata/sata_dwc_460ex.c
index 0a9a774a7e1e..5c4237452f50 100644
--- a/drivers/ata/sata_dwc_460ex.c
+++ b/drivers/ata/sata_dwc_460ex.c
@@ -1329,7 +1329,7 @@ static int sata_dwc_port_start(struct ata_port *ap)
                         dev_err(ap->dev, "%s: dma_alloc_coherent failed\n",
                                  __func__);
                         err = -ENOMEM;
-                        goto CLEANUP;
+                        goto CLEANUP_ALLOC;
                 }
         }
 
@@ -1349,15 +1349,13 @@ static int sata_dwc_port_start(struct ata_port *ap)
         /* Clear any error bits before libata starts issuing commands */
         clear_serror();
         ap->private_data = hsdevp;
+        dev_dbg(ap->dev, "%s: done\n", __func__);
+        return 0;
 
+CLEANUP_ALLOC:
+        kfree(hsdevp);
 CLEANUP:
-        if (err) {
-                sata_dwc_port_stop(ap);
-                dev_dbg(ap->dev, "%s: fail\n", __func__);
-        } else {
-                dev_dbg(ap->dev, "%s: done\n", __func__);
-        }
-
+        dev_dbg(ap->dev, "%s: fail. ap->id = %d\n", __func__, ap->print_id);
         return err;
 }
 
diff --git a/drivers/ata/sata_sil.c b/drivers/ata/sata_sil.c
index 98c1d780f552..9dfb40b8c2c9 100644
--- a/drivers/ata/sata_sil.c
+++ b/drivers/ata/sata_sil.c
@@ -438,7 +438,7 @@ static void sil_host_intr(struct ata_port *ap, u32 bmdma2)
         u8 status;
 
         if (unlikely(bmdma2 & SIL_DMA_SATA_IRQ)) {
-                u32 serror;
+                u32 serror = 0xffffffff;
 
                 /* SIEN doesn't mask SATA IRQs on some 3112s.  Those
                  * controllers continue to assert IRQ as long as
diff --git a/drivers/base/devres.c b/drivers/base/devres.c
index cf7a0c788052..65cd74832450 100644
--- a/drivers/base/devres.c
+++ b/drivers/base/devres.c
@@ -397,6 +397,7 @@ static int remove_nodes(struct device *dev,
 
 static int release_nodes(struct device *dev, struct list_head *first,
                          struct list_head *end, unsigned long flags)
+        __releases(&dev->devres_lock)
 {
         LIST_HEAD(todo);
         int cnt;
diff --git a/drivers/base/devtmpfs.c b/drivers/base/devtmpfs.c
index 33e1bed68fdd..a4760e095ff5 100644
--- a/drivers/base/devtmpfs.c
+++ b/drivers/base/devtmpfs.c
@@ -376,7 +376,7 @@ int devtmpfs_mount(const char *mntdir)
         return err;
 }
 
-static __initdata DECLARE_COMPLETION(setup_done);
+static DECLARE_COMPLETION(setup_done);
 
 static int handle(const char *name, mode_t mode, struct device *dev)
 {
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index bbb03e6f7255..06ed6b4e7df5 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -521,11 +521,6 @@ static int _request_firmware(const struct firmware **firmware_p,
         if (!firmware_p)
                 return -EINVAL;
 
-        if (WARN_ON(usermodehelper_is_disabled())) {
-                dev_err(device, "firmware: %s will not be loaded\n", name);
-                return -EBUSY;
-        }
-
         *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
         if (!firmware) {
                 dev_err(device, "%s: kmalloc(struct firmware) failed\n",
@@ -539,6 +534,12 @@ static int _request_firmware(const struct firmware **firmware_p,
                 return 0;
         }
 
+        if (WARN_ON(usermodehelper_is_disabled())) {
+                dev_err(device, "firmware: %s will not be loaded\n", name);
+                retval = -EBUSY;
+                goto out;
+        }
+
         if (uevent)
                 dev_dbg(device, "firmware: requesting %s\n", name);
 
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 0cad9c7f6bb5..99a5272d7c2f 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -33,7 +33,7 @@ EXPORT_SYMBOL_GPL(platform_bus);
 
 /**
  * arch_setup_pdev_archdata - Allow manipulation of archdata before its used
- * @dev: platform device
+ * @pdev: platform device
  *
  * This is called before platform_device_add() such that any pdev_archdata may
  * be setup before the platform_notifier is called.  So if a user needs to
diff --git a/drivers/base/power/clock_ops.c b/drivers/base/power/clock_ops.c
index a846b2f95cfb..b97294e2d95b 100644
--- a/drivers/base/power/clock_ops.c
+++ b/drivers/base/power/clock_ops.c
@@ -19,7 +19,7 @@
 
 struct pm_clk_data {
         struct list_head clock_list;
-        struct mutex lock;
+        spinlock_t lock;
 };
 
 enum pce_status {
@@ -42,6 +42,22 @@ static struct pm_clk_data *__to_pcd(struct device *dev)
 }
 
 /**
+ * pm_clk_acquire - Acquire a device clock.
+ * @dev: Device whose clock is to be acquired.
+ * @ce: PM clock entry corresponding to the clock.
+ */
+static void pm_clk_acquire(struct device *dev, struct pm_clock_entry *ce)
+{
+        ce->clk = clk_get(dev, ce->con_id);
+        if (IS_ERR(ce->clk)) {
+                ce->status = PCE_STATUS_ERROR;
+        } else {
+                ce->status = PCE_STATUS_ACQUIRED;
+                dev_dbg(dev, "Clock %s managed by runtime PM.\n", ce->con_id);
+        }
+}
+
+/**
  * pm_clk_add - Start using a device clock for power management.
  * @dev: Device whose clock is going to be used for power management.
  * @con_id: Connection ID of the clock.
@@ -73,26 +89,23 @@ int pm_clk_add(struct device *dev, const char *con_id)
                 }
         }
 
-        mutex_lock(&pcd->lock);
+        pm_clk_acquire(dev, ce);
+
+        spin_lock_irq(&pcd->lock);
         list_add_tail(&ce->node, &pcd->clock_list);
-        mutex_unlock(&pcd->lock);
+        spin_unlock_irq(&pcd->lock);
         return 0;
 }
 
 /**
  * __pm_clk_remove - Destroy PM clock entry.
  * @ce: PM clock entry to destroy.
- *
- * This routine must be called under the mutex protecting the PM list of clocks
- * corresponding the the @ce's device.
  */
 static void __pm_clk_remove(struct pm_clock_entry *ce)
 {
         if (!ce)
                 return;
 
-        list_del(&ce->node);
-
         if (ce->status < PCE_STATUS_ERROR) {
                 if (ce->status == PCE_STATUS_ENABLED)
                         clk_disable(ce->clk);
@@ -123,21 +136,25 @@ void pm_clk_remove(struct device *dev, const char *con_id)
         if (!pcd)
                 return;
 
-        mutex_lock(&pcd->lock);
+        spin_lock_irq(&pcd->lock);
 
         list_for_each_entry(ce, &pcd->clock_list, node) {
-                if (!con_id && !ce->con_id) {
-                        __pm_clk_remove(ce);
-                        break;
-                } else if (!con_id || !ce->con_id) {
+                if (!con_id && !ce->con_id)
+                        goto remove;
+                else if (!con_id || !ce->con_id)
                         continue;
-                } else if (!strcmp(con_id, ce->con_id)) {
-                        __pm_clk_remove(ce);
-                        break;
-                }
+                else if (!strcmp(con_id, ce->con_id))
+                        goto remove;
         }
 
-        mutex_unlock(&pcd->lock);
+        spin_unlock_irq(&pcd->lock);
+        return;
+
+ remove:
+        list_del(&ce->node);
+        spin_unlock_irq(&pcd->lock);
+
+        __pm_clk_remove(ce);
 }
 
 /**
@@ -158,7 +175,7 @@ int pm_clk_init(struct device *dev)
         }
 
         INIT_LIST_HEAD(&pcd->clock_list);
-        mutex_init(&pcd->lock);
+        spin_lock_init(&pcd->lock);
         dev->power.subsys_data = pcd;
         return 0;
 }
@@ -175,20 +192,27 @@ void pm_clk_destroy(struct device *dev)
 {
         struct pm_clk_data *pcd = __to_pcd(dev);
         struct pm_clock_entry *ce, *c;
+        struct list_head list;
 
         if (!pcd)
                 return;
 
         dev->power.subsys_data = NULL;
+        INIT_LIST_HEAD(&list);
 
-        mutex_lock(&pcd->lock);
+        spin_lock_irq(&pcd->lock);
 
         list_for_each_entry_safe_reverse(ce, c, &pcd->clock_list, node)
-                __pm_clk_remove(ce);
+                list_move(&ce->node, &list);
 
-        mutex_unlock(&pcd->lock);
+        spin_unlock_irq(&pcd->lock);
 
         kfree(pcd);
+
+        list_for_each_entry_safe_reverse(ce, c, &list, node) {
+                list_del(&ce->node);
+                __pm_clk_remove(ce);
+        }
 }
 
 #endif /* CONFIG_PM */
@@ -196,23 +220,6 @@ void pm_clk_destroy(struct device *dev)
 #ifdef CONFIG_PM_RUNTIME
 
 /**
- * pm_clk_acquire - Acquire a device clock.
- * @dev: Device whose clock is to be acquired.
- * @con_id: Connection ID of the clock.
- */
-static void pm_clk_acquire(struct device *dev,
-                                    struct pm_clock_entry *ce)
-{
-        ce->clk = clk_get(dev, ce->con_id);
-        if (IS_ERR(ce->clk)) {
-                ce->status = PCE_STATUS_ERROR;
-        } else {
-                ce->status = PCE_STATUS_ACQUIRED;
-                dev_dbg(dev, "Clock %s managed by runtime PM.\n", ce->con_id);
-        }
-}
-
-/**
  * pm_clk_suspend - Disable clocks in a device's PM clock list.
  * @dev: Device to disable the clocks for.
  */
@@ -220,25 +227,23 @@ int pm_clk_suspend(struct device *dev)
 {
         struct pm_clk_data *pcd = __to_pcd(dev);
         struct pm_clock_entry *ce;
+        unsigned long flags;
 
         dev_dbg(dev, "%s()\n", __func__);
 
         if (!pcd)
                 return 0;
 
-        mutex_lock(&pcd->lock);
+        spin_lock_irqsave(&pcd->lock, flags);
 
         list_for_each_entry_reverse(ce, &pcd->clock_list, node) {
-                if (ce->status == PCE_STATUS_NONE)
-                        pm_clk_acquire(dev, ce);
-
                 if (ce->status < PCE_STATUS_ERROR) {
                         clk_disable(ce->clk);
                         ce->status = PCE_STATUS_ACQUIRED;
                 }
         }
 
-        mutex_unlock(&pcd->lock);
+        spin_unlock_irqrestore(&pcd->lock, flags);
 
         return 0;
 }
@@ -251,25 +256,23 @@ int pm_clk_resume(struct device *dev)
 {
         struct pm_clk_data *pcd = __to_pcd(dev);
         struct pm_clock_entry *ce;
+        unsigned long flags;
 
         dev_dbg(dev, "%s()\n", __func__);
 
         if (!pcd)
                 return 0;
 
-        mutex_lock(&pcd->lock);
+        spin_lock_irqsave(&pcd->lock, flags);
 
         list_for_each_entry(ce, &pcd->clock_list, node) {
-                if (ce->status == PCE_STATUS_NONE)
-                        pm_clk_acquire(dev, ce);
-
                 if (ce->status < PCE_STATUS_ERROR) {
                         clk_enable(ce->clk);
                         ce->status = PCE_STATUS_ENABLED;
                 }
         }
 
-        mutex_unlock(&pcd->lock);
+        spin_unlock_irqrestore(&pcd->lock, flags);
 
         return 0;
 }
@@ -344,6 +347,7 @@ int pm_clk_suspend(struct device *dev)
 {
         struct pm_clk_data *pcd = __to_pcd(dev);
         struct pm_clock_entry *ce;
+        unsigned long flags;
 
         dev_dbg(dev, "%s()\n", __func__);
 
@@ -351,12 +355,12 @@ int pm_clk_suspend(struct device *dev)
         if (!pcd || !dev->driver)
                 return 0;
 
-        mutex_lock(&pcd->lock);
+        spin_lock_irqsave(&pcd->lock, flags);
 
         list_for_each_entry_reverse(ce, &pcd->clock_list, node)
                 clk_disable(ce->clk);
 
-        mutex_unlock(&pcd->lock);
+        spin_unlock_irqrestore(&pcd->lock, flags);
 
         return 0;
 }
@@ -369,6 +373,7 @@ int pm_clk_resume(struct device *dev)
 {
         struct pm_clk_data *pcd = __to_pcd(dev);
         struct pm_clock_entry *ce;
+        unsigned long flags;
 
         dev_dbg(dev, "%s()\n", __func__);
 
@@ -376,12 +381,12 @@ int pm_clk_resume(struct device *dev)
         if (!pcd || !dev->driver)
                 return 0;
 
-        mutex_lock(&pcd->lock);
+        spin_lock_irqsave(&pcd->lock, flags);
 
         list_for_each_entry(ce, &pcd->clock_list, node)
                 clk_enable(ce->clk);
 
-        mutex_unlock(&pcd->lock);
+        spin_unlock_irqrestore(&pcd->lock, flags);
 
         return 0;
 }
diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c
index e18566a0fedd..1c374579407c 100644
--- a/drivers/base/power/domain.c
+++ b/drivers/base/power/domain.c
@@ -460,6 +460,21 @@ static int pm_genpd_runtime_resume(struct device *dev)
         return 0;
 }
 
+/**
+ * pm_genpd_poweroff_unused - Power off all PM domains with no devices in use.
+ */
+void pm_genpd_poweroff_unused(void)
+{
+        struct generic_pm_domain *genpd;
+
+        mutex_lock(&gpd_list_lock);
+
+        list_for_each_entry(genpd, &gpd_list, gpd_list_node)
+                genpd_queue_power_off_work(genpd);
+
+        mutex_unlock(&gpd_list_lock);
+}
+
 #else
 
 static inline void genpd_power_off_work_fn(struct work_struct *work) {}
@@ -1255,18 +1270,3 @@ void pm_genpd_init(struct generic_pm_domain *genpd,
         list_add(&genpd->gpd_list_node, &gpd_list);
         mutex_unlock(&gpd_list_lock);
 }
-
-/**
- * pm_genpd_poweroff_unused - Power off all PM domains with no devices in use.
- */
-void pm_genpd_poweroff_unused(void)
-{
-        struct generic_pm_domain *genpd;
-
-        mutex_lock(&gpd_list_lock);
-
-        list_for_each_entry(genpd, &gpd_list, gpd_list_node)
-                genpd_queue_power_off_work(genpd);
-
-        mutex_unlock(&gpd_list_lock);
-}
diff --git a/drivers/base/regmap/regmap-i2c.c b/drivers/base/regmap/regmap-i2c.c
index c2231ff06cbc..c4f7a45cd2c3 100644
--- a/drivers/base/regmap/regmap-i2c.c
+++ b/drivers/base/regmap/regmap-i2c.c
@@ -113,3 +113,4 @@ struct regmap *regmap_init_i2c(struct i2c_client *i2c,
 }
 EXPORT_SYMBOL_GPL(regmap_init_i2c);
 
+MODULE_LICENSE("GPL");
diff --git a/drivers/base/regmap/regmap-spi.c b/drivers/base/regmap/regmap-spi.c
index 4deba0621bc7..f8396945d6ed 100644
--- a/drivers/base/regmap/regmap-spi.c
+++ b/drivers/base/regmap/regmap-spi.c
@@ -13,6 +13,7 @@
 #include <linux/regmap.h>
 #include <linux/spi/spi.h>
 #include <linux/init.h>
+#include <linux/module.h>
 
 static int regmap_spi_write(struct device *dev, const void *data, size_t count)
 {
@@ -70,3 +71,5 @@ struct regmap *regmap_init_spi(struct spi_device *spi,
         return regmap_init(&spi->dev, &regmap_spi, config);
 }
 EXPORT_SYMBOL_GPL(regmap_init_spi);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index cf3565cae93d..20663f8dae45 100644
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -168,13 +168,11 @@ struct regmap *regmap_init(struct device *dev,
         map->work_buf = kmalloc(map->format.buf_size, GFP_KERNEL);
         if (map->work_buf == NULL) {
                 ret = -ENOMEM;
-                goto err_bus;
+                goto err_map;
         }
 
         return map;
 
-err_bus:
-        module_put(map->bus->owner);
 err_map:
         kfree(map);
 err:
@@ -188,7 +186,6 @@ EXPORT_SYMBOL_GPL(regmap_init);
 void regmap_exit(struct regmap *map)
 {
         kfree(map->work_buf);
-        module_put(map->bus->owner);
         kfree(map);
 }
 EXPORT_SYMBOL_GPL(regmap_exit);
@@ -317,7 +314,7 @@ static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
                 u8[0] |= map->bus->read_flag_mask;
 
         ret = map->bus->read(map->dev, map->work_buf, map->format.reg_bytes,
-                             val, map->format.val_bytes);
+                             val, val_len);
         if (ret != 0)
                 return ret;
 
diff --git a/drivers/bcma/main.c b/drivers/bcma/main.c
index 873e2e4ac55f..73b7b1a18fab 100644
--- a/drivers/bcma/main.c
+++ b/drivers/bcma/main.c
@@ -15,6 +15,7 @@ MODULE_LICENSE("GPL");
 static int bcma_bus_match(struct device *dev, struct device_driver *drv);
 static int bcma_device_probe(struct device *dev);
 static int bcma_device_remove(struct device *dev);
+static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env);
 
 static ssize_t manuf_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -49,6 +50,7 @@ static struct bus_type bcma_bus_type = {
         .match          = bcma_bus_match,
         .probe          = bcma_device_probe,
         .remove         = bcma_device_remove,
+        .uevent         = bcma_device_uevent,
         .dev_attrs      = bcma_device_attrs,
 };
 
@@ -227,6 +229,16 @@ static int bcma_device_remove(struct device *dev)
         return 0;
 }
 
+static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env)
+{
+        struct bcma_device *core = container_of(dev, struct bcma_device, dev);
+
+        return add_uevent_var(env,
+                              "MODALIAS=bcma:m%04Xid%04Xrev%02Xcl%02X",
+                              core->id.manuf, core->id.id,
+                              core->id.rev, core->id.class);
+}
+
 static int __init bcma_modinit(void)
 {
         int err;
diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index 717d6e4e18d3..6f07ec1c2f58 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -256,6 +256,21 @@ config BLK_DEV_LOOP
 
           Most users will answer N here.
 
+config BLK_DEV_LOOP_MIN_COUNT
+        int "Number of loop devices to pre-create at init time"
+        depends on BLK_DEV_LOOP
+        default 8
+        help
+          Static number of loop devices to be unconditionally pre-created
+          at init time.
+
+          This default value can be overwritten on the kernel command
+          line or with module-parameter loop.max_loop.
+
+          The historic default is 8. If a late 2011 version of losetup(8)
+          is used, it can be set to 0, since needed loop devices can be
+          dynamically allocated with the /dev/loop-control interface.
+
 config BLK_DEV_CRYPTOLOOP
         tristate "Cryptoloop Support"
         select CRYPTO
@@ -471,7 +486,7 @@ config XEN_BLKDEV_FRONTEND
           in another domain which drives the actual block device.
 
 config XEN_BLKDEV_BACKEND
-        tristate "Block-device backend driver"
+        tristate "Xen block-device backend driver"
         depends on XEN_BACKEND
         help
           The block-device backend driver allows the kernel to export its
diff --git a/drivers/block/drbd/drbd_nl.c b/drivers/block/drbd/drbd_nl.c
index 515bcd948a43..0feab261e295 100644
--- a/drivers/block/drbd/drbd_nl.c
+++ b/drivers/block/drbd/drbd_nl.c
@@ -1829,10 +1829,10 @@ static int drbd_nl_syncer_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *n
 
         /* silently ignore cpu mask on UP kernel */
         if (nr_cpu_ids > 1 && sc.cpu_mask[0] != 0) {
-                err = __bitmap_parse(sc.cpu_mask, 32, 0,
+                err = bitmap_parse(sc.cpu_mask, 32,
                                 cpumask_bits(new_cpu_mask), nr_cpu_ids);
                 if (err) {
-                        dev_warn(DEV, "__bitmap_parse() failed with %d\n", err);
+                        dev_warn(DEV, "bitmap_parse() failed with %d\n", err);
                         retcode = ERR_CPU_MASK_PARSE;
                         goto fail;
                 }
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 98de8f418676..9955a53733b2 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -4250,7 +4250,7 @@ static int __init floppy_init(void)
         use_virtual_dma = can_use_virtual_dma & 1;
         fdc_state[0].address = FDC1;
         if (fdc_state[0].address == -1) {
-                del_timer(&fd_timeout);
+                del_timer_sync(&fd_timeout);
                 err = -ENODEV;
                 goto out_unreg_region;
         }
@@ -4261,7 +4261,7 @@ static int __init floppy_init(void)
         fdc = 0;                /* reset fdc in case of unexpected interrupt */
         err = floppy_grab_irq_and_dma();
         if (err) {
-                del_timer(&fd_timeout);
+                del_timer_sync(&fd_timeout);
                 err = -EBUSY;
                 goto out_unreg_region;
         }
@@ -4318,7 +4318,7 @@ static int __init floppy_init(void)
                 user_reset_fdc(-1, FD_RESET_ALWAYS, false);
         }
         fdc = 0;
-        del_timer(&fd_timeout);
+        del_timer_sync(&fd_timeout);
         current_drive = 0;
         initialized = true;
         if (have_no_fdc) {
@@ -4368,7 +4368,7 @@ out_unreg_blkdev:
         unregister_blkdev(FLOPPY_MAJOR, "fd");
 out_put_disk:
         while (dr--) {
-                del_timer(&motor_off_timer[dr]);
+                del_timer_sync(&motor_off_timer[dr]);
                 if (disks[dr]->queue)
                         blk_cleanup_queue(disks[dr]->queue);
                 put_disk(disks[dr]);
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 76c8da78212b..4720c7ade0ae 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -75,11 +75,11 @@
 #include <linux/kthread.h>
 #include <linux/splice.h>
 #include <linux/sysfs.h>
-
+#include <linux/miscdevice.h>
 #include <asm/uaccess.h>
 
-static LIST_HEAD(loop_devices);
-static DEFINE_MUTEX(loop_devices_mutex);
+static DEFINE_IDR(loop_index_idr);
+static DEFINE_MUTEX(loop_index_mutex);
 
 static int max_part;
 static int part_shift;
@@ -722,17 +722,10 @@ static inline int is_loop_device(struct file *file)
 static ssize_t loop_attr_show(struct device *dev, char *page,
                               ssize_t (*callback)(struct loop_device *, char *))
 {
-        struct loop_device *l, *lo = NULL;
-
-        mutex_lock(&loop_devices_mutex);
-        list_for_each_entry(l, &loop_devices, lo_list)
-                if (disk_to_dev(l->lo_disk) == dev) {
-                        lo = l;
-                        break;
-                }
-        mutex_unlock(&loop_devices_mutex);
+        struct gendisk *disk = dev_to_disk(dev);
+        struct loop_device *lo = disk->private_data;
 
-        return lo ? callback(lo, page) : -EIO;
+        return callback(lo, page);
 }
 
 #define LOOP_ATTR_RO(_name)                                             \
@@ -750,10 +743,10 @@ static ssize_t loop_attr_backing_file_show(struct loop_device *lo, char *buf)
         ssize_t ret;
         char *p = NULL;
 
-        mutex_lock(&lo->lo_ctl_mutex);
+        spin_lock_irq(&lo->lo_lock);
         if (lo->lo_backing_file)
                 p = d_path(&lo->lo_backing_file->f_path, buf, PAGE_SIZE - 1);
-        mutex_unlock(&lo->lo_ctl_mutex);
+        spin_unlock_irq(&lo->lo_lock);
 
         if (IS_ERR_OR_NULL(p))
                 ret = PTR_ERR(p);
@@ -1007,7 +1000,9 @@ static int loop_clr_fd(struct loop_device *lo, struct block_device *bdev)
 
         kthread_stop(lo->lo_thread);
 
+        spin_lock_irq(&lo->lo_lock);
         lo->lo_backing_file = NULL;
+        spin_unlock_irq(&lo->lo_lock);
 
         loop_release_xfer(lo);
         lo->transfer = NULL;
@@ -1485,13 +1480,22 @@ static int lo_compat_ioctl(struct block_device *bdev, fmode_t mode,
 
 static int lo_open(struct block_device *bdev, fmode_t mode)
 {
-        struct loop_device *lo = bdev->bd_disk->private_data;
+        struct loop_device *lo;
+        int err = 0;
+
+        mutex_lock(&loop_index_mutex);
+        lo = bdev->bd_disk->private_data;
+        if (!lo) {
+                err = -ENXIO;
+                goto out;
+        }
 
         mutex_lock(&lo->lo_ctl_mutex);
         lo->lo_refcnt++;
         mutex_unlock(&lo->lo_ctl_mutex);
-
-        return 0;
+out:
+        mutex_unlock(&loop_index_mutex);
+        return err;
 }
 
 static int lo_release(struct gendisk *disk, fmode_t mode)
@@ -1557,40 +1561,71 @@ int loop_register_transfer(struct loop_func_table *funcs)
         return 0;
 }
 
+static int unregister_transfer_cb(int id, void *ptr, void *data)
+{
+        struct loop_device *lo = ptr;
+        struct loop_func_table *xfer = data;
+
+        mutex_lock(&lo->lo_ctl_mutex);
+        if (lo->lo_encryption == xfer)
+                loop_release_xfer(lo);
+        mutex_unlock(&lo->lo_ctl_mutex);
+        return 0;
+}
+
 int loop_unregister_transfer(int number)
 {
         unsigned int n = number;
-        struct loop_device *lo;
         struct loop_func_table *xfer;
 
         if (n == 0 || n >= MAX_LO_CRYPT || (xfer = xfer_funcs[n]) == NULL)
                 return -EINVAL;
 
         xfer_funcs[n] = NULL;
-
-        list_for_each_entry(lo, &loop_devices, lo_list) {
-                mutex_lock(&lo->lo_ctl_mutex);
-
-                if (lo->lo_encryption == xfer)
-                        loop_release_xfer(lo);
-
-                mutex_unlock(&lo->lo_ctl_mutex);
-        }
-
+        idr_for_each(&loop_index_idr, &unregister_transfer_cb, xfer);
         return 0;
 }
 
 EXPORT_SYMBOL(loop_register_transfer);
 EXPORT_SYMBOL(loop_unregister_transfer);
 
-static struct loop_device *loop_alloc(int i)
+static int loop_add(struct loop_device **l, int i)
 {
         struct loop_device *lo;
         struct gendisk *disk;
+        int err;
 
         lo = kzalloc(sizeof(*lo), GFP_KERNEL);
-        if (!lo)
+        if (!lo) {
+                err = -ENOMEM;
                 goto out;
+        }
+
+        err = idr_pre_get(&loop_index_idr, GFP_KERNEL);
+        if (err < 0)
+                goto out_free_dev;
+
+        if (i >= 0) {
+                int m;
+
+                /* create specific i in the index */
+                err = idr_get_new_above(&loop_index_idr, lo, i, &m);
+                if (err >= 0 && i != m) {
+                        idr_remove(&loop_index_idr, m);
+                        err = -EEXIST;
+                }
+        } else if (i == -1) {
+                int m;
+
+                /* get next free nr */
+                err = idr_get_new(&loop_index_idr, lo, &m);
+                if (err >= 0)
+                        i = m;
+        } else {
+                err = -EINVAL;
+        }
+        if (err < 0)
+                goto out_free_dev;
 
         lo->lo_queue = blk_alloc_queue(GFP_KERNEL);
         if (!lo->lo_queue)
@@ -1611,81 +1646,158 @@ static struct loop_device *loop_alloc(int i)
         disk->private_data      = lo;
         disk->queue             = lo->lo_queue;
         sprintf(disk->disk_name, "loop%d", i);
-        return lo;
+        add_disk(disk);
+        *l = lo;
+        return lo->lo_number;
 
 out_free_queue:
         blk_cleanup_queue(lo->lo_queue);
 out_free_dev:
         kfree(lo);
 out:
-        return NULL;
+        return err;
 }
 
-static void loop_free(struct loop_device *lo)
+static void loop_remove(struct loop_device *lo)
 {
+        del_gendisk(lo->lo_disk);
         blk_cleanup_queue(lo->lo_queue);
         put_disk(lo->lo_disk);
-        list_del(&lo->lo_list);
         kfree(lo);
 }
 
-static struct loop_device *loop_init_one(int i)
+static int find_free_cb(int id, void *ptr, void *data)
+{
+        struct loop_device *lo = ptr;
+        struct loop_device **l = data;
+
+        if (lo->lo_state == Lo_unbound) {
+                *l = lo;
+                return 1;
+        }
+        return 0;
+}
+
+static int loop_lookup(struct loop_device **l, int i)
 {
         struct loop_device *lo;
+        int ret = -ENODEV;
 
-        list_for_each_entry(lo, &loop_devices, lo_list) {
-                if (lo->lo_number == i)
-                        return lo;
+        if (i < 0) {
+                int err;
+
+                err = idr_for_each(&loop_index_idr, &find_free_cb, &lo);
+                if (err == 1) {
+                        *l = lo;
+                        ret = lo->lo_number;
+                }
+                goto out;
         }
 
-        lo = loop_alloc(i);
+        /* lookup and return a specific i */
+        lo = idr_find(&loop_index_idr, i);
         if (lo) {
-                add_disk(lo->lo_disk);
-                list_add_tail(&lo->lo_list, &loop_devices);
+                *l = lo;
+                ret = lo->lo_number;
         }
-        return lo;
-}
-
-static void loop_del_one(struct loop_device *lo)
-{
-        del_gendisk(lo->lo_disk);
-        loop_free(lo);
+out:
+        return ret;
 }
 
 static struct kobject *loop_probe(dev_t dev, int *part, void *data)
 {
         struct loop_device *lo;
         struct kobject *kobj;
+        int err;
 
-        mutex_lock(&loop_devices_mutex);
-        lo = loop_init_one(MINOR(dev) >> part_shift);
-        kobj = lo ? get_disk(lo->lo_disk) : ERR_PTR(-ENOMEM);
-        mutex_unlock(&loop_devices_mutex);
+        mutex_lock(&loop_index_mutex);
+        err = loop_lookup(&lo, MINOR(dev) >> part_shift);
+        if (err < 0)
+                err = loop_add(&lo, MINOR(dev) >> part_shift);
+        if (err < 0)
+                kobj = ERR_PTR(err);
+        else
+                kobj = get_disk(lo->lo_disk);
+        mutex_unlock(&loop_index_mutex);
 
         *part = 0;
         return kobj;
 }
 
+static long loop_control_ioctl(struct file *file, unsigned int cmd,
+                               unsigned long parm)
+{
+        struct loop_device *lo;
+        int ret = -ENOSYS;
+
+        mutex_lock(&loop_index_mutex);
+        switch (cmd) {
+        case LOOP_CTL_ADD:
+                ret = loop_lookup(&lo, parm);
+                if (ret >= 0) {
+                        ret = -EEXIST;
+                        break;
+                }
+                ret = loop_add(&lo, parm);
+                break;
+        case LOOP_CTL_REMOVE:
+                ret = loop_lookup(&lo, parm);
+                if (ret < 0)
+                        break;
+                mutex_lock(&lo->lo_ctl_mutex);
+                if (lo->lo_state != Lo_unbound) {
+                        ret = -EBUSY;
+                        mutex_unlock(&lo->lo_ctl_mutex);
+                        break;
+                }
+                if (lo->lo_refcnt > 0) {
+                        ret = -EBUSY;
+                        mutex_unlock(&lo->lo_ctl_mutex);
+                        break;
+                }
+                lo->lo_disk->private_data = NULL;
+                mutex_unlock(&lo->lo_ctl_mutex);
+                idr_remove(&loop_index_idr, lo->lo_number);
+                loop_remove(lo);
+                break;
+        case LOOP_CTL_GET_FREE:
+                ret = loop_lookup(&lo, -1);
+                if (ret >= 0)
+                        break;
+                ret = loop_add(&lo, -1);
+        }
+        mutex_unlock(&loop_index_mutex);
+
+        return ret;
+}
+
+static const struct file_operations loop_ctl_fops = {
+        .open           = nonseekable_open,
+        .unlocked_ioctl = loop_control_ioctl,
+        .compat_ioctl   = loop_control_ioctl,
+        .owner          = THIS_MODULE,
+        .llseek         = noop_llseek,
+};
+
+static struct miscdevice loop_misc = {
+        .minor          = LOOP_CTRL_MINOR,
+        .name           = "loop-control",
+        .fops           = &loop_ctl_fops,
+};
+
+MODULE_ALIAS_MISCDEV(LOOP_CTRL_MINOR);
+MODULE_ALIAS("devname:loop-control");
+
 static int __init loop_init(void)
 {
         int i, nr;
         unsigned long range;
-        struct loop_device *lo, *next;
+        struct loop_device *lo;
+        int err;
 
-        /*
-         * loop module now has a feature to instantiate underlying device
-         * structure on-demand, provided that there is an access dev node.
-         * However, this will not work well with user space tool that doesn't
-         * know about such "feature".  In order to not break any existing
-         * tool, we do the following:
-         *
-         * (1) if max_loop is specified, create that many upfront, and this
-         *     also becomes a hard limit.
-         * (2) if max_loop is not specified, create 8 loop device on module
-         *     load, user can further extend loop device by create dev node
-         *     themselves and have kernel automatically instantiate actual
-         *     device on-demand.
-         */
+        err = misc_register(&loop_misc);
+        if (err < 0)
+                return err;
 
         part_shift = 0;
         if (max_part > 0) {
@@ -1708,57 +1820,60 @@ static int __init loop_init(void)
         if (max_loop > 1UL << (MINORBITS - part_shift))
                 return -EINVAL;
 
+        /*
+         * If max_loop is specified, create that many devices upfront.
+         * This also becomes a hard limit. If max_loop is not specified,
+         * create CONFIG_BLK_DEV_LOOP_MIN_COUNT loop devices at module
+         * init time. Loop devices can be requested on-demand with the
+         * /dev/loop-control interface, or be instantiated by accessing
+         * a 'dead' device node.
+         */
         if (max_loop) {
                 nr = max_loop;
                 range = max_loop << part_shift;
         } else {
-                nr = 8;
+                nr = CONFIG_BLK_DEV_LOOP_MIN_COUNT;
                 range = 1UL << MINORBITS;
         }
 
         if (register_blkdev(LOOP_MAJOR, "loop"))
                 return -EIO;
 
-        for (i = 0; i < nr; i++) {
-                lo = loop_alloc(i);
-                if (!lo)
-                        goto Enomem;
-                list_add_tail(&lo->lo_list, &loop_devices);
-        }
-
-        /* point of no return */
-
-        list_for_each_entry(lo, &loop_devices, lo_list)
-                add_disk(lo->lo_disk);
-
         blk_register_region(MKDEV(LOOP_MAJOR, 0), range,
                                   THIS_MODULE, loop_probe, NULL, NULL);
 
+        /* pre-create number of devices given by config or max_loop */
+        mutex_lock(&loop_index_mutex);
+        for (i = 0; i < nr; i++)
+                loop_add(&lo, i);
+        mutex_unlock(&loop_index_mutex);
+
         printk(KERN_INFO "loop: module loaded\n");
         return 0;
+}
 
-Enomem:
-        printk(KERN_INFO "loop: out of memory\n");
-
-        list_for_each_entry_safe(lo, next, &loop_devices, lo_list)
-                loop_free(lo);
+static int loop_exit_cb(int id, void *ptr, void *data)
+{
+        struct loop_device *lo = ptr;
 
-        unregister_blkdev(LOOP_MAJOR, "loop");
-        return -ENOMEM;
+        loop_remove(lo);
+        return 0;
 }
 
 static void __exit loop_exit(void)
 {
         unsigned long range;
-        struct loop_device *lo, *next;
 
         range = max_loop ? max_loop << part_shift : 1UL << MINORBITS;
 
-        list_for_each_entry_safe(lo, next, &loop_devices, lo_list)
-                loop_del_one(lo);
+        idr_for_each(&loop_index_idr, &loop_exit_cb, NULL);
+        idr_remove_all(&loop_index_idr);
+        idr_destroy(&loop_index_idr);
 
         blk_unregister_region(MKDEV(LOOP_MAJOR, 0), range);
         unregister_blkdev(LOOP_MAJOR, "loop");
+
+        misc_deregister(&loop_misc);
 }
 
 module_init(loop_init);
diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index 773bfa792777..ae3e167e17ad 100644
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -1184,6 +1184,7 @@ static struct of_device_id swim3_match[] =
         {
         .compatible     = "swim3"
         },
+        { /* end of list */ }
 };
 
 static struct macio_driver swim3_driver =
diff --git a/drivers/block/xen-blkback/common.h b/drivers/block/xen-blkback/common.h
index 9e40b283a468..00c57c90e2d6 100644
--- a/drivers/block/xen-blkback/common.h
+++ b/drivers/block/xen-blkback/common.h
@@ -46,7 +46,7 @@
 
 #define DRV_PFX "xen-blkback:"
 #define DPRINTK(fmt, args...)                           \
-        pr_debug(DRV_PFX "(%s:%d) " fmt ".\n",  \
+        pr_debug(DRV_PFX "(%s:%d) " fmt ".\n",          \
                  __func__, __LINE__, ##args)
 
 
diff --git a/drivers/block/xen-blkback/xenbus.c b/drivers/block/xen-blkback/xenbus.c
index 3f129b45451a..5fd2010f7d2b 100644
--- a/drivers/block/xen-blkback/xenbus.c
+++ b/drivers/block/xen-blkback/xenbus.c
@@ -590,7 +590,7 @@ static void frontend_changed(struct xenbus_device *dev,
 
                 /*
                  * Enforce precondition before potential leak point.
-                 * blkif_disconnect() is idempotent.
+                 * xen_blkif_disconnect() is idempotent.
                  */
                 xen_blkif_disconnect(be->blkif);
 
@@ -601,17 +601,17 @@ static void frontend_changed(struct xenbus_device *dev,
                 break;
 
         case XenbusStateClosing:
-                xen_blkif_disconnect(be->blkif);
                 xenbus_switch_state(dev, XenbusStateClosing);
                 break;
 
         case XenbusStateClosed:
+                xen_blkif_disconnect(be->blkif);
                 xenbus_switch_state(dev, XenbusStateClosed);
                 if (xenbus_dev_is_online(dev))
                         break;
                 /* fall through if not online */
         case XenbusStateUnknown:
-                /* implies blkif_disconnect() via blkback_remove() */
+                /* implies xen_blkif_disconnect() via xen_blkbk_remove() */
                 device_unregister(&dev->dev);
                 break;
 
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index b536a9cef917..9ea8c2576c70 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -123,8 +123,8 @@ static DEFINE_SPINLOCK(minor_lock);
 #define BLKIF_MINOR_EXT(dev) ((dev)&(~EXTENDED))
 #define EMULATED_HD_DISK_MINOR_OFFSET (0)
 #define EMULATED_HD_DISK_NAME_OFFSET (EMULATED_HD_DISK_MINOR_OFFSET / 256)
-#define EMULATED_SD_DISK_MINOR_OFFSET (EMULATED_HD_DISK_MINOR_OFFSET + (4 * 16))
-#define EMULATED_SD_DISK_NAME_OFFSET (EMULATED_HD_DISK_NAME_OFFSET + 4)
+#define EMULATED_SD_DISK_MINOR_OFFSET (0)
+#define EMULATED_SD_DISK_NAME_OFFSET (EMULATED_SD_DISK_MINOR_OFFSET / 256)
 
 #define DEV_NAME        "xvd"   /* name in /dev */
 
@@ -529,7 +529,7 @@ static int xlvbd_alloc_gendisk(blkif_sector_t capacity,
                 minor = BLKIF_MINOR_EXT(info->vdevice);
                 nr_parts = PARTS_PER_EXT_DISK;
                 offset = minor / nr_parts;
-                if (xen_hvm_domain() && offset <= EMULATED_HD_DISK_NAME_OFFSET + 4)
+                if (xen_hvm_domain() && offset < EMULATED_HD_DISK_NAME_OFFSET + 4)
                         printk(KERN_WARNING "blkfront: vdevice 0x%x might conflict with "
                                         "emulated IDE disks,\n\t choose an xvd device name"
                                         "from xvde on\n", info->vdevice);
diff --git a/drivers/bluetooth/ath3k.c b/drivers/bluetooth/ath3k.c
index a5854735bb2e..db7cb8111fbe 100644
--- a/drivers/bluetooth/ath3k.c
+++ b/drivers/bluetooth/ath3k.c
@@ -63,6 +63,7 @@ static struct usb_device_id ath3k_table[] = {
         /* Atheros AR3011 with sflash firmware*/
         { USB_DEVICE(0x0CF3, 0x3002) },
         { USB_DEVICE(0x13d3, 0x3304) },
+        { USB_DEVICE(0x0930, 0x0215) },
 
         /* Atheros AR9285 Malbec with sflash firmware */
         { USB_DEVICE(0x03F0, 0x311D) },
diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c
index 91d13a9e8c65..9cbac6b445e1 100644
--- a/drivers/bluetooth/btusb.c
+++ b/drivers/bluetooth/btusb.c
@@ -72,9 +72,15 @@ static struct usb_device_id btusb_table[] = {
         /* Apple MacBookAir3,1, MacBookAir3,2 */
         { USB_DEVICE(0x05ac, 0x821b) },
 
+        /* Apple MacBookAir4,1 */
+        { USB_DEVICE(0x05ac, 0x821f) },
+
         /* Apple MacBookPro8,2 */
         { USB_DEVICE(0x05ac, 0x821a) },
 
+        /* Apple MacMini5,1 */
+        { USB_DEVICE(0x05ac, 0x8281) },
+
         /* AVM BlueFRITZ! USB v2.0 */
         { USB_DEVICE(0x057c, 0x3800) },
 
@@ -106,6 +112,7 @@ static struct usb_device_id blacklist_table[] = {
         /* Atheros 3011 with sflash firmware */
         { USB_DEVICE(0x0cf3, 0x3002), .driver_info = BTUSB_IGNORE },
         { USB_DEVICE(0x13d3, 0x3304), .driver_info = BTUSB_IGNORE },
+        { USB_DEVICE(0x0930, 0x0215), .driver_info = BTUSB_IGNORE },
 
         /* Atheros AR9285 Malbec with sflash firmware */
         { USB_DEVICE(0x03f0, 0x311d), .driver_info = BTUSB_IGNORE },
@@ -256,7 +263,9 @@ static void btusb_intr_complete(struct urb *urb)
 
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err < 0) {
-                if (err != -EPERM)
+                /* -EPERM: urb is being killed;
+                 * -ENODEV: device got disconnected */
+                if (err != -EPERM && err != -ENODEV)
                         BT_ERR("%s urb %p failed to resubmit (%d)",
                                                 hdev->name, urb, -err);
                 usb_unanchor_urb(urb);
@@ -341,7 +350,9 @@ static void btusb_bulk_complete(struct urb *urb)
 
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err < 0) {
-                if (err != -EPERM)
+                /* -EPERM: urb is being killed;
+                 * -ENODEV: device got disconnected */
+                if (err != -EPERM && err != -ENODEV)
                         BT_ERR("%s urb %p failed to resubmit (%d)",
                                                 hdev->name, urb, -err);
                 usb_unanchor_urb(urb);
@@ -431,7 +442,9 @@ static void btusb_isoc_complete(struct urb *urb)
 
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err < 0) {
-                if (err != -EPERM)
+                /* -EPERM: urb is being killed;
+                 * -ENODEV: device got disconnected */
+                if (err != -EPERM && err != -ENODEV)
                         BT_ERR("%s urb %p failed to resubmit (%d)",
                                                 hdev->name, urb, -err);
                 usb_unanchor_urb(urb);
diff --git a/drivers/bluetooth/btwilink.c b/drivers/bluetooth/btwilink.c
index 65d27aff553a..04d353f58d71 100644
--- a/drivers/bluetooth/btwilink.c
+++ b/drivers/bluetooth/btwilink.c
@@ -125,6 +125,13 @@ static long st_receive(void *priv_data, struct sk_buff *skb)
 /* protocol structure registered with shared transport */
 static struct st_proto_s ti_st_proto[MAX_BT_CHNL_IDS] = {
         {
+                .chnl_id = HCI_EVENT_PKT, /* HCI Events */
+                .hdr_len = sizeof(struct hci_event_hdr),
+                .offset_len_in_hdr = offsetof(struct hci_event_hdr, plen),
+                .len_size = 1, /* sizeof(plen) in struct hci_event_hdr */
+                .reserve = 8,
+        },
+        {
                 .chnl_id = HCI_ACLDATA_PKT, /* ACL */
                 .hdr_len = sizeof(struct hci_acl_hdr),
                 .offset_len_in_hdr = offsetof(struct hci_acl_hdr, dlen),
@@ -138,13 +145,6 @@ static struct st_proto_s ti_st_proto[MAX_BT_CHNL_IDS] = {
                 .len_size = 1, /* sizeof(dlen) in struct hci_sco_hdr */
                 .reserve = 8,
         },
-        {
-                .chnl_id = HCI_EVENT_PKT, /* HCI Events */
-                .hdr_len = sizeof(struct hci_event_hdr),
-                .offset_len_in_hdr = offsetof(struct hci_event_hdr, plen),
-                .len_size = 1, /* sizeof(plen) in struct hci_event_hdr */
-                .reserve = 8,
-        },
 };
 
 /* Called from HCI core to initialize the device */
@@ -240,7 +240,7 @@ static int ti_st_close(struct hci_dev *hdev)
         if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
                 return 0;
 
-        for (i = 0; i < MAX_BT_CHNL_IDS; i++) {
+        for (i = MAX_BT_CHNL_IDS-1; i >= 0; i--) {
                 err = st_unregister(&ti_st_proto[i]);
                 if (err)
                         BT_ERR("st_unregister(%d) failed with error %d",
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index 75fb965b8f72..f997c27d79e2 100644
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -1929,11 +1929,17 @@ static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s,
                 goto out;
 
         s->manufact.len = buf[0] << 8 | buf[1];
-        if (s->manufact.len < 0 || s->manufact.len > 2048) {
+        if (s->manufact.len < 0) {
                 cdinfo(CD_WARNING, "Received invalid manufacture info length"
                                    " (%d)\n", s->manufact.len);
                 ret = -EIO;
         } else {
+                if (s->manufact.len > 2048) {
+                        cdinfo(CD_WARNING, "Received invalid manufacture info "
+                                        "length (%d): truncating to 2048\n",
+                                        s->manufact.len);
+                        s->manufact.len = 2048;
+                }
                 memcpy(s->manufact.value, &buf[4], s->manufact.len);
         }
 
diff --git a/drivers/char/msm_smd_pkt.c b/drivers/char/msm_smd_pkt.c
index b6f8a65c9960..8eca55deb3a3 100644
--- a/drivers/char/msm_smd_pkt.c
+++ b/drivers/char/msm_smd_pkt.c
@@ -379,9 +379,8 @@ static int __init smd_pkt_init(void)
         for (i = 0; i < NUM_SMD_PKT_PORTS; ++i) {
                 smd_pkt_devp[i] = kzalloc(sizeof(struct smd_pkt_dev),
                                           GFP_KERNEL);
-                if (IS_ERR(smd_pkt_devp[i])) {
-                        r = PTR_ERR(smd_pkt_devp[i]);
-                        pr_err("kmalloc() failed %d\n", r);
+                if (!smd_pkt_devp[i]) {
+                        pr_err("kmalloc() failed\n");
                         goto clean_cdevs;
                 }
 
diff --git a/drivers/char/tpm/Kconfig b/drivers/char/tpm/Kconfig
index f6595aba4f0f..fa567f1158c2 100644
--- a/drivers/char/tpm/Kconfig
+++ b/drivers/char/tpm/Kconfig
@@ -43,6 +43,7 @@ config TCG_NSC
 
 config TCG_ATMEL
         tristate "Atmel TPM Interface"
+        depends on PPC64 || HAS_IOPORT
         ---help---
           If you have a TPM security chip from Atmel say Yes and it 
           will be accessible from within Linux.  To compile this driver 
diff --git a/drivers/char/tpm/tpm.c b/drivers/char/tpm/tpm.c
index caf8012ef47c..9ca5c021d0b6 100644
--- a/drivers/char/tpm/tpm.c
+++ b/drivers/char/tpm/tpm.c
@@ -383,6 +383,9 @@ static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
         u32 count, ordinal;
         unsigned long stop;
 
+        if (bufsiz > TPM_BUFSIZE)
+                bufsiz = TPM_BUFSIZE;
+
         count = be32_to_cpu(*((__be32 *) (buf + 2)));
         ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
         if (count == 0)
@@ -1102,6 +1105,7 @@ ssize_t tpm_read(struct file *file, char __user *buf,
 {
         struct tpm_chip *chip = file->private_data;
         ssize_t ret_size;
+        int rc;
 
         del_singleshot_timer_sync(&chip->user_read_timer);
         flush_work_sync(&chip->work);
@@ -1112,8 +1116,11 @@ ssize_t tpm_read(struct file *file, char __user *buf,
                         ret_size = size;
 
                 mutex_lock(&chip->buffer_mutex);
-                if (copy_to_user(buf, chip->data_buffer, ret_size))
+                rc = copy_to_user(buf, chip->data_buffer, ret_size);
+                memset(chip->data_buffer, 0, ret_size);
+                if (rc)
                         ret_size = -EFAULT;
+
                 mutex_unlock(&chip->buffer_mutex);
         }
 
diff --git a/drivers/char/tpm/tpm_nsc.c b/drivers/char/tpm/tpm_nsc.c
index 82facc9104c7..4d2464871ada 100644
--- a/drivers/char/tpm/tpm_nsc.c
+++ b/drivers/char/tpm/tpm_nsc.c
@@ -396,8 +396,6 @@ static void __exit cleanup_nsc(void)
         if (pdev) {
                 tpm_nsc_remove(&pdev->dev);
                 platform_device_unregister(pdev);
-                kfree(pdev);
-                pdev = NULL;
         }
 
         platform_driver_unregister(&nsc_drv);
diff --git a/drivers/clocksource/sh_cmt.c b/drivers/clocksource/sh_cmt.c
index dc7c033ef587..32a77becc098 100644
--- a/drivers/clocksource/sh_cmt.c
+++ b/drivers/clocksource/sh_cmt.c
@@ -26,6 +26,7 @@
 #include <linux/clk.h>
 #include <linux/irq.h>
 #include <linux/err.h>
+#include <linux/delay.h>
 #include <linux/clocksource.h>
 #include <linux/clockchips.h>
 #include <linux/sh_timer.h>
@@ -150,13 +151,13 @@ static void sh_cmt_start_stop_ch(struct sh_cmt_priv *p, int start)
 
 static int sh_cmt_enable(struct sh_cmt_priv *p, unsigned long *rate)
 {
-        int ret;
+        int k, ret;
 
         /* enable clock */
         ret = clk_enable(p->clk);
         if (ret) {
                 dev_err(&p->pdev->dev, "cannot enable clock\n");
-                return ret;
+                goto err0;
         }
 
         /* make sure channel is disabled */
@@ -174,9 +175,38 @@ static int sh_cmt_enable(struct sh_cmt_priv *p, unsigned long *rate)
         sh_cmt_write(p, CMCOR, 0xffffffff);
         sh_cmt_write(p, CMCNT, 0);
 
+        /*
+         * According to the sh73a0 user's manual, as CMCNT can be operated
+         * only by the RCLK (Pseudo 32 KHz), there's one restriction on
+         * modifying CMCNT register; two RCLK cycles are necessary before
+         * this register is either read or any modification of the value
+         * it holds is reflected in the LSI's actual operation.
+         *
+         * While at it, we're supposed to clear out the CMCNT as of this
+         * moment, so make sure it's processed properly here.  This will
+         * take RCLKx2 at maximum.
+         */
+        for (k = 0; k < 100; k++) {
+                if (!sh_cmt_read(p, CMCNT))
+                        break;
+                udelay(1);
+        }
+
+        if (sh_cmt_read(p, CMCNT)) {
+                dev_err(&p->pdev->dev, "cannot clear CMCNT\n");
+                ret = -ETIMEDOUT;
+                goto err1;
+        }
+
         /* enable channel */
         sh_cmt_start_stop_ch(p, 1);
         return 0;
+ err1:
+        /* stop clock */
+        clk_disable(p->clk);
+
+ err0:
+        return ret;
 }
 
 static void sh_cmt_disable(struct sh_cmt_priv *p)
diff --git a/drivers/cpufreq/pcc-cpufreq.c b/drivers/cpufreq/pcc-cpufreq.c
index 7b0603eb0129..cdc02ac8f41a 100644
--- a/drivers/cpufreq/pcc-cpufreq.c
+++ b/drivers/cpufreq/pcc-cpufreq.c
@@ -261,6 +261,9 @@ static int pcc_get_offset(int cpu)
         pr = per_cpu(processors, cpu);
         pcc_cpu_data = per_cpu_ptr(pcc_cpu_info, cpu);
 
+        if (!pr)
+                return -ENODEV;
+
         status = acpi_evaluate_object(pr->handle, "PCCP", NULL, &buffer);
         if (ACPI_FAILURE(status))
                 return -ENODEV;
diff --git a/drivers/dma/amba-pl08x.c b/drivers/dma/amba-pl08x.c
index 196a7378d332..be21e3f138a8 100644
--- a/drivers/dma/amba-pl08x.c
+++ b/drivers/dma/amba-pl08x.c
@@ -80,6 +80,7 @@
 #include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
+#include <linux/dma-mapping.h>
 #include <linux/dmapool.h>
 #include <linux/dmaengine.h>
 #include <linux/amba/bus.h>
diff --git a/drivers/dma/ste_dma40.c b/drivers/dma/ste_dma40.c
index cd3a7c726bf8..467e4dcb20a0 100644
--- a/drivers/dma/ste_dma40.c
+++ b/drivers/dma/ste_dma40.c
@@ -174,8 +174,10 @@ struct d40_base;
  * @tasklet: Tasklet that gets scheduled from interrupt context to complete a
  * transfer and call client callback.
  * @client: Cliented owned descriptor list.
+ * @pending_queue: Submitted jobs, to be issued by issue_pending()
  * @active: Active descriptor.
  * @queue: Queued jobs.
+ * @prepare_queue: Prepared jobs.
  * @dma_cfg: The client configuration of this dma channel.
  * @configured: whether the dma_cfg configuration is valid
  * @base: Pointer to the device instance struct.
@@ -203,6 +205,7 @@ struct d40_chan {
         struct list_head                 pending_queue;
         struct list_head                 active;
         struct list_head                 queue;
+        struct list_head                 prepare_queue;
         struct stedma40_chan_cfg         dma_cfg;
         bool                             configured;
         struct d40_base                 *base;
@@ -477,7 +480,6 @@ static struct d40_desc *d40_desc_get(struct d40_chan *d40c)
 
                 list_for_each_entry_safe(d, _d, &d40c->client, node)
                         if (async_tx_test_ack(&d->txd)) {
-                                d40_pool_lli_free(d40c, d);
                                 d40_desc_remove(d);
                                 desc = d;
                                 memset(desc, 0, sizeof(*desc));
@@ -644,8 +646,11 @@ static struct d40_desc *d40_first_active_get(struct d40_chan *d40c)
         return d;
 }
 
+/* remove desc from current queue and add it to the pending_queue */
 static void d40_desc_queue(struct d40_chan *d40c, struct d40_desc *desc)
 {
+        d40_desc_remove(desc);
+        desc->is_in_client_list = false;
         list_add_tail(&desc->node, &d40c->pending_queue);
 }
 
@@ -803,6 +808,7 @@ done:
 static void d40_term_all(struct d40_chan *d40c)
 {
         struct d40_desc *d40d;
+        struct d40_desc *_d;
 
         /* Release active descriptors */
         while ((d40d = d40_first_active_get(d40c))) {
@@ -822,6 +828,21 @@ static void d40_term_all(struct d40_chan *d40c)
                 d40_desc_free(d40c, d40d);
         }
 
+        /* Release client owned descriptors */
+        if (!list_empty(&d40c->client))
+                list_for_each_entry_safe(d40d, _d, &d40c->client, node) {
+                        d40_desc_remove(d40d);
+                        d40_desc_free(d40c, d40d);
+                }
+
+        /* Release descriptors in prepare queue */
+        if (!list_empty(&d40c->prepare_queue))
+                list_for_each_entry_safe(d40d, _d,
+                                         &d40c->prepare_queue, node) {
+                        d40_desc_remove(d40d);
+                        d40_desc_free(d40c, d40d);
+                }
+
         d40c->pending_tx = 0;
         d40c->busy = false;
 }
@@ -1208,7 +1229,6 @@ static void dma_tasklet(unsigned long data)
 
         if (!d40d->cyclic) {
                 if (async_tx_test_ack(&d40d->txd)) {
-                        d40_pool_lli_free(d40c, d40d);
                         d40_desc_remove(d40d);
                         d40_desc_free(d40c, d40d);
                 } else {
@@ -1595,21 +1615,10 @@ static int d40_free_dma(struct d40_chan *d40c)
         u32 event;
         struct d40_phy_res *phy = d40c->phy_chan;
         bool is_src;
-        struct d40_desc *d;
-        struct d40_desc *_d;
-
 
         /* Terminate all queued and active transfers */
         d40_term_all(d40c);
 
-        /* Release client owned descriptors */
-        if (!list_empty(&d40c->client))
-                list_for_each_entry_safe(d, _d, &d40c->client, node) {
-                        d40_pool_lli_free(d40c, d);
-                        d40_desc_remove(d);
-                        d40_desc_free(d40c, d);
-                }
-
         if (phy == NULL) {
                 chan_err(d40c, "phy == null\n");
                 return -EINVAL;
@@ -1911,6 +1920,12 @@ d40_prep_sg(struct dma_chan *dchan, struct scatterlist *sg_src,
                 goto err;
         }
 
+        /*
+         * add descriptor to the prepare queue in order to be able
+         * to free them later in terminate_all
+         */
+        list_add_tail(&desc->node, &chan->prepare_queue);
+
         spin_unlock_irqrestore(&chan->lock, flags);
 
         return &desc->txd;
@@ -2400,6 +2415,7 @@ static void __init d40_chan_init(struct d40_base *base, struct dma_device *dma,
                 INIT_LIST_HEAD(&d40c->queue);
                 INIT_LIST_HEAD(&d40c->pending_queue);
                 INIT_LIST_HEAD(&d40c->client);
+                INIT_LIST_HEAD(&d40c->prepare_queue);
 
                 tasklet_init(&d40c->tasklet, dma_tasklet,
                              (unsigned long) d40c);
diff --git a/drivers/edac/i7core_edac.c b/drivers/edac/i7core_edac.c
index 04f1e7ce02b1..f6cf448d69b4 100644
--- a/drivers/edac/i7core_edac.c
+++ b/drivers/edac/i7core_edac.c
@@ -1670,7 +1670,7 @@ static void i7core_mce_output_error(struct mem_ctl_info *mci,
         char *type, *optype, *err, *msg;
         unsigned long error = m->status & 0x1ff0000l;
         u32 optypenum = (m->status >> 4) & 0x07;
-        u32 core_err_cnt = (m->status >> 38) && 0x7fff;
+        u32 core_err_cnt = (m->status >> 38) & 0x7fff;
         u32 dimm = (m->misc >> 16) & 0x3;
         u32 channel = (m->misc >> 18) & 0x3;
         u32 syndrome = m->misc >> 32;
diff --git a/drivers/firewire/core-cdev.c b/drivers/firewire/core-cdev.c
index e6ad3bb6c1a6..4799393247c8 100644
--- a/drivers/firewire/core-cdev.c
+++ b/drivers/firewire/core-cdev.c
@@ -216,15 +216,33 @@ struct inbound_phy_packet_event {
         struct fw_cdev_event_phy_packet phy_packet;
 };
 
-static inline void __user *u64_to_uptr(__u64 value)
+#ifdef CONFIG_COMPAT
+static void __user *u64_to_uptr(u64 value)
+{
+        if (is_compat_task())
+                return compat_ptr(value);
+        else
+                return (void __user *)(unsigned long)value;
+}
+
+static u64 uptr_to_u64(void __user *ptr)
+{
+        if (is_compat_task())
+                return ptr_to_compat(ptr);
+        else
+                return (u64)(unsigned long)ptr;
+}
+#else
+static inline void __user *u64_to_uptr(u64 value)
 {
         return (void __user *)(unsigned long)value;
 }
 
-static inline __u64 uptr_to_u64(void __user *ptr)
+static inline u64 uptr_to_u64(void __user *ptr)
 {
-        return (__u64)(unsigned long)ptr;
+        return (u64)(unsigned long)ptr;
 }
+#endif /* CONFIG_COMPAT */
 
 static int fw_device_op_open(struct inode *inode, struct file *file)
 {
diff --git a/drivers/firewire/core-device.c b/drivers/firewire/core-device.c
index 8ba7f7928f1f..f3b890da1e87 100644
--- a/drivers/firewire/core-device.c
+++ b/drivers/firewire/core-device.c
@@ -455,15 +455,20 @@ static struct device_attribute fw_device_attributes[] = {
 static int read_rom(struct fw_device *device,
                     int generation, int index, u32 *data)
 {
-        int rcode;
+        u64 offset = (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + index * 4;
+        int i, rcode;
 
         /* device->node_id, accessed below, must not be older than generation */
         smp_rmb();
 
-        rcode = fw_run_transaction(device->card, TCODE_READ_QUADLET_REQUEST,
-                        device->node_id, generation, device->max_speed,
-                        (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + index * 4,
-                        data, 4);
+        for (i = 10; i < 100; i += 10) {
+                rcode = fw_run_transaction(device->card,
+                                TCODE_READ_QUADLET_REQUEST, device->node_id,
+                                generation, device->max_speed, offset, data, 4);
+                if (rcode != RCODE_BUSY)
+                        break;
+                msleep(i);
+        }
         be32_to_cpus(data);
 
         return rcode;
diff --git a/drivers/firewire/ohci.c b/drivers/firewire/ohci.c
index bcf792fac442..fd7170a9ad2c 100644
--- a/drivers/firewire/ohci.c
+++ b/drivers/firewire/ohci.c
@@ -290,6 +290,9 @@ static const struct {
         {PCI_VENDOR_ID_NEC, PCI_ANY_ID, PCI_ANY_ID,
                 QUIRK_CYCLE_TIMER},
 
+        {PCI_VENDOR_ID_O2, PCI_ANY_ID, PCI_ANY_ID,
+                QUIRK_NO_MSI},
+
         {PCI_VENDOR_ID_RICOH, PCI_ANY_ID, PCI_ANY_ID,
                 QUIRK_CYCLE_TIMER},
 
@@ -2179,8 +2182,13 @@ static int ohci_enable(struct fw_card *card,
                         ohci_driver_name, ohci)) {
                 fw_error("Failed to allocate interrupt %d.\n", dev->irq);
                 pci_disable_msi(dev);
-                dma_free_coherent(ohci->card.device, CONFIG_ROM_SIZE,
-                                  ohci->config_rom, ohci->config_rom_bus);
+
+                if (config_rom) {
+                        dma_free_coherent(ohci->card.device, CONFIG_ROM_SIZE,
+                                          ohci->next_config_rom,
+                                          ohci->next_config_rom_bus);
+                        ohci->next_config_rom = NULL;
+                }
                 return -EIO;
         }
 
diff --git a/drivers/firewire/sbp2.c b/drivers/firewire/sbp2.c
index 41841a3e3f99..17cef864506a 100644
--- a/drivers/firewire/sbp2.c
+++ b/drivers/firewire/sbp2.c
@@ -1198,6 +1198,10 @@ static int sbp2_remove(struct device *dev)
 {
         struct fw_unit *unit = fw_unit(dev);
         struct sbp2_target *tgt = dev_get_drvdata(&unit->device);
+        struct sbp2_logical_unit *lu;
+
+        list_for_each_entry(lu, &tgt->lu_list, link)
+                cancel_delayed_work_sync(&lu->work);
 
         sbp2_target_put(tgt);
         return 0;
diff --git a/drivers/firmware/google/gsmi.c b/drivers/firmware/google/gsmi.c
index 68810fd1a59d..aa83de9db1b9 100644
--- a/drivers/firmware/google/gsmi.c
+++ b/drivers/firmware/google/gsmi.c
@@ -420,7 +420,7 @@ static efi_status_t gsmi_get_next_variable(unsigned long *name_size,
 
 static efi_status_t gsmi_set_variable(efi_char16_t *name,
                                       efi_guid_t *vendor,
-                                      unsigned long attr,
+                                      u32 attr,
                                       unsigned long data_size,
                                       void *data)
 {
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index d539efd96d4b..4caa3d37bbde 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -178,6 +178,15 @@ config GPIO_SCH
           The Intel Tunnel Creek processor has 5 GPIOs powered by the
           core power rail and 9 from suspend power supply.
 
+config GPIO_U300
+        bool "ST-Ericsson U300 COH 901 335/571 GPIO"
+        depends on GPIOLIB && ARCH_U300
+        help
+          Say yes here to support GPIO interface on ST-Ericsson U300.
+          The names of the two IP block variants supported are
+          COH 901 335 and COH 901 571/3. They contain 3, 5 or 7
+          ports of 8 GPIO pins each.
+
 config GPIO_VX855
         tristate "VIA VX855/VX875 GPIO"
         depends on MFD_SUPPORT && PCI
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 9588948c96f0..19c5d27b6d2e 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -14,11 +14,14 @@ obj-$(CONFIG_GPIO_ADP5588)	+= gpio-adp5588.o
 obj-$(CONFIG_GPIO_BT8XX)        += gpio-bt8xx.o
 obj-$(CONFIG_GPIO_CS5535)       += gpio-cs5535.o
 obj-$(CONFIG_GPIO_DA9052)       += gpio-da9052.o
+obj-$(CONFIG_ARCH_DAVINCI)      += gpio-davinci.o
 obj-$(CONFIG_GPIO_EP93XX)       += gpio-ep93xx.o
 obj-$(CONFIG_GPIO_EXYNOS4)      += gpio-exynos4.o
 obj-$(CONFIG_GPIO_IT8761E)      += gpio-it8761e.o
 obj-$(CONFIG_GPIO_JANZ_TTL)     += gpio-janz-ttl.o
+obj-$(CONFIG_MACH_KS8695)       += gpio-ks8695.o
 obj-$(CONFIG_GPIO_LANGWELL)     += gpio-langwell.o
+obj-$(CONFIG_ARCH_LPC32XX)      += gpio-lpc32xx.o
 obj-$(CONFIG_GPIO_MAX730X)      += gpio-max730x.o
 obj-$(CONFIG_GPIO_MAX7300)      += gpio-max7300.o
 obj-$(CONFIG_GPIO_MAX7301)      += gpio-max7301.o
@@ -37,18 +40,20 @@ obj-$(CONFIG_GPIO_PCA953X)	+= gpio-pca953x.o
 obj-$(CONFIG_GPIO_PCF857X)      += gpio-pcf857x.o
 obj-$(CONFIG_GPIO_PCH)          += gpio-pch.o
 obj-$(CONFIG_GPIO_PL061)        += gpio-pl061.o
+obj-$(CONFIG_PLAT_PXA)          += gpio-pxa.o
 obj-$(CONFIG_GPIO_RDC321X)      += gpio-rdc321x.o
 
 obj-$(CONFIG_GPIO_PLAT_SAMSUNG) += gpio-plat-samsung.o
 obj-$(CONFIG_GPIO_S5PC100)      += gpio-s5pc100.o
 obj-$(CONFIG_GPIO_S5PV210)      += gpio-s5pv210.o
-
+obj-$(CONFIG_ARCH_SA1100)       += gpio-sa1100.o
 obj-$(CONFIG_GPIO_SCH)          += gpio-sch.o
 obj-$(CONFIG_GPIO_STMPE)        += gpio-stmpe.o
 obj-$(CONFIG_GPIO_SX150X)       += gpio-sx150x.o
 obj-$(CONFIG_GPIO_TC3589X)      += gpio-tc3589x.o
 obj-$(CONFIG_ARCH_TEGRA)        += gpio-tegra.o
 obj-$(CONFIG_GPIO_TIMBERDALE)   += gpio-timberdale.o
+obj-$(CONFIG_ARCH_DAVINCI_TNETV107X) += gpio-tnetv107x.o
 obj-$(CONFIG_GPIO_TPS65910)     += gpio-tps65910.o
 obj-$(CONFIG_GPIO_TPS65912)     += gpio-tps65912.o
 obj-$(CONFIG_GPIO_TWL4030)      += gpio-twl4030.o
diff --git a/drivers/gpio/gpio-davinci.c b/drivers/gpio/gpio-davinci.c
new file mode 100644
index 000000000000..df0d59570a84
--- /dev/null
+++ b/drivers/gpio/gpio-davinci.c
@@ -0,0 +1,455 @@
+/*
+ * TI DaVinci GPIO Support
+ *
+ * Copyright (c) 2006-2007 David Brownell
+ * Copyright (c) 2007, MontaVista Software, Inc. <source@mvista.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+#include <linux/gpio.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/io.h>
+
+#include <asm/mach/irq.h>
+
+struct davinci_gpio_regs {
+        u32     dir;
+        u32     out_data;
+        u32     set_data;
+        u32     clr_data;
+        u32     in_data;
+        u32     set_rising;
+        u32     clr_rising;
+        u32     set_falling;
+        u32     clr_falling;
+        u32     intstat;
+};
+
+#define chip2controller(chip)   \
+        container_of(chip, struct davinci_gpio_controller, chip)
+
+static struct davinci_gpio_controller chips[DIV_ROUND_UP(DAVINCI_N_GPIO, 32)];
+static void __iomem *gpio_base;
+
+static struct davinci_gpio_regs __iomem __init *gpio2regs(unsigned gpio)
+{
+        void __iomem *ptr;
+
+        if (gpio < 32 * 1)
+                ptr = gpio_base + 0x10;
+        else if (gpio < 32 * 2)
+                ptr = gpio_base + 0x38;
+        else if (gpio < 32 * 3)
+                ptr = gpio_base + 0x60;
+        else if (gpio < 32 * 4)
+                ptr = gpio_base + 0x88;
+        else if (gpio < 32 * 5)
+                ptr = gpio_base + 0xb0;
+        else
+                ptr = NULL;
+        return ptr;
+}
+
+static inline struct davinci_gpio_regs __iomem *irq2regs(int irq)
+{
+        struct davinci_gpio_regs __iomem *g;
+
+        g = (__force struct davinci_gpio_regs __iomem *)irq_get_chip_data(irq);
+
+        return g;
+}
+
+static int __init davinci_gpio_irq_setup(void);
+
+/*--------------------------------------------------------------------------*/
+
+/* board setup code *MUST* setup pinmux and enable the GPIO clock. */
+static inline int __davinci_direction(struct gpio_chip *chip,
+                        unsigned offset, bool out, int value)
+{
+        struct davinci_gpio_controller *d = chip2controller(chip);
+        struct davinci_gpio_regs __iomem *g = d->regs;
+        unsigned long flags;
+        u32 temp;
+        u32 mask = 1 << offset;
+
+        spin_lock_irqsave(&d->lock, flags);
+        temp = __raw_readl(&g->dir);
+        if (out) {
+                temp &= ~mask;
+                __raw_writel(mask, value ? &g->set_data : &g->clr_data);
+        } else {
+                temp |= mask;
+        }
+        __raw_writel(temp, &g->dir);
+        spin_unlock_irqrestore(&d->lock, flags);
+
+        return 0;
+}
+
+static int davinci_direction_in(struct gpio_chip *chip, unsigned offset)
+{
+        return __davinci_direction(chip, offset, false, 0);
+}
+
+static int
+davinci_direction_out(struct gpio_chip *chip, unsigned offset, int value)
+{
+        return __davinci_direction(chip, offset, true, value);
+}
+
+/*
+ * Read the pin's value (works even if it's set up as output);
+ * returns zero/nonzero.
+ *
+ * Note that changes are synched to the GPIO clock, so reading values back
+ * right after you've set them may give old values.
+ */
+static int davinci_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        struct davinci_gpio_controller *d = chip2controller(chip);
+        struct davinci_gpio_regs __iomem *g = d->regs;
+
+        return (1 << offset) & __raw_readl(&g->in_data);
+}
+
+/*
+ * Assuming the pin is muxed as a gpio output, set its output value.
+ */
+static void
+davinci_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+        struct davinci_gpio_controller *d = chip2controller(chip);
+        struct davinci_gpio_regs __iomem *g = d->regs;
+
+        __raw_writel((1 << offset), value ? &g->set_data : &g->clr_data);
+}
+
+static int __init davinci_gpio_setup(void)
+{
+        int i, base;
+        unsigned ngpio;
+        struct davinci_soc_info *soc_info = &davinci_soc_info;
+        struct davinci_gpio_regs *regs;
+
+        if (soc_info->gpio_type != GPIO_TYPE_DAVINCI)
+                return 0;
+
+        /*
+         * The gpio banks conceptually expose a segmented bitmap,
+         * and "ngpio" is one more than the largest zero-based
+         * bit index that's valid.
+         */
+        ngpio = soc_info->gpio_num;
+        if (ngpio == 0) {
+                pr_err("GPIO setup:  how many GPIOs?\n");
+                return -EINVAL;
+        }
+
+        if (WARN_ON(DAVINCI_N_GPIO < ngpio))
+                ngpio = DAVINCI_N_GPIO;
+
+        gpio_base = ioremap(soc_info->gpio_base, SZ_4K);
+        if (WARN_ON(!gpio_base))
+                return -ENOMEM;
+
+        for (i = 0, base = 0; base < ngpio; i++, base += 32) {
+                chips[i].chip.label = "DaVinci";
+
+                chips[i].chip.direction_input = davinci_direction_in;
+                chips[i].chip.get = davinci_gpio_get;
+                chips[i].chip.direction_output = davinci_direction_out;
+                chips[i].chip.set = davinci_gpio_set;
+
+                chips[i].chip.base = base;
+                chips[i].chip.ngpio = ngpio - base;
+                if (chips[i].chip.ngpio > 32)
+                        chips[i].chip.ngpio = 32;
+
+                spin_lock_init(&chips[i].lock);
+
+                regs = gpio2regs(base);
+                chips[i].regs = regs;
+                chips[i].set_data = &regs->set_data;
+                chips[i].clr_data = &regs->clr_data;
+                chips[i].in_data = &regs->in_data;
+
+                gpiochip_add(&chips[i].chip);
+        }
+
+        soc_info->gpio_ctlrs = chips;
+        soc_info->gpio_ctlrs_num = DIV_ROUND_UP(ngpio, 32);
+
+        davinci_gpio_irq_setup();
+        return 0;
+}
+pure_initcall(davinci_gpio_setup);
+
+/*--------------------------------------------------------------------------*/
+/*
+ * We expect irqs will normally be set up as input pins, but they can also be
+ * used as output pins ... which is convenient for testing.
+ *
+ * NOTE:  The first few GPIOs also have direct INTC hookups in addition
+ * to their GPIOBNK0 irq, with a bit less overhead.
+ *
+ * All those INTC hookups (direct, plus several IRQ banks) can also
+ * serve as EDMA event triggers.
+ */
+
+static void gpio_irq_disable(struct irq_data *d)
+{
+        struct davinci_gpio_regs __iomem *g = irq2regs(d->irq);
+        u32 mask = (u32) irq_data_get_irq_handler_data(d);
+
+        __raw_writel(mask, &g->clr_falling);
+        __raw_writel(mask, &g->clr_rising);
+}
+
+static void gpio_irq_enable(struct irq_data *d)
+{
+        struct davinci_gpio_regs __iomem *g = irq2regs(d->irq);
+        u32 mask = (u32) irq_data_get_irq_handler_data(d);
+        unsigned status = irqd_get_trigger_type(d);
+
+        status &= IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING;
+        if (!status)
+                status = IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING;
+
+        if (status & IRQ_TYPE_EDGE_FALLING)
+                __raw_writel(mask, &g->set_falling);
+        if (status & IRQ_TYPE_EDGE_RISING)
+                __raw_writel(mask, &g->set_rising);
+}
+
+static int gpio_irq_type(struct irq_data *d, unsigned trigger)
+{
+        if (trigger & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
+                return -EINVAL;
+
+        return 0;
+}
+
+static struct irq_chip gpio_irqchip = {
+        .name           = "GPIO",
+        .irq_enable     = gpio_irq_enable,
+        .irq_disable    = gpio_irq_disable,
+        .irq_set_type   = gpio_irq_type,
+        .flags          = IRQCHIP_SET_TYPE_MASKED,
+};
+
+static void
+gpio_irq_handler(unsigned irq, struct irq_desc *desc)
+{
+        struct davinci_gpio_regs __iomem *g;
+        u32 mask = 0xffff;
+        struct davinci_gpio_controller *d;
+
+        d = (struct davinci_gpio_controller *)irq_desc_get_handler_data(desc);
+        g = (struct davinci_gpio_regs __iomem *)d->regs;
+
+        /* we only care about one bank */
+        if (irq & 1)
+                mask <<= 16;
+
+        /* temporarily mask (level sensitive) parent IRQ */
+        desc->irq_data.chip->irq_mask(&desc->irq_data);
+        desc->irq_data.chip->irq_ack(&desc->irq_data);
+        while (1) {
+                u32             status;
+                int             n;
+                int             res;
+
+                /* ack any irqs */
+                status = __raw_readl(&g->intstat) & mask;
+                if (!status)
+                        break;
+                __raw_writel(status, &g->intstat);
+
+                /* now demux them to the right lowlevel handler */
+                n = d->irq_base;
+                if (irq & 1) {
+                        n += 16;
+                        status >>= 16;
+                }
+
+                while (status) {
+                        res = ffs(status);
+                        n += res;
+                        generic_handle_irq(n - 1);
+                        status >>= res;
+                }
+        }
+        desc->irq_data.chip->irq_unmask(&desc->irq_data);
+        /* now it may re-trigger */
+}
+
+static int gpio_to_irq_banked(struct gpio_chip *chip, unsigned offset)
+{
+        struct davinci_gpio_controller *d = chip2controller(chip);
+
+        if (d->irq_base >= 0)
+                return d->irq_base + offset;
+        else
+                return -ENODEV;
+}
+
+static int gpio_to_irq_unbanked(struct gpio_chip *chip, unsigned offset)
+{
+        struct davinci_soc_info *soc_info = &davinci_soc_info;
+
+        /* NOTE:  we assume for now that only irqs in the first gpio_chip
+         * can provide direct-mapped IRQs to AINTC (up to 32 GPIOs).
+         */
+        if (offset < soc_info->gpio_unbanked)
+                return soc_info->gpio_irq + offset;
+        else
+                return -ENODEV;
+}
+
+static int gpio_irq_type_unbanked(struct irq_data *d, unsigned trigger)
+{
+        struct davinci_gpio_regs __iomem *g = irq2regs(d->irq);
+        u32 mask = (u32) irq_data_get_irq_handler_data(d);
+
+        if (trigger & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
+                return -EINVAL;
+
+        __raw_writel(mask, (trigger & IRQ_TYPE_EDGE_FALLING)
+                     ? &g->set_falling : &g->clr_falling);
+        __raw_writel(mask, (trigger & IRQ_TYPE_EDGE_RISING)
+                     ? &g->set_rising : &g->clr_rising);
+
+        return 0;
+}
+
+/*
+ * NOTE:  for suspend/resume, probably best to make a platform_device with
+ * suspend_late/resume_resume calls hooking into results of the set_wake()
+ * calls ... so if no gpios are wakeup events the clock can be disabled,
+ * with outputs left at previously set levels, and so that VDD3P3V.IOPWDN0
+ * (dm6446) can be set appropriately for GPIOV33 pins.
+ */
+
+static int __init davinci_gpio_irq_setup(void)
+{
+        unsigned        gpio, irq, bank;
+        struct clk      *clk;
+        u32             binten = 0;
+        unsigned        ngpio, bank_irq;
+        struct davinci_soc_info *soc_info = &davinci_soc_info;
+        struct davinci_gpio_regs        __iomem *g;
+
+        ngpio = soc_info->gpio_num;
+
+        bank_irq = soc_info->gpio_irq;
+        if (bank_irq == 0) {
+                printk(KERN_ERR "Don't know first GPIO bank IRQ.\n");
+                return -EINVAL;
+        }
+
+        clk = clk_get(NULL, "gpio");
+        if (IS_ERR(clk)) {
+                printk(KERN_ERR "Error %ld getting gpio clock?\n",
+                       PTR_ERR(clk));
+                return PTR_ERR(clk);
+        }
+        clk_enable(clk);
+
+        /* Arrange gpio_to_irq() support, handling either direct IRQs or
+         * banked IRQs.  Having GPIOs in the first GPIO bank use direct
+         * IRQs, while the others use banked IRQs, would need some setup
+         * tweaks to recognize hardware which can do that.
+         */
+        for (gpio = 0, bank = 0; gpio < ngpio; bank++, gpio += 32) {
+                chips[bank].chip.to_irq = gpio_to_irq_banked;
+                chips[bank].irq_base = soc_info->gpio_unbanked
+                        ? -EINVAL
+                        : (soc_info->intc_irq_num + gpio);
+        }
+
+        /*
+         * AINTC can handle direct/unbanked IRQs for GPIOs, with the GPIO
+         * controller only handling trigger modes.  We currently assume no
+         * IRQ mux conflicts; gpio_irq_type_unbanked() is only for GPIOs.
+         */
+        if (soc_info->gpio_unbanked) {
+                static struct irq_chip gpio_irqchip_unbanked;
+
+                /* pass "bank 0" GPIO IRQs to AINTC */
+                chips[0].chip.to_irq = gpio_to_irq_unbanked;
+                binten = BIT(0);
+
+                /* AINTC handles mask/unmask; GPIO handles triggering */
+                irq = bank_irq;
+                gpio_irqchip_unbanked = *irq_get_chip(irq);
+                gpio_irqchip_unbanked.name = "GPIO-AINTC";
+                gpio_irqchip_unbanked.irq_set_type = gpio_irq_type_unbanked;
+
+                /* default trigger: both edges */
+                g = gpio2regs(0);
+                __raw_writel(~0, &g->set_falling);
+                __raw_writel(~0, &g->set_rising);
+
+                /* set the direct IRQs up to use that irqchip */
+                for (gpio = 0; gpio < soc_info->gpio_unbanked; gpio++, irq++) {
+                        irq_set_chip(irq, &gpio_irqchip_unbanked);
+                        irq_set_handler_data(irq, (void *)__gpio_mask(gpio));
+                        irq_set_chip_data(irq, (__force void *)g);
+                        irq_set_status_flags(irq, IRQ_TYPE_EDGE_BOTH);
+                }
+
+                goto done;
+        }
+
+        /*
+         * Or, AINTC can handle IRQs for banks of 16 GPIO IRQs, which we
+         * then chain through our own handler.
+         */
+        for (gpio = 0, irq = gpio_to_irq(0), bank = 0;
+                        gpio < ngpio;
+                        bank++, bank_irq++) {
+                unsigned                i;
+
+                /* disabled by default, enabled only as needed */
+                g = gpio2regs(gpio);
+                __raw_writel(~0, &g->clr_falling);
+                __raw_writel(~0, &g->clr_rising);
+
+                /* set up all irqs in this bank */
+                irq_set_chained_handler(bank_irq, gpio_irq_handler);
+
+                /*
+                 * Each chip handles 32 gpios, and each irq bank consists of 16
+                 * gpio irqs. Pass the irq bank's corresponding controller to
+                 * the chained irq handler.
+                 */
+                irq_set_handler_data(bank_irq, &chips[gpio / 32]);
+
+                for (i = 0; i < 16 && gpio < ngpio; i++, irq++, gpio++) {
+                        irq_set_chip(irq, &gpio_irqchip);
+                        irq_set_chip_data(irq, (__force void *)g);
+                        irq_set_handler_data(irq, (void *)__gpio_mask(gpio));
+                        irq_set_handler(irq, handle_simple_irq);
+                        set_irq_flags(irq, IRQF_VALID);
+                }
+
+                binten |= BIT(bank);
+        }
+
+done:
+        /* BINTEN -- per-bank interrupt enable. genirq would also let these
+         * bits be set/cleared dynamically.
+         */
+        __raw_writel(binten, gpio_base + 0x08);
+
+        printk(KERN_INFO "DaVinci: %d gpio irqs\n", irq - gpio_to_irq(0));
+
+        return 0;
+}
diff --git a/drivers/gpio/gpio-ep93xx.c b/drivers/gpio/gpio-ep93xx.c
index 72fb9c665320..7aafbb437339 100644
--- a/drivers/gpio/gpio-ep93xx.c
+++ b/drivers/gpio/gpio-ep93xx.c
@@ -23,6 +23,9 @@
 #include <linux/basic_mmio_gpio.h>
 
 #include <mach/hardware.h>
+#include <mach/gpio-ep93xx.h>
+
+#define irq_to_gpio(irq)        ((irq) - gpio_to_irq(0))
 
 struct ep93xx_gpio {
         void __iomem            *mmio_base;
@@ -307,6 +310,21 @@ static int ep93xx_gpio_set_debounce(struct gpio_chip *chip,
         return 0;
 }
 
+/*
+ * Map GPIO A0..A7  (0..7)  to irq 64..71,
+ *          B0..B7  (7..15) to irq 72..79, and
+ *          F0..F7 (16..24) to irq 80..87.
+ */
+static int ep93xx_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
+{
+        int gpio = chip->base + offset;
+
+        if (gpio > EP93XX_GPIO_LINE_MAX_IRQ)
+                return -EINVAL;
+
+        return 64 + gpio;
+}
+
 static int ep93xx_gpio_add_bank(struct bgpio_chip *bgc, struct device *dev,
         void __iomem *mmio_base, struct ep93xx_gpio_bank *bank)
 {
@@ -321,8 +339,10 @@ static int ep93xx_gpio_add_bank(struct bgpio_chip *bgc, struct device *dev,
         bgc->gc.label = bank->label;
         bgc->gc.base = bank->base;
 
-        if (bank->has_debounce)
+        if (bank->has_debounce) {
                 bgc->gc.set_debounce = ep93xx_gpio_set_debounce;
+                bgc->gc.to_irq = ep93xx_gpio_to_irq;
+        }
 
         return gpiochip_add(&bgc->gc);
 }
diff --git a/drivers/gpio/gpio-generic.c b/drivers/gpio/gpio-generic.c
index 231714def4d2..4e24436b0f82 100644
--- a/drivers/gpio/gpio-generic.c
+++ b/drivers/gpio/gpio-generic.c
@@ -351,7 +351,7 @@ static int bgpio_setup_direction(struct bgpio_chip *bgc,
         return 0;
 }
 
-int __devexit bgpio_remove(struct bgpio_chip *bgc)
+int bgpio_remove(struct bgpio_chip *bgc)
 {
         int err = gpiochip_remove(&bgc->gc);
 
@@ -361,15 +361,10 @@ int __devexit bgpio_remove(struct bgpio_chip *bgc)
 }
 EXPORT_SYMBOL_GPL(bgpio_remove);
 
-int __devinit bgpio_init(struct bgpio_chip *bgc,
-                         struct device *dev,
-                         unsigned long sz,
-                         void __iomem *dat,
-                         void __iomem *set,
-                         void __iomem *clr,
-                         void __iomem *dirout,
-                         void __iomem *dirin,
-                         bool big_endian)
+int bgpio_init(struct bgpio_chip *bgc, struct device *dev,
+               unsigned long sz, void __iomem *dat, void __iomem *set,
+               void __iomem *clr, void __iomem *dirout, void __iomem *dirin,
+               bool big_endian)
 {
         int ret;
 
diff --git a/drivers/gpio/gpio-ks8695.c b/drivers/gpio/gpio-ks8695.c
new file mode 100644
index 000000000000..a3ac66ea364b
--- /dev/null
+++ b/drivers/gpio/gpio-ks8695.c
@@ -0,0 +1,319 @@
+/*
+ * arch/arm/mach-ks8695/gpio.c
+ *
+ * Copyright (C) 2006 Andrew Victor
+ * Updated to GPIOLIB, Copyright 2008 Simtec Electronics
+ *                     Daniel Silverstone <dsilvers@simtec.co.uk>
+ *
+ * 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/gpio.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/init.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/module.h>
+#include <linux/io.h>
+
+#include <mach/hardware.h>
+#include <asm/mach/irq.h>
+
+#include <mach/regs-gpio.h>
+#include <mach/gpio-ks8695.h>
+
+/*
+ * Configure a GPIO line for either GPIO function, or its internal
+ * function (Interrupt, Timer, etc).
+ */
+static void ks8695_gpio_mode(unsigned int pin, short gpio)
+{
+        unsigned int enable[] = { IOPC_IOEINT0EN, IOPC_IOEINT1EN, IOPC_IOEINT2EN, IOPC_IOEINT3EN, IOPC_IOTIM0EN, IOPC_IOTIM1EN };
+        unsigned long x, flags;
+
+        if (pin > KS8695_GPIO_5)        /* only GPIO 0..5 have internal functions */
+                return;
+
+        local_irq_save(flags);
+
+        x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPC);
+        if (gpio)                       /* GPIO: set bit to 0 */
+                x &= ~enable[pin];
+        else                            /* Internal function: set bit to 1 */
+                x |= enable[pin];
+        __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPC);
+
+        local_irq_restore(flags);
+}
+
+
+static unsigned short gpio_irq[] = { KS8695_IRQ_EXTERN0, KS8695_IRQ_EXTERN1, KS8695_IRQ_EXTERN2, KS8695_IRQ_EXTERN3 };
+
+/*
+ * Configure GPIO pin as external interrupt source.
+ */
+int ks8695_gpio_interrupt(unsigned int pin, unsigned int type)
+{
+        unsigned long x, flags;
+
+        if (pin > KS8695_GPIO_3)        /* only GPIO 0..3 can generate IRQ */
+                return -EINVAL;
+
+        local_irq_save(flags);
+
+        /* set pin as input */
+        x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPM);
+        x &= ~IOPM(pin);
+        __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPM);
+
+        local_irq_restore(flags);
+
+        /* Set IRQ triggering type */
+        irq_set_irq_type(gpio_irq[pin], type);
+
+        /* enable interrupt mode */
+        ks8695_gpio_mode(pin, 0);
+
+        return 0;
+}
+EXPORT_SYMBOL(ks8695_gpio_interrupt);
+
+
+
+/* .... Generic GPIO interface .............................................. */
+
+/*
+ * Configure the GPIO line as an input.
+ */
+static int ks8695_gpio_direction_input(struct gpio_chip *gc, unsigned int pin)
+{
+        unsigned long x, flags;
+
+        if (pin > KS8695_GPIO_15)
+                return -EINVAL;
+
+        /* set pin to GPIO mode */
+        ks8695_gpio_mode(pin, 1);
+
+        local_irq_save(flags);
+
+        /* set pin as input */
+        x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPM);
+        x &= ~IOPM(pin);
+        __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPM);
+
+        local_irq_restore(flags);
+
+        return 0;
+}
+
+
+/*
+ * Configure the GPIO line as an output, with default state.
+ */
+static int ks8695_gpio_direction_output(struct gpio_chip *gc,
+                                        unsigned int pin, int state)
+{
+        unsigned long x, flags;
+
+        if (pin > KS8695_GPIO_15)
+                return -EINVAL;
+
+        /* set pin to GPIO mode */
+        ks8695_gpio_mode(pin, 1);
+
+        local_irq_save(flags);
+
+        /* set line state */
+        x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPD);
+        if (state)
+                x |= IOPD(pin);
+        else
+                x &= ~IOPD(pin);
+        __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPD);
+
+        /* set pin as output */
+        x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPM);
+        x |= IOPM(pin);
+        __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPM);
+
+        local_irq_restore(flags);
+
+        return 0;
+}
+
+
+/*
+ * Set the state of an output GPIO line.
+ */
+static void ks8695_gpio_set_value(struct gpio_chip *gc,
+                                  unsigned int pin, int state)
+{
+        unsigned long x, flags;
+
+        if (pin > KS8695_GPIO_15)
+                return;
+
+        local_irq_save(flags);
+
+        /* set output line state */
+        x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPD);
+        if (state)
+                x |= IOPD(pin);
+        else
+                x &= ~IOPD(pin);
+        __raw_writel(x, KS8695_GPIO_VA + KS8695_IOPD);
+
+        local_irq_restore(flags);
+}
+
+
+/*
+ * Read the state of a GPIO line.
+ */
+static int ks8695_gpio_get_value(struct gpio_chip *gc, unsigned int pin)
+{
+        unsigned long x;
+
+        if (pin > KS8695_GPIO_15)
+                return -EINVAL;
+
+        x = __raw_readl(KS8695_GPIO_VA + KS8695_IOPD);
+        return (x & IOPD(pin)) != 0;
+}
+
+
+/*
+ * Map GPIO line to IRQ number.
+ */
+static int ks8695_gpio_to_irq(struct gpio_chip *gc, unsigned int pin)
+{
+        if (pin > KS8695_GPIO_3)        /* only GPIO 0..3 can generate IRQ */
+                return -EINVAL;
+
+        return gpio_irq[pin];
+}
+
+/*
+ * Map IRQ number to GPIO line.
+ */
+int irq_to_gpio(unsigned int irq)
+{
+        if ((irq < KS8695_IRQ_EXTERN0) || (irq > KS8695_IRQ_EXTERN3))
+                return -EINVAL;
+
+        return (irq - KS8695_IRQ_EXTERN0);
+}
+EXPORT_SYMBOL(irq_to_gpio);
+
+/* GPIOLIB interface */
+
+static struct gpio_chip ks8695_gpio_chip = {
+        .label                  = "KS8695",
+        .direction_input        = ks8695_gpio_direction_input,
+        .direction_output       = ks8695_gpio_direction_output,
+        .get                    = ks8695_gpio_get_value,
+        .set                    = ks8695_gpio_set_value,
+        .to_irq                 = ks8695_gpio_to_irq,
+        .base                   = 0,
+        .ngpio                  = 16,
+        .can_sleep              = 0,
+};
+
+/* Register the GPIOs */
+void ks8695_register_gpios(void)
+{
+        if (gpiochip_add(&ks8695_gpio_chip))
+                printk(KERN_ERR "Unable to register core GPIOs\n");
+}
+
+/* .... Debug interface ..................................................... */
+
+#ifdef CONFIG_DEBUG_FS
+
+static int ks8695_gpio_show(struct seq_file *s, void *unused)
+{
+        unsigned int enable[] = { IOPC_IOEINT0EN, IOPC_IOEINT1EN, IOPC_IOEINT2EN, IOPC_IOEINT3EN, IOPC_IOTIM0EN, IOPC_IOTIM1EN };
+        unsigned int intmask[] = { IOPC_IOEINT0TM, IOPC_IOEINT1TM, IOPC_IOEINT2TM, IOPC_IOEINT3TM };
+        unsigned long mode, ctrl, data;
+        int i;
+
+        mode = __raw_readl(KS8695_GPIO_VA + KS8695_IOPM);
+        ctrl = __raw_readl(KS8695_GPIO_VA + KS8695_IOPC);
+        data = __raw_readl(KS8695_GPIO_VA + KS8695_IOPD);
+
+        seq_printf(s, "Pin\tI/O\tFunction\tState\n\n");
+
+        for (i = KS8695_GPIO_0; i <= KS8695_GPIO_15 ; i++) {
+                seq_printf(s, "%i:\t", i);
+
+                seq_printf(s, "%s\t", (mode & IOPM(i)) ? "Output" : "Input");
+
+                if (i <= KS8695_GPIO_3) {
+                        if (ctrl & enable[i]) {
+                                seq_printf(s, "EXT%i ", i);
+
+                                switch ((ctrl & intmask[i]) >> (4 * i)) {
+                                        case IOPC_TM_LOW:
+                                                seq_printf(s, "(Low)");         break;
+                                        case IOPC_TM_HIGH:
+                                                seq_printf(s, "(High)");        break;
+                                        case IOPC_TM_RISING:
+                                                seq_printf(s, "(Rising)");      break;
+                                        case IOPC_TM_FALLING:
+                                                seq_printf(s, "(Falling)");     break;
+                                        case IOPC_TM_EDGE:
+                                                seq_printf(s, "(Edges)");       break;
+                                }
+                        }
+                        else
+                                seq_printf(s, "GPIO\t");
+                }
+                else if (i <= KS8695_GPIO_5) {
+                        if (ctrl & enable[i])
+                                seq_printf(s, "TOUT%i\t", i - KS8695_GPIO_4);
+                        else
+                                seq_printf(s, "GPIO\t");
+                }
+                else
+                        seq_printf(s, "GPIO\t");
+
+                seq_printf(s, "\t");
+
+                seq_printf(s, "%i\n", (data & IOPD(i)) ? 1 : 0);
+        }
+        return 0;
+}
+
+static int ks8695_gpio_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ks8695_gpio_show, NULL);
+}
+
+static const struct file_operations ks8695_gpio_operations = {
+        .open           = ks8695_gpio_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static int __init ks8695_gpio_debugfs_init(void)
+{
+        /* /sys/kernel/debug/ks8695_gpio */
+        (void) debugfs_create_file("ks8695_gpio", S_IFREG | S_IRUGO, NULL, NULL, &ks8695_gpio_operations);
+        return 0;
+}
+postcore_initcall(ks8695_gpio_debugfs_init);
+
+#endif
diff --git a/drivers/gpio/gpio-lpc32xx.c b/drivers/gpio/gpio-lpc32xx.c
new file mode 100644
index 000000000000..5b6948081f8f
--- /dev/null
+++ b/drivers/gpio/gpio-lpc32xx.c
@@ -0,0 +1,446 @@
+/*
+ * arch/arm/mach-lpc32xx/gpiolib.c
+ *
+ * Author: Kevin Wells <kevin.wells@nxp.com>
+ *
+ * Copyright (C) 2010 NXP Semiconductors
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/errno.h>
+#include <linux/gpio.h>
+
+#include <mach/hardware.h>
+#include <mach/platform.h>
+#include <mach/gpio-lpc32xx.h>
+
+#define LPC32XX_GPIO_P3_INP_STATE               _GPREG(0x000)
+#define LPC32XX_GPIO_P3_OUTP_SET                _GPREG(0x004)
+#define LPC32XX_GPIO_P3_OUTP_CLR                _GPREG(0x008)
+#define LPC32XX_GPIO_P3_OUTP_STATE              _GPREG(0x00C)
+#define LPC32XX_GPIO_P2_DIR_SET                 _GPREG(0x010)
+#define LPC32XX_GPIO_P2_DIR_CLR                 _GPREG(0x014)
+#define LPC32XX_GPIO_P2_DIR_STATE               _GPREG(0x018)
+#define LPC32XX_GPIO_P2_INP_STATE               _GPREG(0x01C)
+#define LPC32XX_GPIO_P2_OUTP_SET                _GPREG(0x020)
+#define LPC32XX_GPIO_P2_OUTP_CLR                _GPREG(0x024)
+#define LPC32XX_GPIO_P2_MUX_SET                 _GPREG(0x028)
+#define LPC32XX_GPIO_P2_MUX_CLR                 _GPREG(0x02C)
+#define LPC32XX_GPIO_P2_MUX_STATE               _GPREG(0x030)
+#define LPC32XX_GPIO_P0_INP_STATE               _GPREG(0x040)
+#define LPC32XX_GPIO_P0_OUTP_SET                _GPREG(0x044)
+#define LPC32XX_GPIO_P0_OUTP_CLR                _GPREG(0x048)
+#define LPC32XX_GPIO_P0_OUTP_STATE              _GPREG(0x04C)
+#define LPC32XX_GPIO_P0_DIR_SET                 _GPREG(0x050)
+#define LPC32XX_GPIO_P0_DIR_CLR                 _GPREG(0x054)
+#define LPC32XX_GPIO_P0_DIR_STATE               _GPREG(0x058)
+#define LPC32XX_GPIO_P1_INP_STATE               _GPREG(0x060)
+#define LPC32XX_GPIO_P1_OUTP_SET                _GPREG(0x064)
+#define LPC32XX_GPIO_P1_OUTP_CLR                _GPREG(0x068)
+#define LPC32XX_GPIO_P1_OUTP_STATE              _GPREG(0x06C)
+#define LPC32XX_GPIO_P1_DIR_SET                 _GPREG(0x070)
+#define LPC32XX_GPIO_P1_DIR_CLR                 _GPREG(0x074)
+#define LPC32XX_GPIO_P1_DIR_STATE               _GPREG(0x078)
+
+#define GPIO012_PIN_TO_BIT(x)                   (1 << (x))
+#define GPIO3_PIN_TO_BIT(x)                     (1 << ((x) + 25))
+#define GPO3_PIN_TO_BIT(x)                      (1 << (x))
+#define GPIO012_PIN_IN_SEL(x, y)                (((x) >> (y)) & 1)
+#define GPIO3_PIN_IN_SHIFT(x)                   ((x) == 5 ? 24 : 10 + (x))
+#define GPIO3_PIN_IN_SEL(x, y)                  ((x) >> GPIO3_PIN_IN_SHIFT(y))
+#define GPIO3_PIN5_IN_SEL(x)                    (((x) >> 24) & 1)
+#define GPI3_PIN_IN_SEL(x, y)                   (((x) >> (y)) & 1)
+
+struct gpio_regs {
+        void __iomem *inp_state;
+        void __iomem *outp_set;
+        void __iomem *outp_clr;
+        void __iomem *dir_set;
+        void __iomem *dir_clr;
+};
+
+/*
+ * GPIO names
+ */
+static const char *gpio_p0_names[LPC32XX_GPIO_P0_MAX] = {
+        "p0.0", "p0.1", "p0.2", "p0.3",
+        "p0.4", "p0.5", "p0.6", "p0.7"
+};
+
+static const char *gpio_p1_names[LPC32XX_GPIO_P1_MAX] = {
+        "p1.0", "p1.1", "p1.2", "p1.3",
+        "p1.4", "p1.5", "p1.6", "p1.7",
+        "p1.8", "p1.9", "p1.10", "p1.11",
+        "p1.12", "p1.13", "p1.14", "p1.15",
+        "p1.16", "p1.17", "p1.18", "p1.19",
+        "p1.20", "p1.21", "p1.22", "p1.23",
+};
+
+static const char *gpio_p2_names[LPC32XX_GPIO_P2_MAX] = {
+        "p2.0", "p2.1", "p2.2", "p2.3",
+        "p2.4", "p2.5", "p2.6", "p2.7",
+        "p2.8", "p2.9", "p2.10", "p2.11",
+        "p2.12"
+};
+
+static const char *gpio_p3_names[LPC32XX_GPIO_P3_MAX] = {
+        "gpi000", "gpio01", "gpio02", "gpio03",
+        "gpio04", "gpio05"
+};
+
+static const char *gpi_p3_names[LPC32XX_GPI_P3_MAX] = {
+        "gpi00", "gpi01", "gpi02", "gpi03",
+        "gpi04", "gpi05", "gpi06", "gpi07",
+        "gpi08", "gpi09",  NULL,    NULL,
+         NULL,    NULL,    NULL,   "gpi15",
+        "gpi16", "gpi17", "gpi18", "gpi19",
+        "gpi20", "gpi21", "gpi22", "gpi23",
+        "gpi24", "gpi25", "gpi26", "gpi27"
+};
+
+static const char *gpo_p3_names[LPC32XX_GPO_P3_MAX] = {
+        "gpo00", "gpo01", "gpo02", "gpo03",
+        "gpo04", "gpo05", "gpo06", "gpo07",
+        "gpo08", "gpo09", "gpo10", "gpo11",
+        "gpo12", "gpo13", "gpo14", "gpo15",
+        "gpo16", "gpo17", "gpo18", "gpo19",
+        "gpo20", "gpo21", "gpo22", "gpo23"
+};
+
+static struct gpio_regs gpio_grp_regs_p0 = {
+        .inp_state      = LPC32XX_GPIO_P0_INP_STATE,
+        .outp_set       = LPC32XX_GPIO_P0_OUTP_SET,
+        .outp_clr       = LPC32XX_GPIO_P0_OUTP_CLR,
+        .dir_set        = LPC32XX_GPIO_P0_DIR_SET,
+        .dir_clr        = LPC32XX_GPIO_P0_DIR_CLR,
+};
+
+static struct gpio_regs gpio_grp_regs_p1 = {
+        .inp_state      = LPC32XX_GPIO_P1_INP_STATE,
+        .outp_set       = LPC32XX_GPIO_P1_OUTP_SET,
+        .outp_clr       = LPC32XX_GPIO_P1_OUTP_CLR,
+        .dir_set        = LPC32XX_GPIO_P1_DIR_SET,
+        .dir_clr        = LPC32XX_GPIO_P1_DIR_CLR,
+};
+
+static struct gpio_regs gpio_grp_regs_p2 = {
+        .inp_state      = LPC32XX_GPIO_P2_INP_STATE,
+        .outp_set       = LPC32XX_GPIO_P2_OUTP_SET,
+        .outp_clr       = LPC32XX_GPIO_P2_OUTP_CLR,
+        .dir_set        = LPC32XX_GPIO_P2_DIR_SET,
+        .dir_clr        = LPC32XX_GPIO_P2_DIR_CLR,
+};
+
+static struct gpio_regs gpio_grp_regs_p3 = {
+        .inp_state      = LPC32XX_GPIO_P3_INP_STATE,
+        .outp_set       = LPC32XX_GPIO_P3_OUTP_SET,
+        .outp_clr       = LPC32XX_GPIO_P3_OUTP_CLR,
+        .dir_set        = LPC32XX_GPIO_P2_DIR_SET,
+        .dir_clr        = LPC32XX_GPIO_P2_DIR_CLR,
+};
+
+struct lpc32xx_gpio_chip {
+        struct gpio_chip        chip;
+        struct gpio_regs        *gpio_grp;
+};
+
+static inline struct lpc32xx_gpio_chip *to_lpc32xx_gpio(
+        struct gpio_chip *gpc)
+{
+        return container_of(gpc, struct lpc32xx_gpio_chip, chip);
+}
+
+static void __set_gpio_dir_p012(struct lpc32xx_gpio_chip *group,
+        unsigned pin, int input)
+{
+        if (input)
+                __raw_writel(GPIO012_PIN_TO_BIT(pin),
+                        group->gpio_grp->dir_clr);
+        else
+                __raw_writel(GPIO012_PIN_TO_BIT(pin),
+                        group->gpio_grp->dir_set);
+}
+
+static void __set_gpio_dir_p3(struct lpc32xx_gpio_chip *group,
+        unsigned pin, int input)
+{
+        u32 u = GPIO3_PIN_TO_BIT(pin);
+
+        if (input)
+                __raw_writel(u, group->gpio_grp->dir_clr);
+        else
+                __raw_writel(u, group->gpio_grp->dir_set);
+}
+
+static void __set_gpio_level_p012(struct lpc32xx_gpio_chip *group,
+        unsigned pin, int high)
+{
+        if (high)
+                __raw_writel(GPIO012_PIN_TO_BIT(pin),
+                        group->gpio_grp->outp_set);
+        else
+                __raw_writel(GPIO012_PIN_TO_BIT(pin),
+                        group->gpio_grp->outp_clr);
+}
+
+static void __set_gpio_level_p3(struct lpc32xx_gpio_chip *group,
+        unsigned pin, int high)
+{
+        u32 u = GPIO3_PIN_TO_BIT(pin);
+
+        if (high)
+                __raw_writel(u, group->gpio_grp->outp_set);
+        else
+                __raw_writel(u, group->gpio_grp->outp_clr);
+}
+
+static void __set_gpo_level_p3(struct lpc32xx_gpio_chip *group,
+        unsigned pin, int high)
+{
+        if (high)
+                __raw_writel(GPO3_PIN_TO_BIT(pin), group->gpio_grp->outp_set);
+        else
+                __raw_writel(GPO3_PIN_TO_BIT(pin), group->gpio_grp->outp_clr);
+}
+
+static int __get_gpio_state_p012(struct lpc32xx_gpio_chip *group,
+        unsigned pin)
+{
+        return GPIO012_PIN_IN_SEL(__raw_readl(group->gpio_grp->inp_state),
+                pin);
+}
+
+static int __get_gpio_state_p3(struct lpc32xx_gpio_chip *group,
+        unsigned pin)
+{
+        int state = __raw_readl(group->gpio_grp->inp_state);
+
+        /*
+         * P3 GPIO pin input mapping is not contiguous, GPIOP3-0..4 is mapped
+         * to bits 10..14, while GPIOP3-5 is mapped to bit 24.
+         */
+        return GPIO3_PIN_IN_SEL(state, pin);
+}
+
+static int __get_gpi_state_p3(struct lpc32xx_gpio_chip *group,
+        unsigned pin)
+{
+        return GPI3_PIN_IN_SEL(__raw_readl(group->gpio_grp->inp_state), pin);
+}
+
+/*
+ * GENERIC_GPIO primitives.
+ */
+static int lpc32xx_gpio_dir_input_p012(struct gpio_chip *chip,
+        unsigned pin)
+{
+        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+
+        __set_gpio_dir_p012(group, pin, 1);
+
+        return 0;
+}
+
+static int lpc32xx_gpio_dir_input_p3(struct gpio_chip *chip,
+        unsigned pin)
+{
+        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+
+        __set_gpio_dir_p3(group, pin, 1);
+
+        return 0;
+}
+
+static int lpc32xx_gpio_dir_in_always(struct gpio_chip *chip,
+        unsigned pin)
+{
+        return 0;
+}
+
+static int lpc32xx_gpio_get_value_p012(struct gpio_chip *chip, unsigned pin)
+{
+        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+
+        return __get_gpio_state_p012(group, pin);
+}
+
+static int lpc32xx_gpio_get_value_p3(struct gpio_chip *chip, unsigned pin)
+{
+        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+
+        return __get_gpio_state_p3(group, pin);
+}
+
+static int lpc32xx_gpi_get_value(struct gpio_chip *chip, unsigned pin)
+{
+        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+
+        return __get_gpi_state_p3(group, pin);
+}
+
+static int lpc32xx_gpio_dir_output_p012(struct gpio_chip *chip, unsigned pin,
+        int value)
+{
+        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+
+        __set_gpio_dir_p012(group, pin, 0);
+
+        return 0;
+}
+
+static int lpc32xx_gpio_dir_output_p3(struct gpio_chip *chip, unsigned pin,
+        int value)
+{
+        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+
+        __set_gpio_dir_p3(group, pin, 0);
+
+        return 0;
+}
+
+static int lpc32xx_gpio_dir_out_always(struct gpio_chip *chip, unsigned pin,
+        int value)
+{
+        return 0;
+}
+
+static void lpc32xx_gpio_set_value_p012(struct gpio_chip *chip, unsigned pin,
+        int value)
+{
+        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+
+        __set_gpio_level_p012(group, pin, value);
+}
+
+static void lpc32xx_gpio_set_value_p3(struct gpio_chip *chip, unsigned pin,
+        int value)
+{
+        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+
+        __set_gpio_level_p3(group, pin, value);
+}
+
+static void lpc32xx_gpo_set_value(struct gpio_chip *chip, unsigned pin,
+        int value)
+{
+        struct lpc32xx_gpio_chip *group = to_lpc32xx_gpio(chip);
+
+        __set_gpo_level_p3(group, pin, value);
+}
+
+static int lpc32xx_gpio_request(struct gpio_chip *chip, unsigned pin)
+{
+        if (pin < chip->ngpio)
+                return 0;
+
+        return -EINVAL;
+}
+
+static struct lpc32xx_gpio_chip lpc32xx_gpiochip[] = {
+        {
+                .chip = {
+                        .label                  = "gpio_p0",
+                        .direction_input        = lpc32xx_gpio_dir_input_p012,
+                        .get                    = lpc32xx_gpio_get_value_p012,
+                        .direction_output       = lpc32xx_gpio_dir_output_p012,
+                        .set                    = lpc32xx_gpio_set_value_p012,
+                        .request                = lpc32xx_gpio_request,
+                        .base                   = LPC32XX_GPIO_P0_GRP,
+                        .ngpio                  = LPC32XX_GPIO_P0_MAX,
+                        .names                  = gpio_p0_names,
+                        .can_sleep              = 0,
+                },
+                .gpio_grp = &gpio_grp_regs_p0,
+        },
+        {
+                .chip = {
+                        .label                  = "gpio_p1",
+                        .direction_input        = lpc32xx_gpio_dir_input_p012,
+                        .get                    = lpc32xx_gpio_get_value_p012,
+                        .direction_output       = lpc32xx_gpio_dir_output_p012,
+                        .set                    = lpc32xx_gpio_set_value_p012,
+                        .request                = lpc32xx_gpio_request,
+                        .base                   = LPC32XX_GPIO_P1_GRP,
+                        .ngpio                  = LPC32XX_GPIO_P1_MAX,
+                        .names                  = gpio_p1_names,
+                        .can_sleep              = 0,
+                },
+                .gpio_grp = &gpio_grp_regs_p1,
+        },
+        {
+                .chip = {
+                        .label                  = "gpio_p2",
+                        .direction_input        = lpc32xx_gpio_dir_input_p012,
+                        .get                    = lpc32xx_gpio_get_value_p012,
+                        .direction_output       = lpc32xx_gpio_dir_output_p012,
+                        .set                    = lpc32xx_gpio_set_value_p012,
+                        .request                = lpc32xx_gpio_request,
+                        .base                   = LPC32XX_GPIO_P2_GRP,
+                        .ngpio                  = LPC32XX_GPIO_P2_MAX,
+                        .names                  = gpio_p2_names,
+                        .can_sleep              = 0,
+                },
+                .gpio_grp = &gpio_grp_regs_p2,
+        },
+        {
+                .chip = {
+                        .label                  = "gpio_p3",
+                        .direction_input        = lpc32xx_gpio_dir_input_p3,
+                        .get                    = lpc32xx_gpio_get_value_p3,
+                        .direction_output       = lpc32xx_gpio_dir_output_p3,
+                        .set                    = lpc32xx_gpio_set_value_p3,
+                        .request                = lpc32xx_gpio_request,
+                        .base                   = LPC32XX_GPIO_P3_GRP,
+                        .ngpio                  = LPC32XX_GPIO_P3_MAX,
+                        .names                  = gpio_p3_names,
+                        .can_sleep              = 0,
+                },
+                .gpio_grp = &gpio_grp_regs_p3,
+        },
+        {
+                .chip = {
+                        .label                  = "gpi_p3",
+                        .direction_input        = lpc32xx_gpio_dir_in_always,
+                        .get                    = lpc32xx_gpi_get_value,
+                        .request                = lpc32xx_gpio_request,
+                        .base                   = LPC32XX_GPI_P3_GRP,
+                        .ngpio                  = LPC32XX_GPI_P3_MAX,
+                        .names                  = gpi_p3_names,
+                        .can_sleep              = 0,
+                },
+                .gpio_grp = &gpio_grp_regs_p3,
+        },
+        {
+                .chip = {
+                        .label                  = "gpo_p3",
+                        .direction_output       = lpc32xx_gpio_dir_out_always,
+                        .set                    = lpc32xx_gpo_set_value,
+                        .request                = lpc32xx_gpio_request,
+                        .base                   = LPC32XX_GPO_P3_GRP,
+                        .ngpio                  = LPC32XX_GPO_P3_MAX,
+                        .names                  = gpo_p3_names,
+                        .can_sleep              = 0,
+                },
+                .gpio_grp = &gpio_grp_regs_p3,
+        },
+};
+
+void __init lpc32xx_gpio_init(void)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(lpc32xx_gpiochip); i++)
+                gpiochip_add(&lpc32xx_gpiochip[i].chip);
+}
diff --git a/drivers/gpio/gpio-nomadik.c b/drivers/gpio/gpio-nomadik.c
index 2c212c732d76..740caed2b278 100644
--- a/drivers/gpio/gpio-nomadik.c
+++ b/drivers/gpio/gpio-nomadik.c
@@ -27,8 +27,9 @@
 #include <asm/mach/irq.h>
 
 #include <plat/pincfg.h>
+#include <plat/gpio-nomadik.h>
 #include <mach/hardware.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 
 /*
  * The GPIO module in the Nomadik family of Systems-on-Chip is an
diff --git a/drivers/gpio/gpio-omap.c b/drivers/gpio/gpio-omap.c
index 0599854e2217..9c27244fd680 100644
--- a/drivers/gpio/gpio-omap.c
+++ b/drivers/gpio/gpio-omap.c
@@ -25,7 +25,7 @@
 #include <mach/hardware.h>
 #include <asm/irq.h>
 #include <mach/irqs.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include <asm/mach/irq.h>
 
 struct gpio_bank {
diff --git a/drivers/gpio/gpio-pxa.c b/drivers/gpio/gpio-pxa.c
new file mode 100644
index 000000000000..9052925c6fa2
--- /dev/null
+++ b/drivers/gpio/gpio-pxa.c
@@ -0,0 +1,338 @@
+/*
+ *  linux/arch/arm/plat-pxa/gpio.c
+ *
+ *  Generic PXA GPIO handling
+ *
+ *  Author:     Nicolas Pitre
+ *  Created:    Jun 15, 2001
+ *  Copyright:  MontaVista Software Inc.
+ *
+ *  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.
+ */
+#include <linux/gpio.h>
+#include <linux/init.h>
+#include <linux/irq.h>
+#include <linux/io.h>
+#include <linux/syscore_ops.h>
+#include <linux/slab.h>
+
+#include <mach/gpio-pxa.h>
+
+int pxa_last_gpio;
+
+struct pxa_gpio_chip {
+        struct gpio_chip chip;
+        void __iomem    *regbase;
+        char label[10];
+
+        unsigned long   irq_mask;
+        unsigned long   irq_edge_rise;
+        unsigned long   irq_edge_fall;
+
+#ifdef CONFIG_PM
+        unsigned long   saved_gplr;
+        unsigned long   saved_gpdr;
+        unsigned long   saved_grer;
+        unsigned long   saved_gfer;
+#endif
+};
+
+static DEFINE_SPINLOCK(gpio_lock);
+static struct pxa_gpio_chip *pxa_gpio_chips;
+
+#define for_each_gpio_chip(i, c)                        \
+        for (i = 0, c = &pxa_gpio_chips[0]; i <= pxa_last_gpio; i += 32, c++)
+
+static inline void __iomem *gpio_chip_base(struct gpio_chip *c)
+{
+        return container_of(c, struct pxa_gpio_chip, chip)->regbase;
+}
+
+static inline struct pxa_gpio_chip *gpio_to_pxachip(unsigned gpio)
+{
+        return &pxa_gpio_chips[gpio_to_bank(gpio)];
+}
+
+static int pxa_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        void __iomem *base = gpio_chip_base(chip);
+        uint32_t value, mask = 1 << offset;
+        unsigned long flags;
+
+        spin_lock_irqsave(&gpio_lock, flags);
+
+        value = __raw_readl(base + GPDR_OFFSET);
+        if (__gpio_is_inverted(chip->base + offset))
+                value |= mask;
+        else
+                value &= ~mask;
+        __raw_writel(value, base + GPDR_OFFSET);
+
+        spin_unlock_irqrestore(&gpio_lock, flags);
+        return 0;
+}
+
+static int pxa_gpio_direction_output(struct gpio_chip *chip,
+                                     unsigned offset, int value)
+{
+        void __iomem *base = gpio_chip_base(chip);
+        uint32_t tmp, mask = 1 << offset;
+        unsigned long flags;
+
+        __raw_writel(mask, base + (value ? GPSR_OFFSET : GPCR_OFFSET));
+
+        spin_lock_irqsave(&gpio_lock, flags);
+
+        tmp = __raw_readl(base + GPDR_OFFSET);
+        if (__gpio_is_inverted(chip->base + offset))
+                tmp &= ~mask;
+        else
+                tmp |= mask;
+        __raw_writel(tmp, base + GPDR_OFFSET);
+
+        spin_unlock_irqrestore(&gpio_lock, flags);
+        return 0;
+}
+
+static int pxa_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        return __raw_readl(gpio_chip_base(chip) + GPLR_OFFSET) & (1 << offset);
+}
+
+static void pxa_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+        __raw_writel(1 << offset, gpio_chip_base(chip) +
+                                (value ? GPSR_OFFSET : GPCR_OFFSET));
+}
+
+static int __init pxa_init_gpio_chip(int gpio_end)
+{
+        int i, gpio, nbanks = gpio_to_bank(gpio_end) + 1;
+        struct pxa_gpio_chip *chips;
+
+        chips = kzalloc(nbanks * sizeof(struct pxa_gpio_chip), GFP_KERNEL);
+        if (chips == NULL) {
+                pr_err("%s: failed to allocate GPIO chips\n", __func__);
+                return -ENOMEM;
+        }
+
+        for (i = 0, gpio = 0; i < nbanks; i++, gpio += 32) {
+                struct gpio_chip *c = &chips[i].chip;
+
+                sprintf(chips[i].label, "gpio-%d", i);
+                chips[i].regbase = (void __iomem *)GPIO_BANK(i);
+
+                c->base  = gpio;
+                c->label = chips[i].label;
+
+                c->direction_input  = pxa_gpio_direction_input;
+                c->direction_output = pxa_gpio_direction_output;
+                c->get = pxa_gpio_get;
+                c->set = pxa_gpio_set;
+
+                /* number of GPIOs on last bank may be less than 32 */
+                c->ngpio = (gpio + 31 > gpio_end) ? (gpio_end - gpio + 1) : 32;
+                gpiochip_add(c);
+        }
+        pxa_gpio_chips = chips;
+        return 0;
+}
+
+/* Update only those GRERx and GFERx edge detection register bits if those
+ * bits are set in c->irq_mask
+ */
+static inline void update_edge_detect(struct pxa_gpio_chip *c)
+{
+        uint32_t grer, gfer;
+
+        grer = __raw_readl(c->regbase + GRER_OFFSET) & ~c->irq_mask;
+        gfer = __raw_readl(c->regbase + GFER_OFFSET) & ~c->irq_mask;
+        grer |= c->irq_edge_rise & c->irq_mask;
+        gfer |= c->irq_edge_fall & c->irq_mask;
+        __raw_writel(grer, c->regbase + GRER_OFFSET);
+        __raw_writel(gfer, c->regbase + GFER_OFFSET);
+}
+
+static int pxa_gpio_irq_type(struct irq_data *d, unsigned int type)
+{
+        struct pxa_gpio_chip *c;
+        int gpio = irq_to_gpio(d->irq);
+        unsigned long gpdr, mask = GPIO_bit(gpio);
+
+        c = gpio_to_pxachip(gpio);
+
+        if (type == IRQ_TYPE_PROBE) {
+                /* Don't mess with enabled GPIOs using preconfigured edges or
+                 * GPIOs set to alternate function or to output during probe
+                 */
+                if ((c->irq_edge_rise | c->irq_edge_fall) & GPIO_bit(gpio))
+                        return 0;
+
+                if (__gpio_is_occupied(gpio))
+                        return 0;
+
+                type = IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING;
+        }
+
+        gpdr = __raw_readl(c->regbase + GPDR_OFFSET);
+
+        if (__gpio_is_inverted(gpio))
+                __raw_writel(gpdr | mask,  c->regbase + GPDR_OFFSET);
+        else
+                __raw_writel(gpdr & ~mask, c->regbase + GPDR_OFFSET);
+
+        if (type & IRQ_TYPE_EDGE_RISING)
+                c->irq_edge_rise |= mask;
+        else
+                c->irq_edge_rise &= ~mask;
+
+        if (type & IRQ_TYPE_EDGE_FALLING)
+                c->irq_edge_fall |= mask;
+        else
+                c->irq_edge_fall &= ~mask;
+
+        update_edge_detect(c);
+
+        pr_debug("%s: IRQ%d (GPIO%d) - edge%s%s\n", __func__, d->irq, gpio,
+                ((type & IRQ_TYPE_EDGE_RISING)  ? " rising"  : ""),
+                ((type & IRQ_TYPE_EDGE_FALLING) ? " falling" : ""));
+        return 0;
+}
+
+static void pxa_gpio_demux_handler(unsigned int irq, struct irq_desc *desc)
+{
+        struct pxa_gpio_chip *c;
+        int loop, gpio, gpio_base, n;
+        unsigned long gedr;
+
+        do {
+                loop = 0;
+                for_each_gpio_chip(gpio, c) {
+                        gpio_base = c->chip.base;
+
+                        gedr = __raw_readl(c->regbase + GEDR_OFFSET);
+                        gedr = gedr & c->irq_mask;
+                        __raw_writel(gedr, c->regbase + GEDR_OFFSET);
+
+                        n = find_first_bit(&gedr, BITS_PER_LONG);
+                        while (n < BITS_PER_LONG) {
+                                loop = 1;
+
+                                generic_handle_irq(gpio_to_irq(gpio_base + n));
+                                n = find_next_bit(&gedr, BITS_PER_LONG, n + 1);
+                        }
+                }
+        } while (loop);
+}
+
+static void pxa_ack_muxed_gpio(struct irq_data *d)
+{
+        int gpio = irq_to_gpio(d->irq);
+        struct pxa_gpio_chip *c = gpio_to_pxachip(gpio);
+
+        __raw_writel(GPIO_bit(gpio), c->regbase + GEDR_OFFSET);
+}
+
+static void pxa_mask_muxed_gpio(struct irq_data *d)
+{
+        int gpio = irq_to_gpio(d->irq);
+        struct pxa_gpio_chip *c = gpio_to_pxachip(gpio);
+        uint32_t grer, gfer;
+
+        c->irq_mask &= ~GPIO_bit(gpio);
+
+        grer = __raw_readl(c->regbase + GRER_OFFSET) & ~GPIO_bit(gpio);
+        gfer = __raw_readl(c->regbase + GFER_OFFSET) & ~GPIO_bit(gpio);
+        __raw_writel(grer, c->regbase + GRER_OFFSET);
+        __raw_writel(gfer, c->regbase + GFER_OFFSET);
+}
+
+static void pxa_unmask_muxed_gpio(struct irq_data *d)
+{
+        int gpio = irq_to_gpio(d->irq);
+        struct pxa_gpio_chip *c = gpio_to_pxachip(gpio);
+
+        c->irq_mask |= GPIO_bit(gpio);
+        update_edge_detect(c);
+}
+
+static struct irq_chip pxa_muxed_gpio_chip = {
+        .name           = "GPIO",
+        .irq_ack        = pxa_ack_muxed_gpio,
+        .irq_mask       = pxa_mask_muxed_gpio,
+        .irq_unmask     = pxa_unmask_muxed_gpio,
+        .irq_set_type   = pxa_gpio_irq_type,
+};
+
+void __init pxa_init_gpio(int mux_irq, int start, int end, set_wake_t fn)
+{
+        struct pxa_gpio_chip *c;
+        int gpio, irq;
+
+        pxa_last_gpio = end;
+
+        /* Initialize GPIO chips */
+        pxa_init_gpio_chip(end);
+
+        /* clear all GPIO edge detects */
+        for_each_gpio_chip(gpio, c) {
+                __raw_writel(0, c->regbase + GFER_OFFSET);
+                __raw_writel(0, c->regbase + GRER_OFFSET);
+                __raw_writel(~0,c->regbase + GEDR_OFFSET);
+        }
+
+        for (irq  = gpio_to_irq(start); irq <= gpio_to_irq(end); irq++) {
+                irq_set_chip_and_handler(irq, &pxa_muxed_gpio_chip,
+                                         handle_edge_irq);
+                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
+        }
+
+        /* Install handler for GPIO>=2 edge detect interrupts */
+        irq_set_chained_handler(mux_irq, pxa_gpio_demux_handler);
+        pxa_muxed_gpio_chip.irq_set_wake = fn;
+}
+
+#ifdef CONFIG_PM
+static int pxa_gpio_suspend(void)
+{
+        struct pxa_gpio_chip *c;
+        int gpio;
+
+        for_each_gpio_chip(gpio, c) {
+                c->saved_gplr = __raw_readl(c->regbase + GPLR_OFFSET);
+                c->saved_gpdr = __raw_readl(c->regbase + GPDR_OFFSET);
+                c->saved_grer = __raw_readl(c->regbase + GRER_OFFSET);
+                c->saved_gfer = __raw_readl(c->regbase + GFER_OFFSET);
+
+                /* Clear GPIO transition detect bits */
+                __raw_writel(0xffffffff, c->regbase + GEDR_OFFSET);
+        }
+        return 0;
+}
+
+static void pxa_gpio_resume(void)
+{
+        struct pxa_gpio_chip *c;
+        int gpio;
+
+        for_each_gpio_chip(gpio, c) {
+                /* restore level with set/clear */
+                __raw_writel( c->saved_gplr, c->regbase + GPSR_OFFSET);
+                __raw_writel(~c->saved_gplr, c->regbase + GPCR_OFFSET);
+
+                __raw_writel(c->saved_grer, c->regbase + GRER_OFFSET);
+                __raw_writel(c->saved_gfer, c->regbase + GFER_OFFSET);
+                __raw_writel(c->saved_gpdr, c->regbase + GPDR_OFFSET);
+        }
+}
+#else
+#define pxa_gpio_suspend        NULL
+#define pxa_gpio_resume         NULL
+#endif
+
+struct syscore_ops pxa_gpio_syscore_ops = {
+        .suspend        = pxa_gpio_suspend,
+        .resume         = pxa_gpio_resume,
+};
diff --git a/drivers/gpio/gpio-sa1100.c b/drivers/gpio/gpio-sa1100.c
new file mode 100644
index 000000000000..b6c1f6d80649
--- /dev/null
+++ b/drivers/gpio/gpio-sa1100.c
@@ -0,0 +1,63 @@
+/*
+ * linux/arch/arm/mach-sa1100/gpio.c
+ *
+ * Generic SA-1100 GPIO handling
+ *
+ * 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.
+ */
+#include <linux/gpio.h>
+#include <linux/init.h>
+#include <linux/module.h>
+
+#include <mach/hardware.h>
+
+static int sa1100_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        return GPLR & GPIO_GPIO(offset);
+}
+
+static void sa1100_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+        if (value)
+                GPSR = GPIO_GPIO(offset);
+        else
+                GPCR = GPIO_GPIO(offset);
+}
+
+static int sa1100_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        GPDR &= ~GPIO_GPIO(offset);
+        local_irq_restore(flags);
+        return 0;
+}
+
+static int sa1100_direction_output(struct gpio_chip *chip, unsigned offset, int value)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        sa1100_gpio_set(chip, offset, value);
+        GPDR |= GPIO_GPIO(offset);
+        local_irq_restore(flags);
+        return 0;
+}
+
+static struct gpio_chip sa1100_gpio_chip = {
+        .label                  = "gpio",
+        .direction_input        = sa1100_direction_input,
+        .direction_output       = sa1100_direction_output,
+        .set                    = sa1100_gpio_set,
+        .get                    = sa1100_gpio_get,
+        .base                   = 0,
+        .ngpio                  = GPIO_MAX + 1,
+};
+
+void __init sa1100_init_gpio(void)
+{
+        gpiochip_add(&sa1100_gpio_chip);
+}
diff --git a/drivers/gpio/gpio-tegra.c b/drivers/gpio/gpio-tegra.c
index 747eb40e8afe..6b65207c8106 100644
--- a/drivers/gpio/gpio-tegra.c
+++ b/drivers/gpio/gpio-tegra.c
@@ -27,6 +27,7 @@
 
 #include <asm/mach/irq.h>
 
+#include <mach/gpio-tegra.h>
 #include <mach/iomap.h>
 #include <mach/suspend.h>
 
@@ -134,7 +135,10 @@ static int tegra_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
         return 0;
 }
 
-
+static int tegra_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
+{
+        return TEGRA_GPIO_TO_IRQ(offset);
+}
 
 static struct gpio_chip tegra_gpio_chip = {
         .label                  = "tegra-gpio",
@@ -142,6 +146,7 @@ static struct gpio_chip tegra_gpio_chip = {
         .get                    = tegra_gpio_get,
         .direction_output       = tegra_gpio_direction_output,
         .set                    = tegra_gpio_set,
+        .to_irq                 = tegra_gpio_to_irq,
         .base                   = 0,
         .ngpio                  = TEGRA_NR_GPIOS,
 };
@@ -331,6 +336,7 @@ static struct lock_class_key gpio_lock_class;
 static int __init tegra_gpio_init(void)
 {
         struct tegra_gpio_bank *bank;
+        int gpio;
         int i;
         int j;
 
@@ -352,14 +358,17 @@ static int __init tegra_gpio_init(void)
 
         gpiochip_add(&tegra_gpio_chip);
 
-        for (i = INT_GPIO_BASE; i < (INT_GPIO_BASE + TEGRA_NR_GPIOS); i++) {
-                bank = &tegra_gpio_banks[GPIO_BANK(irq_to_gpio(i))];
+        for (gpio = 0; gpio < TEGRA_NR_GPIOS; gpio++) {
+                int irq = TEGRA_GPIO_TO_IRQ(gpio);
+                /* No validity check; all Tegra GPIOs are valid IRQs */
+
+                bank = &tegra_gpio_banks[GPIO_BANK(gpio)];
 
-                irq_set_lockdep_class(i, &gpio_lock_class);
-                irq_set_chip_data(i, bank);
-                irq_set_chip_and_handler(i, &tegra_gpio_irq_chip,
+                irq_set_lockdep_class(irq, &gpio_lock_class);
+                irq_set_chip_data(irq, bank);
+                irq_set_chip_and_handler(irq, &tegra_gpio_irq_chip,
                                          handle_simple_irq);
-                set_irq_flags(i, IRQF_VALID);
+                set_irq_flags(irq, IRQF_VALID);
         }
 
         for (i = 0; i < ARRAY_SIZE(tegra_gpio_banks); i++) {
diff --git a/drivers/gpio/gpio-tnetv107x.c b/drivers/gpio/gpio-tnetv107x.c
new file mode 100644
index 000000000000..3fa3e2867e19
--- /dev/null
+++ b/drivers/gpio/gpio-tnetv107x.c
@@ -0,0 +1,205 @@
+/*
+ * Texas Instruments TNETV107X GPIO Controller
+ *
+ * Copyright (C) 2010 Texas Instruments
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/gpio.h>
+
+#include <mach/common.h>
+#include <mach/tnetv107x.h>
+
+struct tnetv107x_gpio_regs {
+        u32     idver;
+        u32     data_in[3];
+        u32     data_out[3];
+        u32     direction[3];
+        u32     enable[3];
+};
+
+#define gpio_reg_index(gpio)    ((gpio) >> 5)
+#define gpio_reg_bit(gpio)      BIT((gpio) & 0x1f)
+
+#define gpio_reg_rmw(reg, mask, val)    \
+        __raw_writel((__raw_readl(reg) & ~(mask)) | (val), (reg))
+
+#define gpio_reg_set_bit(reg, gpio)     \
+        gpio_reg_rmw((reg) + gpio_reg_index(gpio), 0, gpio_reg_bit(gpio))
+
+#define gpio_reg_clear_bit(reg, gpio)   \
+        gpio_reg_rmw((reg) + gpio_reg_index(gpio), gpio_reg_bit(gpio), 0)
+
+#define gpio_reg_get_bit(reg, gpio)     \
+        (__raw_readl((reg) + gpio_reg_index(gpio)) & gpio_reg_bit(gpio))
+
+#define chip2controller(chip)           \
+        container_of(chip, struct davinci_gpio_controller, chip)
+
+#define TNETV107X_GPIO_CTLRS    DIV_ROUND_UP(TNETV107X_N_GPIO, 32)
+
+static struct davinci_gpio_controller chips[TNETV107X_GPIO_CTLRS];
+
+static int tnetv107x_gpio_request(struct gpio_chip *chip, unsigned offset)
+{
+        struct davinci_gpio_controller *ctlr = chip2controller(chip);
+        struct tnetv107x_gpio_regs __iomem *regs = ctlr->regs;
+        unsigned gpio = chip->base + offset;
+        unsigned long flags;
+
+        spin_lock_irqsave(&ctlr->lock, flags);
+
+        gpio_reg_set_bit(regs->enable, gpio);
+
+        spin_unlock_irqrestore(&ctlr->lock, flags);
+
+        return 0;
+}
+
+static void tnetv107x_gpio_free(struct gpio_chip *chip, unsigned offset)
+{
+        struct davinci_gpio_controller *ctlr = chip2controller(chip);
+        struct tnetv107x_gpio_regs __iomem *regs = ctlr->regs;
+        unsigned gpio = chip->base + offset;
+        unsigned long flags;
+
+        spin_lock_irqsave(&ctlr->lock, flags);
+
+        gpio_reg_clear_bit(regs->enable, gpio);
+
+        spin_unlock_irqrestore(&ctlr->lock, flags);
+}
+
+static int tnetv107x_gpio_dir_in(struct gpio_chip *chip, unsigned offset)
+{
+        struct davinci_gpio_controller *ctlr = chip2controller(chip);
+        struct tnetv107x_gpio_regs __iomem *regs = ctlr->regs;
+        unsigned gpio = chip->base + offset;
+        unsigned long flags;
+
+        spin_lock_irqsave(&ctlr->lock, flags);
+
+        gpio_reg_set_bit(regs->direction, gpio);
+
+        spin_unlock_irqrestore(&ctlr->lock, flags);
+
+        return 0;
+}
+
+static int tnetv107x_gpio_dir_out(struct gpio_chip *chip,
+                unsigned offset, int value)
+{
+        struct davinci_gpio_controller *ctlr = chip2controller(chip);
+        struct tnetv107x_gpio_regs __iomem *regs = ctlr->regs;
+        unsigned gpio = chip->base + offset;
+        unsigned long flags;
+
+        spin_lock_irqsave(&ctlr->lock, flags);
+
+        if (value)
+                gpio_reg_set_bit(regs->data_out, gpio);
+        else
+                gpio_reg_clear_bit(regs->data_out, gpio);
+
+        gpio_reg_clear_bit(regs->direction, gpio);
+
+        spin_unlock_irqrestore(&ctlr->lock, flags);
+
+        return 0;
+}
+
+static int tnetv107x_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        struct davinci_gpio_controller *ctlr = chip2controller(chip);
+        struct tnetv107x_gpio_regs __iomem *regs = ctlr->regs;
+        unsigned gpio = chip->base + offset;
+        int ret;
+
+        ret = gpio_reg_get_bit(regs->data_in, gpio);
+
+        return ret ? 1 : 0;
+}
+
+static void tnetv107x_gpio_set(struct gpio_chip *chip,
+                unsigned offset, int value)
+{
+        struct davinci_gpio_controller *ctlr = chip2controller(chip);
+        struct tnetv107x_gpio_regs __iomem *regs = ctlr->regs;
+        unsigned gpio = chip->base + offset;
+        unsigned long flags;
+
+        spin_lock_irqsave(&ctlr->lock, flags);
+
+        if (value)
+                gpio_reg_set_bit(regs->data_out, gpio);
+        else
+                gpio_reg_clear_bit(regs->data_out, gpio);
+
+        spin_unlock_irqrestore(&ctlr->lock, flags);
+}
+
+static int __init tnetv107x_gpio_setup(void)
+{
+        int i, base;
+        unsigned ngpio;
+        struct davinci_soc_info *soc_info = &davinci_soc_info;
+        struct tnetv107x_gpio_regs *regs;
+        struct davinci_gpio_controller *ctlr;
+
+        if (soc_info->gpio_type != GPIO_TYPE_TNETV107X)
+                return 0;
+
+        ngpio = soc_info->gpio_num;
+        if (ngpio == 0) {
+                pr_err("GPIO setup:  how many GPIOs?\n");
+                return -EINVAL;
+        }
+
+        if (WARN_ON(TNETV107X_N_GPIO < ngpio))
+                ngpio = TNETV107X_N_GPIO;
+
+        regs = ioremap(soc_info->gpio_base, SZ_4K);
+        if (WARN_ON(!regs))
+                return -EINVAL;
+
+        for (i = 0, base = 0; base < ngpio; i++, base += 32) {
+                ctlr = &chips[i];
+
+                ctlr->chip.label        = "tnetv107x";
+                ctlr->chip.can_sleep    = 0;
+                ctlr->chip.base         = base;
+                ctlr->chip.ngpio        = ngpio - base;
+                if (ctlr->chip.ngpio > 32)
+                        ctlr->chip.ngpio = 32;
+
+                ctlr->chip.request              = tnetv107x_gpio_request;
+                ctlr->chip.free                 = tnetv107x_gpio_free;
+                ctlr->chip.direction_input      = tnetv107x_gpio_dir_in;
+                ctlr->chip.get                  = tnetv107x_gpio_get;
+                ctlr->chip.direction_output     = tnetv107x_gpio_dir_out;
+                ctlr->chip.set                  = tnetv107x_gpio_set;
+
+                spin_lock_init(&ctlr->lock);
+
+                ctlr->regs      = regs;
+                ctlr->set_data  = &regs->data_out[i];
+                ctlr->clr_data  = &regs->data_out[i];
+                ctlr->in_data   = &regs->data_in[i];
+
+                gpiochip_add(&ctlr->chip);
+        }
+
+        soc_info->gpio_ctlrs = chips;
+        soc_info->gpio_ctlrs_num = DIV_ROUND_UP(ngpio, 32);
+        return 0;
+}
+pure_initcall(tnetv107x_gpio_setup);
diff --git a/drivers/gpio/gpio-u300.c b/drivers/gpio/gpio-u300.c
index 53e8255cb0ba..4035778852b0 100644
--- a/drivers/gpio/gpio-u300.c
+++ b/drivers/gpio/gpio-u300.c
@@ -1,18 +1,17 @@
 /*
  * U300 GPIO module.
  *
- * Copyright (C) 2007-2009 ST-Ericsson AB
+ * Copyright (C) 2007-2011 ST-Ericsson AB
  * License terms: GNU General Public License (GPL) version 2
  * This can driver either of the two basic GPIO cores
  * available in the U300 platforms:
  * COH 901 335   - Used in DB3150 (U300 1.0) and DB3200 (U330 1.0)
  * COH 901 571/3 - Used in DB3210 (U365 2.0) and DB3350 (U335 1.0)
- * Notice that you also have inline macros in <asm-arch/gpio.h>
- * Author: Linus Walleij <linus.walleij@stericsson.com>
+ * Author: Linus Walleij <linus.walleij@linaro.org>
  * Author: Jonas Aaberg <jonas.aberg@stericsson.com>
- *
  */
 #include <linux/module.h>
+#include <linux/irq.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/errno.h>
@@ -21,677 +20,898 @@
 #include <linux/err.h>
 #include <linux/platform_device.h>
 #include <linux/gpio.h>
+#include <linux/list.h>
+#include <linux/slab.h>
+#include <mach/gpio-u300.h>
 
-/* Reference to GPIO block clock */
-static struct clk *clk;
+/*
+ * Bias modes for U300 GPIOs
+ *
+ * GPIO_U300_CONFIG_BIAS_UNKNOWN: this bias mode is not known to us
+ * GPIO_U300_CONFIG_BIAS_FLOAT: no specific bias, the GPIO will float or state
+ *      is not controlled by software
+ * GPIO_U300_CONFIG_BIAS_PULL_UP: the GPIO will be pulled up (usually with high
+ *      impedance to VDD)
+ */
+#define GPIO_U300_CONFIG_BIAS_UNKNOWN   0x1000
+#define GPIO_U300_CONFIG_BIAS_FLOAT     0x1001
+#define GPIO_U300_CONFIG_BIAS_PULL_UP   0x1002
 
-/* Memory resource */
-static struct resource *memres;
-static void __iomem *virtbase;
-static struct device *gpiodev;
+/*
+ * Drive modes for U300 GPIOs (output)
+ *
+ * GPIO_U300_CONFIG_DRIVE_PUSH_PULL: the GPIO will be driven actively high and
+ *      low, this is the most typical case and is typically achieved with two
+ *      active transistors on the output
+ * GPIO_U300_CONFIG_DRIVE_OPEN_DRAIN: the GPIO will be driven with open drain
+ *      (open collector) which means it is usually wired with other output
+ *      ports which are then pulled up with an external resistor
+ * GPIO_U300_CONFIG_DRIVE_OPEN_SOURCE: the GPIO will be driven with open drain
+ *      (open emitter) which is the same as open drain mutatis mutandis but
+ *      pulled to ground
+ */
+#define GPIO_U300_CONFIG_DRIVE_PUSH_PULL        0x2000
+#define GPIO_U300_CONFIG_DRIVE_OPEN_DRAIN       0x2001
+#define GPIO_U300_CONFIG_DRIVE_OPEN_SOURCE      0x2002
+
+/*
+ * Register definitions for COH 901 335 variant
+ */
+#define U300_335_PORT_STRIDE                            (0x1C)
+/* Port X Pin Data Register 32bit, this is both input and output (R/W) */
+#define U300_335_PXPDIR                                 (0x00)
+#define U300_335_PXPDOR                                 (0x00)
+/* Port X Pin Config Register 32bit (R/W) */
+#define U300_335_PXPCR                                  (0x04)
+/* This register layout is the same in both blocks */
+#define U300_GPIO_PXPCR_ALL_PINS_MODE_MASK              (0x0000FFFFUL)
+#define U300_GPIO_PXPCR_PIN_MODE_MASK                   (0x00000003UL)
+#define U300_GPIO_PXPCR_PIN_MODE_SHIFT                  (0x00000002UL)
+#define U300_GPIO_PXPCR_PIN_MODE_INPUT                  (0x00000000UL)
+#define U300_GPIO_PXPCR_PIN_MODE_OUTPUT_PUSH_PULL       (0x00000001UL)
+#define U300_GPIO_PXPCR_PIN_MODE_OUTPUT_OPEN_DRAIN      (0x00000002UL)
+#define U300_GPIO_PXPCR_PIN_MODE_OUTPUT_OPEN_SOURCE     (0x00000003UL)
+/* Port X Interrupt Event Register 32bit (R/W) */
+#define U300_335_PXIEV                                  (0x08)
+/* Port X Interrupt Enable Register 32bit (R/W) */
+#define U300_335_PXIEN                                  (0x0C)
+/* Port X Interrupt Force Register 32bit (R/W) */
+#define U300_335_PXIFR                                  (0x10)
+/* Port X Interrupt Config Register 32bit (R/W) */
+#define U300_335_PXICR                                  (0x14)
+/* This register layout is the same in both blocks */
+#define U300_GPIO_PXICR_ALL_IRQ_CONFIG_MASK             (0x000000FFUL)
+#define U300_GPIO_PXICR_IRQ_CONFIG_MASK                 (0x00000001UL)
+#define U300_GPIO_PXICR_IRQ_CONFIG_FALLING_EDGE         (0x00000000UL)
+#define U300_GPIO_PXICR_IRQ_CONFIG_RISING_EDGE          (0x00000001UL)
+/* Port X Pull-up Enable Register 32bit (R/W) */
+#define U300_335_PXPER                                  (0x18)
+/* This register layout is the same in both blocks */
+#define U300_GPIO_PXPER_ALL_PULL_UP_DISABLE_MASK        (0x000000FFUL)
+#define U300_GPIO_PXPER_PULL_UP_DISABLE                 (0x00000001UL)
+/* Control Register 32bit (R/W) */
+#define U300_335_CR                                     (0x54)
+#define U300_335_CR_BLOCK_CLOCK_ENABLE                  (0x00000001UL)
+
+/*
+ * Register definitions for COH 901 571 / 3 variant
+ */
+#define U300_571_PORT_STRIDE                            (0x30)
+/*
+ * Control Register 32bit (R/W)
+ * bit 15-9 (mask 0x0000FE00) contains the number of cores. 8*cores
+ * gives the number of GPIO pins.
+ * bit 8-2  (mask 0x000001FC) contains the core version ID.
+ */
+#define U300_571_CR                                     (0x00)
+#define U300_571_CR_SYNC_SEL_ENABLE                     (0x00000002UL)
+#define U300_571_CR_BLOCK_CLKRQ_ENABLE                  (0x00000001UL)
+/*
+ * These registers have the same layout and function as the corresponding
+ * COH 901 335 registers, just at different offset.
+ */
+#define U300_571_PXPDIR                                 (0x04)
+#define U300_571_PXPDOR                                 (0x08)
+#define U300_571_PXPCR                                  (0x0C)
+#define U300_571_PXPER                                  (0x10)
+#define U300_571_PXIEV                                  (0x14)
+#define U300_571_PXIEN                                  (0x18)
+#define U300_571_PXIFR                                  (0x1C)
+#define U300_571_PXICR                                  (0x20)
+
+/* 8 bits per port, no version has more than 7 ports */
+#define U300_GPIO_PINS_PER_PORT 8
+#define U300_GPIO_MAX (U300_GPIO_PINS_PER_PORT * 7)
+
+struct u300_gpio {
+        struct gpio_chip chip;
+        struct list_head port_list;
+        struct clk *clk;
+        struct resource *memres;
+        void __iomem *base;
+        struct device *dev;
+        int irq_base;
+        u32 stride;
+        /* Register offsets */
+        u32 pcr;
+        u32 dor;
+        u32 dir;
+        u32 per;
+        u32 icr;
+        u32 ien;
+        u32 iev;
+};
 
 struct u300_gpio_port {
-        const char *name;
+        struct list_head node;
+        struct u300_gpio *gpio;
+        char name[8];
         int irq;
         int number;
+        u8 toggle_edge_mode;
 };
 
+/*
+ * Macro to expand to read a specific register found in the "gpio"
+ * struct. It requires the struct u300_gpio *gpio variable to exist in
+ * its context. It calculates the port offset from the given pin
+ * offset, muliplies by the port stride and adds the register offset
+ * so it provides a pointer to the desired register.
+ */
+#define U300_PIN_REG(pin, reg) \
+        (gpio->base + (pin >> 3) * gpio->stride + gpio->reg)
 
-static struct u300_gpio_port gpio_ports[] = {
-        {
-                .name = "gpio0",
-                .number = 0,
-        },
-        {
-                .name = "gpio1",
-                .number = 1,
-        },
-        {
-                .name = "gpio2",
-                .number = 2,
-        },
-#ifdef U300_COH901571_3
-        {
-                .name = "gpio3",
-                .number = 3,
-        },
-        {
-                .name = "gpio4",
-                .number = 4,
-        },
-#ifdef CONFIG_MACH_U300_BS335
-        {
-                .name = "gpio5",
-                .number = 5,
-        },
-        {
-                .name = "gpio6",
-                .number = 6,
-        },
-#endif
-#endif
+/*
+ * Provides a bitmask for a specific gpio pin inside an 8-bit GPIO
+ * register.
+ */
+#define U300_PIN_BIT(pin) \
+        (1 << (pin & 0x07))
 
+struct u300_gpio_confdata {
+        u16 bias_mode;
+        bool output;
+        int outval;
 };
 
+/* BS335 has seven ports of 8 bits each = GPIO pins 0..55 */
+#define BS335_GPIO_NUM_PORTS 7
+/* BS365 has five ports of 8 bits each = GPIO pins 0..39 */
+#define BS365_GPIO_NUM_PORTS 5
 
-#ifdef U300_COH901571_3
+#define U300_FLOATING_INPUT { \
+        .bias_mode = GPIO_U300_CONFIG_BIAS_FLOAT, \
+        .output = false, \
+}
 
-/* Default input value */
-#define DEFAULT_OUTPUT_LOW   0
-#define DEFAULT_OUTPUT_HIGH  1
+#define U300_PULL_UP_INPUT { \
+        .bias_mode = GPIO_U300_CONFIG_BIAS_PULL_UP, \
+        .output = false, \
+}
 
-/* GPIO Pull-Up status */
-#define DISABLE_PULL_UP  0
-#define ENABLE_PULL_UP  1
+#define U300_OUTPUT_LOW { \
+        .output = true, \
+        .outval = 0, \
+}
 
-#define GPIO_NOT_USED 0
-#define GPIO_IN       1
-#define GPIO_OUT      2
+#define U300_OUTPUT_HIGH { \
+        .output = true, \
+        .outval = 1, \
+}
 
-struct u300_gpio_configuration_data {
-        unsigned char pin_usage;
-        unsigned char default_output_value;
-        unsigned char pull_up;
-};
 
 /* Initial configuration */
-const struct u300_gpio_configuration_data
-u300_gpio_config[U300_GPIO_NUM_PORTS][U300_GPIO_PINS_PER_PORT] = {
-#ifdef CONFIG_MACH_U300_BS335
+static const struct __initdata u300_gpio_confdata
+bs335_gpio_config[BS335_GPIO_NUM_PORTS][U300_GPIO_PINS_PER_PORT] = {
         /* Port 0, pins 0-7 */
         {
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_HIGH,  DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+                U300_FLOATING_INPUT,
+                U300_OUTPUT_HIGH,
+                U300_FLOATING_INPUT,
+                U300_OUTPUT_LOW,
+                U300_OUTPUT_LOW,
+                U300_OUTPUT_LOW,
+                U300_OUTPUT_LOW,
+                U300_OUTPUT_LOW,
         },
         /* Port 1, pins 0-7 */
         {
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_HIGH,  DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+                U300_OUTPUT_LOW,
+                U300_OUTPUT_LOW,
+                U300_OUTPUT_LOW,
+                U300_PULL_UP_INPUT,
+                U300_FLOATING_INPUT,
+                U300_OUTPUT_HIGH,
+                U300_OUTPUT_LOW,
+                U300_OUTPUT_LOW,
         },
         /* Port 2, pins 0-7 */
         {
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP}
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_OUTPUT_LOW,
+                U300_PULL_UP_INPUT,
+                U300_OUTPUT_LOW,
+                U300_PULL_UP_INPUT,
         },
         /* Port 3, pins 0-7 */
         {
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+                U300_PULL_UP_INPUT,
+                U300_OUTPUT_LOW,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
         },
         /* Port 4, pins 0-7 */
         {
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
         },
         /* Port 5, pins 0-7 */
         {
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
         },
         /* Port 6, pind 0-7 */
         {
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
         }
-#endif
+};
 
-#ifdef CONFIG_MACH_U300_BS365
+static const struct __initdata u300_gpio_confdata
+bs365_gpio_config[BS365_GPIO_NUM_PORTS][U300_GPIO_PINS_PER_PORT] = {
         /* Port 0, pins 0-7 */
         {
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+                U300_FLOATING_INPUT,
+                U300_OUTPUT_LOW,
+                U300_FLOATING_INPUT,
+                U300_OUTPUT_LOW,
+                U300_OUTPUT_LOW,
+                U300_OUTPUT_LOW,
+                U300_PULL_UP_INPUT,
+                U300_FLOATING_INPUT,
         },
         /* Port 1, pins 0-7 */
         {
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_HIGH,  DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+                U300_OUTPUT_LOW,
+                U300_FLOATING_INPUT,
+                U300_OUTPUT_LOW,
+                U300_FLOATING_INPUT,
+                U300_FLOATING_INPUT,
+                U300_OUTPUT_HIGH,
+                U300_OUTPUT_LOW,
+                U300_OUTPUT_LOW,
         },
         /* Port 2, pins 0-7 */
         {
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP}
+                U300_FLOATING_INPUT,
+                U300_PULL_UP_INPUT,
+                U300_OUTPUT_LOW,
+                U300_OUTPUT_LOW,
+                U300_PULL_UP_INPUT,
+                U300_PULL_UP_INPUT,
+                U300_PULL_UP_INPUT,
+                U300_PULL_UP_INPUT,
         },
         /* Port 3, pins 0-7 */
         {
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP}
+                U300_PULL_UP_INPUT,
+                U300_PULL_UP_INPUT,
+                U300_PULL_UP_INPUT,
+                U300_PULL_UP_INPUT,
+                U300_PULL_UP_INPUT,
+                U300_PULL_UP_INPUT,
+                U300_PULL_UP_INPUT,
+                U300_PULL_UP_INPUT,
         },
         /* Port 4, pins 0-7 */
         {
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                U300_PULL_UP_INPUT,
+                U300_PULL_UP_INPUT,
+                U300_PULL_UP_INPUT,
+                U300_PULL_UP_INPUT,
                 /* These 4 pins doesn't exist on DB3210 */
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
-                {GPIO_OUT, DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP}
+                U300_OUTPUT_LOW,
+                U300_OUTPUT_LOW,
+                U300_OUTPUT_LOW,
+                U300_OUTPUT_LOW,
         }
-#endif
 };
-#endif
 
-
-/* No users == we can power down GPIO */
-static int gpio_users;
-
-struct gpio_struct {
-        int (*callback)(void *);
-        void *data;
-        int users;
-};
-
-static struct gpio_struct gpio_pin[U300_GPIO_MAX];
-
-/*
- * Let drivers register callback in order to get notified when there is
- * an interrupt on the gpio pin
+/**
+ * to_u300_gpio() - get the pointer to u300_gpio
+ * @chip: the gpio chip member of the structure u300_gpio
  */
-int gpio_register_callback(unsigned gpio, int (*func)(void *arg), void *data)
+static inline struct u300_gpio *to_u300_gpio(struct gpio_chip *chip)
 {
-        if (gpio_pin[gpio].callback)
-                dev_warn(gpiodev, "%s: WARNING: callback already "
-                         "registered for gpio pin#%d\n", __func__, gpio);
-        gpio_pin[gpio].callback = func;
-        gpio_pin[gpio].data = data;
-
-        return 0;
+        return container_of(chip, struct u300_gpio, chip);
 }
-EXPORT_SYMBOL(gpio_register_callback);
 
-int gpio_unregister_callback(unsigned gpio)
+static int u300_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        if (!gpio_pin[gpio].callback)
-                dev_warn(gpiodev, "%s: WARNING: callback already "
-                         "unregistered for gpio pin#%d\n", __func__, gpio);
-        gpio_pin[gpio].callback = NULL;
-        gpio_pin[gpio].data = NULL;
+        struct u300_gpio *gpio = to_u300_gpio(chip);
 
-        return 0;
+        return readl(U300_PIN_REG(offset, dir)) & U300_PIN_BIT(offset);
 }
-EXPORT_SYMBOL(gpio_unregister_callback);
 
-/* Non-zero means valid */
-int gpio_is_valid(int number)
+static void u300_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        if (number >= 0 &&
-            number < (U300_GPIO_NUM_PORTS * U300_GPIO_PINS_PER_PORT))
-                return 1;
-        return 0;
-}
-EXPORT_SYMBOL(gpio_is_valid);
+        struct u300_gpio *gpio = to_u300_gpio(chip);
+        unsigned long flags;
+        u32 val;
 
-int gpio_request(unsigned gpio, const char *label)
-{
-        if (gpio_pin[gpio].users)
-                return -EINVAL;
-        else
-                gpio_pin[gpio].users++;
+        local_irq_save(flags);
 
-        gpio_users++;
+        val = readl(U300_PIN_REG(offset, dor));
+        if (value)
+                writel(val | U300_PIN_BIT(offset), U300_PIN_REG(offset, dor));
+        else
+                writel(val & ~U300_PIN_BIT(offset), U300_PIN_REG(offset, dor));
 
-        return 0;
+        local_irq_restore(flags);
 }
-EXPORT_SYMBOL(gpio_request);
 
-void gpio_free(unsigned gpio)
+static int u300_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        gpio_users--;
-        gpio_pin[gpio].users--;
-        if (unlikely(gpio_pin[gpio].users < 0)) {
-                dev_warn(gpiodev, "warning: gpio#%d release mismatch\n",
-                         gpio);
-                gpio_pin[gpio].users = 0;
-        }
-
-        return;
-}
-EXPORT_SYMBOL(gpio_free);
+        struct u300_gpio *gpio = to_u300_gpio(chip);
+        unsigned long flags;
+        u32 val;
 
-/* This returns zero or nonzero */
-int gpio_get_value(unsigned gpio)
-{
-        return readl(virtbase + U300_GPIO_PXPDIR +
-          PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING) & (1 << (gpio & 0x07));
+        local_irq_save(flags);
+        val = readl(U300_PIN_REG(offset, pcr));
+        /* Mask out this pin, note 2 bits per setting */
+        val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK << ((offset & 0x07) << 1));
+        writel(val, U300_PIN_REG(offset, pcr));
+        local_irq_restore(flags);
+        return 0;
 }
-EXPORT_SYMBOL(gpio_get_value);
 
-/*
- * We hope that the compiler will optimize away the unused branch
- * in case "value" is a constant
- */
-void gpio_set_value(unsigned gpio, int value)
+static int u300_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
+                                      int value)
 {
-        u32 val;
+        struct u300_gpio *gpio = to_u300_gpio(chip);
         unsigned long flags;
+        u32 oldmode;
+        u32 val;
 
         local_irq_save(flags);
-        if (value) {
-                /* set */
-                val = readl(virtbase + U300_GPIO_PXPDOR +
-                  PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING)
-                  & (1 << (gpio & 0x07));
-                writel(val | (1 << (gpio & 0x07)), virtbase +
-                  U300_GPIO_PXPDOR +
-                  PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING);
-        } else {
-                /* clear */
-                val = readl(virtbase + U300_GPIO_PXPDOR +
-                  PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING)
-                  & (1 << (gpio & 0x07));
-                writel(val & ~(1 << (gpio & 0x07)), virtbase +
-                  U300_GPIO_PXPDOR +
-                  PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING);
+        val = readl(U300_PIN_REG(offset, pcr));
+        /*
+         * Drive mode must be set by the special mode set function, set
+         * push/pull mode by default if no mode has been selected.
+         */
+        oldmode = val & (U300_GPIO_PXPCR_PIN_MODE_MASK <<
+                         ((offset & 0x07) << 1));
+        /* mode = 0 means input, else some mode is already set */
+        if (oldmode == 0) {
+                val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK <<
+                         ((offset & 0x07) << 1));
+                val |= (U300_GPIO_PXPCR_PIN_MODE_OUTPUT_PUSH_PULL
+                        << ((offset & 0x07) << 1));
+                writel(val, U300_PIN_REG(offset, pcr));
         }
+        u300_gpio_set(chip, offset, value);
         local_irq_restore(flags);
+        return 0;
 }
-EXPORT_SYMBOL(gpio_set_value);
 
-int gpio_direction_input(unsigned gpio)
+static int u300_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 {
+        struct u300_gpio *gpio = to_u300_gpio(chip);
+        int retirq = gpio->irq_base + offset;
+
+        dev_dbg(gpio->dev, "request IRQ for GPIO %d, return %d\n", offset,
+                retirq);
+        return retirq;
+}
+
+static int u300_gpio_config(struct gpio_chip *chip, unsigned offset,
+                     u16 param, unsigned long *data)
+{
+        struct u300_gpio *gpio = to_u300_gpio(chip);
         unsigned long flags;
         u32 val;
 
-        if (gpio > U300_GPIO_MAX)
-                return -EINVAL;
-
         local_irq_save(flags);
-        val = readl(virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) *
-                                U300_GPIO_PORTX_SPACING);
-        /* Mask out this pin*/
-        val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK << ((gpio & 0x07) << 1));
-        /* This is not needed since it sets the bits to zero.*/
-        /* val |= (U300_GPIO_PXPCR_PIN_MODE_INPUT << (gpio*2)); */
-        writel(val, virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) *
-                                U300_GPIO_PORTX_SPACING);
+        switch (param) {
+        case GPIO_U300_CONFIG_BIAS_UNKNOWN:
+        case GPIO_U300_CONFIG_BIAS_FLOAT:
+                val = readl(U300_PIN_REG(offset, per));
+                writel(val | U300_PIN_BIT(offset), U300_PIN_REG(offset, per));
+                break;
+        case GPIO_U300_CONFIG_BIAS_PULL_UP:
+                val = readl(U300_PIN_REG(offset, per));
+                writel(val & ~U300_PIN_BIT(offset), U300_PIN_REG(offset, per));
+                break;
+        case GPIO_U300_CONFIG_DRIVE_PUSH_PULL:
+                val = readl(U300_PIN_REG(offset, pcr));
+                val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK
+                         << ((offset & 0x07) << 1));
+                val |= (U300_GPIO_PXPCR_PIN_MODE_OUTPUT_PUSH_PULL
+                        << ((offset & 0x07) << 1));
+                writel(val, U300_PIN_REG(offset, pcr));
+                break;
+        case GPIO_U300_CONFIG_DRIVE_OPEN_DRAIN:
+                val = readl(U300_PIN_REG(offset, pcr));
+                val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK
+                         << ((offset & 0x07) << 1));
+                val |= (U300_GPIO_PXPCR_PIN_MODE_OUTPUT_OPEN_DRAIN
+                        << ((offset & 0x07) << 1));
+                writel(val, U300_PIN_REG(offset, pcr));
+                break;
+        case GPIO_U300_CONFIG_DRIVE_OPEN_SOURCE:
+                val = readl(U300_PIN_REG(offset, pcr));
+                val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK
+                         << ((offset & 0x07) << 1));
+                val |= (U300_GPIO_PXPCR_PIN_MODE_OUTPUT_OPEN_SOURCE
+                        << ((offset & 0x07) << 1));
+                writel(val, U300_PIN_REG(offset, pcr));
+                break;
+        default:
+                local_irq_restore(flags);
+                dev_err(gpio->dev, "illegal configuration requested\n");
+                return -EINVAL;
+        }
         local_irq_restore(flags);
         return 0;
 }
-EXPORT_SYMBOL(gpio_direction_input);
 
-int gpio_direction_output(unsigned gpio, int value)
+static struct gpio_chip u300_gpio_chip = {
+        .label                  = "u300-gpio-chip",
+        .owner                  = THIS_MODULE,
+        .get                    = u300_gpio_get,
+        .set                    = u300_gpio_set,
+        .direction_input        = u300_gpio_direction_input,
+        .direction_output       = u300_gpio_direction_output,
+        .to_irq                 = u300_gpio_to_irq,
+};
+
+static void u300_toggle_trigger(struct u300_gpio *gpio, unsigned offset)
 {
-        unsigned long flags;
         u32 val;
 
-        if (gpio > U300_GPIO_MAX)
-                return -EINVAL;
-
-        local_irq_save(flags);
-        val = readl(virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) *
-                                U300_GPIO_PORTX_SPACING);
-        /* Mask out this pin */
-        val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK << ((gpio & 0x07) << 1));
-        /*
-         * FIXME: configure for push/pull, open drain or open source per pin
-         * in setup. The current driver will only support push/pull.
-         */
-        val |= (U300_GPIO_PXPCR_PIN_MODE_OUTPUT_PUSH_PULL
-                        << ((gpio & 0x07) << 1));
-        writel(val, virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) *
-                                U300_GPIO_PORTX_SPACING);
-        gpio_set_value(gpio, value);
-        local_irq_restore(flags);
-        return 0;
+        val = readl(U300_PIN_REG(offset, icr));
+        /* Set mode depending on state */
+        if (u300_gpio_get(&gpio->chip, offset)) {
+                /* High now, let's trigger on falling edge next then */
+                writel(val & ~U300_PIN_BIT(offset), U300_PIN_REG(offset, icr));
+                dev_dbg(gpio->dev, "next IRQ on falling edge on pin %d\n",
+                        offset);
+        } else {
+                /* Low now, let's trigger on rising edge next then */
+                writel(val | U300_PIN_BIT(offset), U300_PIN_REG(offset, icr));
+                dev_dbg(gpio->dev, "next IRQ on rising edge on pin %d\n",
+                        offset);
+        }
 }
-EXPORT_SYMBOL(gpio_direction_output);
 
-/*
- * Enable an IRQ, edge is rising edge (!= 0) or falling edge (==0).
- */
-void enable_irq_on_gpio_pin(unsigned gpio, int edge)
+static int u300_gpio_irq_type(struct irq_data *d, unsigned trigger)
 {
+        struct u300_gpio_port *port = irq_data_get_irq_chip_data(d);
+        struct u300_gpio *gpio = port->gpio;
+        int offset = d->irq - gpio->irq_base;
         u32 val;
-        unsigned long flags;
-        local_irq_save(flags);
 
-        val = readl(virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) *
-                                U300_GPIO_PORTX_SPACING);
-        val |= (1 << (gpio & 0x07));
-        writel(val, virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) *
-                                U300_GPIO_PORTX_SPACING);
-        val = readl(virtbase + U300_GPIO_PXICR + PIN_TO_PORT(gpio) *
-                                U300_GPIO_PORTX_SPACING);
-        if (edge)
-                val |= (1 << (gpio & 0x07));
-        else
-                val &= ~(1 << (gpio & 0x07));
-        writel(val, virtbase + U300_GPIO_PXICR + PIN_TO_PORT(gpio) *
-                                U300_GPIO_PORTX_SPACING);
-        local_irq_restore(flags);
+        if ((trigger & IRQF_TRIGGER_RISING) &&
+            (trigger & IRQF_TRIGGER_FALLING)) {
+                /*
+                 * The GPIO block can only trigger on falling OR rising edges,
+                 * not both. So we need to toggle the mode whenever the pin
+                 * goes from one state to the other with a special state flag
+                 */
+                dev_dbg(gpio->dev,
+                        "trigger on both rising and falling edge on pin %d\n",
+                        offset);
+                port->toggle_edge_mode |= U300_PIN_BIT(offset);
+                u300_toggle_trigger(gpio, offset);
+        } else if (trigger & IRQF_TRIGGER_RISING) {
+                dev_dbg(gpio->dev, "trigger on rising edge on pin %d\n",
+                        offset);
+                val = readl(U300_PIN_REG(offset, icr));
+                writel(val | U300_PIN_BIT(offset), U300_PIN_REG(offset, icr));
+                port->toggle_edge_mode &= ~U300_PIN_BIT(offset);
+        } else if (trigger & IRQF_TRIGGER_FALLING) {
+                dev_dbg(gpio->dev, "trigger on falling edge on pin %d\n",
+                        offset);
+                val = readl(U300_PIN_REG(offset, icr));
+                writel(val & ~U300_PIN_BIT(offset), U300_PIN_REG(offset, icr));
+                port->toggle_edge_mode &= ~U300_PIN_BIT(offset);
+        }
+
+        return 0;
 }
-EXPORT_SYMBOL(enable_irq_on_gpio_pin);
 
-void disable_irq_on_gpio_pin(unsigned gpio)
+static void u300_gpio_irq_enable(struct irq_data *d)
 {
+        struct u300_gpio_port *port = irq_data_get_irq_chip_data(d);
+        struct u300_gpio *gpio = port->gpio;
+        int offset = d->irq - gpio->irq_base;
         u32 val;
         unsigned long flags;
 
         local_irq_save(flags);
-        val = readl(virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) *
-                                U300_GPIO_PORTX_SPACING);
-        val &= ~(1 << (gpio & 0x07));
-        writel(val, virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) *
-                                U300_GPIO_PORTX_SPACING);
+        val = readl(U300_PIN_REG(offset, ien));
+        writel(val | U300_PIN_BIT(offset), U300_PIN_REG(offset, ien));
         local_irq_restore(flags);
 }
-EXPORT_SYMBOL(disable_irq_on_gpio_pin);
 
-/* Enable (value == 0) or disable (value == 1) internal pullup */
-void gpio_pullup(unsigned gpio, int value)
+static void u300_gpio_irq_disable(struct irq_data *d)
 {
+        struct u300_gpio_port *port = irq_data_get_irq_chip_data(d);
+        struct u300_gpio *gpio = port->gpio;
+        int offset = d->irq - gpio->irq_base;
         u32 val;
         unsigned long flags;
 
         local_irq_save(flags);
-        if (value) {
-                val = readl(virtbase + U300_GPIO_PXPER + PIN_TO_PORT(gpio) *
-                                        U300_GPIO_PORTX_SPACING);
-                writel(val | (1 << (gpio & 0x07)), virtbase + U300_GPIO_PXPER +
-                                PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING);
-        } else {
-                val = readl(virtbase + U300_GPIO_PXPER + PIN_TO_PORT(gpio) *
-                                        U300_GPIO_PORTX_SPACING);
-                writel(val & ~(1 << (gpio & 0x07)), virtbase + U300_GPIO_PXPER +
-                                PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING);
-        }
+        val = readl(U300_PIN_REG(offset, ien));
+        writel(val & ~U300_PIN_BIT(offset), U300_PIN_REG(offset, ien));
         local_irq_restore(flags);
 }
-EXPORT_SYMBOL(gpio_pullup);
 
-static irqreturn_t gpio_irq_handler(int irq, void *dev_id)
+static struct irq_chip u300_gpio_irqchip = {
+        .name                   = "u300-gpio-irqchip",
+        .irq_enable             = u300_gpio_irq_enable,
+        .irq_disable            = u300_gpio_irq_disable,
+        .irq_set_type           = u300_gpio_irq_type,
+
+};
+
+static void u300_gpio_irq_handler(unsigned irq, struct irq_desc *desc)
 {
-        struct u300_gpio_port *port = dev_id;
-        u32 val;
-        int pin;
+        struct u300_gpio_port *port = irq_get_handler_data(irq);
+        struct u300_gpio *gpio = port->gpio;
+        int pinoffset = port->number << 3; /* get the right stride */
+        unsigned long val;
 
+        desc->irq_data.chip->irq_ack(&desc->irq_data);
         /* Read event register */
-        val = readl(virtbase + U300_GPIO_PXIEV + port->number *
-                                U300_GPIO_PORTX_SPACING);
-        /* Mask with enable register */
-        val &= readl(virtbase + U300_GPIO_PXIEV + port->number *
-                                U300_GPIO_PORTX_SPACING);
+        val = readl(U300_PIN_REG(pinoffset, iev));
         /* Mask relevant bits */
-        val &= U300_GPIO_PXIEV_ALL_IRQ_EVENT_MASK;
+        val &= 0xFFU; /* 8 bits per port */
         /* ACK IRQ (clear event) */
-        writel(val, virtbase + U300_GPIO_PXIEV + port->number *
-                                U300_GPIO_PORTX_SPACING);
-        /* Print message */
-        while (val != 0) {
-                unsigned gpio;
-
-                pin = __ffs(val);
-                /* mask off this pin */
-                val &= ~(1 << pin);
-                gpio = (port->number << 3) + pin;
-
-                if (gpio_pin[gpio].callback)
-                        (void)gpio_pin[gpio].callback(gpio_pin[gpio].data);
-                else
-                        dev_dbg(gpiodev, "stray GPIO IRQ on line %d\n",
-                               gpio);
+        writel(val, U300_PIN_REG(pinoffset, iev));
+
+        /* Call IRQ handler */
+        if (val != 0) {
+                int irqoffset;
+
+                for_each_set_bit(irqoffset, &val, U300_GPIO_PINS_PER_PORT) {
+                        int pin_irq = gpio->irq_base + (port->number << 3)
+                                + irqoffset;
+                        int offset = pinoffset + irqoffset;
+
+                        dev_dbg(gpio->dev, "GPIO IRQ %d on pin %d\n",
+                                pin_irq, offset);
+                        generic_handle_irq(pin_irq);
+                        /*
+                         * Triggering IRQ on both rising and falling edge
+                         * needs mockery
+                         */
+                        if (port->toggle_edge_mode & U300_PIN_BIT(offset))
+                                u300_toggle_trigger(gpio, offset);
+                }
         }
-        return IRQ_HANDLED;
+
+        desc->irq_data.chip->irq_unmask(&desc->irq_data);
 }
 
-static void gpio_set_initial_values(void)
+static void __init u300_gpio_init_pin(struct u300_gpio *gpio,
+                                      int offset,
+                                      const struct u300_gpio_confdata *conf)
 {
-#ifdef U300_COH901571_3
-        int i, j;
-        unsigned long flags;
-        u32 val;
+        /* Set mode: input or output */
+        if (conf->output) {
+                u300_gpio_direction_output(&gpio->chip, offset, conf->outval);
 
-        /* Write default values to all pins */
-        for (i = 0; i < U300_GPIO_NUM_PORTS; i++) {
-                val = 0;
-                for (j = 0; j < 8; j++)
-                        val |= (u32) (u300_gpio_config[i][j].default_output_value != DEFAULT_OUTPUT_LOW) << j;
-                local_irq_save(flags);
-                writel(val, virtbase + U300_GPIO_PXPDOR + i * U300_GPIO_PORTX_SPACING);
-                local_irq_restore(flags);
+                /* Deactivate bias mode for output */
+                u300_gpio_config(&gpio->chip, offset,
+                                 GPIO_U300_CONFIG_BIAS_FLOAT,
+                                 NULL);
+
+                /* Set drive mode for output */
+                u300_gpio_config(&gpio->chip, offset,
+                                 GPIO_U300_CONFIG_DRIVE_PUSH_PULL, NULL);
+
+                dev_dbg(gpio->dev, "set up pin %d as output, value: %d\n",
+                        offset, conf->outval);
+        } else {
+                u300_gpio_direction_input(&gpio->chip, offset);
+
+                /* Always set output low on input pins */
+                u300_gpio_set(&gpio->chip, offset, 0);
+
+                /* Set bias mode for input */
+                u300_gpio_config(&gpio->chip, offset, conf->bias_mode, NULL);
+
+                dev_dbg(gpio->dev, "set up pin %d as input, bias: %04x\n",
+                        offset, conf->bias_mode);
         }
+}
 
-        /*
-         * Put all pins that are set to either 'GPIO_OUT' or 'GPIO_NOT_USED'
-         * to output and 'GPIO_IN' to input for each port. And initialize
-         * default value on outputs.
-         */
-        for (i = 0; i < U300_GPIO_NUM_PORTS; i++) {
-                for (j = 0; j < U300_GPIO_PINS_PER_PORT; j++) {
-                        local_irq_save(flags);
-                        val = readl(virtbase + U300_GPIO_PXPCR +
-                                         i * U300_GPIO_PORTX_SPACING);
-                        /* Mask out this pin */
-                        val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK << (j << 1));
-
-                        if (u300_gpio_config[i][j].pin_usage != GPIO_IN)
-                                val |= (U300_GPIO_PXPCR_PIN_MODE_OUTPUT_PUSH_PULL << (j << 1));
-                        writel(val, virtbase + U300_GPIO_PXPCR +
-                                         i * U300_GPIO_PORTX_SPACING);
-                        local_irq_restore(flags);
+static void __init u300_gpio_init_coh901571(struct u300_gpio *gpio,
+                                     struct u300_gpio_platform *plat)
+{
+        int i, j;
+
+        /* Write default config and values to all pins */
+        for (i = 0; i < plat->ports; i++) {
+                for (j = 0; j < 8; j++) {
+                        const struct u300_gpio_confdata *conf;
+                        int offset = (i*8) + j;
+
+                        if (plat->variant == U300_GPIO_COH901571_3_BS335)
+                                conf = &bs335_gpio_config[i][j];
+                        else if (plat->variant == U300_GPIO_COH901571_3_BS365)
+                                conf = &bs365_gpio_config[i][j];
+                        else
+                                break;
+
+                        u300_gpio_init_pin(gpio, offset, conf);
                 }
         }
+}
 
-        /* Enable or disable the internal pull-ups in the GPIO ASIC block */
-        for (i = 0; i < U300_GPIO_MAX; i++) {
-                val = 0;
-                for (j = 0; j < 8; j++)
-                        val |= (u32)((u300_gpio_config[i][j].pull_up == DISABLE_PULL_UP) << j);
-                local_irq_save(flags);
-                writel(val, virtbase + U300_GPIO_PXPER + i * U300_GPIO_PORTX_SPACING);
-                local_irq_restore(flags);
+static inline void u300_gpio_free_ports(struct u300_gpio *gpio)
+{
+        struct u300_gpio_port *port;
+        struct list_head *p, *n;
+
+        list_for_each_safe(p, n, &gpio->port_list) {
+                port = list_entry(p, struct u300_gpio_port, node);
+                list_del(&port->node);
+                free_irq(port->irq, port);
+                kfree(port);
         }
-#endif
 }
 
-static int __init gpio_probe(struct platform_device *pdev)
+static int __init u300_gpio_probe(struct platform_device *pdev)
 {
-        u32 val;
+        struct u300_gpio_platform *plat = dev_get_platdata(&pdev->dev);
+        struct u300_gpio *gpio;
         int err = 0;
+        int portno;
+        u32 val;
+        u32 ifr;
         int i;
-        int num_irqs;
 
-        gpiodev = &pdev->dev;
-        memset(gpio_pin, 0, sizeof(gpio_pin));
+        gpio = kzalloc(sizeof(struct u300_gpio), GFP_KERNEL);
+        if (gpio == NULL) {
+                dev_err(&pdev->dev, "failed to allocate memory\n");
+                return -ENOMEM;
+        }
+
+        gpio->chip = u300_gpio_chip;
+        gpio->chip.ngpio = plat->ports * U300_GPIO_PINS_PER_PORT;
+        gpio->irq_base = plat->gpio_irq_base;
+        gpio->chip.dev = &pdev->dev;
+        gpio->chip.base = plat->gpio_base;
+        gpio->dev = &pdev->dev;
 
         /* Get GPIO clock */
-        clk = clk_get(&pdev->dev, NULL);
-        if (IS_ERR(clk)) {
-                err = PTR_ERR(clk);
-                dev_err(gpiodev, "could not get GPIO clock\n");
+        gpio->clk = clk_get(gpio->dev, NULL);
+        if (IS_ERR(gpio->clk)) {
+                err = PTR_ERR(gpio->clk);
+                dev_err(gpio->dev, "could not get GPIO clock\n");
                 goto err_no_clk;
         }
-        err = clk_enable(clk);
+        err = clk_enable(gpio->clk);
         if (err) {
-                dev_err(gpiodev, "could not enable GPIO clock\n");
+                dev_err(gpio->dev, "could not enable GPIO clock\n");
                 goto err_no_clk_enable;
         }
 
-        memres = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!memres)
+        gpio->memres = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!gpio->memres) {
+                dev_err(gpio->dev, "could not get GPIO memory resource\n");
+                err = -ENODEV;
                 goto err_no_resource;
+        }
 
-        if (!request_mem_region(memres->start, resource_size(memres),
+        if (!request_mem_region(gpio->memres->start,
+                                resource_size(gpio->memres),
                                 "GPIO Controller")) {
                 err = -ENODEV;
                 goto err_no_ioregion;
         }
 
-        virtbase = ioremap(memres->start, resource_size(memres));
-        if (!virtbase) {
+        gpio->base = ioremap(gpio->memres->start, resource_size(gpio->memres));
+        if (!gpio->base) {
                 err = -ENOMEM;
                 goto err_no_ioremap;
         }
-        dev_info(gpiodev, "remapped 0x%08x to %p\n",
-                 memres->start, virtbase);
-
-#ifdef U300_COH901335
-        dev_info(gpiodev, "initializing GPIO Controller COH 901 335\n");
-        /* Turn on the GPIO block */
-        writel(U300_GPIO_CR_BLOCK_CLOCK_ENABLE, virtbase + U300_GPIO_CR);
-#endif
-
-#ifdef U300_COH901571_3
-        dev_info(gpiodev, "initializing GPIO Controller COH 901 571/3\n");
-        val = readl(virtbase + U300_GPIO_CR);
-        dev_info(gpiodev, "COH901571/3 block version: %d, " \
-               "number of cores: %d\n",
-               ((val & 0x0000FE00) >> 9),
-               ((val & 0x000001FC) >> 2));
-        writel(U300_GPIO_CR_BLOCK_CLKRQ_ENABLE, virtbase + U300_GPIO_CR);
-#endif
-
-        gpio_set_initial_values();
-
-        for (num_irqs = 0 ; num_irqs < U300_GPIO_NUM_PORTS; num_irqs++) {
-
-                gpio_ports[num_irqs].irq =
-                        platform_get_irq_byname(pdev,
-                                                gpio_ports[num_irqs].name);
-
-                err = request_irq(gpio_ports[num_irqs].irq,
-                                  gpio_irq_handler, IRQF_DISABLED,
-                                  gpio_ports[num_irqs].name,
-                                  &gpio_ports[num_irqs]);
-                if (err) {
-                        dev_err(gpiodev, "cannot allocate IRQ for %s!\n",
-                                gpio_ports[num_irqs].name);
-                        goto err_no_irq;
+
+        if (plat->variant == U300_GPIO_COH901335) {
+                dev_info(gpio->dev,
+                         "initializing GPIO Controller COH 901 335\n");
+                gpio->stride = U300_335_PORT_STRIDE;
+                gpio->pcr = U300_335_PXPCR;
+                gpio->dor = U300_335_PXPDOR;
+                gpio->dir = U300_335_PXPDIR;
+                gpio->per = U300_335_PXPER;
+                gpio->icr = U300_335_PXICR;
+                gpio->ien = U300_335_PXIEN;
+                gpio->iev = U300_335_PXIEV;
+                ifr = U300_335_PXIFR;
+
+                /* Turn on the GPIO block */
+                writel(U300_335_CR_BLOCK_CLOCK_ENABLE,
+                       gpio->base + U300_335_CR);
+        } else if (plat->variant == U300_GPIO_COH901571_3_BS335 ||
+                   plat->variant == U300_GPIO_COH901571_3_BS365) {
+                dev_info(gpio->dev,
+                         "initializing GPIO Controller COH 901 571/3\n");
+                gpio->stride = U300_571_PORT_STRIDE;
+                gpio->pcr = U300_571_PXPCR;
+                gpio->dor = U300_571_PXPDOR;
+                gpio->dir = U300_571_PXPDIR;
+                gpio->per = U300_571_PXPER;
+                gpio->icr = U300_571_PXICR;
+                gpio->ien = U300_571_PXIEN;
+                gpio->iev = U300_571_PXIEV;
+                ifr = U300_571_PXIFR;
+
+                val = readl(gpio->base + U300_571_CR);
+                dev_info(gpio->dev, "COH901571/3 block version: %d, " \
+                         "number of cores: %d totalling %d pins\n",
+                         ((val & 0x000001FC) >> 2),
+                         ((val & 0x0000FE00) >> 9),
+                         ((val & 0x0000FE00) >> 9) * 8);
+                writel(U300_571_CR_BLOCK_CLKRQ_ENABLE,
+                       gpio->base + U300_571_CR);
+                u300_gpio_init_coh901571(gpio, plat);
+        } else {
+                dev_err(gpio->dev, "unknown block variant\n");
+                err = -ENODEV;
+                goto err_unknown_variant;
+        }
+
+        /* Add each port with its IRQ separately */
+        INIT_LIST_HEAD(&gpio->port_list);
+        for (portno = 0 ; portno < plat->ports; portno++) {
+                struct u300_gpio_port *port =
+                        kmalloc(sizeof(struct u300_gpio_port), GFP_KERNEL);
+
+                if (!port) {
+                        dev_err(gpio->dev, "out of memory\n");
+                        err = -ENOMEM;
+                        goto err_no_port;
                 }
-                /* Turns off PortX_irq_force */
-                writel(0x0, virtbase + U300_GPIO_PXIFR +
-                                 num_irqs * U300_GPIO_PORTX_SPACING);
+
+                snprintf(port->name, 8, "gpio%d", portno);
+                port->number = portno;
+                port->gpio = gpio;
+
+                port->irq = platform_get_irq_byname(pdev,
+                                                    port->name);
+
+                dev_dbg(gpio->dev, "register IRQ %d for %s\n", port->irq,
+                        port->name);
+
+                irq_set_chained_handler(port->irq, u300_gpio_irq_handler);
+                irq_set_handler_data(port->irq, port);
+
+                /* For each GPIO pin set the unique IRQ handler */
+                for (i = 0; i < U300_GPIO_PINS_PER_PORT; i++) {
+                        int irqno = gpio->irq_base + (portno << 3) + i;
+
+                        dev_dbg(gpio->dev, "handler for IRQ %d on %s\n",
+                                irqno, port->name);
+                        irq_set_chip_and_handler(irqno, &u300_gpio_irqchip,
+                                                 handle_simple_irq);
+                        set_irq_flags(irqno, IRQF_VALID);
+                        irq_set_chip_data(irqno, port);
+                }
+
+                /* Turns off irq force (test register) for this port */
+                writel(0x0, gpio->base + portno * gpio->stride + ifr);
+
+                list_add_tail(&port->node, &gpio->port_list);
         }
+        dev_dbg(gpio->dev, "initialized %d GPIO ports\n", portno);
+
+        err = gpiochip_add(&gpio->chip);
+        if (err) {
+                dev_err(gpio->dev, "unable to add gpiochip: %d\n", err);
+                goto err_no_chip;
+        }
+
+        platform_set_drvdata(pdev, gpio);
 
         return 0;
 
- err_no_irq:
-        for (i = 0; i < num_irqs; i++)
-                free_irq(gpio_ports[i].irq, &gpio_ports[i]);
-        iounmap(virtbase);
- err_no_ioremap:
-        release_mem_region(memres->start, resource_size(memres));
- err_no_ioregion:
- err_no_resource:
-        clk_disable(clk);
- err_no_clk_enable:
-        clk_put(clk);
- err_no_clk:
-        dev_info(gpiodev, "module ERROR:%d\n", err);
+err_no_chip:
+err_no_port:
+        u300_gpio_free_ports(gpio);
+err_unknown_variant:
+        iounmap(gpio->base);
+err_no_ioremap:
+        release_mem_region(gpio->memres->start, resource_size(gpio->memres));
+err_no_ioregion:
+err_no_resource:
+        clk_disable(gpio->clk);
+err_no_clk_enable:
+        clk_put(gpio->clk);
+err_no_clk:
+        kfree(gpio);
+        dev_info(&pdev->dev, "module ERROR:%d\n", err);
         return err;
 }
 
-static int __exit gpio_remove(struct platform_device *pdev)
+static int __exit u300_gpio_remove(struct platform_device *pdev)
 {
-        int i;
+        struct u300_gpio_platform *plat = dev_get_platdata(&pdev->dev);
+        struct u300_gpio *gpio = platform_get_drvdata(pdev);
+        int err;
 
         /* Turn off the GPIO block */
-        writel(0x00000000U, virtbase + U300_GPIO_CR);
-        for (i = 0 ; i < U300_GPIO_NUM_PORTS; i++)
-                free_irq(gpio_ports[i].irq, &gpio_ports[i]);
-        iounmap(virtbase);
-        release_mem_region(memres->start, resource_size(memres));
-        clk_disable(clk);
-        clk_put(clk);
+        if (plat->variant == U300_GPIO_COH901335)
+                writel(0x00000000U, gpio->base + U300_335_CR);
+        if (plat->variant == U300_GPIO_COH901571_3_BS335 ||
+            plat->variant == U300_GPIO_COH901571_3_BS365)
+                writel(0x00000000U, gpio->base + U300_571_CR);
+
+        err = gpiochip_remove(&gpio->chip);
+        if (err < 0) {
+                dev_err(gpio->dev, "unable to remove gpiochip: %d\n", err);
+                return err;
+        }
+        u300_gpio_free_ports(gpio);
+        iounmap(gpio->base);
+        release_mem_region(gpio->memres->start,
+                           resource_size(gpio->memres));
+        clk_disable(gpio->clk);
+        clk_put(gpio->clk);
+        platform_set_drvdata(pdev, NULL);
+        kfree(gpio);
         return 0;
 }
 
-static struct platform_driver gpio_driver = {
+static struct platform_driver u300_gpio_driver = {
         .driver         = {
                 .name   = "u300-gpio",
         },
-        .remove         = __exit_p(gpio_remove),
+        .remove         = __exit_p(u300_gpio_remove),
 };
 
 
 static int __init u300_gpio_init(void)
 {
-        return platform_driver_probe(&gpio_driver, gpio_probe);
+        return platform_driver_probe(&u300_gpio_driver, u300_gpio_probe);
 }
 
 static void __exit u300_gpio_exit(void)
 {
-        platform_driver_unregister(&gpio_driver);
+        platform_driver_unregister(&u300_gpio_driver);
 }
 
 arch_initcall(u300_gpio_init);
 module_exit(u300_gpio_exit);
 
 MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
-
-#ifdef U300_COH901571_3
-MODULE_DESCRIPTION("ST-Ericsson AB COH 901 571/3 GPIO driver");
-#endif
-
-#ifdef U300_COH901335
-MODULE_DESCRIPTION("ST-Ericsson AB COH 901 335 GPIO driver");
-#endif
-
+MODULE_DESCRIPTION("ST-Ericsson AB COH 901 335/COH 901 571/3 GPIO driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index 82db18506662..fe738f05309b 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
@@ -499,6 +499,7 @@ void drm_connector_cleanup(struct drm_connector *connector)
         mutex_lock(&dev->mode_config.mutex);
         drm_mode_object_put(dev, &connector->base);
         list_del(&connector->head);
+        dev->mode_config.num_connector--;
         mutex_unlock(&dev->mode_config.mutex);
 }
 EXPORT_SYMBOL(drm_connector_cleanup);
@@ -529,6 +530,7 @@ void drm_encoder_cleanup(struct drm_encoder *encoder)
         mutex_lock(&dev->mode_config.mutex);
         drm_mode_object_put(dev, &encoder->base);
         list_del(&encoder->head);
+        dev->mode_config.num_encoder--;
         mutex_unlock(&dev->mode_config.mutex);
 }
 EXPORT_SYMBOL(drm_encoder_cleanup);
diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c
index 802b61ac3139..f7c6854eb4dd 100644
--- a/drivers/gpu/drm/drm_fb_helper.c
+++ b/drivers/gpu/drm/drm_fb_helper.c
@@ -256,7 +256,6 @@ int drm_fb_helper_panic(struct notifier_block *n, unsigned long ununsed,
 {
         printk(KERN_ERR "panic occurred, switching back to text console\n");
         return drm_fb_helper_force_kernel_mode();
-        return 0;
 }
 EXPORT_SYMBOL(drm_fb_helper_panic);
 
diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
index a8ab6263e0d7..3c395a59da35 100644
--- a/drivers/gpu/drm/i915/i915_debugfs.c
+++ b/drivers/gpu/drm/i915/i915_debugfs.c
@@ -499,7 +499,7 @@ static int i915_interrupt_info(struct seq_file *m, void *data)
         seq_printf(m, "Interrupts received: %d\n",
                    atomic_read(&dev_priv->irq_received));
         for (i = 0; i < I915_NUM_RINGS; i++) {
-                if (IS_GEN6(dev)) {
+                if (IS_GEN6(dev) || IS_GEN7(dev)) {
                         seq_printf(m, "Graphics Interrupt mask (%s):    %08x\n",
                                    dev_priv->ring[i].name,
                                    I915_READ_IMR(&dev_priv->ring[i]));
diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
index ce045a8cf82c..f07e4252b708 100644
--- a/drivers/gpu/drm/i915/i915_drv.c
+++ b/drivers/gpu/drm/i915/i915_drv.c
@@ -67,11 +67,11 @@ module_param_named(i915_enable_rc6, i915_enable_rc6, int, 0600);
 MODULE_PARM_DESC(i915_enable_rc6,
                 "Enable power-saving render C-state 6 (default: true)");
 
-unsigned int i915_enable_fbc __read_mostly = 1;
+unsigned int i915_enable_fbc __read_mostly = -1;
 module_param_named(i915_enable_fbc, i915_enable_fbc, int, 0600);
 MODULE_PARM_DESC(i915_enable_fbc,
                 "Enable frame buffer compression for power savings "
-                "(default: false)");
+                "(default: -1 (use per-chip default))");
 
 unsigned int i915_lvds_downclock __read_mostly = 0;
 module_param_named(lvds_downclock, i915_lvds_downclock, int, 0400);
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index feb4f164fd1b..7916bd97d5c1 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -36,6 +36,7 @@
 #include <linux/io-mapping.h>
 #include <linux/i2c.h>
 #include <drm/intel-gtt.h>
+#include <linux/backlight.h>
 
 /* General customization:
  */
@@ -690,6 +691,7 @@ typedef struct drm_i915_private {
         int child_dev_num;
         struct child_device_config *child_dev;
         struct drm_connector *int_lvds_connector;
+        struct drm_connector *int_edp_connector;
 
         bool mchbar_need_disable;
 
@@ -723,6 +725,8 @@ typedef struct drm_i915_private {
         /* list of fbdev register on this device */
         struct intel_fbdev *fbdev;
 
+        struct backlight_device *backlight;
+
         struct drm_property *broadcast_rgb_property;
         struct drm_property *force_audio_property;
 
diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
index 02f96fd0d52d..9cbb0cd8f46a 100644
--- a/drivers/gpu/drm/i915/i915_irq.c
+++ b/drivers/gpu/drm/i915/i915_irq.c
@@ -2058,8 +2058,10 @@ void intel_irq_init(struct drm_device *dev)
                 dev->driver->get_vblank_counter = gm45_get_vblank_counter;
         }
 
-
-        dev->driver->get_vblank_timestamp = i915_get_vblank_timestamp;
+        if (drm_core_check_feature(dev, DRIVER_MODESET))
+                dev->driver->get_vblank_timestamp = i915_get_vblank_timestamp;
+        else
+                dev->driver->get_vblank_timestamp = NULL;
         dev->driver->get_scanout_position = i915_get_crtc_scanoutpos;
 
         if (IS_IVYBRIDGE(dev)) {
diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h
index d1331f771e2f..542453f7498c 100644
--- a/drivers/gpu/drm/i915/i915_reg.h
+++ b/drivers/gpu/drm/i915/i915_reg.h
@@ -375,6 +375,7 @@
 # define MI_FLUSH_ENABLE                                (1 << 11)
 
 #define GFX_MODE        0x02520
+#define GFX_MODE_GEN7   0x0229c
 #define   GFX_RUN_LIST_ENABLE           (1<<15)
 #define   GFX_TLB_INVALIDATE_ALWAYS     (1<<13)
 #define   GFX_SURFACE_FAULT_ENABLE      (1<<12)
@@ -382,6 +383,9 @@
 #define   GFX_PSMI_GRANULARITY          (1<<10)
 #define   GFX_PPGTT_ENABLE              (1<<9)
 
+#define GFX_MODE_ENABLE(bit) (((bit) << 16) | (bit))
+#define GFX_MODE_DISABLE(bit) (((bit) << 16) | (0))
+
 #define SCPD0           0x0209c /* 915+ only */
 #define IER             0x020a0
 #define IIR             0x020a4
@@ -1318,6 +1322,7 @@
 #define   ADPA_PIPE_SELECT_MASK (1<<30)
 #define   ADPA_PIPE_A_SELECT    0
 #define   ADPA_PIPE_B_SELECT    (1<<30)
+#define   ADPA_PIPE_SELECT(pipe) ((pipe) << 30)
 #define   ADPA_USE_VGA_HVPOLARITY (1<<15)
 #define   ADPA_SETS_HVPOLARITY  0
 #define   ADPA_VSYNC_CNTL_DISABLE (1<<11)
@@ -1460,6 +1465,7 @@
 /* Selects pipe B for LVDS data.  Must be set on pre-965. */
 #define   LVDS_PIPEB_SELECT             (1 << 30)
 #define   LVDS_PIPE_MASK                (1 << 30)
+#define   LVDS_PIPE(pipe)               ((pipe) << 30)
 /* LVDS dithering flag on 965/g4x platform */
 #define   LVDS_ENABLE_DITHER            (1 << 25)
 /* LVDS sync polarity flags. Set to invert (i.e. negative) */
@@ -1499,9 +1505,6 @@
 #define   LVDS_B0B3_POWER_DOWN          (0 << 2)
 #define   LVDS_B0B3_POWER_UP            (3 << 2)
 
-#define LVDS_PIPE_ENABLED(V, P) \
-        (((V) & (LVDS_PIPE_MASK | LVDS_PORT_EN)) == ((P) << 30 | LVDS_PORT_EN))
-
 /* Video Data Island Packet control */
 #define VIDEO_DIP_DATA          0x61178
 #define VIDEO_DIP_CTL           0x61170
@@ -3256,14 +3259,12 @@
 #define  ADPA_CRT_HOTPLUG_VOLREF_475MV  (1<<17)
 #define  ADPA_CRT_HOTPLUG_FORCE_TRIGGER (1<<16)
 
-#define ADPA_PIPE_ENABLED(V, P) \
-        (((V) & (ADPA_TRANS_SELECT_MASK | ADPA_DAC_ENABLE)) == ((P) << 30 | ADPA_DAC_ENABLE))
-
 /* or SDVOB */
 #define HDMIB   0xe1140
 #define  PORT_ENABLE    (1 << 31)
 #define  TRANSCODER_A   (0)
 #define  TRANSCODER_B   (1 << 30)
+#define  TRANSCODER(pipe)       ((pipe) << 30)
 #define  TRANSCODER_MASK   (1 << 30)
 #define  COLOR_FORMAT_8bpc      (0)
 #define  COLOR_FORMAT_12bpc     (3 << 26)
@@ -3280,9 +3281,6 @@
 #define  HSYNC_ACTIVE_HIGH      (1 << 3)
 #define  PORT_DETECTED          (1 << 2)
 
-#define HDMI_PIPE_ENABLED(V, P) \
-        (((V) & (TRANSCODER_MASK | PORT_ENABLE)) == ((P) << 30 | PORT_ENABLE))
-
 /* PCH SDVOB multiplex with HDMIB */
 #define PCH_SDVOB       HDMIB
 
@@ -3349,6 +3347,7 @@
 #define  PORT_TRANS_B_SEL_CPT   (1<<29)
 #define  PORT_TRANS_C_SEL_CPT   (2<<29)
 #define  PORT_TRANS_SEL_MASK    (3<<29)
+#define  PORT_TRANS_SEL_CPT(pipe)       ((pipe) << 29)
 
 #define TRANS_DP_CTL_A          0xe0300
 #define TRANS_DP_CTL_B          0xe1300
diff --git a/drivers/gpu/drm/i915/i915_suspend.c b/drivers/gpu/drm/i915/i915_suspend.c
index 87677d60d0df..f10742359ec9 100644
--- a/drivers/gpu/drm/i915/i915_suspend.c
+++ b/drivers/gpu/drm/i915/i915_suspend.c
@@ -871,7 +871,8 @@ int i915_restore_state(struct drm_device *dev)
         }
         mutex_unlock(&dev->struct_mutex);
 
-        intel_init_clock_gating(dev);
+        if (drm_core_check_feature(dev, DRIVER_MODESET))
+                intel_init_clock_gating(dev);
 
         if (IS_IRONLAKE_M(dev)) {
                 ironlake_enable_drps(dev);
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 35364e68a091..04411ad2e779 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -878,7 +878,7 @@ static void assert_panel_unlocked(struct drm_i915_private *dev_priv,
         int pp_reg, lvds_reg;
         u32 val;
         enum pipe panel_pipe = PIPE_A;
-        bool locked = locked;
+        bool locked = true;
 
         if (HAS_PCH_SPLIT(dev_priv->dev)) {
                 pp_reg = PCH_PP_CONTROL;
@@ -980,8 +980,8 @@ static void assert_transcoder_disabled(struct drm_i915_private *dev_priv,
              pipe_name(pipe));
 }
 
-static bool dp_pipe_enabled(struct drm_i915_private *dev_priv, enum pipe pipe,
-                            int reg, u32 port_sel, u32 val)
+static bool dp_pipe_enabled(struct drm_i915_private *dev_priv,
+                            enum pipe pipe, u32 port_sel, u32 val)
 {
         if ((val & DP_PORT_EN) == 0)
                 return false;
@@ -998,11 +998,58 @@ static bool dp_pipe_enabled(struct drm_i915_private *dev_priv, enum pipe pipe,
         return true;
 }
 
+static bool hdmi_pipe_enabled(struct drm_i915_private *dev_priv,
+                              enum pipe pipe, u32 val)
+{
+        if ((val & PORT_ENABLE) == 0)
+                return false;
+
+        if (HAS_PCH_CPT(dev_priv->dev)) {
+                if ((val & PORT_TRANS_SEL_MASK) != PORT_TRANS_SEL_CPT(pipe))
+                        return false;
+        } else {
+                if ((val & TRANSCODER_MASK) != TRANSCODER(pipe))
+                        return false;
+        }
+        return true;
+}
+
+static bool lvds_pipe_enabled(struct drm_i915_private *dev_priv,
+                              enum pipe pipe, u32 val)
+{
+        if ((val & LVDS_PORT_EN) == 0)
+                return false;
+
+        if (HAS_PCH_CPT(dev_priv->dev)) {
+                if ((val & PORT_TRANS_SEL_MASK) != PORT_TRANS_SEL_CPT(pipe))
+                        return false;
+        } else {
+                if ((val & LVDS_PIPE_MASK) != LVDS_PIPE(pipe))
+                        return false;
+        }
+        return true;
+}
+
+static bool adpa_pipe_enabled(struct drm_i915_private *dev_priv,
+                              enum pipe pipe, u32 val)
+{
+        if ((val & ADPA_DAC_ENABLE) == 0)
+                return false;
+        if (HAS_PCH_CPT(dev_priv->dev)) {
+                if ((val & PORT_TRANS_SEL_MASK) != PORT_TRANS_SEL_CPT(pipe))
+                        return false;
+        } else {
+                if ((val & ADPA_PIPE_SELECT_MASK) != ADPA_PIPE_SELECT(pipe))
+                        return false;
+        }
+        return true;
+}
+
 static void assert_pch_dp_disabled(struct drm_i915_private *dev_priv,
                                    enum pipe pipe, int reg, u32 port_sel)
 {
         u32 val = I915_READ(reg);
-        WARN(dp_pipe_enabled(dev_priv, pipe, reg, port_sel, val),
+        WARN(dp_pipe_enabled(dev_priv, pipe, port_sel, val),
              "PCH DP (0x%08x) enabled on transcoder %c, should be disabled\n",
              reg, pipe_name(pipe));
 }
@@ -1011,7 +1058,7 @@ static void assert_pch_hdmi_disabled(struct drm_i915_private *dev_priv,
                                      enum pipe pipe, int reg)
 {
         u32 val = I915_READ(reg);
-        WARN(HDMI_PIPE_ENABLED(val, pipe),
+        WARN(hdmi_pipe_enabled(dev_priv, val, pipe),
              "PCH DP (0x%08x) enabled on transcoder %c, should be disabled\n",
              reg, pipe_name(pipe));
 }
@@ -1028,13 +1075,13 @@ static void assert_pch_ports_disabled(struct drm_i915_private *dev_priv,
 
         reg = PCH_ADPA;
         val = I915_READ(reg);
-        WARN(ADPA_PIPE_ENABLED(val, pipe),
+        WARN(adpa_pipe_enabled(dev_priv, val, pipe),
              "PCH VGA enabled on transcoder %c, should be disabled\n",
              pipe_name(pipe));
 
         reg = PCH_LVDS;
         val = I915_READ(reg);
-        WARN(LVDS_PIPE_ENABLED(val, pipe),
+        WARN(lvds_pipe_enabled(dev_priv, val, pipe),
              "PCH LVDS enabled on transcoder %c, should be disabled\n",
              pipe_name(pipe));
 
@@ -1360,7 +1407,7 @@ static void disable_pch_dp(struct drm_i915_private *dev_priv,
                            enum pipe pipe, int reg, u32 port_sel)
 {
         u32 val = I915_READ(reg);
-        if (dp_pipe_enabled(dev_priv, pipe, reg, port_sel, val)) {
+        if (dp_pipe_enabled(dev_priv, pipe, port_sel, val)) {
                 DRM_DEBUG_KMS("Disabling pch dp %x on pipe %d\n", reg, pipe);
                 I915_WRITE(reg, val & ~DP_PORT_EN);
         }
@@ -1370,7 +1417,7 @@ static void disable_pch_hdmi(struct drm_i915_private *dev_priv,
                              enum pipe pipe, int reg)
 {
         u32 val = I915_READ(reg);
-        if (HDMI_PIPE_ENABLED(val, pipe)) {
+        if (hdmi_pipe_enabled(dev_priv, val, pipe)) {
                 DRM_DEBUG_KMS("Disabling pch HDMI %x on pipe %d\n",
                               reg, pipe);
                 I915_WRITE(reg, val & ~PORT_ENABLE);
@@ -1392,12 +1439,13 @@ static void intel_disable_pch_ports(struct drm_i915_private *dev_priv,
 
         reg = PCH_ADPA;
         val = I915_READ(reg);
-        if (ADPA_PIPE_ENABLED(val, pipe))
+        if (adpa_pipe_enabled(dev_priv, val, pipe))
                 I915_WRITE(reg, val & ~ADPA_DAC_ENABLE);
 
         reg = PCH_LVDS;
         val = I915_READ(reg);
-        if (LVDS_PIPE_ENABLED(val, pipe)) {
+        if (lvds_pipe_enabled(dev_priv, val, pipe)) {
+                DRM_DEBUG_KMS("disable lvds on pipe %d val 0x%08x\n", pipe, val);
                 I915_WRITE(reg, val & ~LVDS_PORT_EN);
                 POSTING_READ(reg);
                 udelay(100);
@@ -1751,6 +1799,7 @@ static void intel_update_fbc(struct drm_device *dev)
         struct drm_framebuffer *fb;
         struct intel_framebuffer *intel_fb;
         struct drm_i915_gem_object *obj;
+        int enable_fbc;
 
         DRM_DEBUG_KMS("\n");
 
@@ -1791,8 +1840,15 @@ static void intel_update_fbc(struct drm_device *dev)
         intel_fb = to_intel_framebuffer(fb);
         obj = intel_fb->obj;
 
-        if (!i915_enable_fbc) {
-                DRM_DEBUG_KMS("fbc disabled per module param (default off)\n");
+        enable_fbc = i915_enable_fbc;
+        if (enable_fbc < 0) {
+                DRM_DEBUG_KMS("fbc set to per-chip default\n");
+                enable_fbc = 1;
+                if (INTEL_INFO(dev)->gen <= 5)
+                        enable_fbc = 0;
+        }
+        if (!enable_fbc) {
+                DRM_DEBUG_KMS("fbc disabled per module param\n");
                 dev_priv->no_fbc_reason = FBC_MODULE_PARAM;
                 goto out_disable;
         }
@@ -4639,13 +4695,13 @@ static bool intel_choose_pipe_bpp_dither(struct drm_crtc *crtc,
                 bpc = 6; /* min is 18bpp */
                 break;
         case 24:
-                bpc = min((unsigned int)8, display_bpc);
+                bpc = 8;
                 break;
         case 30:
-                bpc = min((unsigned int)10, display_bpc);
+                bpc = 10;
                 break;
         case 48:
-                bpc = min((unsigned int)12, display_bpc);
+                bpc = 12;
                 break;
         default:
                 DRM_DEBUG("unsupported depth, assuming 24 bits\n");
@@ -4653,10 +4709,12 @@ static bool intel_choose_pipe_bpp_dither(struct drm_crtc *crtc,
                 break;
         }
 
+        display_bpc = min(display_bpc, bpc);
+
         DRM_DEBUG_DRIVER("setting pipe bpc to %d (max display bpc %d)\n",
                          bpc, display_bpc);
 
-        *pipe_bpp = bpc * 3;
+        *pipe_bpp = display_bpc * 3;
 
         return display_bpc != bpc;
 }
@@ -5049,6 +5107,81 @@ static int i9xx_crtc_mode_set(struct drm_crtc *crtc,
         return ret;
 }
 
+static void ironlake_update_pch_refclk(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct drm_mode_config *mode_config = &dev->mode_config;
+        struct drm_crtc *crtc;
+        struct intel_encoder *encoder;
+        struct intel_encoder *has_edp_encoder = NULL;
+        u32 temp;
+        bool has_lvds = false;
+
+        /* We need to take the global config into account */
+        list_for_each_entry(crtc, &mode_config->crtc_list, head) {
+                if (!crtc->enabled)
+                        continue;
+
+                list_for_each_entry(encoder, &mode_config->encoder_list,
+                                    base.head) {
+                        if (encoder->base.crtc != crtc)
+                                continue;
+
+                        switch (encoder->type) {
+                        case INTEL_OUTPUT_LVDS:
+                                has_lvds = true;
+                        case INTEL_OUTPUT_EDP:
+                                has_edp_encoder = encoder;
+                                break;
+                        }
+                }
+        }
+
+        /* Ironlake: try to setup display ref clock before DPLL
+         * enabling. This is only under driver's control after
+         * PCH B stepping, previous chipset stepping should be
+         * ignoring this setting.
+         */
+        temp = I915_READ(PCH_DREF_CONTROL);
+        /* Always enable nonspread source */
+        temp &= ~DREF_NONSPREAD_SOURCE_MASK;
+        temp |= DREF_NONSPREAD_SOURCE_ENABLE;
+        temp &= ~DREF_SSC_SOURCE_MASK;
+        temp |= DREF_SSC_SOURCE_ENABLE;
+        I915_WRITE(PCH_DREF_CONTROL, temp);
+
+        POSTING_READ(PCH_DREF_CONTROL);
+        udelay(200);
+
+        if (has_edp_encoder) {
+                if (intel_panel_use_ssc(dev_priv)) {
+                        temp |= DREF_SSC1_ENABLE;
+                        I915_WRITE(PCH_DREF_CONTROL, temp);
+
+                        POSTING_READ(PCH_DREF_CONTROL);
+                        udelay(200);
+                }
+                temp &= ~DREF_CPU_SOURCE_OUTPUT_MASK;
+
+                /* Enable CPU source on CPU attached eDP */
+                if (!intel_encoder_is_pch_edp(&has_edp_encoder->base)) {
+                        if (intel_panel_use_ssc(dev_priv))
+                                temp |= DREF_CPU_SOURCE_OUTPUT_DOWNSPREAD;
+                        else
+                                temp |= DREF_CPU_SOURCE_OUTPUT_NONSPREAD;
+                } else {
+                        /* Enable SSC on PCH eDP if needed */
+                        if (intel_panel_use_ssc(dev_priv)) {
+                                DRM_ERROR("enabling SSC on PCH\n");
+                                temp |= DREF_SUPERSPREAD_SOURCE_ENABLE;
+                        }
+                }
+                I915_WRITE(PCH_DREF_CONTROL, temp);
+                POSTING_READ(PCH_DREF_CONTROL);
+                udelay(200);
+        }
+}
+
 static int ironlake_crtc_mode_set(struct drm_crtc *crtc,
                                   struct drm_display_mode *mode,
                                   struct drm_display_mode *adjusted_mode,
@@ -5244,49 +5377,7 @@ static int ironlake_crtc_mode_set(struct drm_crtc *crtc,
         ironlake_compute_m_n(intel_crtc->bpp, lane, target_clock, link_bw,
                              &m_n);
 
-        /* Ironlake: try to setup display ref clock before DPLL
-         * enabling. This is only under driver's control after
-         * PCH B stepping, previous chipset stepping should be
-         * ignoring this setting.
-         */
-        temp = I915_READ(PCH_DREF_CONTROL);
-        /* Always enable nonspread source */
-        temp &= ~DREF_NONSPREAD_SOURCE_MASK;
-        temp |= DREF_NONSPREAD_SOURCE_ENABLE;
-        temp &= ~DREF_SSC_SOURCE_MASK;
-        temp |= DREF_SSC_SOURCE_ENABLE;
-        I915_WRITE(PCH_DREF_CONTROL, temp);
-
-        POSTING_READ(PCH_DREF_CONTROL);
-        udelay(200);
-
-        if (has_edp_encoder) {
-                if (intel_panel_use_ssc(dev_priv)) {
-                        temp |= DREF_SSC1_ENABLE;
-                        I915_WRITE(PCH_DREF_CONTROL, temp);
-
-                        POSTING_READ(PCH_DREF_CONTROL);
-                        udelay(200);
-                }
-                temp &= ~DREF_CPU_SOURCE_OUTPUT_MASK;
-
-                /* Enable CPU source on CPU attached eDP */
-                if (!intel_encoder_is_pch_edp(&has_edp_encoder->base)) {
-                        if (intel_panel_use_ssc(dev_priv))
-                                temp |= DREF_CPU_SOURCE_OUTPUT_DOWNSPREAD;
-                        else
-                                temp |= DREF_CPU_SOURCE_OUTPUT_NONSPREAD;
-                } else {
-                        /* Enable SSC on PCH eDP if needed */
-                        if (intel_panel_use_ssc(dev_priv)) {
-                                DRM_ERROR("enabling SSC on PCH\n");
-                                temp |= DREF_SUPERSPREAD_SOURCE_ENABLE;
-                        }
-                }
-                I915_WRITE(PCH_DREF_CONTROL, temp);
-                POSTING_READ(PCH_DREF_CONTROL);
-                udelay(200);
-        }
+        ironlake_update_pch_refclk(dev);
 
         fp = clock.n << 16 | clock.m1 << 8 | clock.m2;
         if (has_reduced_clock)
@@ -7157,8 +7248,6 @@ static void intel_setup_outputs(struct drm_device *dev)
                         intel_encoder_clones(dev, encoder->clone_mask);
         }
 
-        intel_panel_setup_backlight(dev);
-
         /* disable all the possible outputs/crtcs before entering KMS mode */
         drm_helper_disable_unused_functions(dev);
 }
diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
index 0feae908bb37..44fef5e1c490 100644
--- a/drivers/gpu/drm/i915/intel_dp.c
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -1841,6 +1841,11 @@ done:
 static void
 intel_dp_destroy (struct drm_connector *connector)
 {
+        struct drm_device *dev = connector->dev;
+
+        if (intel_dpd_is_edp(dev))
+                intel_panel_destroy_backlight(dev);
+
         drm_sysfs_connector_remove(connector);
         drm_connector_cleanup(connector);
         kfree(connector);
@@ -2072,6 +2077,8 @@ intel_dp_init(struct drm_device *dev, int output_reg)
                                         DRM_MODE_TYPE_PREFERRED;
                         }
                 }
+                dev_priv->int_edp_connector = connector;
+                intel_panel_setup_backlight(dev);
         }
 
         intel_dp_add_properties(intel_dp, connector);
diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
index 7b330e76a435..fe1099d8817e 100644
--- a/drivers/gpu/drm/i915/intel_drv.h
+++ b/drivers/gpu/drm/i915/intel_drv.h
@@ -297,9 +297,10 @@ extern void intel_pch_panel_fitting(struct drm_device *dev,
 extern u32 intel_panel_get_max_backlight(struct drm_device *dev);
 extern u32 intel_panel_get_backlight(struct drm_device *dev);
 extern void intel_panel_set_backlight(struct drm_device *dev, u32 level);
-extern void intel_panel_setup_backlight(struct drm_device *dev);
+extern int intel_panel_setup_backlight(struct drm_device *dev);
 extern void intel_panel_enable_backlight(struct drm_device *dev);
 extern void intel_panel_disable_backlight(struct drm_device *dev);
+extern void intel_panel_destroy_backlight(struct drm_device *dev);
 extern enum drm_connector_status intel_panel_detect(struct drm_device *dev);
 
 extern void intel_crtc_load_lut(struct drm_crtc *crtc);
@@ -336,9 +337,6 @@ extern void intel_release_load_detect_pipe(struct intel_encoder *intel_encoder,
                                            struct drm_connector *connector,
                                            struct intel_load_detect_pipe *old);
 
-extern struct drm_connector* intel_sdvo_find(struct drm_device *dev, int sdvoB);
-extern int intel_sdvo_supports_hotplug(struct drm_connector *connector);
-extern void intel_sdvo_set_hotplug(struct drm_connector *connector, int enable);
 extern void intelfb_restore(void);
 extern void intel_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green,
                                     u16 blue, int regno);
diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c
index 2e8ddfcba40c..31da77f5c051 100644
--- a/drivers/gpu/drm/i915/intel_lvds.c
+++ b/drivers/gpu/drm/i915/intel_lvds.c
@@ -72,14 +72,16 @@ static void intel_lvds_enable(struct intel_lvds *intel_lvds)
 {
         struct drm_device *dev = intel_lvds->base.base.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        u32 ctl_reg, lvds_reg;
+        u32 ctl_reg, lvds_reg, stat_reg;
 
         if (HAS_PCH_SPLIT(dev)) {
                 ctl_reg = PCH_PP_CONTROL;
                 lvds_reg = PCH_LVDS;
+                stat_reg = PCH_PP_STATUS;
         } else {
                 ctl_reg = PP_CONTROL;
                 lvds_reg = LVDS;
+                stat_reg = PP_STATUS;
         }
 
         I915_WRITE(lvds_reg, I915_READ(lvds_reg) | LVDS_PORT_EN);
@@ -94,17 +96,16 @@ static void intel_lvds_enable(struct intel_lvds *intel_lvds)
                 DRM_DEBUG_KMS("applying panel-fitter: %x, %x\n",
                               intel_lvds->pfit_control,
                               intel_lvds->pfit_pgm_ratios);
-                if (wait_for((I915_READ(PP_STATUS) & PP_ON) == 0, 1000)) {
-                        DRM_ERROR("timed out waiting for panel to power off\n");
-                } else {
-                        I915_WRITE(PFIT_PGM_RATIOS, intel_lvds->pfit_pgm_ratios);
-                        I915_WRITE(PFIT_CONTROL, intel_lvds->pfit_control);
-                        intel_lvds->pfit_dirty = false;
-                }
+
+                I915_WRITE(PFIT_PGM_RATIOS, intel_lvds->pfit_pgm_ratios);
+                I915_WRITE(PFIT_CONTROL, intel_lvds->pfit_control);
+                intel_lvds->pfit_dirty = false;
         }
 
         I915_WRITE(ctl_reg, I915_READ(ctl_reg) | POWER_TARGET_ON);
         POSTING_READ(lvds_reg);
+        if (wait_for((I915_READ(stat_reg) & PP_ON) != 0, 1000))
+                DRM_ERROR("timed out waiting for panel to power on\n");
 
         intel_panel_enable_backlight(dev);
 }
@@ -113,24 +114,25 @@ static void intel_lvds_disable(struct intel_lvds *intel_lvds)
 {
         struct drm_device *dev = intel_lvds->base.base.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        u32 ctl_reg, lvds_reg;
+        u32 ctl_reg, lvds_reg, stat_reg;
 
         if (HAS_PCH_SPLIT(dev)) {
                 ctl_reg = PCH_PP_CONTROL;
                 lvds_reg = PCH_LVDS;
+                stat_reg = PCH_PP_STATUS;
         } else {
                 ctl_reg = PP_CONTROL;
                 lvds_reg = LVDS;
+                stat_reg = PP_STATUS;
         }
 
         intel_panel_disable_backlight(dev);
 
         I915_WRITE(ctl_reg, I915_READ(ctl_reg) & ~POWER_TARGET_ON);
+        if (wait_for((I915_READ(stat_reg) & PP_ON) == 0, 1000))
+                DRM_ERROR("timed out waiting for panel to power off\n");
 
         if (intel_lvds->pfit_control) {
-                if (wait_for((I915_READ(PP_STATUS) & PP_ON) == 0, 1000))
-                        DRM_ERROR("timed out waiting for panel to power off\n");
-
                 I915_WRITE(PFIT_CONTROL, 0);
                 intel_lvds->pfit_dirty = true;
         }
@@ -398,53 +400,21 @@ out:
 
 static void intel_lvds_prepare(struct drm_encoder *encoder)
 {
-        struct drm_device *dev = encoder->dev;
-        struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
 
-        /* We try to do the minimum that is necessary in order to unlock
-         * the registers for mode setting.
-         *
-         * On Ironlake, this is quite simple as we just set the unlock key
-         * and ignore all subtleties. (This may cause some issues...)
-         *
+        /*
          * Prior to Ironlake, we must disable the pipe if we want to adjust
          * the panel fitter. However at all other times we can just reset
          * the registers regardless.
          */
-
-        if (HAS_PCH_SPLIT(dev)) {
-                I915_WRITE(PCH_PP_CONTROL,
-                           I915_READ(PCH_PP_CONTROL) | PANEL_UNLOCK_REGS);
-        } else if (intel_lvds->pfit_dirty) {
-                I915_WRITE(PP_CONTROL,
-                           (I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS)
-                           & ~POWER_TARGET_ON);
-        } else {
-                I915_WRITE(PP_CONTROL,
-                           I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS);
-        }
+        if (!HAS_PCH_SPLIT(encoder->dev) && intel_lvds->pfit_dirty)
+                intel_lvds_disable(intel_lvds);
 }
 
 static void intel_lvds_commit(struct drm_encoder *encoder)
 {
-        struct drm_device *dev = encoder->dev;
-        struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
 
-        /* Undo any unlocking done in prepare to prevent accidental
-         * adjustment of the registers.
-         */
-        if (HAS_PCH_SPLIT(dev)) {
-                u32 val = I915_READ(PCH_PP_CONTROL);
-                if ((val & PANEL_UNLOCK_REGS) == PANEL_UNLOCK_REGS)
-                        I915_WRITE(PCH_PP_CONTROL, val & 0x3);
-        } else {
-                u32 val = I915_READ(PP_CONTROL);
-                if ((val & PANEL_UNLOCK_REGS) == PANEL_UNLOCK_REGS)
-                        I915_WRITE(PP_CONTROL, val & 0x3);
-        }
-
         /* Always do a full power on as we do not know what state
          * we were left in.
          */
@@ -582,6 +552,8 @@ static void intel_lvds_destroy(struct drm_connector *connector)
         struct drm_device *dev = connector->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
 
+        intel_panel_destroy_backlight(dev);
+
         if (dev_priv->lid_notifier.notifier_call)
                 acpi_lid_notifier_unregister(&dev_priv->lid_notifier);
         drm_sysfs_connector_remove(connector);
@@ -1040,6 +1012,19 @@ out:
                 pwm = I915_READ(BLC_PWM_PCH_CTL1);
                 pwm |= PWM_PCH_ENABLE;
                 I915_WRITE(BLC_PWM_PCH_CTL1, pwm);
+                /*
+                 * Unlock registers and just
+                 * leave them unlocked
+                 */
+                I915_WRITE(PCH_PP_CONTROL,
+                           I915_READ(PCH_PP_CONTROL) | PANEL_UNLOCK_REGS);
+        } else {
+                /*
+                 * Unlock registers and just
+                 * leave them unlocked
+                 */
+                I915_WRITE(PP_CONTROL,
+                           I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS);
         }
         dev_priv->lid_notifier.notifier_call = intel_lid_notify;
         if (acpi_lid_notifier_register(&dev_priv->lid_notifier)) {
@@ -1049,6 +1034,9 @@ out:
         /* keep the LVDS connector */
         dev_priv->int_lvds_connector = connector;
         drm_sysfs_connector_add(connector);
+
+        intel_panel_setup_backlight(dev);
+
         return true;
 
 failed:
diff --git a/drivers/gpu/drm/i915/intel_opregion.c b/drivers/gpu/drm/i915/intel_opregion.c
index b7c5ddb564d1..b8e8158bb16e 100644
--- a/drivers/gpu/drm/i915/intel_opregion.c
+++ b/drivers/gpu/drm/i915/intel_opregion.c
@@ -227,7 +227,6 @@ void intel_opregion_asle_intr(struct drm_device *dev)
         asle->aslc = asle_stat;
 }
 
-/* Only present on Ironlake+ */
 void intel_opregion_gse_intr(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
diff --git a/drivers/gpu/drm/i915/intel_panel.c b/drivers/gpu/drm/i915/intel_panel.c
index 05f500cd9c24..a9e0c7bcd317 100644
--- a/drivers/gpu/drm/i915/intel_panel.c
+++ b/drivers/gpu/drm/i915/intel_panel.c
@@ -277,7 +277,7 @@ void intel_panel_enable_backlight(struct drm_device *dev)
         dev_priv->backlight_enabled = true;
 }
 
-void intel_panel_setup_backlight(struct drm_device *dev)
+static void intel_panel_init_backlight(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
 
@@ -309,3 +309,73 @@ intel_panel_detect(struct drm_device *dev)
 
         return connector_status_unknown;
 }
+
+#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
+static int intel_panel_update_status(struct backlight_device *bd)
+{
+        struct drm_device *dev = bl_get_data(bd);
+        intel_panel_set_backlight(dev, bd->props.brightness);
+        return 0;
+}
+
+static int intel_panel_get_brightness(struct backlight_device *bd)
+{
+        struct drm_device *dev = bl_get_data(bd);
+        return intel_panel_get_backlight(dev);
+}
+
+static const struct backlight_ops intel_panel_bl_ops = {
+        .update_status = intel_panel_update_status,
+        .get_brightness = intel_panel_get_brightness,
+};
+
+int intel_panel_setup_backlight(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct backlight_properties props;
+        struct drm_connector *connector;
+
+        intel_panel_init_backlight(dev);
+
+        if (dev_priv->int_lvds_connector)
+                connector = dev_priv->int_lvds_connector;
+        else if (dev_priv->int_edp_connector)
+                connector = dev_priv->int_edp_connector;
+        else
+                return -ENODEV;
+
+        props.type = BACKLIGHT_RAW;
+        props.max_brightness = intel_panel_get_max_backlight(dev);
+        dev_priv->backlight =
+                backlight_device_register("intel_backlight",
+                                          &connector->kdev, dev,
+                                          &intel_panel_bl_ops, &props);
+
+        if (IS_ERR(dev_priv->backlight)) {
+                DRM_ERROR("Failed to register backlight: %ld\n",
+                          PTR_ERR(dev_priv->backlight));
+                dev_priv->backlight = NULL;
+                return -ENODEV;
+        }
+        dev_priv->backlight->props.brightness = intel_panel_get_backlight(dev);
+        return 0;
+}
+
+void intel_panel_destroy_backlight(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        if (dev_priv->backlight)
+                backlight_device_unregister(dev_priv->backlight);
+}
+#else
+int intel_panel_setup_backlight(struct drm_device *dev)
+{
+        intel_panel_init_backlight(dev);
+        return 0;
+}
+
+void intel_panel_destroy_backlight(struct drm_device *dev)
+{
+        return;
+}
+#endif
diff --git a/drivers/gpu/drm/i915/intel_ringbuffer.c b/drivers/gpu/drm/i915/intel_ringbuffer.c
index 47b9b2777038..c30626ea9f93 100644
--- a/drivers/gpu/drm/i915/intel_ringbuffer.c
+++ b/drivers/gpu/drm/i915/intel_ringbuffer.c
@@ -290,6 +290,10 @@ static int init_render_ring(struct intel_ring_buffer *ring)
                 if (IS_GEN6(dev) || IS_GEN7(dev))
                         mode |= MI_FLUSH_ENABLE << 16 | MI_FLUSH_ENABLE;
                 I915_WRITE(MI_MODE, mode);
+                if (IS_GEN7(dev))
+                        I915_WRITE(GFX_MODE_GEN7,
+                                   GFX_MODE_DISABLE(GFX_TLB_INVALIDATE_ALWAYS) |
+                                   GFX_MODE_ENABLE(GFX_REPLAY_MODE));
         }
 
         if (INTEL_INFO(dev)->gen >= 6) {
diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c
index 30fe554d8936..6348c499616f 100644
--- a/drivers/gpu/drm/i915/intel_sdvo.c
+++ b/drivers/gpu/drm/i915/intel_sdvo.c
@@ -92,6 +92,11 @@ struct intel_sdvo {
         */
         uint16_t attached_output;
 
+        /*
+         * Hotplug activation bits for this device
+         */
+        uint8_t hotplug_active[2];
+
         /**
          * This is used to select the color range of RBG outputs in HDMI mode.
          * It is only valid when using TMDS encoding and 8 bit per color mode.
@@ -1208,74 +1213,20 @@ static bool intel_sdvo_get_capabilities(struct intel_sdvo *intel_sdvo, struct in
         return true;
 }
 
-/* No use! */
-#if 0
-struct drm_connector* intel_sdvo_find(struct drm_device *dev, int sdvoB)
-{
-        struct drm_connector *connector = NULL;
-        struct intel_sdvo *iout = NULL;
-        struct intel_sdvo *sdvo;
-
-        /* find the sdvo connector */
-        list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
-                iout = to_intel_sdvo(connector);
-
-                if (iout->type != INTEL_OUTPUT_SDVO)
-                        continue;
-
-                sdvo = iout->dev_priv;
-
-                if (sdvo->sdvo_reg == SDVOB && sdvoB)
-                        return connector;
-
-                if (sdvo->sdvo_reg == SDVOC && !sdvoB)
-                        return connector;
-
-        }
-
-        return NULL;
-}
-
-int intel_sdvo_supports_hotplug(struct drm_connector *connector)
+static int intel_sdvo_supports_hotplug(struct intel_sdvo *intel_sdvo)
 {
         u8 response[2];
-        u8 status;
-        struct intel_sdvo *intel_sdvo;
-        DRM_DEBUG_KMS("\n");
-
-        if (!connector)
-                return 0;
-
-        intel_sdvo = to_intel_sdvo(connector);
 
         return intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_HOT_PLUG_SUPPORT,
                                     &response, 2) && response[0];
 }
 
-void intel_sdvo_set_hotplug(struct drm_connector *connector, int on)
+static void intel_sdvo_enable_hotplug(struct intel_encoder *encoder)
 {
-        u8 response[2];
-        u8 status;
-        struct intel_sdvo *intel_sdvo = to_intel_sdvo(connector);
-
-        intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0);
-        intel_sdvo_read_response(intel_sdvo, &response, 2);
-
-        if (on) {
-                intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0);
-                status = intel_sdvo_read_response(intel_sdvo, &response, 2);
-
-                intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2);
-        } else {
-                response[0] = 0;
-                response[1] = 0;
-                intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2);
-        }
+        struct intel_sdvo *intel_sdvo = to_intel_sdvo(&encoder->base);
 
-        intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0);
-        intel_sdvo_read_response(intel_sdvo, &response, 2);
+        intel_sdvo_write_cmd(intel_sdvo, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &intel_sdvo->hotplug_active, 2);
 }
-#endif
 
 static bool
 intel_sdvo_multifunc_encoder(struct intel_sdvo *intel_sdvo)
@@ -2045,6 +1996,7 @@ intel_sdvo_dvi_init(struct intel_sdvo *intel_sdvo, int device)
 {
         struct drm_encoder *encoder = &intel_sdvo->base.base;
         struct drm_connector *connector;
+        struct intel_encoder *intel_encoder = to_intel_encoder(encoder);
         struct intel_connector *intel_connector;
         struct intel_sdvo_connector *intel_sdvo_connector;
 
@@ -2062,7 +2014,17 @@ intel_sdvo_dvi_init(struct intel_sdvo *intel_sdvo, int device)
 
         intel_connector = &intel_sdvo_connector->base;
         connector = &intel_connector->base;
-        connector->polled = DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT;
+        if (intel_sdvo_supports_hotplug(intel_sdvo) & (1 << device)) {
+                connector->polled = DRM_CONNECTOR_POLL_HPD;
+                intel_sdvo->hotplug_active[0] |= 1 << device;
+                /* Some SDVO devices have one-shot hotplug interrupts.
+                 * Ensure that they get re-enabled when an interrupt happens.
+                 */
+                intel_encoder->hot_plug = intel_sdvo_enable_hotplug;
+                intel_sdvo_enable_hotplug(intel_encoder);
+        }
+        else
+                connector->polled = DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT;
         encoder->encoder_type = DRM_MODE_ENCODER_TMDS;
         connector->connector_type = DRM_MODE_CONNECTOR_DVID;
 
@@ -2569,6 +2531,14 @@ bool intel_sdvo_init(struct drm_device *dev, int sdvo_reg)
         if (!intel_sdvo_get_capabilities(intel_sdvo, &intel_sdvo->caps))
                 goto err;
 
+        /* Set up hotplug command - note paranoia about contents of reply.
+         * We assume that the hardware is in a sane state, and only touch
+         * the bits we think we understand.
+         */
+        intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_ACTIVE_HOT_PLUG,
+                             &intel_sdvo->hotplug_active, 2);
+        intel_sdvo->hotplug_active[0] &= ~0x3;
+
         if (intel_sdvo_output_setup(intel_sdvo,
                                     intel_sdvo->caps.output_flags) != true) {
                 DRM_DEBUG_KMS("SDVO output failed to setup on SDVO%c\n",
diff --git a/drivers/gpu/drm/nouveau/nouveau_fence.c b/drivers/gpu/drm/nouveau/nouveau_fence.c
index 8d02d875376d..c919cfc8f2fd 100644
--- a/drivers/gpu/drm/nouveau/nouveau_fence.c
+++ b/drivers/gpu/drm/nouveau/nouveau_fence.c
@@ -530,7 +530,8 @@ nouveau_fence_channel_init(struct nouveau_channel *chan)
                 nouveau_gpuobj_ref(NULL, &obj);
                 if (ret)
                         return ret;
-        } else {
+        } else
+        if (USE_SEMA(dev)) {
                 /* map fence bo into channel's vm */
                 ret = nouveau_bo_vma_add(dev_priv->fence.bo, chan->vm,
                                          &chan->fence.vma);
diff --git a/drivers/gpu/drm/nouveau/nouveau_sgdma.c b/drivers/gpu/drm/nouveau/nouveau_sgdma.c
index c444cadbf849..2706cb3d871a 100644
--- a/drivers/gpu/drm/nouveau/nouveau_sgdma.c
+++ b/drivers/gpu/drm/nouveau/nouveau_sgdma.c
@@ -37,8 +37,11 @@ nouveau_sgdma_populate(struct ttm_backend *be, unsigned long num_pages,
                 return -ENOMEM;
 
         nvbe->ttm_alloced = kmalloc(sizeof(bool) * num_pages, GFP_KERNEL);
-        if (!nvbe->ttm_alloced)
+        if (!nvbe->ttm_alloced) {
+                kfree(nvbe->pages);
+                nvbe->pages = NULL;
                 return -ENOMEM;
+        }
 
         nvbe->nr_pages = 0;
         while (num_pages--) {
@@ -126,7 +129,7 @@ nv04_sgdma_bind(struct ttm_backend *be, struct ttm_mem_reg *mem)
 
                 for (j = 0; j < PAGE_SIZE / NV_CTXDMA_PAGE_SIZE; j++, pte++) {
                         nv_wo32(gpuobj, (pte * 4) + 0, offset_l | 3);
-                        dma_offset += NV_CTXDMA_PAGE_SIZE;
+                        offset_l += NV_CTXDMA_PAGE_SIZE;
                 }
         }
 
diff --git a/drivers/gpu/drm/nouveau/nv04_crtc.c b/drivers/gpu/drm/nouveau/nv04_crtc.c
index 118261d4927a..5e45398a9e2d 100644
--- a/drivers/gpu/drm/nouveau/nv04_crtc.c
+++ b/drivers/gpu/drm/nouveau/nv04_crtc.c
@@ -781,11 +781,20 @@ nv04_crtc_do_mode_set_base(struct drm_crtc *crtc,
         struct drm_device *dev = crtc->dev;
         struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct nv04_crtc_reg *regp = &dev_priv->mode_reg.crtc_reg[nv_crtc->index];
-        struct drm_framebuffer *drm_fb = nv_crtc->base.fb;
-        struct nouveau_framebuffer *fb = nouveau_framebuffer(drm_fb);
+        struct drm_framebuffer *drm_fb;
+        struct nouveau_framebuffer *fb;
         int arb_burst, arb_lwm;
         int ret;
 
+        NV_DEBUG_KMS(dev, "index %d\n", nv_crtc->index);
+
+        /* no fb bound */
+        if (!atomic && !crtc->fb) {
+                NV_DEBUG_KMS(dev, "No FB bound\n");
+                return 0;
+        }
+
+
         /* If atomic, we want to switch to the fb we were passed, so
          * now we update pointers to do that.  (We don't pin; just
          * assume we're already pinned and update the base address.)
@@ -794,6 +803,8 @@ nv04_crtc_do_mode_set_base(struct drm_crtc *crtc,
                 drm_fb = passed_fb;
                 fb = nouveau_framebuffer(passed_fb);
         } else {
+                drm_fb = crtc->fb;
+                fb = nouveau_framebuffer(crtc->fb);
                 /* If not atomic, we can go ahead and pin, and unpin the
                  * old fb we were passed.
                  */
diff --git a/drivers/gpu/drm/nouveau/nv50_crtc.c b/drivers/gpu/drm/nouveau/nv50_crtc.c
index 46ad59ea2185..5d989073ba6e 100644
--- a/drivers/gpu/drm/nouveau/nv50_crtc.c
+++ b/drivers/gpu/drm/nouveau/nv50_crtc.c
@@ -519,12 +519,18 @@ nv50_crtc_do_mode_set_base(struct drm_crtc *crtc,
         struct drm_device *dev = nv_crtc->base.dev;
         struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct nouveau_channel *evo = nv50_display(dev)->master;
-        struct drm_framebuffer *drm_fb = nv_crtc->base.fb;
-        struct nouveau_framebuffer *fb = nouveau_framebuffer(drm_fb);
+        struct drm_framebuffer *drm_fb;
+        struct nouveau_framebuffer *fb;
         int ret;
 
         NV_DEBUG_KMS(dev, "index %d\n", nv_crtc->index);
 
+        /* no fb bound */
+        if (!atomic && !crtc->fb) {
+                NV_DEBUG_KMS(dev, "No FB bound\n");
+                return 0;
+        }
+
         /* If atomic, we want to switch to the fb we were passed, so
          * now we update pointers to do that.  (We don't pin; just
          * assume we're already pinned and update the base address.)
@@ -533,6 +539,8 @@ nv50_crtc_do_mode_set_base(struct drm_crtc *crtc,
                 drm_fb = passed_fb;
                 fb = nouveau_framebuffer(passed_fb);
         } else {
+                drm_fb = crtc->fb;
+                fb = nouveau_framebuffer(crtc->fb);
                 /* If not atomic, we can go ahead and pin, and unpin the
                  * old fb we were passed.
                  */
diff --git a/drivers/gpu/drm/radeon/atombios_dp.c b/drivers/gpu/drm/radeon/atombios_dp.c
index 645b84b3d203..4da23889fea6 100644
--- a/drivers/gpu/drm/radeon/atombios_dp.c
+++ b/drivers/gpu/drm/radeon/atombios_dp.c
@@ -115,6 +115,7 @@ static int radeon_dp_aux_native_write(struct radeon_connector *radeon_connector,
         u8 msg[20];
         int msg_bytes = send_bytes + 4;
         u8 ack;
+        unsigned retry;
 
         if (send_bytes > 16)
                 return -1;
@@ -125,20 +126,20 @@ static int radeon_dp_aux_native_write(struct radeon_connector *radeon_connector,
         msg[3] = (msg_bytes << 4) | (send_bytes - 1);
         memcpy(&msg[4], send, send_bytes);
 
-        while (1) {
+        for (retry = 0; retry < 4; retry++) {
                 ret = radeon_process_aux_ch(dig_connector->dp_i2c_bus,
                                             msg, msg_bytes, NULL, 0, delay, &ack);
                 if (ret < 0)
                         return ret;
                 if ((ack & AUX_NATIVE_REPLY_MASK) == AUX_NATIVE_REPLY_ACK)
-                        break;
+                        return send_bytes;
                 else if ((ack & AUX_NATIVE_REPLY_MASK) == AUX_NATIVE_REPLY_DEFER)
                         udelay(400);
                 else
                         return -EIO;
         }
 
-        return send_bytes;
+        return -EIO;
 }
 
 static int radeon_dp_aux_native_read(struct radeon_connector *radeon_connector,
@@ -149,26 +150,29 @@ static int radeon_dp_aux_native_read(struct radeon_connector *radeon_connector,
         int msg_bytes = 4;
         u8 ack;
         int ret;
+        unsigned retry;
 
         msg[0] = address;
         msg[1] = address >> 8;
         msg[2] = AUX_NATIVE_READ << 4;
         msg[3] = (msg_bytes << 4) | (recv_bytes - 1);
 
-        while (1) {
+        for (retry = 0; retry < 4; retry++) {
                 ret = radeon_process_aux_ch(dig_connector->dp_i2c_bus,
                                             msg, msg_bytes, recv, recv_bytes, delay, &ack);
-                if (ret == 0)
-                        return -EPROTO;
                 if (ret < 0)
                         return ret;
                 if ((ack & AUX_NATIVE_REPLY_MASK) == AUX_NATIVE_REPLY_ACK)
                         return ret;
                 else if ((ack & AUX_NATIVE_REPLY_MASK) == AUX_NATIVE_REPLY_DEFER)
                         udelay(400);
+                else if (ret == 0)
+                        return -EPROTO;
                 else
                         return -EIO;
         }
+
+        return -EIO;
 }
 
 static void radeon_write_dpcd_reg(struct radeon_connector *radeon_connector,
@@ -613,6 +617,18 @@ static bool radeon_dp_get_link_status(struct radeon_connector *radeon_connector,
         return true;
 }
 
+bool radeon_dp_needs_link_train(struct radeon_connector *radeon_connector)
+{
+        u8 link_status[DP_LINK_STATUS_SIZE];
+        struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
+
+        if (!radeon_dp_get_link_status(radeon_connector, link_status))
+                return false;
+        if (dp_channel_eq_ok(link_status, dig->dp_lane_count))
+                return false;
+        return true;
+}
+
 struct radeon_dp_link_train_info {
         struct radeon_device *rdev;
         struct drm_encoder *encoder;
diff --git a/drivers/gpu/drm/radeon/evergreen.c b/drivers/gpu/drm/radeon/evergreen.c
index 14dce9f22172..c4ffa14fb2f4 100644
--- a/drivers/gpu/drm/radeon/evergreen.c
+++ b/drivers/gpu/drm/radeon/evergreen.c
@@ -41,6 +41,31 @@ static void evergreen_gpu_init(struct radeon_device *rdev);
 void evergreen_fini(struct radeon_device *rdev);
 static void evergreen_pcie_gen2_enable(struct radeon_device *rdev);
 
+void evergreen_fix_pci_max_read_req_size(struct radeon_device *rdev)
+{
+        u16 ctl, v;
+        int cap, err;
+
+        cap = pci_pcie_cap(rdev->pdev);
+        if (!cap)
+                return;
+
+        err = pci_read_config_word(rdev->pdev, cap + PCI_EXP_DEVCTL, &ctl);
+        if (err)
+                return;
+
+        v = (ctl & PCI_EXP_DEVCTL_READRQ) >> 12;
+
+        /* if bios or OS sets MAX_READ_REQUEST_SIZE to an invalid value, fix it
+         * to avoid hangs or perfomance issues
+         */
+        if ((v == 0) || (v == 6) || (v == 7)) {
+                ctl &= ~PCI_EXP_DEVCTL_READRQ;
+                ctl |= (2 << 12);
+                pci_write_config_word(rdev->pdev, cap + PCI_EXP_DEVCTL, ctl);
+        }
+}
+
 void evergreen_pre_page_flip(struct radeon_device *rdev, int crtc)
 {
         /* enable the pflip int */
@@ -743,7 +768,7 @@ static void evergreen_program_watermarks(struct radeon_device *rdev,
                     !evergreen_average_bandwidth_vs_available_bandwidth(&wm) ||
                     !evergreen_check_latency_hiding(&wm) ||
                     (rdev->disp_priority == 2)) {
-                        DRM_INFO("force priority to high\n");
+                        DRM_DEBUG_KMS("force priority to high\n");
                         priority_a_cnt |= PRIORITY_ALWAYS_ON;
                         priority_b_cnt |= PRIORITY_ALWAYS_ON;
                 }
@@ -1357,6 +1382,7 @@ int evergreen_cp_resume(struct radeon_device *rdev)
                                  SOFT_RESET_PA |
                                  SOFT_RESET_SH |
                                  SOFT_RESET_VGT |
+                                 SOFT_RESET_SPI |
                                  SOFT_RESET_SX));
         RREG32(GRBM_SOFT_RESET);
         mdelay(15);
@@ -1378,7 +1404,8 @@ int evergreen_cp_resume(struct radeon_device *rdev)
         /* Initialize the ring buffer's read and write pointers */
         WREG32(CP_RB_CNTL, tmp | RB_RPTR_WR_ENA);
         WREG32(CP_RB_RPTR_WR, 0);
-        WREG32(CP_RB_WPTR, 0);
+        rdev->cp.wptr = 0;
+        WREG32(CP_RB_WPTR, rdev->cp.wptr);
 
         /* set the wb address wether it's enabled or not */
         WREG32(CP_RB_RPTR_ADDR,
@@ -1400,7 +1427,6 @@ int evergreen_cp_resume(struct radeon_device *rdev)
         WREG32(CP_DEBUG, (1 << 27) | (1 << 28));
 
         rdev->cp.rptr = RREG32(CP_RB_RPTR);
-        rdev->cp.wptr = RREG32(CP_RB_WPTR);
 
         evergreen_cp_start(rdev);
         rdev->cp.ready = true;
@@ -1564,48 +1590,6 @@ static u32 evergreen_get_tile_pipe_to_backend_map(struct radeon_device *rdev,
         return backend_map;
 }
 
-static void evergreen_program_channel_remap(struct radeon_device *rdev)
-{
-        u32 tcp_chan_steer_lo, tcp_chan_steer_hi, mc_shared_chremap, tmp;
-
-        tmp = RREG32(MC_SHARED_CHMAP);
-        switch ((tmp & NOOFCHAN_MASK) >> NOOFCHAN_SHIFT) {
-        case 0:
-        case 1:
-        case 2:
-        case 3:
-        default:
-                /* default mapping */
-                mc_shared_chremap = 0x00fac688;
-                break;
-        }
-
-        switch (rdev->family) {
-        case CHIP_HEMLOCK:
-        case CHIP_CYPRESS:
-        case CHIP_BARTS:
-                tcp_chan_steer_lo = 0x54763210;
-                tcp_chan_steer_hi = 0x0000ba98;
-                break;
-        case CHIP_JUNIPER:
-        case CHIP_REDWOOD:
-        case CHIP_CEDAR:
-        case CHIP_PALM:
-        case CHIP_SUMO:
-        case CHIP_SUMO2:
-        case CHIP_TURKS:
-        case CHIP_CAICOS:
-        default:
-                tcp_chan_steer_lo = 0x76543210;
-                tcp_chan_steer_hi = 0x0000ba98;
-                break;
-        }
-
-        WREG32(TCP_CHAN_STEER_LO, tcp_chan_steer_lo);
-        WREG32(TCP_CHAN_STEER_HI, tcp_chan_steer_hi);
-        WREG32(MC_SHARED_CHREMAP, mc_shared_chremap);
-}
-
 static void evergreen_gpu_init(struct radeon_device *rdev)
 {
         u32 cc_rb_backend_disable = 0;
@@ -1862,6 +1846,8 @@ static void evergreen_gpu_init(struct radeon_device *rdev)
 
         WREG32(GRBM_CNTL, GRBM_READ_TIMEOUT(0xff));
 
+        evergreen_fix_pci_max_read_req_size(rdev);
+
         cc_gc_shader_pipe_config = RREG32(CC_GC_SHADER_PIPE_CONFIG) & ~2;
 
         cc_gc_shader_pipe_config |=
@@ -2050,8 +2036,6 @@ static void evergreen_gpu_init(struct radeon_device *rdev)
         WREG32(DMIF_ADDR_CONFIG, gb_addr_config);
         WREG32(HDP_ADDR_CONFIG, gb_addr_config);
 
-        evergreen_program_channel_remap(rdev);
-
         num_shader_engines = ((RREG32(GB_ADDR_CONFIG) & NUM_SHADER_ENGINES(3)) >> 12) + 1;
         grbm_gfx_index = INSTANCE_BROADCAST_WRITES;
 
@@ -3143,21 +3127,23 @@ int evergreen_suspend(struct radeon_device *rdev)
 }
 
 int evergreen_copy_blit(struct radeon_device *rdev,
-                        uint64_t src_offset, uint64_t dst_offset,
-                        unsigned num_pages, struct radeon_fence *fence)
+                        uint64_t src_offset,
+                        uint64_t dst_offset,
+                        unsigned num_gpu_pages,
+                        struct radeon_fence *fence)
 {
         int r;
 
         mutex_lock(&rdev->r600_blit.mutex);
         rdev->r600_blit.vb_ib = NULL;
-        r = evergreen_blit_prepare_copy(rdev, num_pages * RADEON_GPU_PAGE_SIZE);
+        r = evergreen_blit_prepare_copy(rdev, num_gpu_pages * RADEON_GPU_PAGE_SIZE);
         if (r) {
                 if (rdev->r600_blit.vb_ib)
                         radeon_ib_free(rdev, &rdev->r600_blit.vb_ib);
                 mutex_unlock(&rdev->r600_blit.mutex);
                 return r;
         }
-        evergreen_kms_blit_copy(rdev, src_offset, dst_offset, num_pages * RADEON_GPU_PAGE_SIZE);
+        evergreen_kms_blit_copy(rdev, src_offset, dst_offset, num_gpu_pages * RADEON_GPU_PAGE_SIZE);
         evergreen_blit_done_copy(rdev, fence);
         mutex_unlock(&rdev->r600_blit.mutex);
         return 0;
diff --git a/drivers/gpu/drm/radeon/ni.c b/drivers/gpu/drm/radeon/ni.c
index 44c4750f4518..8c79ca97753d 100644
--- a/drivers/gpu/drm/radeon/ni.c
+++ b/drivers/gpu/drm/radeon/ni.c
@@ -39,6 +39,7 @@ extern int evergreen_mc_wait_for_idle(struct radeon_device *rdev);
 extern void evergreen_mc_program(struct radeon_device *rdev);
 extern void evergreen_irq_suspend(struct radeon_device *rdev);
 extern int evergreen_mc_init(struct radeon_device *rdev);
+extern void evergreen_fix_pci_max_read_req_size(struct radeon_device *rdev);
 
 #define EVERGREEN_PFP_UCODE_SIZE 1120
 #define EVERGREEN_PM4_UCODE_SIZE 1376
@@ -568,36 +569,6 @@ static u32 cayman_get_tile_pipe_to_backend_map(struct radeon_device *rdev,
         return backend_map;
 }
 
-static void cayman_program_channel_remap(struct radeon_device *rdev)
-{
-        u32 tcp_chan_steer_lo, tcp_chan_steer_hi, mc_shared_chremap, tmp;
-
-        tmp = RREG32(MC_SHARED_CHMAP);
-        switch ((tmp & NOOFCHAN_MASK) >> NOOFCHAN_SHIFT) {
-        case 0:
-        case 1:
-        case 2:
-        case 3:
-        default:
-                /* default mapping */
-                mc_shared_chremap = 0x00fac688;
-                break;
-        }
-
-        switch (rdev->family) {
-        case CHIP_CAYMAN:
-        default:
-                //tcp_chan_steer_lo = 0x54763210
-                tcp_chan_steer_lo = 0x76543210;
-                tcp_chan_steer_hi = 0x0000ba98;
-                break;
-        }
-
-        WREG32(TCP_CHAN_STEER_LO, tcp_chan_steer_lo);
-        WREG32(TCP_CHAN_STEER_HI, tcp_chan_steer_hi);
-        WREG32(MC_SHARED_CHREMAP, mc_shared_chremap);
-}
-
 static u32 cayman_get_disable_mask_per_asic(struct radeon_device *rdev,
                                             u32 disable_mask_per_se,
                                             u32 max_disable_mask_per_se,
@@ -669,6 +640,8 @@ static void cayman_gpu_init(struct radeon_device *rdev)
 
         WREG32(GRBM_CNTL, GRBM_READ_TIMEOUT(0xff));
 
+        evergreen_fix_pci_max_read_req_size(rdev);
+
         mc_shared_chmap = RREG32(MC_SHARED_CHMAP);
         mc_arb_ramcfg = RREG32(MC_ARB_RAMCFG);
 
@@ -839,8 +812,6 @@ static void cayman_gpu_init(struct radeon_device *rdev)
         WREG32(DMIF_ADDR_CONFIG, gb_addr_config);
         WREG32(HDP_ADDR_CONFIG, gb_addr_config);
 
-        cayman_program_channel_remap(rdev);
-
         /* primary versions */
         WREG32(CC_RB_BACKEND_DISABLE, cc_rb_backend_disable);
         WREG32(CC_SYS_RB_BACKEND_DISABLE, cc_rb_backend_disable);
@@ -1159,6 +1130,7 @@ int cayman_cp_resume(struct radeon_device *rdev)
                                  SOFT_RESET_PA |
                                  SOFT_RESET_SH |
                                  SOFT_RESET_VGT |
+                                 SOFT_RESET_SPI |
                                  SOFT_RESET_SX));
         RREG32(GRBM_SOFT_RESET);
         mdelay(15);
@@ -1183,7 +1155,8 @@ int cayman_cp_resume(struct radeon_device *rdev)
 
         /* Initialize the ring buffer's read and write pointers */
         WREG32(CP_RB0_CNTL, tmp | RB_RPTR_WR_ENA);
-        WREG32(CP_RB0_WPTR, 0);
+        rdev->cp.wptr = 0;
+        WREG32(CP_RB0_WPTR, rdev->cp.wptr);
 
         /* set the wb address wether it's enabled or not */
         WREG32(CP_RB0_RPTR_ADDR, (rdev->wb.gpu_addr + RADEON_WB_CP_RPTR_OFFSET) & 0xFFFFFFFC);
@@ -1203,7 +1176,6 @@ int cayman_cp_resume(struct radeon_device *rdev)
         WREG32(CP_RB0_BASE, rdev->cp.gpu_addr >> 8);
 
         rdev->cp.rptr = RREG32(CP_RB0_RPTR);
-        rdev->cp.wptr = RREG32(CP_RB0_WPTR);
 
         /* ring1  - compute only */
         /* Set ring buffer size */
@@ -1216,7 +1188,8 @@ int cayman_cp_resume(struct radeon_device *rdev)
 
         /* Initialize the ring buffer's read and write pointers */
         WREG32(CP_RB1_CNTL, tmp | RB_RPTR_WR_ENA);
-        WREG32(CP_RB1_WPTR, 0);
+        rdev->cp1.wptr = 0;
+        WREG32(CP_RB1_WPTR, rdev->cp1.wptr);
 
         /* set the wb address wether it's enabled or not */
         WREG32(CP_RB1_RPTR_ADDR, (rdev->wb.gpu_addr + RADEON_WB_CP1_RPTR_OFFSET) & 0xFFFFFFFC);
@@ -1228,7 +1201,6 @@ int cayman_cp_resume(struct radeon_device *rdev)
         WREG32(CP_RB1_BASE, rdev->cp1.gpu_addr >> 8);
 
         rdev->cp1.rptr = RREG32(CP_RB1_RPTR);
-        rdev->cp1.wptr = RREG32(CP_RB1_WPTR);
 
         /* ring2 - compute only */
         /* Set ring buffer size */
@@ -1241,7 +1213,8 @@ int cayman_cp_resume(struct radeon_device *rdev)
 
         /* Initialize the ring buffer's read and write pointers */
         WREG32(CP_RB2_CNTL, tmp | RB_RPTR_WR_ENA);
-        WREG32(CP_RB2_WPTR, 0);
+        rdev->cp2.wptr = 0;
+        WREG32(CP_RB2_WPTR, rdev->cp2.wptr);
 
         /* set the wb address wether it's enabled or not */
         WREG32(CP_RB2_RPTR_ADDR, (rdev->wb.gpu_addr + RADEON_WB_CP2_RPTR_OFFSET) & 0xFFFFFFFC);
@@ -1253,7 +1226,6 @@ int cayman_cp_resume(struct radeon_device *rdev)
         WREG32(CP_RB2_BASE, rdev->cp2.gpu_addr >> 8);
 
         rdev->cp2.rptr = RREG32(CP_RB2_RPTR);
-        rdev->cp2.wptr = RREG32(CP_RB2_WPTR);
 
         /* start the rings */
         cayman_cp_start(rdev);
diff --git a/drivers/gpu/drm/radeon/r100.c b/drivers/gpu/drm/radeon/r100.c
index f2204cb1ccdf..7fcdbbbf2979 100644
--- a/drivers/gpu/drm/radeon/r100.c
+++ b/drivers/gpu/drm/radeon/r100.c
@@ -721,11 +721,11 @@ void r100_fence_ring_emit(struct radeon_device *rdev,
 int r100_copy_blit(struct radeon_device *rdev,
                    uint64_t src_offset,
                    uint64_t dst_offset,
-                   unsigned num_pages,
+                   unsigned num_gpu_pages,
                    struct radeon_fence *fence)
 {
         uint32_t cur_pages;
-        uint32_t stride_bytes = PAGE_SIZE;
+        uint32_t stride_bytes = RADEON_GPU_PAGE_SIZE;
         uint32_t pitch;
         uint32_t stride_pixels;
         unsigned ndw;
@@ -737,7 +737,7 @@ int r100_copy_blit(struct radeon_device *rdev,
         /* radeon pitch is /64 */
         pitch = stride_bytes / 64;
         stride_pixels = stride_bytes / 4;
-        num_loops = DIV_ROUND_UP(num_pages, 8191);
+        num_loops = DIV_ROUND_UP(num_gpu_pages, 8191);
 
         /* Ask for enough room for blit + flush + fence */
         ndw = 64 + (10 * num_loops);
@@ -746,12 +746,12 @@ int r100_copy_blit(struct radeon_device *rdev,
                 DRM_ERROR("radeon: moving bo (%d) asking for %u dw.\n", r, ndw);
                 return -EINVAL;
         }
-        while (num_pages > 0) {
-                cur_pages = num_pages;
+        while (num_gpu_pages > 0) {
+                cur_pages = num_gpu_pages;
                 if (cur_pages > 8191) {
                         cur_pages = 8191;
                 }
-                num_pages -= cur_pages;
+                num_gpu_pages -= cur_pages;
 
                 /* pages are in Y direction - height
                    page width in X direction - width */
@@ -773,8 +773,8 @@ int r100_copy_blit(struct radeon_device *rdev,
                 radeon_ring_write(rdev, (0x1fff) | (0x1fff << 16));
                 radeon_ring_write(rdev, 0);
                 radeon_ring_write(rdev, (0x1fff) | (0x1fff << 16));
-                radeon_ring_write(rdev, num_pages);
-                radeon_ring_write(rdev, num_pages);
+                radeon_ring_write(rdev, num_gpu_pages);
+                radeon_ring_write(rdev, num_gpu_pages);
                 radeon_ring_write(rdev, cur_pages | (stride_pixels << 16));
         }
         radeon_ring_write(rdev, PACKET0(RADEON_DSTCACHE_CTLSTAT, 0));
@@ -990,7 +990,8 @@ int r100_cp_init(struct radeon_device *rdev, unsigned ring_size)
         /* Force read & write ptr to 0 */
         WREG32(RADEON_CP_RB_CNTL, tmp | RADEON_RB_RPTR_WR_ENA | RADEON_RB_NO_UPDATE);
         WREG32(RADEON_CP_RB_RPTR_WR, 0);
-        WREG32(RADEON_CP_RB_WPTR, 0);
+        rdev->cp.wptr = 0;
+        WREG32(RADEON_CP_RB_WPTR, rdev->cp.wptr);
 
         /* set the wb address whether it's enabled or not */
         WREG32(R_00070C_CP_RB_RPTR_ADDR,
@@ -1007,9 +1008,6 @@ int r100_cp_init(struct radeon_device *rdev, unsigned ring_size)
         WREG32(RADEON_CP_RB_CNTL, tmp);
         udelay(10);
         rdev->cp.rptr = RREG32(RADEON_CP_RB_RPTR);
-        rdev->cp.wptr = RREG32(RADEON_CP_RB_WPTR);
-        /* protect against crazy HW on resume */
-        rdev->cp.wptr &= rdev->cp.ptr_mask;
         /* Set cp mode to bus mastering & enable cp*/
         WREG32(RADEON_CP_CSQ_MODE,
                REG_SET(RADEON_INDIRECT2_START, indirect2_start) |
diff --git a/drivers/gpu/drm/radeon/r200.c b/drivers/gpu/drm/radeon/r200.c
index f24058300413..a1f3ba063c2d 100644
--- a/drivers/gpu/drm/radeon/r200.c
+++ b/drivers/gpu/drm/radeon/r200.c
@@ -84,7 +84,7 @@ static int r200_get_vtx_size_0(uint32_t vtx_fmt_0)
 int r200_copy_dma(struct radeon_device *rdev,
                   uint64_t src_offset,
                   uint64_t dst_offset,
-                  unsigned num_pages,
+                  unsigned num_gpu_pages,
                   struct radeon_fence *fence)
 {
         uint32_t size;
@@ -93,7 +93,7 @@ int r200_copy_dma(struct radeon_device *rdev,
         int r = 0;
 
         /* radeon pitch is /64 */
-        size = num_pages << PAGE_SHIFT;
+        size = num_gpu_pages << RADEON_GPU_PAGE_SHIFT;
         num_loops = DIV_ROUND_UP(size, 0x1FFFFF);
         r = radeon_ring_lock(rdev, num_loops * 4 + 64);
         if (r) {
diff --git a/drivers/gpu/drm/radeon/r600.c b/drivers/gpu/drm/radeon/r600.c
index aa5571b73aa0..720dd99163f8 100644
--- a/drivers/gpu/drm/radeon/r600.c
+++ b/drivers/gpu/drm/radeon/r600.c
@@ -2209,7 +2209,8 @@ int r600_cp_resume(struct radeon_device *rdev)
         /* Initialize the ring buffer's read and write pointers */
         WREG32(CP_RB_CNTL, tmp | RB_RPTR_WR_ENA);
         WREG32(CP_RB_RPTR_WR, 0);
-        WREG32(CP_RB_WPTR, 0);
+        rdev->cp.wptr = 0;
+        WREG32(CP_RB_WPTR, rdev->cp.wptr);
 
         /* set the wb address whether it's enabled or not */
         WREG32(CP_RB_RPTR_ADDR,
@@ -2231,7 +2232,6 @@ int r600_cp_resume(struct radeon_device *rdev)
         WREG32(CP_DEBUG, (1 << 27) | (1 << 28));
 
         rdev->cp.rptr = RREG32(CP_RB_RPTR);
-        rdev->cp.wptr = RREG32(CP_RB_WPTR);
 
         r600_cp_start(rdev);
         rdev->cp.ready = true;
@@ -2353,21 +2353,23 @@ void r600_fence_ring_emit(struct radeon_device *rdev,
 }
 
 int r600_copy_blit(struct radeon_device *rdev,
-                   uint64_t src_offset, uint64_t dst_offset,
-                   unsigned num_pages, struct radeon_fence *fence)
+                   uint64_t src_offset,
+                   uint64_t dst_offset,
+                   unsigned num_gpu_pages,
+                   struct radeon_fence *fence)
 {
         int r;
 
         mutex_lock(&rdev->r600_blit.mutex);
         rdev->r600_blit.vb_ib = NULL;
-        r = r600_blit_prepare_copy(rdev, num_pages * RADEON_GPU_PAGE_SIZE);
+        r = r600_blit_prepare_copy(rdev, num_gpu_pages * RADEON_GPU_PAGE_SIZE);
         if (r) {
                 if (rdev->r600_blit.vb_ib)
                         radeon_ib_free(rdev, &rdev->r600_blit.vb_ib);
                 mutex_unlock(&rdev->r600_blit.mutex);
                 return r;
         }
-        r600_kms_blit_copy(rdev, src_offset, dst_offset, num_pages * RADEON_GPU_PAGE_SIZE);
+        r600_kms_blit_copy(rdev, src_offset, dst_offset, num_gpu_pages * RADEON_GPU_PAGE_SIZE);
         r600_blit_done_copy(rdev, fence);
         mutex_unlock(&rdev->r600_blit.mutex);
         return 0;
diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h
index 32807baf55e2..c1e056b35b29 100644
--- a/drivers/gpu/drm/radeon/radeon.h
+++ b/drivers/gpu/drm/radeon/radeon.h
@@ -322,6 +322,7 @@ union radeon_gart_table {
 
 #define RADEON_GPU_PAGE_SIZE 4096
 #define RADEON_GPU_PAGE_MASK (RADEON_GPU_PAGE_SIZE - 1)
+#define RADEON_GPU_PAGE_SHIFT 12
 
 struct radeon_gart {
         dma_addr_t                      table_addr;
@@ -914,17 +915,17 @@ struct radeon_asic {
         int (*copy_blit)(struct radeon_device *rdev,
                          uint64_t src_offset,
                          uint64_t dst_offset,
-                         unsigned num_pages,
+                         unsigned num_gpu_pages,
                          struct radeon_fence *fence);
         int (*copy_dma)(struct radeon_device *rdev,
                         uint64_t src_offset,
                         uint64_t dst_offset,
-                        unsigned num_pages,
+                        unsigned num_gpu_pages,
                         struct radeon_fence *fence);
         int (*copy)(struct radeon_device *rdev,
                     uint64_t src_offset,
                     uint64_t dst_offset,
-                    unsigned num_pages,
+                    unsigned num_gpu_pages,
                     struct radeon_fence *fence);
         uint32_t (*get_engine_clock)(struct radeon_device *rdev);
         void (*set_engine_clock)(struct radeon_device *rdev, uint32_t eng_clock);
diff --git a/drivers/gpu/drm/radeon/radeon_asic.h b/drivers/gpu/drm/radeon/radeon_asic.h
index 3d7a0d7c6a9a..3dedaa07aac1 100644
--- a/drivers/gpu/drm/radeon/radeon_asic.h
+++ b/drivers/gpu/drm/radeon/radeon_asic.h
@@ -75,7 +75,7 @@ uint32_t r100_pll_rreg(struct radeon_device *rdev, uint32_t reg);
 int r100_copy_blit(struct radeon_device *rdev,
                    uint64_t src_offset,
                    uint64_t dst_offset,
-                   unsigned num_pages,
+                   unsigned num_gpu_pages,
                    struct radeon_fence *fence);
 int r100_set_surface_reg(struct radeon_device *rdev, int reg,
                          uint32_t tiling_flags, uint32_t pitch,
@@ -143,7 +143,7 @@ extern void r100_post_page_flip(struct radeon_device *rdev, int crtc);
 extern int r200_copy_dma(struct radeon_device *rdev,
                          uint64_t src_offset,
                          uint64_t dst_offset,
-                         unsigned num_pages,
+                         unsigned num_gpu_pages,
                          struct radeon_fence *fence);
 void r200_set_safe_registers(struct radeon_device *rdev);
 
@@ -311,7 +311,7 @@ void r600_ring_ib_execute(struct radeon_device *rdev, struct radeon_ib *ib);
 int r600_ring_test(struct radeon_device *rdev);
 int r600_copy_blit(struct radeon_device *rdev,
                    uint64_t src_offset, uint64_t dst_offset,
-                   unsigned num_pages, struct radeon_fence *fence);
+                   unsigned num_gpu_pages, struct radeon_fence *fence);
 void r600_hpd_init(struct radeon_device *rdev);
 void r600_hpd_fini(struct radeon_device *rdev);
 bool r600_hpd_sense(struct radeon_device *rdev, enum radeon_hpd_id hpd);
@@ -403,7 +403,7 @@ void evergreen_bandwidth_update(struct radeon_device *rdev);
 void evergreen_ring_ib_execute(struct radeon_device *rdev, struct radeon_ib *ib);
 int evergreen_copy_blit(struct radeon_device *rdev,
                         uint64_t src_offset, uint64_t dst_offset,
-                        unsigned num_pages, struct radeon_fence *fence);
+                        unsigned num_gpu_pages, struct radeon_fence *fence);
 void evergreen_hpd_init(struct radeon_device *rdev);
 void evergreen_hpd_fini(struct radeon_device *rdev);
 bool evergreen_hpd_sense(struct radeon_device *rdev, enum radeon_hpd_id hpd);
diff --git a/drivers/gpu/drm/radeon/radeon_clocks.c b/drivers/gpu/drm/radeon/radeon_clocks.c
index dcd0863e31ae..b6e18c8db9f5 100644
--- a/drivers/gpu/drm/radeon/radeon_clocks.c
+++ b/drivers/gpu/drm/radeon/radeon_clocks.c
@@ -219,6 +219,9 @@ void radeon_get_clock_info(struct drm_device *dev)
                 } else {
                         DRM_INFO("Using generic clock info\n");
 
+                        /* may need to be per card */
+                        rdev->clock.max_pixel_clock = 35000;
+
                         if (rdev->flags & RADEON_IS_IGP) {
                                 p1pll->reference_freq = 1432;
                                 p2pll->reference_freq = 1432;
diff --git a/drivers/gpu/drm/radeon/radeon_combios.c b/drivers/gpu/drm/radeon/radeon_combios.c
index e0138b674aca..63675241c7ff 100644
--- a/drivers/gpu/drm/radeon/radeon_combios.c
+++ b/drivers/gpu/drm/radeon/radeon_combios.c
@@ -3298,6 +3298,14 @@ void radeon_combios_asic_init(struct drm_device *dev)
             rdev->pdev->subsystem_device == 0x30a4)
                 return;
 
+        /* quirk for rs4xx Compaq Presario V5245EU laptop to make it resume
+         * - it hangs on resume inside the dynclk 1 table.
+         */
+        if (rdev->family == CHIP_RS480 &&
+            rdev->pdev->subsystem_vendor == 0x103c &&
+            rdev->pdev->subsystem_device == 0x30ae)
+                return;
+
         /* DYN CLK 1 */
         table = combios_get_table_offset(dev, COMBIOS_DYN_CLK_1_TABLE);
         if (table)
diff --git a/drivers/gpu/drm/radeon/radeon_connectors.c b/drivers/gpu/drm/radeon/radeon_connectors.c
index 6d6b5f16bc09..bce63fd329d4 100644
--- a/drivers/gpu/drm/radeon/radeon_connectors.c
+++ b/drivers/gpu/drm/radeon/radeon_connectors.c
@@ -60,18 +60,20 @@ void radeon_connector_hotplug(struct drm_connector *connector)
 
         radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
 
-        /* powering up/down the eDP panel generates hpd events which
-         * can interfere with modesetting.
-         */
-        if (connector->connector_type == DRM_MODE_CONNECTOR_eDP)
+        /* if the connector is already off, don't turn it back on */
+        if (connector->dpms != DRM_MODE_DPMS_ON)
                 return;
 
-        /* pre-r600 did not always have the hpd pins mapped accurately to connectors */
-        if (rdev->family >= CHIP_R600) {
-                if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
-                        drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
-                else
+        /* just deal with DP (not eDP) here. */
+        if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
+                int saved_dpms = connector->dpms;
+
+                /* Only turn off the display it it's physically disconnected */
+                if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
                         drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
+                else if (radeon_dp_needs_link_train(radeon_connector))
+                        drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
+                connector->dpms = saved_dpms;
         }
 }
 
@@ -464,6 +466,16 @@ static bool radeon_connector_needs_extended_probe(struct radeon_device *dev,
                     (supported_device == ATOM_DEVICE_DFP2_SUPPORT))
                         return true;
         }
+        /* TOSHIBA Satellite L300D with ATI Mobility Radeon x1100
+         * (RS690M) sends data to i2c bus for a HDMI connector that
+         * is not implemented */
+        if ((dev->pdev->device == 0x791f) &&
+            (dev->pdev->subsystem_vendor == 0x1179) &&
+            (dev->pdev->subsystem_device == 0xff68)) {
+                if ((connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
+                    (supported_device == ATOM_DEVICE_DFP2_SUPPORT))
+                        return true;
+        }
 
         /* Default: no EDID header probe required for DDC probing */
         return false;
@@ -474,11 +486,19 @@ static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
 {
         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
+        struct drm_display_mode *t, *mode;
+
+        /* If the EDID preferred mode doesn't match the native mode, use it */
+        list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
+                if (mode->type & DRM_MODE_TYPE_PREFERRED) {
+                        if (mode->hdisplay != native_mode->hdisplay ||
+                            mode->vdisplay != native_mode->vdisplay)
+                                memcpy(native_mode, mode, sizeof(*mode));
+                }
+        }
 
         /* Try to get native mode details from EDID if necessary */
         if (!native_mode->clock) {
-                struct drm_display_mode *t, *mode;
-
                 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
                         if (mode->hdisplay == native_mode->hdisplay &&
                             mode->vdisplay == native_mode->vdisplay) {
@@ -489,6 +509,7 @@ static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
                         }
                 }
         }
+
         if (!native_mode->clock) {
                 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
                 radeon_encoder->rmx_type = RMX_OFF;
@@ -1276,12 +1297,33 @@ radeon_dp_detect(struct drm_connector *connector, bool force)
                 if (!radeon_dig_connector->edp_on)
                         atombios_set_edp_panel_power(connector,
                                                      ATOM_TRANSMITTER_ACTION_POWER_OFF);
-        } else {
-                /* need to setup ddc on the bridge */
-                if (radeon_connector_encoder_is_dp_bridge(connector)) {
+        } else if (radeon_connector_encoder_is_dp_bridge(connector)) {
+                /* DP bridges are always DP */
+                radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
+                /* get the DPCD from the bridge */
+                radeon_dp_getdpcd(radeon_connector);
+
+                if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
+                        ret = connector_status_connected;
+                else {
+                        /* need to setup ddc on the bridge */
                         if (encoder)
                                 radeon_atom_ext_encoder_setup_ddc(encoder);
+                        if (radeon_ddc_probe(radeon_connector,
+                                             radeon_connector->requires_extended_probe))
+                                ret = connector_status_connected;
                 }
+
+                if ((ret == connector_status_disconnected) &&
+                    radeon_connector->dac_load_detect) {
+                        struct drm_encoder *encoder = radeon_best_single_encoder(connector);
+                        struct drm_encoder_helper_funcs *encoder_funcs;
+                        if (encoder) {
+                                encoder_funcs = encoder->helper_private;
+                                ret = encoder_funcs->detect(encoder, connector);
+                        }
+                }
+        } else {
                 radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
                 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
                         ret = connector_status_connected;
@@ -1297,16 +1339,6 @@ radeon_dp_detect(struct drm_connector *connector, bool force)
                                         ret = connector_status_connected;
                         }
                 }
-
-                if ((ret == connector_status_disconnected) &&
-                    radeon_connector->dac_load_detect) {
-                        struct drm_encoder *encoder = radeon_best_single_encoder(connector);
-                        struct drm_encoder_helper_funcs *encoder_funcs;
-                        if (encoder) {
-                                encoder_funcs = encoder->helper_private;
-                                ret = encoder_funcs->detect(encoder, connector);
-                        }
-                }
         }
 
         radeon_connector_update_scratch_regs(connector, ret);
diff --git a/drivers/gpu/drm/radeon/radeon_cursor.c b/drivers/gpu/drm/radeon/radeon_cursor.c
index 3189a7efb2e9..fde25c0d65a0 100644
--- a/drivers/gpu/drm/radeon/radeon_cursor.c
+++ b/drivers/gpu/drm/radeon/radeon_cursor.c
@@ -208,23 +208,25 @@ int radeon_crtc_cursor_move(struct drm_crtc *crtc,
         int xorigin = 0, yorigin = 0;
         int w = radeon_crtc->cursor_width;
 
-        if (x < 0)
-                xorigin = -x + 1;
-        if (y < 0)
-                yorigin = -y + 1;
-        if (xorigin >= CURSOR_WIDTH)
-                xorigin = CURSOR_WIDTH - 1;
-        if (yorigin >= CURSOR_HEIGHT)
-                yorigin = CURSOR_HEIGHT - 1;
-
         if (ASIC_IS_AVIVO(rdev)) {
-                int i = 0;
-                struct drm_crtc *crtc_p;
-
                 /* avivo cursor are offset into the total surface */
                 x += crtc->x;
                 y += crtc->y;
-                DRM_DEBUG("x %d y %d c->x %d c->y %d\n", x, y, crtc->x, crtc->y);
+        }
+        DRM_DEBUG("x %d y %d c->x %d c->y %d\n", x, y, crtc->x, crtc->y);
+
+        if (x < 0) {
+                xorigin = min(-x, CURSOR_WIDTH - 1);
+                x = 0;
+        }
+        if (y < 0) {
+                yorigin = min(-y, CURSOR_HEIGHT - 1);
+                y = 0;
+        }
+
+        if (ASIC_IS_AVIVO(rdev)) {
+                int i = 0;
+                struct drm_crtc *crtc_p;
 
                 /* avivo cursor image can't end on 128 pixel boundary or
                  * go past the end of the frame if both crtcs are enabled
@@ -253,16 +255,12 @@ int radeon_crtc_cursor_move(struct drm_crtc *crtc,
 
         radeon_lock_cursor(crtc, true);
         if (ASIC_IS_DCE4(rdev)) {
-                WREG32(EVERGREEN_CUR_POSITION + radeon_crtc->crtc_offset,
-                       ((xorigin ? 0 : x) << 16) |
-                       (yorigin ? 0 : y));
+                WREG32(EVERGREEN_CUR_POSITION + radeon_crtc->crtc_offset, (x << 16) | y);
                 WREG32(EVERGREEN_CUR_HOT_SPOT + radeon_crtc->crtc_offset, (xorigin << 16) | yorigin);
                 WREG32(EVERGREEN_CUR_SIZE + radeon_crtc->crtc_offset,
                        ((w - 1) << 16) | (radeon_crtc->cursor_height - 1));
         } else if (ASIC_IS_AVIVO(rdev)) {
-                WREG32(AVIVO_D1CUR_POSITION + radeon_crtc->crtc_offset,
-                             ((xorigin ? 0 : x) << 16) |
-                             (yorigin ? 0 : y));
+                WREG32(AVIVO_D1CUR_POSITION + radeon_crtc->crtc_offset, (x << 16) | y);
                 WREG32(AVIVO_D1CUR_HOT_SPOT + radeon_crtc->crtc_offset, (xorigin << 16) | yorigin);
                 WREG32(AVIVO_D1CUR_SIZE + radeon_crtc->crtc_offset,
                        ((w - 1) << 16) | (radeon_crtc->cursor_height - 1));
@@ -276,8 +274,8 @@ int radeon_crtc_cursor_move(struct drm_crtc *crtc,
                         | yorigin));
                 WREG32(RADEON_CUR_HORZ_VERT_POSN + radeon_crtc->crtc_offset,
                        (RADEON_CUR_LOCK
-                        | ((xorigin ? 0 : x) << 16)
-                        | (yorigin ? 0 : y)));
+                        | (x << 16)
+                        | y));
                 /* offset is from DISP(2)_BASE_ADDRESS */
                 WREG32(RADEON_CUR_OFFSET + radeon_crtc->crtc_offset, (radeon_crtc->legacy_cursor_offset +
                                                                       (yorigin * 256)));
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c
index 440e6ecccc40..b51e15725c6e 100644
--- a/drivers/gpu/drm/radeon/radeon_device.c
+++ b/drivers/gpu/drm/radeon/radeon_device.c
@@ -32,6 +32,7 @@
 #include <drm/radeon_drm.h>
 #include <linux/vgaarb.h>
 #include <linux/vga_switcheroo.h>
+#include <linux/efi.h>
 #include "radeon_reg.h"
 #include "radeon.h"
 #include "atom.h"
@@ -300,6 +301,8 @@ void radeon_vram_location(struct radeon_device *rdev, struct radeon_mc *mc, u64
                 mc->mc_vram_size = mc->aper_size;
         }
         mc->vram_end = mc->vram_start + mc->mc_vram_size - 1;
+        if (radeon_vram_limit && radeon_vram_limit < mc->real_vram_size)
+                mc->real_vram_size = radeon_vram_limit;
         dev_info(rdev->dev, "VRAM: %lluM 0x%016llX - 0x%016llX (%lluM used)\n",
                         mc->mc_vram_size >> 20, mc->vram_start,
                         mc->vram_end, mc->real_vram_size >> 20);
@@ -348,6 +351,9 @@ bool radeon_card_posted(struct radeon_device *rdev)
 {
         uint32_t reg;
 
+        if (efi_enabled && rdev->pdev->subsystem_vendor == PCI_VENDOR_ID_APPLE)
+                return false;
+
         /* first check CRTCs */
         if (ASIC_IS_DCE41(rdev)) {
                 reg = RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC0_REGISTER_OFFSET) |
diff --git a/drivers/gpu/drm/radeon/radeon_display.c b/drivers/gpu/drm/radeon/radeon_display.c
index 1a858944e4f3..6adb3e58affd 100644
--- a/drivers/gpu/drm/radeon/radeon_display.c
+++ b/drivers/gpu/drm/radeon/radeon_display.c
@@ -473,8 +473,8 @@ pflip_cleanup:
         spin_lock_irqsave(&dev->event_lock, flags);
         radeon_crtc->unpin_work = NULL;
 unlock_free:
-        drm_gem_object_unreference_unlocked(old_radeon_fb->obj);
         spin_unlock_irqrestore(&dev->event_lock, flags);
+        drm_gem_object_unreference_unlocked(old_radeon_fb->obj);
         radeon_fence_unref(&work->fence);
         kfree(work);
 
@@ -707,16 +707,21 @@ int radeon_ddc_get_modes(struct radeon_connector *radeon_connector)
                 radeon_router_select_ddc_port(radeon_connector);
 
         if ((radeon_connector->base.connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
-            (radeon_connector->base.connector_type == DRM_MODE_CONNECTOR_eDP)) {
+            (radeon_connector->base.connector_type == DRM_MODE_CONNECTOR_eDP) ||
+            radeon_connector_encoder_is_dp_bridge(&radeon_connector->base)) {
                 struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
+
                 if ((dig->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT ||
                      dig->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) && dig->dp_i2c_bus)
-                        radeon_connector->edid = drm_get_edid(&radeon_connector->base, &dig->dp_i2c_bus->adapter);
-        }
-        if (!radeon_connector->ddc_bus)
-                return -1;
-        if (!radeon_connector->edid) {
-                radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
+                        radeon_connector->edid = drm_get_edid(&radeon_connector->base,
+                                                              &dig->dp_i2c_bus->adapter);
+                else if (radeon_connector->ddc_bus && !radeon_connector->edid)
+                        radeon_connector->edid = drm_get_edid(&radeon_connector->base,
+                                                              &radeon_connector->ddc_bus->adapter);
+        } else {
+                if (radeon_connector->ddc_bus && !radeon_connector->edid)
+                        radeon_connector->edid = drm_get_edid(&radeon_connector->base,
+                                                              &radeon_connector->ddc_bus->adapter);
         }
 
         if (!radeon_connector->edid) {
diff --git a/drivers/gpu/drm/radeon/radeon_encoders.c b/drivers/gpu/drm/radeon/radeon_encoders.c
index b293487e5aa3..13690f3eb4a4 100644
--- a/drivers/gpu/drm/radeon/radeon_encoders.c
+++ b/drivers/gpu/drm/radeon/radeon_encoders.c
@@ -1507,7 +1507,14 @@ radeon_atom_encoder_dpms(struct drm_encoder *encoder, int mode)
                 switch (mode) {
                 case DRM_MODE_DPMS_ON:
                         args.ucAction = ATOM_ENABLE;
-                        atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
+                        /* workaround for DVOOutputControl on some RS690 systems */
+                        if (radeon_encoder->encoder_id == ENCODER_OBJECT_ID_INTERNAL_DDI) {
+                                u32 reg = RREG32(RADEON_BIOS_3_SCRATCH);
+                                WREG32(RADEON_BIOS_3_SCRATCH, reg & ~ATOM_S3_DFP2I_ACTIVE);
+                                atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
+                                WREG32(RADEON_BIOS_3_SCRATCH, reg);
+                        } else
+                                atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
                         if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
                                 args.ucAction = ATOM_LCD_BLON;
                                 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
@@ -2323,6 +2330,9 @@ radeon_add_atom_encoder(struct drm_device *dev,
         default:
                 encoder->possible_crtcs = 0x3;
                 break;
+        case 4:
+                encoder->possible_crtcs = 0xf;
+                break;
         case 6:
                 encoder->possible_crtcs = 0x3f;
                 break;
diff --git a/drivers/gpu/drm/radeon/radeon_mode.h b/drivers/gpu/drm/radeon/radeon_mode.h
index d09031c03e26..68820f5f6303 100644
--- a/drivers/gpu/drm/radeon/radeon_mode.h
+++ b/drivers/gpu/drm/radeon/radeon_mode.h
@@ -479,6 +479,7 @@ extern void radeon_dp_set_link_config(struct drm_connector *connector,
                                       struct drm_display_mode *mode);
 extern void radeon_dp_link_train(struct drm_encoder *encoder,
                                  struct drm_connector *connector);
+extern bool radeon_dp_needs_link_train(struct radeon_connector *radeon_connector);
 extern u8 radeon_dp_getsinktype(struct radeon_connector *radeon_connector);
 extern bool radeon_dp_getdpcd(struct radeon_connector *radeon_connector);
 extern void atombios_dig_encoder_setup(struct drm_encoder *encoder, int action, int panel_mode);
diff --git a/drivers/gpu/drm/radeon/radeon_test.c b/drivers/gpu/drm/radeon/radeon_test.c
index dee4a0c1b4b2..602fa3541c45 100644
--- a/drivers/gpu/drm/radeon/radeon_test.c
+++ b/drivers/gpu/drm/radeon/radeon_test.c
@@ -40,10 +40,14 @@ void radeon_test_moves(struct radeon_device *rdev)
         size = 1024 * 1024;
 
         /* Number of tests =
-         * (Total GTT - IB pool - writeback page - ring buffer) / test size
+         * (Total GTT - IB pool - writeback page - ring buffers) / test size
          */
-        n = ((u32)(rdev->mc.gtt_size - RADEON_IB_POOL_SIZE*64*1024 - RADEON_GPU_PAGE_SIZE -
-             rdev->cp.ring_size)) / size;
+        n = rdev->mc.gtt_size - RADEON_IB_POOL_SIZE*64*1024 - rdev->cp.ring_size;
+        if (rdev->wb.wb_obj)
+                n -= RADEON_GPU_PAGE_SIZE;
+        if (rdev->ih.ring_obj)
+                n -= rdev->ih.ring_size;
+        n /= size;
 
         gtt_obj = kzalloc(n * sizeof(*gtt_obj), GFP_KERNEL);
         if (!gtt_obj) {
@@ -132,9 +136,15 @@ void radeon_test_moves(struct radeon_device *rdev)
                      gtt_start++, vram_start++) {
                         if (*vram_start != gtt_start) {
                                 DRM_ERROR("Incorrect GTT->VRAM copy %d: Got 0x%p, "
-                                          "expected 0x%p (GTT map 0x%p-0x%p)\n",
-                                          i, *vram_start, gtt_start, gtt_map,
-                                          gtt_end);
+                                          "expected 0x%p (GTT/VRAM offset "
+                                          "0x%16llx/0x%16llx)\n",
+                                          i, *vram_start, gtt_start,
+                                          (unsigned long long)
+                                          (gtt_addr - rdev->mc.gtt_start +
+                                           (void*)gtt_start - gtt_map),
+                                          (unsigned long long)
+                                          (vram_addr - rdev->mc.vram_start +
+                                           (void*)gtt_start - gtt_map));
                                 radeon_bo_kunmap(vram_obj);
                                 goto out_cleanup;
                         }
@@ -175,9 +185,15 @@ void radeon_test_moves(struct radeon_device *rdev)
                      gtt_start++, vram_start++) {
                         if (*gtt_start != vram_start) {
                                 DRM_ERROR("Incorrect VRAM->GTT copy %d: Got 0x%p, "
-                                          "expected 0x%p (VRAM map 0x%p-0x%p)\n",
-                                          i, *gtt_start, vram_start, vram_map,
-                                          vram_end);
+                                          "expected 0x%p (VRAM/GTT offset "
+                                          "0x%16llx/0x%16llx)\n",
+                                          i, *gtt_start, vram_start,
+                                          (unsigned long long)
+                                          (vram_addr - rdev->mc.vram_start +
+                                           (void*)vram_start - vram_map),
+                                          (unsigned long long)
+                                          (gtt_addr - rdev->mc.gtt_start +
+                                           (void*)vram_start - vram_map));
                                 radeon_bo_kunmap(gtt_obj[i]);
                                 goto out_cleanup;
                         }
diff --git a/drivers/gpu/drm/radeon/radeon_ttm.c b/drivers/gpu/drm/radeon/radeon_ttm.c
index 60125ddba1e9..0b5468bfaf54 100644
--- a/drivers/gpu/drm/radeon/radeon_ttm.c
+++ b/drivers/gpu/drm/radeon/radeon_ttm.c
@@ -277,7 +277,12 @@ static int radeon_move_blit(struct ttm_buffer_object *bo,
                 DRM_ERROR("Trying to move memory with CP turned off.\n");
                 return -EINVAL;
         }
-        r = radeon_copy(rdev, old_start, new_start, new_mem->num_pages, fence);
+
+        BUILD_BUG_ON((PAGE_SIZE % RADEON_GPU_PAGE_SIZE) != 0);
+
+        r = radeon_copy(rdev, old_start, new_start,
+                        new_mem->num_pages * (PAGE_SIZE / RADEON_GPU_PAGE_SIZE), /* GPU pages */
+                        fence);
         /* FIXME: handle copy error */
         r = ttm_bo_move_accel_cleanup(bo, (void *)fence, NULL,
                                       evict, no_wait_reserve, no_wait_gpu, new_mem);
@@ -450,6 +455,29 @@ static int radeon_ttm_io_mem_reserve(struct ttm_bo_device *bdev, struct ttm_mem_
                         return -EINVAL;
                 mem->bus.base = rdev->mc.aper_base;
                 mem->bus.is_iomem = true;
+#ifdef __alpha__
+                /*
+                 * Alpha: use bus.addr to hold the ioremap() return,
+                 * so we can modify bus.base below.
+                 */
+                if (mem->placement & TTM_PL_FLAG_WC)
+                        mem->bus.addr =
+                                ioremap_wc(mem->bus.base + mem->bus.offset,
+                                           mem->bus.size);
+                else
+                        mem->bus.addr =
+                                ioremap_nocache(mem->bus.base + mem->bus.offset,
+                                                mem->bus.size);
+
+                /*
+                 * Alpha: Use just the bus offset plus
+                 * the hose/domain memory base for bus.base.
+                 * It then can be used to build PTEs for VRAM
+                 * access, as done in ttm_bo_vm_fault().
+                 */
+                mem->bus.base = (mem->bus.base & 0x0ffffffffUL) +
+                        rdev->ddev->hose->dense_mem_base;
+#endif
                 break;
         default:
                 return -EINVAL;
diff --git a/drivers/gpu/drm/radeon/rv770.c b/drivers/gpu/drm/radeon/rv770.c
index 4720d000d440..b13c2eedc321 100644
--- a/drivers/gpu/drm/radeon/rv770.c
+++ b/drivers/gpu/drm/radeon/rv770.c
@@ -536,55 +536,6 @@ static u32 r700_get_tile_pipe_to_backend_map(struct radeon_device *rdev,
         return backend_map;
 }
 
-static void rv770_program_channel_remap(struct radeon_device *rdev)
-{
-        u32 tcp_chan_steer, mc_shared_chremap, tmp;
-        bool force_no_swizzle;
-
-        switch (rdev->family) {
-        case CHIP_RV770:
-        case CHIP_RV730:
-                force_no_swizzle = false;
-                break;
-        case CHIP_RV710:
-        case CHIP_RV740:
-        default:
-                force_no_swizzle = true;
-                break;
-        }
-
-        tmp = RREG32(MC_SHARED_CHMAP);
-        switch ((tmp & NOOFCHAN_MASK) >> NOOFCHAN_SHIFT) {
-        case 0:
-        case 1:
-        default:
-                /* default mapping */
-                mc_shared_chremap = 0x00fac688;
-                break;
-        case 2:
-        case 3:
-                if (force_no_swizzle)
-                        mc_shared_chremap = 0x00fac688;
-                else
-                        mc_shared_chremap = 0x00bbc298;
-                break;
-        }
-
-        if (rdev->family == CHIP_RV740)
-                tcp_chan_steer = 0x00ef2a60;
-        else
-                tcp_chan_steer = 0x00fac688;
-
-        /* RV770 CE has special chremap setup */
-        if (rdev->pdev->device == 0x944e) {
-                tcp_chan_steer = 0x00b08b08;
-                mc_shared_chremap = 0x00b08b08;
-        }
-
-        WREG32(TCP_CHAN_STEER, tcp_chan_steer);
-        WREG32(MC_SHARED_CHREMAP, mc_shared_chremap);
-}
-
 static void rv770_gpu_init(struct radeon_device *rdev)
 {
         int i, j, num_qd_pipes;
@@ -785,8 +736,6 @@ static void rv770_gpu_init(struct radeon_device *rdev)
         WREG32(DCP_TILING_CONFIG, (gb_tiling_config & 0xffff));
         WREG32(HDP_TILING_CONFIG, (gb_tiling_config & 0xffff));
 
-        rv770_program_channel_remap(rdev);
-
         WREG32(CC_RB_BACKEND_DISABLE,      cc_rb_backend_disable);
         WREG32(CC_GC_SHADER_PIPE_CONFIG,   cc_gc_shader_pipe_config);
         WREG32(GC_USER_SHADER_PIPE_CONFIG, cc_gc_shader_pipe_config);
diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c
index 56619f64b6bf..ef06194c5aa6 100644
--- a/drivers/gpu/drm/ttm/ttm_bo.c
+++ b/drivers/gpu/drm/ttm/ttm_bo.c
@@ -353,8 +353,10 @@ static int ttm_bo_add_ttm(struct ttm_buffer_object *bo, bool zero_alloc)
 
                 ret = ttm_tt_set_user(bo->ttm, current,
                                       bo->buffer_start, bo->num_pages);
-                if (unlikely(ret != 0))
+                if (unlikely(ret != 0)) {
                         ttm_tt_destroy(bo->ttm);
+                        bo->ttm = NULL;
+                }
                 break;
         default:
                 printk(KERN_ERR TTM_PFX "Illegal buffer object type\n");
@@ -390,10 +392,13 @@ static int ttm_bo_handle_move_mem(struct ttm_buffer_object *bo,
          * Create and bind a ttm if required.
          */
 
-        if (!(new_man->flags & TTM_MEMTYPE_FLAG_FIXED) && (bo->ttm == NULL)) {
-                ret = ttm_bo_add_ttm(bo, false);
-                if (ret)
-                        goto out_err;
+        if (!(new_man->flags & TTM_MEMTYPE_FLAG_FIXED)) {
+                if (bo->ttm == NULL) {
+                        bool zero = !(old_man->flags & TTM_MEMTYPE_FLAG_FIXED);
+                        ret = ttm_bo_add_ttm(bo, zero);
+                        if (ret)
+                                goto out_err;
+                }
 
                 ret = ttm_tt_set_placement_caching(bo->ttm, mem->placement);
                 if (ret)
diff --git a/drivers/gpu/drm/ttm/ttm_bo_util.c b/drivers/gpu/drm/ttm/ttm_bo_util.c
index 77dbf408c0d0..ae3c6f5dd2b7 100644
--- a/drivers/gpu/drm/ttm/ttm_bo_util.c
+++ b/drivers/gpu/drm/ttm/ttm_bo_util.c
@@ -635,13 +635,13 @@ int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
                 if (ret)
                         return ret;
 
-                ttm_bo_free_old_node(bo);
                 if ((man->flags & TTM_MEMTYPE_FLAG_FIXED) &&
                     (bo->ttm != NULL)) {
                         ttm_tt_unbind(bo->ttm);
                         ttm_tt_destroy(bo->ttm);
                         bo->ttm = NULL;
                 }
+                ttm_bo_free_old_node(bo);
         } else {
                 /**
                  * This should help pipeline ordinary buffer moves.
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 306b15f39c9c..1130a8987125 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -589,6 +589,7 @@ config HID_WACOM_POWER_SUPPLY
 config HID_WIIMOTE
         tristate "Nintendo Wii Remote support"
         depends on BT_HIDP
+        depends on LEDS_CLASS
         ---help---
         Support for the Nintendo Wii Remote bluetooth device.
 
diff --git a/drivers/hid/hid-apple.c b/drivers/hid/hid-apple.c
index b85744fe8464..18b3bc646bf3 100644
--- a/drivers/hid/hid-apple.c
+++ b/drivers/hid/hid-apple.c
@@ -444,6 +444,12 @@ static const struct hid_device_id apple_devices[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS),
                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
                         APPLE_RDESC_JIS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI),
+                .driver_data = APPLE_HAS_FN },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO),
+                .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS),
+                .driver_data = APPLE_HAS_FN },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO),
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 1a5cf0c9cfca..242353df3dc4 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1340,6 +1340,9 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) },
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index db63ccf21cc8..7484e1b67249 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -109,6 +109,9 @@
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI    0x0245
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_ISO     0x0246
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_JIS     0x0247
+#define USB_DEVICE_ID_APPLE_ALU_REVB_ANSI       0x024f
+#define USB_DEVICE_ID_APPLE_ALU_REVB_ISO        0x0250
+#define USB_DEVICE_ID_APPLE_ALU_REVB_JIS        0x0251
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI  0x0239
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO   0x023a
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS   0x023b
@@ -274,6 +277,7 @@
 #define USB_DEVICE_ID_PENPOWER          0x00f4
 
 #define USB_VENDOR_ID_GREENASIA         0x0e8f
+#define USB_DEVICE_ID_GREENASIA_DUAL_USB_JOYPAD 0x3013
 
 #define USB_VENDOR_ID_GRETAGMACBETH     0x0971
 #define USB_DEVICE_ID_GRETAGMACBETH_HUEY        0x2005
@@ -576,6 +580,9 @@
 #define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001
 #define USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE        0x0600
 
+#define USB_VENDOR_ID_SIGMA_MICRO       0x1c4f
+#define USB_DEVICE_ID_SIGMA_MICRO_KEYBOARD      0x0002
+
 #define USB_VENDOR_ID_SKYCABLE                  0x1223
 #define USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER       0x3F07
 
diff --git a/drivers/hid/hid-magicmouse.c b/drivers/hid/hid-magicmouse.c
index 0ec91c18a421..f0fbd7bd239e 100644
--- a/drivers/hid/hid-magicmouse.c
+++ b/drivers/hid/hid-magicmouse.c
@@ -81,6 +81,28 @@ MODULE_PARM_DESC(report_undeciphered, "Report undeciphered multi-touch state fie
 #define NO_TOUCHES -1
 #define SINGLE_TOUCH_UP -2
 
+/* Touch surface information. Dimension is in hundredths of a mm, min and max
+ * are in units. */
+#define MOUSE_DIMENSION_X (float)9056
+#define MOUSE_MIN_X -1100
+#define MOUSE_MAX_X 1258
+#define MOUSE_RES_X ((MOUSE_MAX_X - MOUSE_MIN_X) / (MOUSE_DIMENSION_X / 100))
+#define MOUSE_DIMENSION_Y (float)5152
+#define MOUSE_MIN_Y -1589
+#define MOUSE_MAX_Y 2047
+#define MOUSE_RES_Y ((MOUSE_MAX_Y - MOUSE_MIN_Y) / (MOUSE_DIMENSION_Y / 100))
+
+#define TRACKPAD_DIMENSION_X (float)13000
+#define TRACKPAD_MIN_X -2909
+#define TRACKPAD_MAX_X 3167
+#define TRACKPAD_RES_X \
+        ((TRACKPAD_MAX_X - TRACKPAD_MIN_X) / (TRACKPAD_DIMENSION_X / 100))
+#define TRACKPAD_DIMENSION_Y (float)11000
+#define TRACKPAD_MIN_Y -2456
+#define TRACKPAD_MAX_Y 2565
+#define TRACKPAD_RES_Y \
+        ((TRACKPAD_MAX_Y - TRACKPAD_MIN_Y) / (TRACKPAD_DIMENSION_Y / 100))
+
 /**
  * struct magicmouse_sc - Tracks Magic Mouse-specific data.
  * @input: Input device through which we report events.
@@ -406,17 +428,31 @@ static void magicmouse_setup_input(struct input_dev *input, struct hid_device *h
                  * inverse of the reported Y.
                  */
                 if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE) {
-                        input_set_abs_params(input, ABS_MT_POSITION_X, -1100,
-                                1358, 4, 0);
-                        input_set_abs_params(input, ABS_MT_POSITION_Y, -1589,
-                                2047, 4, 0);
+                        input_set_abs_params(input, ABS_MT_POSITION_X,
+                                MOUSE_MIN_X, MOUSE_MAX_X, 4, 0);
+                        input_set_abs_params(input, ABS_MT_POSITION_Y,
+                                MOUSE_MIN_Y, MOUSE_MAX_Y, 4, 0);
+
+                        input_abs_set_res(input, ABS_MT_POSITION_X,
+                                MOUSE_RES_X);
+                        input_abs_set_res(input, ABS_MT_POSITION_Y,
+                                MOUSE_RES_Y);
                 } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
-                        input_set_abs_params(input, ABS_X, -2909, 3167, 4, 0);
-                        input_set_abs_params(input, ABS_Y, -2456, 2565, 4, 0);
-                        input_set_abs_params(input, ABS_MT_POSITION_X, -2909,
-                                3167, 4, 0);
-                        input_set_abs_params(input, ABS_MT_POSITION_Y, -2456,
-                                2565, 4, 0);
+                        input_set_abs_params(input, ABS_X, TRACKPAD_MIN_X,
+                                TRACKPAD_MAX_X, 4, 0);
+                        input_set_abs_params(input, ABS_Y, TRACKPAD_MIN_Y,
+                                TRACKPAD_MAX_Y, 4, 0);
+                        input_set_abs_params(input, ABS_MT_POSITION_X,
+                                TRACKPAD_MIN_X, TRACKPAD_MAX_X, 4, 0);
+                        input_set_abs_params(input, ABS_MT_POSITION_Y,
+                                TRACKPAD_MIN_Y, TRACKPAD_MAX_Y, 4, 0);
+
+                        input_abs_set_res(input, ABS_X, TRACKPAD_RES_X);
+                        input_abs_set_res(input, ABS_Y, TRACKPAD_RES_Y);
+                        input_abs_set_res(input, ABS_MT_POSITION_X,
+                                TRACKPAD_RES_X);
+                        input_abs_set_res(input, ABS_MT_POSITION_Y,
+                                TRACKPAD_RES_Y);
                 }
 
                 input_set_events_per_packet(input, 60);
@@ -501,9 +537,17 @@ static int magicmouse_probe(struct hid_device *hdev,
         }
         report->size = 6;
 
+        /*
+         * Some devices repond with 'invalid report id' when feature
+         * report switching it into multitouch mode is sent to it.
+         *
+         * This results in -EIO from the _raw low-level transport callback,
+         * but there seems to be no other way of switching the mode.
+         * Thus the super-ugly hacky success check below.
+         */
         ret = hdev->hid_output_raw_report(hdev, feature, sizeof(feature),
                         HID_FEATURE_REPORT);
-        if (ret != sizeof(feature)) {
+        if (ret != -EIO && ret != sizeof(feature)) {
                 hid_err(hdev, "unable to request touch data (%d)\n", ret);
                 goto err_stop_hw;
         }
diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c
index 06888323828c..72ca689b6474 100644
--- a/drivers/hid/hid-wacom.c
+++ b/drivers/hid/hid-wacom.c
@@ -353,11 +353,7 @@ static int wacom_probe(struct hid_device *hdev,
         if (ret) {
                 hid_warn(hdev, "can't create sysfs battery attribute, err: %d\n",
                          ret);
-                /*
-                 * battery attribute is not critical for the tablet, but if it
-                 * failed then there is no need to create ac attribute
-                 */
-                goto move_on;
+                goto err_battery;
         }
 
         wdata->ac.properties = wacom_ac_props;
@@ -371,18 +367,14 @@ static int wacom_probe(struct hid_device *hdev,
         if (ret) {
                 hid_warn(hdev,
                          "can't create ac battery attribute, err: %d\n", ret);
-                /*
-                 * ac attribute is not critical for the tablet, but if it
-                 * failed then we don't want to battery attribute to exist
-                 */
-                power_supply_unregister(&wdata->battery);
+                goto err_ac;
         }
-
-move_on:
 #endif
         hidinput = list_entry(hdev->inputs.next, struct hid_input, list);
         input = hidinput->input;
 
+        __set_bit(INPUT_PROP_POINTER, input->propbit);
+
         /* Basics */
         input->evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_REL);
 
@@ -416,6 +408,13 @@ move_on:
 
         return 0;
 
+#ifdef CONFIG_HID_WACOM_POWER_SUPPLY
+err_ac:
+        power_supply_unregister(&wdata->battery);
+err_battery:
+        device_remove_file(&hdev->dev, &dev_attr_speed);
+        hid_hw_stop(hdev);
+#endif
 err_free:
         kfree(wdata);
         return ret;
@@ -426,6 +425,7 @@ static void wacom_remove(struct hid_device *hdev)
 #ifdef CONFIG_HID_WACOM_POWER_SUPPLY
         struct wacom_data *wdata = hid_get_drvdata(hdev);
 #endif
+        device_remove_file(&hdev->dev, &dev_attr_speed);
         hid_hw_stop(hdev);
 
 #ifdef CONFIG_HID_WACOM_POWER_SUPPLY
diff --git a/drivers/hid/hid-wiimote.c b/drivers/hid/hid-wiimote.c
index a594383ce03d..85a02e5f9fe8 100644
--- a/drivers/hid/hid-wiimote.c
+++ b/drivers/hid/hid-wiimote.c
@@ -10,10 +10,10 @@
  * any later version.
  */
 
-#include <linux/atomic.h>
 #include <linux/device.h>
 #include <linux/hid.h>
 #include <linux/input.h>
+#include <linux/leds.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
 #include "hid-ids.h"
@@ -33,9 +33,9 @@ struct wiimote_state {
 };
 
 struct wiimote_data {
-        atomic_t ready;
         struct hid_device *hdev;
         struct input_dev *input;
+        struct led_classdev *leds[4];
 
         spinlock_t qlock;
         __u8 head;
@@ -53,8 +53,15 @@ struct wiimote_data {
 #define WIIPROTO_FLAGS_LEDS (WIIPROTO_FLAG_LED1 | WIIPROTO_FLAG_LED2 | \
                                         WIIPROTO_FLAG_LED3 | WIIPROTO_FLAG_LED4)
 
+/* return flag for led \num */
+#define WIIPROTO_FLAG_LED(num) (WIIPROTO_FLAG_LED1 << (num - 1))
+
 enum wiiproto_reqs {
+        WIIPROTO_REQ_NULL = 0x0,
         WIIPROTO_REQ_LED = 0x11,
+        WIIPROTO_REQ_DRM = 0x12,
+        WIIPROTO_REQ_STATUS = 0x20,
+        WIIPROTO_REQ_RETURN = 0x22,
         WIIPROTO_REQ_DRM_K = 0x30,
 };
 
@@ -87,9 +94,6 @@ static __u16 wiiproto_keymap[] = {
         BTN_MODE,       /* WIIPROTO_KEY_HOME */
 };
 
-#define dev_to_wii(pdev) hid_get_drvdata(container_of(pdev, struct hid_device, \
-                                                                        dev))
-
 static ssize_t wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
                                                                 size_t count)
 {
@@ -192,66 +196,96 @@ static void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
         wiimote_queue(wdata, cmd, sizeof(cmd));
 }
 
-#define wiifs_led_show_set(num)                                         \
-static ssize_t wiifs_led_show_##num(struct device *dev,                 \
-                        struct device_attribute *attr, char *buf)       \
-{                                                                       \
-        struct wiimote_data *wdata = dev_to_wii(dev);                   \
-        unsigned long flags;                                            \
-        int state;                                                      \
-                                                                        \
-        if (!atomic_read(&wdata->ready))                                \
-                return -EBUSY;                                          \
-                                                                        \
-        spin_lock_irqsave(&wdata->state.lock, flags);                   \
-        state = !!(wdata->state.flags & WIIPROTO_FLAG_LED##num);        \
-        spin_unlock_irqrestore(&wdata->state.lock, flags);              \
-                                                                        \
-        return sprintf(buf, "%d\n", state);                             \
-}                                                                       \
-static ssize_t wiifs_led_set_##num(struct device *dev,                  \
-        struct device_attribute *attr, const char *buf, size_t count)   \
-{                                                                       \
-        struct wiimote_data *wdata = dev_to_wii(dev);                   \
-        int tmp = simple_strtoul(buf, NULL, 10);                        \
-        unsigned long flags;                                            \
-        __u8 state;                                                     \
-                                                                        \
-        if (!atomic_read(&wdata->ready))                                \
-                return -EBUSY;                                          \
-                                                                        \
-        spin_lock_irqsave(&wdata->state.lock, flags);                   \
-                                                                        \
-        state = wdata->state.flags;                                     \
-                                                                        \
-        if (tmp)                                                        \
-                wiiproto_req_leds(wdata, state | WIIPROTO_FLAG_LED##num);\
-        else                                                            \
-                wiiproto_req_leds(wdata, state & ~WIIPROTO_FLAG_LED##num);\
-                                                                        \
-        spin_unlock_irqrestore(&wdata->state.lock, flags);              \
-                                                                        \
-        return count;                                                   \
-}                                                                       \
-static DEVICE_ATTR(led##num, S_IRUGO | S_IWUSR, wiifs_led_show_##num,   \
-                                                wiifs_led_set_##num)
-
-wiifs_led_show_set(1);
-wiifs_led_show_set(2);
-wiifs_led_show_set(3);
-wiifs_led_show_set(4);
+/*
+ * Check what peripherals of the wiimote are currently
+ * active and select a proper DRM that supports all of
+ * the requested data inputs.
+ */
+static __u8 select_drm(struct wiimote_data *wdata)
+{
+        return WIIPROTO_REQ_DRM_K;
+}
+
+static void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
+{
+        __u8 cmd[3];
+
+        if (drm == WIIPROTO_REQ_NULL)
+                drm = select_drm(wdata);
+
+        cmd[0] = WIIPROTO_REQ_DRM;
+        cmd[1] = 0;
+        cmd[2] = drm;
+
+        wiimote_queue(wdata, cmd, sizeof(cmd));
+}
+
+static enum led_brightness wiimote_leds_get(struct led_classdev *led_dev)
+{
+        struct wiimote_data *wdata;
+        struct device *dev = led_dev->dev->parent;
+        int i;
+        unsigned long flags;
+        bool value = false;
+
+        wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
+
+        for (i = 0; i < 4; ++i) {
+                if (wdata->leds[i] == led_dev) {
+                        spin_lock_irqsave(&wdata->state.lock, flags);
+                        value = wdata->state.flags & WIIPROTO_FLAG_LED(i + 1);
+                        spin_unlock_irqrestore(&wdata->state.lock, flags);
+                        break;
+                }
+        }
+
+        return value ? LED_FULL : LED_OFF;
+}
+
+static void wiimote_leds_set(struct led_classdev *led_dev,
+                                                enum led_brightness value)
+{
+        struct wiimote_data *wdata;
+        struct device *dev = led_dev->dev->parent;
+        int i;
+        unsigned long flags;
+        __u8 state, flag;
+
+        wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
+
+        for (i = 0; i < 4; ++i) {
+                if (wdata->leds[i] == led_dev) {
+                        flag = WIIPROTO_FLAG_LED(i + 1);
+                        spin_lock_irqsave(&wdata->state.lock, flags);
+                        state = wdata->state.flags;
+                        if (value == LED_OFF)
+                                wiiproto_req_leds(wdata, state & ~flag);
+                        else
+                                wiiproto_req_leds(wdata, state | flag);
+                        spin_unlock_irqrestore(&wdata->state.lock, flags);
+                        break;
+                }
+        }
+}
 
 static int wiimote_input_event(struct input_dev *dev, unsigned int type,
                                                 unsigned int code, int value)
 {
+        return 0;
+}
+
+static int wiimote_input_open(struct input_dev *dev)
+{
         struct wiimote_data *wdata = input_get_drvdata(dev);
 
-        if (!atomic_read(&wdata->ready))
-                return -EBUSY;
-        /* smp_rmb: Make sure wdata->xy is available when wdata->ready is 1 */
-        smp_rmb();
+        return hid_hw_open(wdata->hdev);
+}
 
-        return 0;
+static void wiimote_input_close(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+
+        hid_hw_close(wdata->hdev);
 }
 
 static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
@@ -281,6 +315,26 @@ static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
         input_sync(wdata->input);
 }
 
+static void handler_status(struct wiimote_data *wdata, const __u8 *payload)
+{
+        handler_keys(wdata, payload);
+
+        /* on status reports the drm is reset so we need to resend the drm */
+        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+}
+
+static void handler_return(struct wiimote_data *wdata, const __u8 *payload)
+{
+        __u8 err = payload[3];
+        __u8 cmd = payload[2];
+
+        handler_keys(wdata, payload);
+
+        if (err)
+                hid_warn(wdata->hdev, "Remote error %hhu on req %hhu\n", err,
+                                                                        cmd);
+}
+
 struct wiiproto_handler {
         __u8 id;
         size_t size;
@@ -288,6 +342,8 @@ struct wiiproto_handler {
 };
 
 static struct wiiproto_handler handlers[] = {
+        { .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status },
+        { .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return },
         { .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
         { .id = 0 }
 };
@@ -300,11 +356,6 @@ static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
         int i;
         unsigned long flags;
 
-        if (!atomic_read(&wdata->ready))
-                return -EBUSY;
-        /* smp_rmb: Make sure wdata->xy is available when wdata->ready is 1 */
-        smp_rmb();
-
         if (size < 1)
                 return -EINVAL;
 
@@ -321,6 +372,58 @@ static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
         return 0;
 }
 
+static void wiimote_leds_destroy(struct wiimote_data *wdata)
+{
+        int i;
+        struct led_classdev *led;
+
+        for (i = 0; i < 4; ++i) {
+                if (wdata->leds[i]) {
+                        led = wdata->leds[i];
+                        wdata->leds[i] = NULL;
+                        led_classdev_unregister(led);
+                        kfree(led);
+                }
+        }
+}
+
+static int wiimote_leds_create(struct wiimote_data *wdata)
+{
+        int i, ret;
+        struct device *dev = &wdata->hdev->dev;
+        size_t namesz = strlen(dev_name(dev)) + 9;
+        struct led_classdev *led;
+        char *name;
+
+        for (i = 0; i < 4; ++i) {
+                led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL);
+                if (!led) {
+                        ret = -ENOMEM;
+                        goto err;
+                }
+                name = (void*)&led[1];
+                snprintf(name, namesz, "%s:blue:p%d", dev_name(dev), i);
+                led->name = name;
+                led->brightness = 0;
+                led->max_brightness = 1;
+                led->brightness_get = wiimote_leds_get;
+                led->brightness_set = wiimote_leds_set;
+
+                ret = led_classdev_register(dev, led);
+                if (ret) {
+                        kfree(led);
+                        goto err;
+                }
+                wdata->leds[i] = led;
+        }
+
+        return 0;
+
+err:
+        wiimote_leds_destroy(wdata);
+        return ret;
+}
+
 static struct wiimote_data *wiimote_create(struct hid_device *hdev)
 {
         struct wiimote_data *wdata;
@@ -341,6 +444,8 @@ static struct wiimote_data *wiimote_create(struct hid_device *hdev)
 
         input_set_drvdata(wdata->input, wdata);
         wdata->input->event = wiimote_input_event;
+        wdata->input->open = wiimote_input_open;
+        wdata->input->close = wiimote_input_close;
         wdata->input->dev.parent = &wdata->hdev->dev;
         wdata->input->id.bustype = wdata->hdev->bus;
         wdata->input->id.vendor = wdata->hdev->vendor;
@@ -362,6 +467,12 @@ static struct wiimote_data *wiimote_create(struct hid_device *hdev)
 
 static void wiimote_destroy(struct wiimote_data *wdata)
 {
+        wiimote_leds_destroy(wdata);
+
+        input_unregister_device(wdata->input);
+        cancel_work_sync(&wdata->worker);
+        hid_hw_stop(wdata->hdev);
+
         kfree(wdata);
 }
 
@@ -377,19 +488,6 @@ static int wiimote_hid_probe(struct hid_device *hdev,
                 return -ENOMEM;
         }
 
-        ret = device_create_file(&hdev->dev, &dev_attr_led1);
-        if (ret)
-                goto err;
-        ret = device_create_file(&hdev->dev, &dev_attr_led2);
-        if (ret)
-                goto err;
-        ret = device_create_file(&hdev->dev, &dev_attr_led3);
-        if (ret)
-                goto err;
-        ret = device_create_file(&hdev->dev, &dev_attr_led4);
-        if (ret)
-                goto err;
-
         ret = hid_parse(hdev);
         if (ret) {
                 hid_err(hdev, "HID parse failed\n");
@@ -408,9 +506,10 @@ static int wiimote_hid_probe(struct hid_device *hdev,
                 goto err_stop;
         }
 
-        /* smp_wmb: Write wdata->xy first before wdata->ready is set to 1 */
-        smp_wmb();
-        atomic_set(&wdata->ready, 1);
+        ret = wiimote_leds_create(wdata);
+        if (ret)
+                goto err_free;
+
         hid_info(hdev, "New device registered\n");
 
         /* by default set led1 after device initialization */
@@ -420,15 +519,15 @@ static int wiimote_hid_probe(struct hid_device *hdev,
 
         return 0;
 
+err_free:
+        wiimote_destroy(wdata);
+        return ret;
+
 err_stop:
         hid_hw_stop(hdev);
 err:
         input_free_device(wdata->input);
-        device_remove_file(&hdev->dev, &dev_attr_led1);
-        device_remove_file(&hdev->dev, &dev_attr_led2);
-        device_remove_file(&hdev->dev, &dev_attr_led3);
-        device_remove_file(&hdev->dev, &dev_attr_led4);
-        wiimote_destroy(wdata);
+        kfree(wdata);
         return ret;
 }
 
@@ -437,16 +536,6 @@ static void wiimote_hid_remove(struct hid_device *hdev)
         struct wiimote_data *wdata = hid_get_drvdata(hdev);
 
         hid_info(hdev, "Device removed\n");
-
-        device_remove_file(&hdev->dev, &dev_attr_led1);
-        device_remove_file(&hdev->dev, &dev_attr_led2);
-        device_remove_file(&hdev->dev, &dev_attr_led3);
-        device_remove_file(&hdev->dev, &dev_attr_led4);
-
-        hid_hw_stop(hdev);
-        input_unregister_device(wdata->input);
-
-        cancel_work_sync(&wdata->worker);
         wiimote_destroy(wdata);
 }
 
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index 621959d5cc42..3146fdcda272 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -47,6 +47,7 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_AFATECH, USB_DEVICE_ID_AFATECH_AF9016, HID_QUIRK_FULLSPEED_INTERVAL },
 
         { USB_VENDOR_ID_ETURBOTOUCH, USB_DEVICE_ID_ETURBOTOUCH, HID_QUIRK_MULTI_INPUT },
+        { USB_VENDOR_ID_GREENASIA, USB_DEVICE_ID_GREENASIA_DUAL_USB_JOYPAD, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_PANTHERLORD, USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK, HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
         { USB_VENDOR_ID_PLAYDOTCOM, USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_TOUCHPACK, USB_DEVICE_ID_TOUCHPACK_RTS, HID_QUIRK_MULTI_INPUT },
@@ -89,6 +90,7 @@ static const struct hid_blacklist {
 
         { USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_MULTI_TOUCH, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS, HID_QUIRK_MULTI_INPUT },
+        { USB_VENDOR_ID_SIGMA_MICRO, USB_DEVICE_ID_SIGMA_MICRO_KEYBOARD, HID_QUIRK_NO_INIT_REPORTS },
         { 0, 0 }
 };
 
diff --git a/drivers/hwmon/coretemp.c b/drivers/hwmon/coretemp.c
index 59d83e83da7f..932383786642 100644
--- a/drivers/hwmon/coretemp.c
+++ b/drivers/hwmon/coretemp.c
@@ -36,17 +36,25 @@
 #include <linux/cpu.h>
 #include <linux/pci.h>
 #include <linux/smp.h>
+#include <linux/moduleparam.h>
 #include <asm/msr.h>
 #include <asm/processor.h>
 
 #define DRVNAME "coretemp"
 
+/*
+ * force_tjmax only matters when TjMax can't be read from the CPU itself.
+ * When set, it replaces the driver's suboptimal heuristic.
+ */
+static int force_tjmax;
+module_param_named(tjmax, force_tjmax, int, 0444);
+MODULE_PARM_DESC(tjmax, "TjMax value in degrees Celsius");
+
 #define BASE_SYSFS_ATTR_NO      2       /* Sysfs Base attr no for coretemp */
 #define NUM_REAL_CORES          16      /* Number of Real cores per cpu */
 #define CORETEMP_NAME_LENGTH    17      /* String Length of attrs */
 #define MAX_CORE_ATTRS          4       /* Maximum no of basic attrs */
-#define MAX_THRESH_ATTRS        3       /* Maximum no of Threshold attrs */
-#define TOTAL_ATTRS             (MAX_CORE_ATTRS + MAX_THRESH_ATTRS)
+#define TOTAL_ATTRS             (MAX_CORE_ATTRS + 1)
 #define MAX_CORE_DATA           (NUM_REAL_CORES + BASE_SYSFS_ATTR_NO)
 
 #ifdef CONFIG_SMP
@@ -69,8 +77,6 @@
  *              This value is passed as "id" field to rdmsr/wrmsr functions.
  * @status_reg: One of IA32_THERM_STATUS or IA32_PACKAGE_THERM_STATUS,
  *              from where the temperature values should be read.
- * @intrpt_reg: One of IA32_THERM_INTERRUPT or IA32_PACKAGE_THERM_INTERRUPT,
- *              from where the thresholds are read.
  * @attr_size:  Total number of pre-core attrs displayed in the sysfs.
  * @is_pkg_data: If this is 1, the temp_data holds pkgtemp data.
  *              Otherwise, temp_data holds coretemp data.
@@ -79,13 +85,11 @@
 struct temp_data {
         int temp;
         int ttarget;
-        int tmin;
         int tjmax;
         unsigned long last_updated;
         unsigned int cpu;
         u32 cpu_core_id;
         u32 status_reg;
-        u32 intrpt_reg;
         int attr_size;
         bool is_pkg_data;
         bool valid;
@@ -143,19 +147,6 @@ static ssize_t show_crit_alarm(struct device *dev,
         return sprintf(buf, "%d\n", (eax >> 5) & 1);
 }
 
-static ssize_t show_max_alarm(struct device *dev,
-                                struct device_attribute *devattr, char *buf)
-{
-        u32 eax, edx;
-        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct platform_data *pdata = dev_get_drvdata(dev);
-        struct temp_data *tdata = pdata->core_data[attr->index];
-
-        rdmsr_on_cpu(tdata->cpu, tdata->status_reg, &eax, &edx);
-
-        return sprintf(buf, "%d\n", !!(eax & THERM_STATUS_THRESHOLD1));
-}
-
 static ssize_t show_tjmax(struct device *dev,
                         struct device_attribute *devattr, char *buf)
 {
@@ -174,83 +165,6 @@ static ssize_t show_ttarget(struct device *dev,
         return sprintf(buf, "%d\n", pdata->core_data[attr->index]->ttarget);
 }
 
-static ssize_t store_ttarget(struct device *dev,
-                                struct device_attribute *devattr,
-                                const char *buf, size_t count)
-{
-        struct platform_data *pdata = dev_get_drvdata(dev);
-        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct temp_data *tdata = pdata->core_data[attr->index];
-        u32 eax, edx;
-        unsigned long val;
-        int diff;
-
-        if (strict_strtoul(buf, 10, &val))
-                return -EINVAL;
-
-        /*
-         * THERM_MASK_THRESHOLD1 is 7 bits wide. Values are entered in terms
-         * of milli degree celsius. Hence don't accept val > (127 * 1000)
-         */
-        if (val > tdata->tjmax || val > 127000)
-                return -EINVAL;
-
-        diff = (tdata->tjmax - val) / 1000;
-
-        mutex_lock(&tdata->update_lock);
-        rdmsr_on_cpu(tdata->cpu, tdata->intrpt_reg, &eax, &edx);
-        eax = (eax & ~THERM_MASK_THRESHOLD1) |
-                                (diff << THERM_SHIFT_THRESHOLD1);
-        wrmsr_on_cpu(tdata->cpu, tdata->intrpt_reg, eax, edx);
-        tdata->ttarget = val;
-        mutex_unlock(&tdata->update_lock);
-
-        return count;
-}
-
-static ssize_t show_tmin(struct device *dev,
-                        struct device_attribute *devattr, char *buf)
-{
-        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct platform_data *pdata = dev_get_drvdata(dev);
-
-        return sprintf(buf, "%d\n", pdata->core_data[attr->index]->tmin);
-}
-
-static ssize_t store_tmin(struct device *dev,
-                                struct device_attribute *devattr,
-                                const char *buf, size_t count)
-{
-        struct platform_data *pdata = dev_get_drvdata(dev);
-        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct temp_data *tdata = pdata->core_data[attr->index];
-        u32 eax, edx;
-        unsigned long val;
-        int diff;
-
-        if (strict_strtoul(buf, 10, &val))
-                return -EINVAL;
-
-        /*
-         * THERM_MASK_THRESHOLD0 is 7 bits wide. Values are entered in terms
-         * of milli degree celsius. Hence don't accept val > (127 * 1000)
-         */
-        if (val > tdata->tjmax || val > 127000)
-                return -EINVAL;
-
-        diff = (tdata->tjmax - val) / 1000;
-
-        mutex_lock(&tdata->update_lock);
-        rdmsr_on_cpu(tdata->cpu, tdata->intrpt_reg, &eax, &edx);
-        eax = (eax & ~THERM_MASK_THRESHOLD0) |
-                                (diff << THERM_SHIFT_THRESHOLD0);
-        wrmsr_on_cpu(tdata->cpu, tdata->intrpt_reg, eax, edx);
-        tdata->tmin = val;
-        mutex_unlock(&tdata->update_lock);
-
-        return count;
-}
-
 static ssize_t show_temp(struct device *dev,
                         struct device_attribute *devattr, char *buf)
 {
@@ -374,7 +288,6 @@ static int adjust_tjmax(struct cpuinfo_x86 *c, u32 id, struct device *dev)
 
 static int get_tjmax(struct cpuinfo_x86 *c, u32 id, struct device *dev)
 {
-        /* The 100C is default for both mobile and non mobile CPUs */
         int err;
         u32 eax, edx;
         u32 val;
@@ -385,7 +298,8 @@ static int get_tjmax(struct cpuinfo_x86 *c, u32 id, struct device *dev)
          */
         err = rdmsr_safe_on_cpu(id, MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
         if (err) {
-                dev_warn(dev, "Unable to read TjMax from CPU.\n");
+                if (c->x86_model > 0xe && c->x86_model != 0x1c)
+                        dev_warn(dev, "Unable to read TjMax from CPU %u\n", id);
         } else {
                 val = (eax >> 16) & 0xff;
                 /*
@@ -393,11 +307,17 @@ static int get_tjmax(struct cpuinfo_x86 *c, u32 id, struct device *dev)
                  * will be used
                  */
                 if (val) {
-                        dev_info(dev, "TjMax is %d C.\n", val);
+                        dev_dbg(dev, "TjMax is %d degrees C\n", val);
                         return val * 1000;
                 }
         }
 
+        if (force_tjmax) {
+                dev_notice(dev, "TjMax forced to %d degrees C by user\n",
+                           force_tjmax);
+                return force_tjmax * 1000;
+        }
+
         /*
          * An assumption is made for early CPUs and unreadable MSR.
          * NOTE: the calculated value may not be correct.
@@ -414,21 +334,6 @@ static void __devinit get_ucode_rev_on_cpu(void *edx)
         rdmsr(MSR_IA32_UCODE_REV, eax, *(u32 *)edx);
 }
 
-static int get_pkg_tjmax(unsigned int cpu, struct device *dev)
-{
-        int err;
-        u32 eax, edx, val;
-
-        err = rdmsr_safe_on_cpu(cpu, MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
-        if (!err) {
-                val = (eax >> 16) & 0xff;
-                if (val)
-                        return val * 1000;
-        }
-        dev_warn(dev, "Unable to read Pkg-TjMax from CPU:%u\n", cpu);
-        return 100000; /* Default TjMax: 100 degree celsius */
-}
-
 static int create_name_attr(struct platform_data *pdata, struct device *dev)
 {
         sysfs_attr_init(&pdata->name_attr.attr);
@@ -442,19 +347,14 @@ static int create_core_attrs(struct temp_data *tdata, struct device *dev,
                                 int attr_no)
 {
         int err, i;
-        static ssize_t (*rd_ptr[TOTAL_ATTRS]) (struct device *dev,
+        static ssize_t (*const rd_ptr[TOTAL_ATTRS]) (struct device *dev,
                         struct device_attribute *devattr, char *buf) = {
                         show_label, show_crit_alarm, show_temp, show_tjmax,
-                        show_max_alarm, show_ttarget, show_tmin };
-        static ssize_t (*rw_ptr[TOTAL_ATTRS]) (struct device *dev,
-                        struct device_attribute *devattr, const char *buf,
-                        size_t count) = { NULL, NULL, NULL, NULL, NULL,
-                                        store_ttarget, store_tmin };
-        static const char *names[TOTAL_ATTRS] = {
+                        show_ttarget };
+        static const char *const names[TOTAL_ATTRS] = {
                                         "temp%d_label", "temp%d_crit_alarm",
                                         "temp%d_input", "temp%d_crit",
-                                        "temp%d_max_alarm", "temp%d_max",
-                                        "temp%d_max_hyst" };
+                                        "temp%d_max" };
 
         for (i = 0; i < tdata->attr_size; i++) {
                 snprintf(tdata->attr_name[i], CORETEMP_NAME_LENGTH, names[i],
@@ -462,10 +362,6 @@ static int create_core_attrs(struct temp_data *tdata, struct device *dev,
                 sysfs_attr_init(&tdata->sd_attrs[i].dev_attr.attr);
                 tdata->sd_attrs[i].dev_attr.attr.name = tdata->attr_name[i];
                 tdata->sd_attrs[i].dev_attr.attr.mode = S_IRUGO;
-                if (rw_ptr[i]) {
-                        tdata->sd_attrs[i].dev_attr.attr.mode |= S_IWUSR;
-                        tdata->sd_attrs[i].dev_attr.store = rw_ptr[i];
-                }
                 tdata->sd_attrs[i].dev_attr.show = rd_ptr[i];
                 tdata->sd_attrs[i].index = attr_no;
                 err = device_create_file(dev, &tdata->sd_attrs[i].dev_attr);
@@ -481,9 +377,9 @@ exit_free:
 }
 
 
-static int __devinit chk_ucode_version(struct platform_device *pdev)
+static int __cpuinit chk_ucode_version(unsigned int cpu)
 {
-        struct cpuinfo_x86 *c = &cpu_data(pdev->id);
+        struct cpuinfo_x86 *c = &cpu_data(cpu);
         int err;
         u32 edx;
 
@@ -494,17 +390,15 @@ static int __devinit chk_ucode_version(struct platform_device *pdev)
          */
         if (c->x86_model == 0xe && c->x86_mask < 0xc) {
                 /* check for microcode update */
-                err = smp_call_function_single(pdev->id, get_ucode_rev_on_cpu,
+                err = smp_call_function_single(cpu, get_ucode_rev_on_cpu,
                                                &edx, 1);
                 if (err) {
-                        dev_err(&pdev->dev,
-                                "Cannot determine microcode revision of "
-                                "CPU#%u (%d)!\n", pdev->id, err);
+                        pr_err("Cannot determine microcode revision of "
+                               "CPU#%u (%d)!\n", cpu, err);
                         return -ENODEV;
                 } else if (edx < 0x39) {
-                        dev_err(&pdev->dev,
-                                "Errata AE18 not fixed, update BIOS or "
-                                "microcode of the CPU!\n");
+                        pr_err("Errata AE18 not fixed, update BIOS or "
+                               "microcode of the CPU!\n");
                         return -ENODEV;
                 }
         }
@@ -538,8 +432,6 @@ static struct temp_data *init_temp_data(unsigned int cpu, int pkg_flag)
 
         tdata->status_reg = pkg_flag ? MSR_IA32_PACKAGE_THERM_STATUS :
                                                         MSR_IA32_THERM_STATUS;
-        tdata->intrpt_reg = pkg_flag ? MSR_IA32_PACKAGE_THERM_INTERRUPT :
-                                                MSR_IA32_THERM_INTERRUPT;
         tdata->is_pkg_data = pkg_flag;
         tdata->cpu = cpu;
         tdata->cpu_core_id = TO_CORE_ID(cpu);
@@ -548,11 +440,11 @@ static struct temp_data *init_temp_data(unsigned int cpu, int pkg_flag)
         return tdata;
 }
 
-static int create_core_data(struct platform_data *pdata,
-                                struct platform_device *pdev,
+static int create_core_data(struct platform_device *pdev,
                                 unsigned int cpu, int pkg_flag)
 {
         struct temp_data *tdata;
+        struct platform_data *pdata = platform_get_drvdata(pdev);
         struct cpuinfo_x86 *c = &cpu_data(cpu);
         u32 eax, edx;
         int err, attr_no;
@@ -588,20 +480,21 @@ static int create_core_data(struct platform_data *pdata,
                 goto exit_free;
 
         /* We can access status register. Get Critical Temperature */
-        if (pkg_flag)
-                tdata->tjmax = get_pkg_tjmax(pdev->id, &pdev->dev);
-        else
-                tdata->tjmax = get_tjmax(c, cpu, &pdev->dev);
+        tdata->tjmax = get_tjmax(c, cpu, &pdev->dev);
 
         /*
-         * Test if we can access the intrpt register. If so, increase the
-         * 'size' enough to have ttarget/tmin/max_alarm interfaces.
-         * Initialize ttarget with bits 16:22 of MSR_IA32_THERM_INTERRUPT
+         * Read the still undocumented bits 8:15 of IA32_TEMPERATURE_TARGET.
+         * The target temperature is available on older CPUs but not in this
+         * register. Atoms don't have the register at all.
          */
-        err = rdmsr_safe_on_cpu(cpu, tdata->intrpt_reg, &eax, &edx);
-        if (!err) {
-                tdata->attr_size += MAX_THRESH_ATTRS;
-                tdata->ttarget = tdata->tjmax - ((eax >> 16) & 0x7f) * 1000;
+        if (c->x86_model > 0xe && c->x86_model != 0x1c) {
+                err = rdmsr_safe_on_cpu(cpu, MSR_IA32_TEMPERATURE_TARGET,
+                                        &eax, &edx);
+                if (!err) {
+                        tdata->ttarget
+                          = tdata->tjmax - ((eax >> 8) & 0xff) * 1000;
+                        tdata->attr_size++;
+                }
         }
 
         pdata->core_data[attr_no] = tdata;
@@ -613,22 +506,20 @@ static int create_core_data(struct platform_data *pdata,
 
         return 0;
 exit_free:
+        pdata->core_data[attr_no] = NULL;
         kfree(tdata);
         return err;
 }
 
 static void coretemp_add_core(unsigned int cpu, int pkg_flag)
 {
-        struct platform_data *pdata;
         struct platform_device *pdev = coretemp_get_pdev(cpu);
         int err;
 
         if (!pdev)
                 return;
 
-        pdata = platform_get_drvdata(pdev);
-
-        err = create_core_data(pdata, pdev, cpu, pkg_flag);
+        err = create_core_data(pdev, cpu, pkg_flag);
         if (err)
                 dev_err(&pdev->dev, "Adding Core %u failed\n", cpu);
 }
@@ -652,11 +543,6 @@ static int __devinit coretemp_probe(struct platform_device *pdev)
         struct platform_data *pdata;
         int err;
 
-        /* Check the microcode version of the CPU */
-        err = chk_ucode_version(pdev);
-        if (err)
-                return err;
-
         /* Initialize the per-package data structures */
         pdata = kzalloc(sizeof(struct platform_data), GFP_KERNEL);
         if (!pdata)
@@ -666,7 +552,7 @@ static int __devinit coretemp_probe(struct platform_device *pdev)
         if (err)
                 goto exit_free;
 
-        pdata->phys_proc_id = TO_PHYS_ID(pdev->id);
+        pdata->phys_proc_id = pdev->id;
         platform_set_drvdata(pdev, pdata);
 
         pdata->hwmon_dev = hwmon_device_register(&pdev->dev);
@@ -718,7 +604,7 @@ static int __cpuinit coretemp_device_add(unsigned int cpu)
 
         mutex_lock(&pdev_list_mutex);
 
-        pdev = platform_device_alloc(DRVNAME, cpu);
+        pdev = platform_device_alloc(DRVNAME, TO_PHYS_ID(cpu));
         if (!pdev) {
                 err = -ENOMEM;
                 pr_err("Device allocation failed\n");
@@ -738,7 +624,7 @@ static int __cpuinit coretemp_device_add(unsigned int cpu)
         }
 
         pdev_entry->pdev = pdev;
-        pdev_entry->phys_proc_id = TO_PHYS_ID(cpu);
+        pdev_entry->phys_proc_id = pdev->id;
 
         list_add_tail(&pdev_entry->list, &pdev_list);
         mutex_unlock(&pdev_list_mutex);
@@ -799,6 +685,10 @@ static void __cpuinit get_core_online(unsigned int cpu)
                 return;
 
         if (!pdev) {
+                /* Check the microcode version of the CPU */
+                if (chk_ucode_version(cpu))
+                        return;
+
                 /*
                  * Alright, we have DTS support.
                  * We are bringing the _first_ core in this pkg
diff --git a/drivers/hwmon/ds620.c b/drivers/hwmon/ds620.c
index 257957c69d92..4f7c3fc40a89 100644
--- a/drivers/hwmon/ds620.c
+++ b/drivers/hwmon/ds620.c
@@ -72,7 +72,7 @@ struct ds620_data {
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
-        u16 temp[3];            /* Register values, word */
+        s16 temp[3];            /* Register values, word */
 };
 
 /*
diff --git a/drivers/hwmon/i5k_amb.c b/drivers/hwmon/i5k_amb.c
index c4c40be0edbf..d22f241b6a67 100644
--- a/drivers/hwmon/i5k_amb.c
+++ b/drivers/hwmon/i5k_amb.c
@@ -114,7 +114,6 @@ struct i5k_amb_data {
         void __iomem *amb_mmio;
         struct i5k_device_attribute *attrs;
         unsigned int num_attrs;
-        unsigned long chipset_id;
 };
 
 static ssize_t show_name(struct device *dev, struct device_attribute *devattr,
@@ -444,8 +443,6 @@ static int __devinit i5k_find_amb_registers(struct i5k_amb_data *data,
                 goto out;
         }
 
-        data->chipset_id = devid;
-
         res = 0;
 out:
         pci_dev_put(pcidev);
@@ -478,23 +475,13 @@ out:
         return res;
 }
 
-static unsigned long i5k_channel_pci_id(struct i5k_amb_data *data,
-                                        unsigned long channel)
-{
-        switch (data->chipset_id) {
-        case PCI_DEVICE_ID_INTEL_5000_ERR:
-                return PCI_DEVICE_ID_INTEL_5000_FBD0 + channel;
-        case PCI_DEVICE_ID_INTEL_5400_ERR:
-                return PCI_DEVICE_ID_INTEL_5400_FBD0 + channel;
-        default:
-                BUG();
-        }
-}
-
-static unsigned long chipset_ids[] = {
-        PCI_DEVICE_ID_INTEL_5000_ERR,
-        PCI_DEVICE_ID_INTEL_5400_ERR,
-        0
+static struct {
+        unsigned long err;
+        unsigned long fbd0;
+} chipset_ids[] __devinitdata  = {
+        { PCI_DEVICE_ID_INTEL_5000_ERR, PCI_DEVICE_ID_INTEL_5000_FBD0 },
+        { PCI_DEVICE_ID_INTEL_5400_ERR, PCI_DEVICE_ID_INTEL_5400_FBD0 },
+        { 0, 0 }
 };
 
 #ifdef MODULE
@@ -510,8 +497,7 @@ static int __devinit i5k_amb_probe(struct platform_device *pdev)
 {
         struct i5k_amb_data *data;
         struct resource *reso;
-        int i;
-        int res = -ENODEV;
+        int i, res;
 
         data = kzalloc(sizeof(*data), GFP_KERNEL);
         if (!data)
@@ -520,22 +506,22 @@ static int __devinit i5k_amb_probe(struct platform_device *pdev)
         /* Figure out where the AMB registers live */
         i = 0;
         do {
-                res = i5k_find_amb_registers(data, chipset_ids[i]);
+                res = i5k_find_amb_registers(data, chipset_ids[i].err);
+                if (res == 0)
+                        break;
                 i++;
-        } while (res && chipset_ids[i]);
+        } while (chipset_ids[i].err);
 
         if (res)
                 goto err;
 
         /* Copy the DIMM presence map for the first two channels */
-        res = i5k_channel_probe(&data->amb_present[0],
-                                i5k_channel_pci_id(data, 0));
+        res = i5k_channel_probe(&data->amb_present[0], chipset_ids[i].fbd0);
         if (res)
                 goto err;
 
         /* Copy the DIMM presence map for the optional second two channels */
-        i5k_channel_probe(&data->amb_present[2],
-                          i5k_channel_pci_id(data, 1));
+        i5k_channel_probe(&data->amb_present[2], chipset_ids[i].fbd0 + 1);
 
         /* Set up resource regions */
         reso = request_mem_region(data->amb_base, data->amb_len, DRVNAME);
diff --git a/drivers/hwmon/ibmaem.c b/drivers/hwmon/ibmaem.c
index 1a409c5bc9bc..c316294c48b4 100644
--- a/drivers/hwmon/ibmaem.c
+++ b/drivers/hwmon/ibmaem.c
@@ -432,13 +432,15 @@ static int aem_read_sensor(struct aem_data *data, u8 elt, u8 reg,
         aem_send_message(ipmi);
 
         res = wait_for_completion_timeout(&ipmi->read_complete, IPMI_TIMEOUT);
-        if (!res)
-                return -ETIMEDOUT;
+        if (!res) {
+                res = -ETIMEDOUT;
+                goto out;
+        }
 
         if (ipmi->rx_result || ipmi->rx_msg_len != rs_size ||
             memcmp(&rs_resp->id, &system_x_id, sizeof(system_x_id))) {
-                kfree(rs_resp);
-                return -ENOENT;
+                res = -ENOENT;
+                goto out;
         }
 
         switch (size) {
@@ -463,8 +465,11 @@ static int aem_read_sensor(struct aem_data *data, u8 elt, u8 reg,
                 break;
         }
         }
+        res = 0;
 
-        return 0;
+out:
+        kfree(rs_resp);
+        return res;
 }
 
 /* Update AEM energy registers */
diff --git a/drivers/hwmon/max16065.c b/drivers/hwmon/max16065.c
index d94a24fdf4ba..dd2d7b9620c2 100644
--- a/drivers/hwmon/max16065.c
+++ b/drivers/hwmon/max16065.c
@@ -124,7 +124,7 @@ static inline int MV_TO_LIMIT(int mv, int range)
 
 static inline int ADC_TO_CURR(int adc, int gain)
 {
-        return adc * 1400000 / gain * 255;
+        return adc * 1400000 / (gain * 255);
 }
 
 /*
diff --git a/drivers/hwmon/ntc_thermistor.c b/drivers/hwmon/ntc_thermistor.c
index d7926f4336b5..eab11615dced 100644
--- a/drivers/hwmon/ntc_thermistor.c
+++ b/drivers/hwmon/ntc_thermistor.c
@@ -211,8 +211,7 @@ static int lookup_comp(struct ntc_data *data,
         if (data->comp[mid].ohm <= ohm) {
                 *i_low = mid;
                 *i_high = mid - 1;
-        }
-        if (data->comp[mid].ohm > ohm) {
+        } else {
                 *i_low = mid + 1;
                 *i_high = mid;
         }
diff --git a/drivers/hwmon/pmbus/lm25066.c b/drivers/hwmon/pmbus/lm25066.c
index d4bc114572de..ac254fba551b 100644
--- a/drivers/hwmon/pmbus/lm25066.c
+++ b/drivers/hwmon/pmbus/lm25066.c
@@ -161,6 +161,17 @@ static int lm25066_write_word_data(struct i2c_client *client, int page, int reg,
         return ret;
 }
 
+static int lm25066_write_byte(struct i2c_client *client, int page, u8 value)
+{
+        if (page > 1)
+                return -EINVAL;
+
+        if (page == 0)
+                return pmbus_write_byte(client, 0, value);
+
+        return 0;
+}
+
 static int lm25066_probe(struct i2c_client *client,
                           const struct i2c_device_id *id)
 {
@@ -204,6 +215,7 @@ static int lm25066_probe(struct i2c_client *client,
 
         info->read_word_data = lm25066_read_word_data;
         info->write_word_data = lm25066_write_word_data;
+        info->write_byte = lm25066_write_byte;
 
         switch (id->driver_data) {
         case lm25066:
diff --git a/drivers/hwmon/pmbus/pmbus.h b/drivers/hwmon/pmbus/pmbus.h
index 0808d986d75b..a6ae20ffef6b 100644
--- a/drivers/hwmon/pmbus/pmbus.h
+++ b/drivers/hwmon/pmbus/pmbus.h
@@ -325,6 +325,7 @@ struct pmbus_driver_info {
         int (*read_word_data)(struct i2c_client *client, int page, int reg);
         int (*write_word_data)(struct i2c_client *client, int page, int reg,
                                u16 word);
+        int (*write_byte)(struct i2c_client *client, int page, u8 value);
         /*
          * The identify function determines supported PMBus functionality.
          * This function is only necessary if a chip driver supports multiple
diff --git a/drivers/hwmon/pmbus/pmbus_core.c b/drivers/hwmon/pmbus/pmbus_core.c
index 5c1b6cf31701..397fc59b5682 100644
--- a/drivers/hwmon/pmbus/pmbus_core.c
+++ b/drivers/hwmon/pmbus/pmbus_core.c
@@ -182,6 +182,24 @@ int pmbus_write_byte(struct i2c_client *client, int page, u8 value)
 }
 EXPORT_SYMBOL_GPL(pmbus_write_byte);
 
+/*
+ * _pmbus_write_byte() is similar to pmbus_write_byte(), but checks if
+ * a device specific mapping funcion exists and calls it if necessary.
+ */
+static int _pmbus_write_byte(struct i2c_client *client, int page, u8 value)
+{
+        struct pmbus_data *data = i2c_get_clientdata(client);
+        const struct pmbus_driver_info *info = data->info;
+        int status;
+
+        if (info->write_byte) {
+                status = info->write_byte(client, page, value);
+                if (status != -ENODATA)
+                        return status;
+        }
+        return pmbus_write_byte(client, page, value);
+}
+
 int pmbus_write_word_data(struct i2c_client *client, u8 page, u8 reg, u16 word)
 {
         int rv;
@@ -281,7 +299,7 @@ static int _pmbus_read_byte_data(struct i2c_client *client, int page, int reg)
 
 static void pmbus_clear_fault_page(struct i2c_client *client, int page)
 {
-        pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
+        _pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
 }
 
 void pmbus_clear_faults(struct i2c_client *client)
@@ -960,6 +978,8 @@ static void pmbus_find_max_attr(struct i2c_client *client,
 struct pmbus_limit_attr {
         u16 reg;                /* Limit register */
         bool update;            /* True if register needs updates */
+        bool low;               /* True if low limit; for limits with compare
+                                   functions only */
         const char *attr;       /* Attribute name */
         const char *alarm;      /* Alarm attribute name */
         u32 sbit;               /* Alarm attribute status bit */
@@ -1011,7 +1031,8 @@ static bool pmbus_add_limit_attrs(struct i2c_client *client,
                                 if (attr->compare) {
                                         pmbus_add_boolean_cmp(data, name,
                                                 l->alarm, index,
-                                                cbase, cindex,
+                                                l->low ? cindex : cbase,
+                                                l->low ? cbase : cindex,
                                                 attr->sbase + page, l->sbit);
                                 } else {
                                         pmbus_add_boolean_reg(data, name,
@@ -1348,11 +1369,13 @@ static const struct pmbus_sensor_attr power_attributes[] = {
 static const struct pmbus_limit_attr temp_limit_attrs[] = {
         {
                 .reg = PMBUS_UT_WARN_LIMIT,
+                .low = true,
                 .attr = "min",
                 .alarm = "min_alarm",
                 .sbit = PB_TEMP_UT_WARNING,
         }, {
                 .reg = PMBUS_UT_FAULT_LIMIT,
+                .low = true,
                 .attr = "lcrit",
                 .alarm = "lcrit_alarm",
                 .sbit = PB_TEMP_UT_FAULT,
@@ -1381,11 +1404,13 @@ static const struct pmbus_limit_attr temp_limit_attrs[] = {
 static const struct pmbus_limit_attr temp_limit_attrs23[] = {
         {
                 .reg = PMBUS_UT_WARN_LIMIT,
+                .low = true,
                 .attr = "min",
                 .alarm = "min_alarm",
                 .sbit = PB_TEMP_UT_WARNING,
         }, {
                 .reg = PMBUS_UT_FAULT_LIMIT,
+                .low = true,
                 .attr = "lcrit",
                 .alarm = "lcrit_alarm",
                 .sbit = PB_TEMP_UT_FAULT,
diff --git a/drivers/hwmon/pmbus/ucd9000.c b/drivers/hwmon/pmbus/ucd9000.c
index ace1c7319734..d0ddb60155c9 100644
--- a/drivers/hwmon/pmbus/ucd9000.c
+++ b/drivers/hwmon/pmbus/ucd9000.c
@@ -141,13 +141,11 @@ static int ucd9000_probe(struct i2c_client *client,
         block_buffer[ret] = '\0';
         dev_info(&client->dev, "Device ID %s\n", block_buffer);
 
-        mid = NULL;
-        for (i = 0; i < ARRAY_SIZE(ucd9000_id); i++) {
-                mid = &ucd9000_id[i];
+        for (mid = ucd9000_id; mid->name[0]; mid++) {
                 if (!strncasecmp(mid->name, block_buffer, strlen(mid->name)))
                         break;
         }
-        if (!mid || !strlen(mid->name)) {
+        if (!mid->name[0]) {
                 dev_err(&client->dev, "Unsupported device\n");
                 return -ENODEV;
         }
diff --git a/drivers/hwmon/pmbus/ucd9200.c b/drivers/hwmon/pmbus/ucd9200.c
index ffcc1cf3609d..c65e9da707cc 100644
--- a/drivers/hwmon/pmbus/ucd9200.c
+++ b/drivers/hwmon/pmbus/ucd9200.c
@@ -68,13 +68,11 @@ static int ucd9200_probe(struct i2c_client *client,
         block_buffer[ret] = '\0';
         dev_info(&client->dev, "Device ID %s\n", block_buffer);
 
-        mid = NULL;
-        for (i = 0; i < ARRAY_SIZE(ucd9200_id); i++) {
-                mid = &ucd9200_id[i];
+        for (mid = ucd9200_id; mid->name[0]; mid++) {
                 if (!strncasecmp(mid->name, block_buffer, strlen(mid->name)))
                         break;
         }
-        if (!mid || !strlen(mid->name)) {
+        if (!mid->name[0]) {
                 dev_err(&client->dev, "Unsupported device\n");
                 return -ENODEV;
         }
diff --git a/drivers/hwmon/w83791d.c b/drivers/hwmon/w83791d.c
index 17cf1ab95521..8c2844e5691c 100644
--- a/drivers/hwmon/w83791d.c
+++ b/drivers/hwmon/w83791d.c
@@ -329,8 +329,8 @@ static int w83791d_detect(struct i2c_client *client,
                           struct i2c_board_info *info);
 static int w83791d_remove(struct i2c_client *client);
 
-static int w83791d_read(struct i2c_client *client, u8 register);
-static int w83791d_write(struct i2c_client *client, u8 register, u8 value);
+static int w83791d_read(struct i2c_client *client, u8 reg);
+static int w83791d_write(struct i2c_client *client, u8 reg, u8 value);
 static struct w83791d_data *w83791d_update_device(struct device *dev);
 
 #ifdef DEBUG
diff --git a/drivers/i2c/busses/i2c-ixp2000.c b/drivers/i2c/busses/i2c-ixp2000.c
index 5d8aed5ec21b..c01e9519f6c1 100644
--- a/drivers/i2c/busses/i2c-ixp2000.c
+++ b/drivers/i2c/busses/i2c-ixp2000.c
@@ -35,7 +35,7 @@
 #include <linux/slab.h>
 
 #include <mach/hardware.h>      /* Pick up IXP2000-specific bits */
-#include <mach/gpio.h>
+#include <mach/gpio-ixp2000.h>
 
 static inline int ixp2000_scl_pin(void *data)
 {
diff --git a/drivers/i2c/busses/i2c-nomadik.c b/drivers/i2c/busses/i2c-nomadik.c
index 0c731ca69f15..b228e09c5d05 100644
--- a/drivers/i2c/busses/i2c-nomadik.c
+++ b/drivers/i2c/busses/i2c-nomadik.c
@@ -146,6 +146,7 @@ struct i2c_nmk_client {
  * @stop: stop condition
  * @xfer_complete: acknowledge completion for a I2C message
  * @result: controller propogated result
+ * @regulator: pointer to i2c regulator
  * @busy: Busy doing transfer
  */
 struct nmk_i2c_dev {
@@ -417,12 +418,12 @@ static int read_i2c(struct nmk_i2c_dev *dev)
         writel(readl(dev->virtbase + I2C_IMSCR) | irq_mask,
                         dev->virtbase + I2C_IMSCR);
 
-        timeout = wait_for_completion_interruptible_timeout(
+        timeout = wait_for_completion_timeout(
                 &dev->xfer_complete, dev->adap.timeout);
 
         if (timeout < 0) {
                 dev_err(&dev->pdev->dev,
-                        "wait_for_completion_interruptible_timeout"
+                        "wait_for_completion_timeout"
                         "returned %d waiting for event\n", timeout);
                 status = timeout;
         }
@@ -504,12 +505,12 @@ static int write_i2c(struct nmk_i2c_dev *dev)
         writel(readl(dev->virtbase + I2C_IMSCR) | irq_mask,
                         dev->virtbase + I2C_IMSCR);
 
-        timeout = wait_for_completion_interruptible_timeout(
+        timeout = wait_for_completion_timeout(
                 &dev->xfer_complete, dev->adap.timeout);
 
         if (timeout < 0) {
                 dev_err(&dev->pdev->dev,
-                        "wait_for_completion_interruptible_timeout"
+                        "wait_for_completion_timeout "
                         "returned %d waiting for event\n", timeout);
                 status = timeout;
         }
diff --git a/drivers/i2c/busses/i2c-omap.c b/drivers/i2c/busses/i2c-omap.c
index 1a766cf74f6b..2dfb63176856 100644
--- a/drivers/i2c/busses/i2c-omap.c
+++ b/drivers/i2c/busses/i2c-omap.c
@@ -1139,41 +1139,12 @@ omap_i2c_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_SUSPEND
-static int omap_i2c_suspend(struct device *dev)
-{
-        if (!pm_runtime_suspended(dev))
-                if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_suspend)
-                        dev->bus->pm->runtime_suspend(dev);
-
-        return 0;
-}
-
-static int omap_i2c_resume(struct device *dev)
-{
-        if (!pm_runtime_suspended(dev))
-                if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_resume)
-                        dev->bus->pm->runtime_resume(dev);
-
-        return 0;
-}
-
-static struct dev_pm_ops omap_i2c_pm_ops = {
-        .suspend = omap_i2c_suspend,
-        .resume = omap_i2c_resume,
-};
-#define OMAP_I2C_PM_OPS (&omap_i2c_pm_ops)
-#else
-#define OMAP_I2C_PM_OPS NULL
-#endif
-
 static struct platform_driver omap_i2c_driver = {
         .probe          = omap_i2c_probe,
         .remove         = omap_i2c_remove,
         .driver         = {
                 .name   = "omap_i2c",
                 .owner  = THIS_MODULE,
-                .pm     = OMAP_I2C_PM_OPS,
         },
 };
 
diff --git a/drivers/i2c/busses/i2c-pxa-pci.c b/drivers/i2c/busses/i2c-pxa-pci.c
index 6659d269b841..b73da6cd6f91 100644
--- a/drivers/i2c/busses/i2c-pxa-pci.c
+++ b/drivers/i2c/busses/i2c-pxa-pci.c
@@ -109,12 +109,15 @@ static int __devinit ce4100_i2c_probe(struct pci_dev *dev,
                 return -EINVAL;
         }
         sds = kzalloc(sizeof(*sds), GFP_KERNEL);
-        if (!sds)
+        if (!sds) {
+                ret = -ENOMEM;
                 goto err_mem;
+        }
 
         for (i = 0; i < ARRAY_SIZE(sds->pdev); i++) {
                 sds->pdev[i] = add_i2c_device(dev, i);
                 if (IS_ERR(sds->pdev[i])) {
+                        ret = PTR_ERR(sds->pdev[i]);
                         while (--i >= 0)
                                 platform_device_unregister(sds->pdev[i]);
                         goto err_dev_add;
diff --git a/drivers/i2c/busses/i2c-tegra.c b/drivers/i2c/busses/i2c-tegra.c
index 2440b7411978..3c94c4a81a55 100644
--- a/drivers/i2c/busses/i2c-tegra.c
+++ b/drivers/i2c/busses/i2c-tegra.c
@@ -270,14 +270,30 @@ static int tegra_i2c_fill_tx_fifo(struct tegra_i2c_dev *i2c_dev)
 
         /* Rounds down to not include partial word at the end of buf */
         words_to_transfer = buf_remaining / BYTES_PER_FIFO_WORD;
-        if (words_to_transfer > tx_fifo_avail)
-                words_to_transfer = tx_fifo_avail;
 
-        i2c_writesl(i2c_dev, buf, I2C_TX_FIFO, words_to_transfer);
-
-        buf += words_to_transfer * BYTES_PER_FIFO_WORD;
-        buf_remaining -= words_to_transfer * BYTES_PER_FIFO_WORD;
-        tx_fifo_avail -= words_to_transfer;
+        /* It's very common to have < 4 bytes, so optimize that case. */
+        if (words_to_transfer) {
+                if (words_to_transfer > tx_fifo_avail)
+                        words_to_transfer = tx_fifo_avail;
+
+                /*
+                 * Update state before writing to FIFO.  If this casues us
+                 * to finish writing all bytes (AKA buf_remaining goes to 0) we
+                 * have a potential for an interrupt (PACKET_XFER_COMPLETE is
+                 * not maskable).  We need to make sure that the isr sees
+                 * buf_remaining as 0 and doesn't call us back re-entrantly.
+                 */
+                buf_remaining -= words_to_transfer * BYTES_PER_FIFO_WORD;
+                tx_fifo_avail -= words_to_transfer;
+                i2c_dev->msg_buf_remaining = buf_remaining;
+                i2c_dev->msg_buf = buf +
+                        words_to_transfer * BYTES_PER_FIFO_WORD;
+                barrier();
+
+                i2c_writesl(i2c_dev, buf, I2C_TX_FIFO, words_to_transfer);
+
+                buf += words_to_transfer * BYTES_PER_FIFO_WORD;
+        }
 
         /*
          * If there is a partial word at the end of buf, handle it manually to
@@ -287,14 +303,15 @@ static int tegra_i2c_fill_tx_fifo(struct tegra_i2c_dev *i2c_dev)
         if (tx_fifo_avail > 0 && buf_remaining > 0) {
                 BUG_ON(buf_remaining > 3);
                 memcpy(&val, buf, buf_remaining);
+
+                /* Again update before writing to FIFO to make sure isr sees. */
+                i2c_dev->msg_buf_remaining = 0;
+                i2c_dev->msg_buf = NULL;
+                barrier();
+
                 i2c_writel(i2c_dev, val, I2C_TX_FIFO);
-                buf_remaining = 0;
-                tx_fifo_avail--;
         }
 
-        BUG_ON(tx_fifo_avail > 0 && buf_remaining > 0);
-        i2c_dev->msg_buf_remaining = buf_remaining;
-        i2c_dev->msg_buf = buf;
         return 0;
 }
 
@@ -411,9 +428,10 @@ static irqreturn_t tegra_i2c_isr(int irq, void *dev_id)
                         tegra_i2c_mask_irq(i2c_dev, I2C_INT_TX_FIFO_DATA_REQ);
         }
 
-        if ((status & I2C_INT_PACKET_XFER_COMPLETE) &&
-                        !i2c_dev->msg_buf_remaining)
+        if (status & I2C_INT_PACKET_XFER_COMPLETE) {
+                BUG_ON(i2c_dev->msg_buf_remaining);
                 complete(&i2c_dev->msg_complete);
+        }
 
         i2c_writel(i2c_dev, status, I2C_INT_STATUS);
         if (i2c_dev->is_dvc)
@@ -531,7 +549,7 @@ static int tegra_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[],
 
 static u32 tegra_i2c_func(struct i2c_adapter *adap)
 {
-        return I2C_FUNC_I2C;
+        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 }
 
 static const struct i2c_algorithm tegra_i2c_algo = {
@@ -719,6 +737,17 @@ static int tegra_i2c_resume(struct platform_device *pdev)
 }
 #endif
 
+#if defined(CONFIG_OF)
+/* Match table for of_platform binding */
+static const struct of_device_id tegra_i2c_of_match[] __devinitconst = {
+        { .compatible = "nvidia,tegra20-i2c", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, tegra_i2c_of_match);
+#else
+#define tegra_i2c_of_match NULL
+#endif
+
 static struct platform_driver tegra_i2c_driver = {
         .probe   = tegra_i2c_probe,
         .remove  = tegra_i2c_remove,
@@ -729,6 +758,7 @@ static struct platform_driver tegra_i2c_driver = {
         .driver  = {
                 .name  = "tegra-i2c",
                 .owner = THIS_MODULE,
+                .of_match_table = tegra_i2c_of_match,
         },
 };
 
diff --git a/drivers/ide/at91_ide.c b/drivers/ide/at91_ide.c
index 000a78e5246c..6dede8f366c5 100644
--- a/drivers/ide/at91_ide.c
+++ b/drivers/ide/at91_ide.c
@@ -28,7 +28,7 @@
 #include <linux/platform_device.h>
 
 #include <mach/board.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include <mach/at91sam9_smc.h>
 
 #define DRV_NAME "at91_ide"
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index 274798068a54..16f69be820c7 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -435,7 +435,12 @@ static int idedisk_prep_fn(struct request_queue *q, struct request *rq)
         if (!(rq->cmd_flags & REQ_FLUSH))
                 return BLKPREP_OK;
 
-        cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC);
+        if (rq->special) {
+                cmd = rq->special;
+                memset(cmd, 0, sizeof(*cmd));
+        } else {
+                cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC);
+        }
 
         /* FIXME: map struct ide_taskfile on rq->cmd[] */
         BUG_ON(cmd == NULL);
diff --git a/drivers/infiniband/hw/cxgb3/iwch_cm.c b/drivers/infiniband/hw/cxgb3/iwch_cm.c
index 17bf9d95463c..6cd642aaa4de 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_cm.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_cm.c
@@ -287,7 +287,7 @@ void __free_ep(struct kref *kref)
         if (test_bit(RELEASE_RESOURCES, &ep->com.flags)) {
                 cxgb3_remove_tid(ep->com.tdev, (void *)ep, ep->hwtid);
                 dst_release(ep->dst);
-                l2t_release(L2DATA(ep->com.tdev), ep->l2t);
+                l2t_release(ep->com.tdev, ep->l2t);
         }
         kfree(ep);
 }
@@ -1178,7 +1178,7 @@ static int act_open_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
                 release_tid(ep->com.tdev, GET_TID(rpl), NULL);
         cxgb3_free_atid(ep->com.tdev, ep->atid);
         dst_release(ep->dst);
-        l2t_release(L2DATA(ep->com.tdev), ep->l2t);
+        l2t_release(ep->com.tdev, ep->l2t);
         put_ep(&ep->com);
         return CPL_RET_BUF_DONE;
 }
@@ -1377,7 +1377,7 @@ static int pass_accept_req(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
         if (!child_ep) {
                 printk(KERN_ERR MOD "%s - failed to allocate ep entry!\n",
                        __func__);
-                l2t_release(L2DATA(tdev), l2t);
+                l2t_release(tdev, l2t);
                 dst_release(dst);
                 goto reject;
         }
@@ -1956,7 +1956,7 @@ int iwch_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
         if (!err)
                 goto out;
 
-        l2t_release(L2DATA(h->rdev.t3cdev_p), ep->l2t);
+        l2t_release(h->rdev.t3cdev_p, ep->l2t);
 fail4:
         dst_release(ep->dst);
 fail3:
@@ -2127,7 +2127,7 @@ int iwch_ep_redirect(void *ctx, struct dst_entry *old, struct dst_entry *new,
         PDBG("%s ep %p redirect to dst %p l2t %p\n", __func__, ep, new,
              l2t);
         dst_hold(new);
-        l2t_release(L2DATA(ep->com.tdev), ep->l2t);
+        l2t_release(ep->com.tdev, ep->l2t);
         ep->l2t = l2t;
         dst_release(old);
         ep->dst = new;
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c
index 43f89ba0a908..fe89c4660d55 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_main.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c
@@ -717,11 +717,13 @@ static int ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
         struct ipoib_neigh *neigh;
-        struct neighbour *n;
+        struct neighbour *n = NULL;
         unsigned long flags;
 
-        n = dst_get_neighbour(skb_dst(skb));
-        if (likely(skb_dst(skb) && n)) {
+        if (likely(skb_dst(skb)))
+                n = dst_get_neighbour(skb_dst(skb));
+
+        if (likely(n)) {
                 if (unlikely(!*to_ipoib_neigh(n))) {
                         ipoib_path_lookup(skb, dev);
                         return NETDEV_TX_OK;
diff --git a/drivers/infiniband/ulp/iser/iscsi_iser.c b/drivers/infiniband/ulp/iser/iscsi_iser.c
index 8db008de5392..9c61b9c2c597 100644
--- a/drivers/infiniband/ulp/iser/iscsi_iser.c
+++ b/drivers/infiniband/ulp/iser/iscsi_iser.c
@@ -101,13 +101,17 @@ iscsi_iser_recv(struct iscsi_conn *conn,
 
         /* verify PDU length */
         datalen = ntoh24(hdr->dlength);
-        if (datalen != rx_data_len) {
-                printk(KERN_ERR "iscsi_iser: datalen %d (hdr) != %d (IB) \n",
-                       datalen, rx_data_len);
+        if (datalen > rx_data_len || (datalen + 4) < rx_data_len) {
+                iser_err("wrong datalen %d (hdr), %d (IB)\n",
+                        datalen, rx_data_len);
                 rc = ISCSI_ERR_DATALEN;
                 goto error;
         }
 
+        if (datalen != rx_data_len)
+                iser_dbg("aligned datalen (%d) hdr, %d (IB)\n",
+                        datalen, rx_data_len);
+
         /* read AHS */
         ahslen = hdr->hlength * 4;
 
diff --git a/drivers/infiniband/ulp/iser/iscsi_iser.h b/drivers/infiniband/ulp/iser/iscsi_iser.h
index 342cbc1bdaae..db6f3ce9f3bf 100644
--- a/drivers/infiniband/ulp/iser/iscsi_iser.h
+++ b/drivers/infiniband/ulp/iser/iscsi_iser.h
@@ -89,7 +89,7 @@
         } while (0)
 
 #define SHIFT_4K        12
-#define SIZE_4K (1UL << SHIFT_4K)
+#define SIZE_4K (1ULL << SHIFT_4K)
 #define MASK_4K (~(SIZE_4K-1))
 
                                         /* support up to 512KB in one RDMA */
diff --git a/drivers/infiniband/ulp/iser/iser_initiator.c b/drivers/infiniband/ulp/iser/iser_initiator.c
index 5745b7fe158c..f299de6b419b 100644
--- a/drivers/infiniband/ulp/iser/iser_initiator.c
+++ b/drivers/infiniband/ulp/iser/iser_initiator.c
@@ -412,7 +412,7 @@ int iser_send_control(struct iscsi_conn *conn,
                 memcpy(iser_conn->ib_conn->login_buf, task->data,
                                                         task->data_count);
                 tx_dsg->addr    = iser_conn->ib_conn->login_dma;
-                tx_dsg->length  = data_seg_len;
+                tx_dsg->length  = task->data_count;
                 tx_dsg->lkey    = device->mr->lkey;
                 mdesc->num_sge = 2;
         }
diff --git a/drivers/input/joystick/analog.c b/drivers/input/joystick/analog.c
index 9882971827e6..358cd7ee905b 100644
--- a/drivers/input/joystick/analog.c
+++ b/drivers/input/joystick/analog.c
@@ -139,7 +139,7 @@ struct analog_port {
 #include <linux/i8253.h>
 
 #define GET_TIME(x)     do { if (cpu_has_tsc) rdtscl(x); else x = get_time_pit(); } while (0)
-#define DELTA(x,y)      (cpu_has_tsc ? ((y) - (x)) : ((x) - (y) + ((x) < (y) ? CLOCK_TICK_RATE / HZ : 0)))
+#define DELTA(x,y)      (cpu_has_tsc ? ((y) - (x)) : ((x) - (y) + ((x) < (y) ? PIT_TICK_RATE / HZ : 0)))
 #define TIME_NAME       (cpu_has_tsc?"TSC":"PIT")
 static unsigned int get_time_pit(void)
 {
diff --git a/drivers/input/keyboard/adp5588-keys.c b/drivers/input/keyboard/adp5588-keys.c
index 7b404e5443ed..e34eeb8ae371 100644
--- a/drivers/input/keyboard/adp5588-keys.c
+++ b/drivers/input/keyboard/adp5588-keys.c
@@ -668,4 +668,3 @@ module_exit(adp5588_exit);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 MODULE_DESCRIPTION("ADP5588/87 Keypad driver");
-MODULE_ALIAS("platform:adp5588-keys");
diff --git a/drivers/input/keyboard/ep93xx_keypad.c b/drivers/input/keyboard/ep93xx_keypad.c
index c8242dd190d0..aa17e024d803 100644
--- a/drivers/input/keyboard/ep93xx_keypad.c
+++ b/drivers/input/keyboard/ep93xx_keypad.c
@@ -20,6 +20,7 @@
  * flag.
  */
 
+#include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/interrupt.h>
 #include <linux/clk.h>
diff --git a/drivers/input/keyboard/omap-keypad.c b/drivers/input/keyboard/omap-keypad.c
index 33d0bdc837c0..323bcdfff248 100644
--- a/drivers/input/keyboard/omap-keypad.c
+++ b/drivers/input/keyboard/omap-keypad.c
@@ -35,7 +35,7 @@
 #include <linux/mutex.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include <plat/keypad.h>
 #include <plat/menelaus.h>
 #include <asm/irq.h>
diff --git a/drivers/input/keyboard/tegra-kbc.c b/drivers/input/keyboard/tegra-kbc.c
index f270447ba951..a5a77915c650 100644
--- a/drivers/input/keyboard/tegra-kbc.c
+++ b/drivers/input/keyboard/tegra-kbc.c
@@ -702,7 +702,7 @@ err_iounmap:
 err_free_mem_region:
         release_mem_region(res->start, resource_size(res));
 err_free_mem:
-        input_free_device(kbc->idev);
+        input_free_device(input_dev);
         kfree(kbc);
 
         return err;
diff --git a/drivers/input/misc/ad714x-i2c.c b/drivers/input/misc/ad714x-i2c.c
index e21deb1baa8a..025417d74ca2 100644
--- a/drivers/input/misc/ad714x-i2c.c
+++ b/drivers/input/misc/ad714x-i2c.c
@@ -1,7 +1,7 @@
 /*
  * AD714X CapTouch Programmable Controller driver (I2C bus)
  *
- * Copyright 2009 Analog Devices Inc.
+ * Copyright 2009-2011 Analog Devices Inc.
  *
  * Licensed under the GPL-2 or later.
  */
@@ -27,54 +27,49 @@ static int ad714x_i2c_resume(struct device *dev)
 
 static SIMPLE_DEV_PM_OPS(ad714x_i2c_pm, ad714x_i2c_suspend, ad714x_i2c_resume);
 
-static int ad714x_i2c_write(struct device *dev, unsigned short reg,
-                                unsigned short data)
+static int ad714x_i2c_write(struct ad714x_chip *chip,
+                            unsigned short reg, unsigned short data)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        int ret = 0;
-        u8 *_reg = (u8 *)&reg;
-        u8 *_data = (u8 *)&data;
-
-        u8 tx[4] = {
-                _reg[1],
-                _reg[0],
-                _data[1],
-                _data[0]
-        };
-
-        ret = i2c_master_send(client, tx, 4);
-        if (ret < 0)
-                dev_err(&client->dev, "I2C write error\n");
-
-        return ret;
+        struct i2c_client *client = to_i2c_client(chip->dev);
+        int error;
+
+        chip->xfer_buf[0] = cpu_to_be16(reg);
+        chip->xfer_buf[1] = cpu_to_be16(data);
+
+        error = i2c_master_send(client, (u8 *)chip->xfer_buf,
+                                2 * sizeof(*chip->xfer_buf));
+        if (unlikely(error < 0)) {
+                dev_err(&client->dev, "I2C write error: %d\n", error);
+                return error;
+        }
+
+        return 0;
 }
 
-static int ad714x_i2c_read(struct device *dev, unsigned short reg,
-                                unsigned short *data)
+static int ad714x_i2c_read(struct ad714x_chip *chip,
+                           unsigned short reg, unsigned short *data, size_t len)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        int ret = 0;
-        u8 *_reg = (u8 *)&reg;
-        u8 *_data = (u8 *)data;
-
-        u8 tx[2] = {
-                _reg[1],
-                _reg[0]
-        };
-        u8 rx[2];
-
-        ret = i2c_master_send(client, tx, 2);
-        if (ret >= 0)
-                ret = i2c_master_recv(client, rx, 2);
-
-        if (unlikely(ret < 0)) {
-                dev_err(&client->dev, "I2C read error\n");
-        } else {
-                _data[0] = rx[1];
-                _data[1] = rx[0];
+        struct i2c_client *client = to_i2c_client(chip->dev);
+        int i;
+        int error;
+
+        chip->xfer_buf[0] = cpu_to_be16(reg);
+
+        error = i2c_master_send(client, (u8 *)chip->xfer_buf,
+                                sizeof(*chip->xfer_buf));
+        if (error >= 0)
+                error = i2c_master_recv(client, (u8 *)chip->xfer_buf,
+                                        len * sizeof(*chip->xfer_buf));
+
+        if (unlikely(error < 0)) {
+                dev_err(&client->dev, "I2C read error: %d\n", error);
+                return error;
         }
 
-        return ret;
+        for (i = 0; i < len; i++)
+                data[i] = be16_to_cpu(chip->xfer_buf[i]);
+
+        return 0;
 }
 
 static int __devinit ad714x_i2c_probe(struct i2c_client *client,
diff --git a/drivers/input/misc/ad714x-spi.c b/drivers/input/misc/ad714x-spi.c
index 4120dd549305..875b50811361 100644
--- a/drivers/input/misc/ad714x-spi.c
+++ b/drivers/input/misc/ad714x-spi.c
@@ -1,12 +1,12 @@
 /*
  * AD714X CapTouch Programmable Controller driver (SPI bus)
  *
- * Copyright 2009 Analog Devices Inc.
+ * Copyright 2009-2011 Analog Devices Inc.
  *
  * Licensed under the GPL-2 or later.
  */
 
-#include <linux/input.h>        /* BUS_I2C */
+#include <linux/input.h>        /* BUS_SPI */
 #include <linux/module.h>
 #include <linux/spi/spi.h>
 #include <linux/pm.h>
@@ -30,30 +30,68 @@ static int ad714x_spi_resume(struct device *dev)
 
 static SIMPLE_DEV_PM_OPS(ad714x_spi_pm, ad714x_spi_suspend, ad714x_spi_resume);
 
-static int ad714x_spi_read(struct device *dev, unsigned short reg,
-                unsigned short *data)
+static int ad714x_spi_read(struct ad714x_chip *chip,
+                           unsigned short reg, unsigned short *data, size_t len)
 {
-        struct spi_device *spi = to_spi_device(dev);
-        unsigned short tx = AD714x_SPI_CMD_PREFIX | AD714x_SPI_READ | reg;
+        struct spi_device *spi = to_spi_device(chip->dev);
+        struct spi_message message;
+        struct spi_transfer xfer[2];
+        int i;
+        int error;
+
+        spi_message_init(&message);
+        memset(xfer, 0, sizeof(xfer));
+
+        chip->xfer_buf[0] = cpu_to_be16(AD714x_SPI_CMD_PREFIX |
+                                        AD714x_SPI_READ | reg);
+        xfer[0].tx_buf = &chip->xfer_buf[0];
+        xfer[0].len = sizeof(chip->xfer_buf[0]);
+        spi_message_add_tail(&xfer[0], &message);
+
+        xfer[1].rx_buf = &chip->xfer_buf[1];
+        xfer[1].len = sizeof(chip->xfer_buf[1]) * len;
+        spi_message_add_tail(&xfer[1], &message);
+
+        error = spi_sync(spi, &message);
+        if (unlikely(error)) {
+                dev_err(chip->dev, "SPI read error: %d\n", error);
+                return error;
+        }
+
+        for (i = 0; i < len; i++)
+                data[i] = be16_to_cpu(chip->xfer_buf[i + 1]);
 
-        return spi_write_then_read(spi, (u8 *)&tx, 2, (u8 *)data, 2);
+        return 0;
 }
 
-static int ad714x_spi_write(struct device *dev, unsigned short reg,
-                unsigned short data)
+static int ad714x_spi_write(struct ad714x_chip *chip,
+                            unsigned short reg, unsigned short data)
 {
-        struct spi_device *spi = to_spi_device(dev);
-        unsigned short tx[2] = {
-                AD714x_SPI_CMD_PREFIX | reg,
-                data
-        };
+        struct spi_device *spi = to_spi_device(chip->dev);
+        int error;
+
+        chip->xfer_buf[0] = cpu_to_be16(AD714x_SPI_CMD_PREFIX | reg);
+        chip->xfer_buf[1] = cpu_to_be16(data);
+
+        error = spi_write(spi, (u8 *)chip->xfer_buf,
+                          2 * sizeof(*chip->xfer_buf));
+        if (unlikely(error)) {
+                dev_err(chip->dev, "SPI write error: %d\n", error);
+                return error;
+        }
 
-        return spi_write(spi, (u8 *)tx, 4);
+        return 0;
 }
 
 static int __devinit ad714x_spi_probe(struct spi_device *spi)
 {
         struct ad714x_chip *chip;
+        int err;
+
+        spi->bits_per_word = 8;
+        err = spi_setup(spi);
+        if (err < 0)
+                return err;
 
         chip = ad714x_probe(&spi->dev, BUS_SPI, spi->irq,
                             ad714x_spi_read, ad714x_spi_write);
diff --git a/drivers/input/misc/ad714x.c b/drivers/input/misc/ad714x.c
index c3a62c42cd28..ca42c7d2a3c7 100644
--- a/drivers/input/misc/ad714x.c
+++ b/drivers/input/misc/ad714x.c
@@ -1,7 +1,7 @@
 /*
  * AD714X CapTouch Programmable Controller driver supporting AD7142/3/7/8/7A
  *
- * Copyright 2009 Analog Devices Inc.
+ * Copyright 2009-2011 Analog Devices Inc.
  *
  * Licensed under the GPL-2 or later.
  */
@@ -59,7 +59,6 @@
 #define STAGE11_AMBIENT         0x27D
 
 #define PER_STAGE_REG_NUM      36
-#define STAGE_NUM              12
 #define STAGE_CFGREG_NUM       8
 #define SYS_CFGREG_NUM         8
 
@@ -124,27 +123,6 @@ struct ad714x_driver_data {
  * information to integrate all things which will be private data
  * of spi/i2c device
  */
-struct ad714x_chip {
-        unsigned short h_state;
-        unsigned short l_state;
-        unsigned short c_state;
-        unsigned short adc_reg[STAGE_NUM];
-        unsigned short amb_reg[STAGE_NUM];
-        unsigned short sensor_val[STAGE_NUM];
-
-        struct ad714x_platform_data *hw;
-        struct ad714x_driver_data *sw;
-
-        int irq;
-        struct device *dev;
-        ad714x_read_t read;
-        ad714x_write_t write;
-
-        struct mutex mutex;
-
-        unsigned product;
-        unsigned version;
-};
 
 static void ad714x_use_com_int(struct ad714x_chip *ad714x,
                                 int start_stage, int end_stage)
@@ -154,13 +132,13 @@ static void ad714x_use_com_int(struct ad714x_chip *ad714x,
 
         mask = ((1 << (end_stage + 1)) - 1) - ((1 << start_stage) - 1);
 
-        ad714x->read(ad714x->dev, STG_COM_INT_EN_REG, &data);
+        ad714x->read(ad714x, STG_COM_INT_EN_REG, &data, 1);
         data |= 1 << end_stage;
-        ad714x->write(ad714x->dev, STG_COM_INT_EN_REG, data);
+        ad714x->write(ad714x, STG_COM_INT_EN_REG, data);
 
-        ad714x->read(ad714x->dev, STG_HIGH_INT_EN_REG, &data);
+        ad714x->read(ad714x, STG_HIGH_INT_EN_REG, &data, 1);
         data &= ~mask;
-        ad714x->write(ad714x->dev, STG_HIGH_INT_EN_REG, data);
+        ad714x->write(ad714x, STG_HIGH_INT_EN_REG, data);
 }
 
 static void ad714x_use_thr_int(struct ad714x_chip *ad714x,
@@ -171,13 +149,13 @@ static void ad714x_use_thr_int(struct ad714x_chip *ad714x,
 
         mask = ((1 << (end_stage + 1)) - 1) - ((1 << start_stage) - 1);
 
-        ad714x->read(ad714x->dev, STG_COM_INT_EN_REG, &data);
+        ad714x->read(ad714x, STG_COM_INT_EN_REG, &data, 1);
         data &= ~(1 << end_stage);
-        ad714x->write(ad714x->dev, STG_COM_INT_EN_REG, data);
+        ad714x->write(ad714x, STG_COM_INT_EN_REG, data);
 
-        ad714x->read(ad714x->dev, STG_HIGH_INT_EN_REG, &data);
+        ad714x->read(ad714x, STG_HIGH_INT_EN_REG, &data, 1);
         data |= mask;
-        ad714x->write(ad714x->dev, STG_HIGH_INT_EN_REG, data);
+        ad714x->write(ad714x, STG_HIGH_INT_EN_REG, data);
 }
 
 static int ad714x_cal_highest_stage(struct ad714x_chip *ad714x,
@@ -273,15 +251,16 @@ static void ad714x_slider_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
         struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
         int i;
 
+        ad714x->read(ad714x, CDC_RESULT_S0 + hw->start_stage,
+                        &ad714x->adc_reg[hw->start_stage],
+                        hw->end_stage - hw->start_stage + 1);
+
         for (i = hw->start_stage; i <= hw->end_stage; i++) {
-                ad714x->read(ad714x->dev, CDC_RESULT_S0 + i,
-                        &ad714x->adc_reg[i]);
-                ad714x->read(ad714x->dev,
-                                STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
-                                &ad714x->amb_reg[i]);
-
-                ad714x->sensor_val[i] = abs(ad714x->adc_reg[i] -
-                                ad714x->amb_reg[i]);
+                ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
+                                &ad714x->amb_reg[i], 1);
+
+                ad714x->sensor_val[i] =
+                        abs(ad714x->adc_reg[i] - ad714x->amb_reg[i]);
         }
 }
 
@@ -444,15 +423,16 @@ static void ad714x_wheel_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
         int i;
 
+        ad714x->read(ad714x, CDC_RESULT_S0 + hw->start_stage,
+                        &ad714x->adc_reg[hw->start_stage],
+                        hw->end_stage - hw->start_stage + 1);
+
         for (i = hw->start_stage; i <= hw->end_stage; i++) {
-                ad714x->read(ad714x->dev, CDC_RESULT_S0 + i,
-                        &ad714x->adc_reg[i]);
-                ad714x->read(ad714x->dev,
-                                STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
-                                &ad714x->amb_reg[i]);
+                ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
+                                &ad714x->amb_reg[i], 1);
                 if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
-                        ad714x->sensor_val[i] = ad714x->adc_reg[i] -
-                                ad714x->amb_reg[i];
+                        ad714x->sensor_val[i] =
+                                ad714x->adc_reg[i] - ad714x->amb_reg[i];
                 else
                         ad714x->sensor_val[i] = 0;
         }
@@ -597,15 +577,16 @@ static void touchpad_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
         int i;
 
+        ad714x->read(ad714x, CDC_RESULT_S0 + hw->x_start_stage,
+                        &ad714x->adc_reg[hw->x_start_stage],
+                        hw->x_end_stage - hw->x_start_stage + 1);
+
         for (i = hw->x_start_stage; i <= hw->x_end_stage; i++) {
-                ad714x->read(ad714x->dev, CDC_RESULT_S0 + i,
-                                &ad714x->adc_reg[i]);
-                ad714x->read(ad714x->dev,
-                                STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
-                                &ad714x->amb_reg[i]);
+                ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
+                                &ad714x->amb_reg[i], 1);
                 if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
-                        ad714x->sensor_val[i] = ad714x->adc_reg[i] -
-                                ad714x->amb_reg[i];
+                        ad714x->sensor_val[i] =
+                                ad714x->adc_reg[i] - ad714x->amb_reg[i];
                 else
                         ad714x->sensor_val[i] = 0;
         }
@@ -891,7 +872,7 @@ static int ad714x_hw_detect(struct ad714x_chip *ad714x)
 {
         unsigned short data;
 
-        ad714x->read(ad714x->dev, AD714X_PARTID_REG, &data);
+        ad714x->read(ad714x, AD714X_PARTID_REG, &data, 1);
         switch (data & 0xFFF0) {
         case AD7142_PARTID:
                 ad714x->product = 0x7142;
@@ -940,23 +921,20 @@ static void ad714x_hw_init(struct ad714x_chip *ad714x)
         for (i = 0; i < STAGE_NUM; i++) {
                 reg_base = AD714X_STAGECFG_REG + i * STAGE_CFGREG_NUM;
                 for (j = 0; j < STAGE_CFGREG_NUM; j++)
-                        ad714x->write(ad714x->dev, reg_base + j,
+                        ad714x->write(ad714x, reg_base + j,
                                         ad714x->hw->stage_cfg_reg[i][j]);
         }
 
         for (i = 0; i < SYS_CFGREG_NUM; i++)
-                ad714x->write(ad714x->dev, AD714X_SYSCFG_REG + i,
+                ad714x->write(ad714x, AD714X_SYSCFG_REG + i,
                         ad714x->hw->sys_cfg_reg[i]);
         for (i = 0; i < SYS_CFGREG_NUM; i++)
-                ad714x->read(ad714x->dev, AD714X_SYSCFG_REG + i,
-                        &data);
+                ad714x->read(ad714x, AD714X_SYSCFG_REG + i, &data, 1);
 
-        ad714x->write(ad714x->dev, AD714X_STG_CAL_EN_REG, 0xFFF);
+        ad714x->write(ad714x, AD714X_STG_CAL_EN_REG, 0xFFF);
 
         /* clear all interrupts */
-        ad714x->read(ad714x->dev, STG_LOW_INT_STA_REG, &data);
-        ad714x->read(ad714x->dev, STG_HIGH_INT_STA_REG, &data);
-        ad714x->read(ad714x->dev, STG_COM_INT_STA_REG, &data);
+        ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
 }
 
 static irqreturn_t ad714x_interrupt_thread(int irq, void *data)
@@ -966,9 +944,7 @@ static irqreturn_t ad714x_interrupt_thread(int irq, void *data)
 
         mutex_lock(&ad714x->mutex);
 
-        ad714x->read(ad714x->dev, STG_LOW_INT_STA_REG, &ad714x->l_state);
-        ad714x->read(ad714x->dev, STG_HIGH_INT_STA_REG, &ad714x->h_state);
-        ad714x->read(ad714x->dev, STG_COM_INT_STA_REG, &ad714x->c_state);
+        ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
 
         for (i = 0; i < ad714x->hw->button_num; i++)
                 ad714x_button_state_machine(ad714x, i);
@@ -1245,7 +1221,7 @@ int ad714x_disable(struct ad714x_chip *ad714x)
         mutex_lock(&ad714x->mutex);
 
         data = ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL] | 0x3;
-        ad714x->write(ad714x->dev, AD714X_PWR_CTRL, data);
+        ad714x->write(ad714x, AD714X_PWR_CTRL, data);
 
         mutex_unlock(&ad714x->mutex);
 
@@ -1255,24 +1231,20 @@ EXPORT_SYMBOL(ad714x_disable);
 
 int ad714x_enable(struct ad714x_chip *ad714x)
 {
-        unsigned short data;
-
         dev_dbg(ad714x->dev, "%s enter\n", __func__);
 
         mutex_lock(&ad714x->mutex);
 
         /* resume to non-shutdown mode */
 
-        ad714x->write(ad714x->dev, AD714X_PWR_CTRL,
+        ad714x->write(ad714x, AD714X_PWR_CTRL,
                         ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL]);
 
         /* make sure the interrupt output line is not low level after resume,
          * otherwise we will get no chance to enter falling-edge irq again
          */
 
-        ad714x->read(ad714x->dev, STG_LOW_INT_STA_REG, &data);
-        ad714x->read(ad714x->dev, STG_HIGH_INT_STA_REG, &data);
-        ad714x->read(ad714x->dev, STG_COM_INT_STA_REG, &data);
+        ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
 
         mutex_unlock(&ad714x->mutex);
 
diff --git a/drivers/input/misc/ad714x.h b/drivers/input/misc/ad714x.h
index 45c54fb13f07..3c85455aa66d 100644
--- a/drivers/input/misc/ad714x.h
+++ b/drivers/input/misc/ad714x.h
@@ -1,7 +1,7 @@
 /*
  * AD714X CapTouch Programmable Controller driver (bus interfaces)
  *
- * Copyright 2009 Analog Devices Inc.
+ * Copyright 2009-2011 Analog Devices Inc.
  *
  * Licensed under the GPL-2 or later.
  */
@@ -11,11 +11,40 @@
 
 #include <linux/types.h>
 
+#define STAGE_NUM              12
+
 struct device;
+struct ad714x_platform_data;
+struct ad714x_driver_data;
 struct ad714x_chip;
 
-typedef int (*ad714x_read_t)(struct device *, unsigned short, unsigned short *);
-typedef int (*ad714x_write_t)(struct device *, unsigned short, unsigned short);
+typedef int (*ad714x_read_t)(struct ad714x_chip *, unsigned short, unsigned short *, size_t);
+typedef int (*ad714x_write_t)(struct ad714x_chip *, unsigned short, unsigned short);
+
+struct ad714x_chip {
+        unsigned short l_state;
+        unsigned short h_state;
+        unsigned short c_state;
+        unsigned short adc_reg[STAGE_NUM];
+        unsigned short amb_reg[STAGE_NUM];
+        unsigned short sensor_val[STAGE_NUM];
+
+        struct ad714x_platform_data *hw;
+        struct ad714x_driver_data *sw;
+
+        int irq;
+        struct device *dev;
+        ad714x_read_t read;
+        ad714x_write_t write;
+
+        struct mutex mutex;
+
+        unsigned product;
+        unsigned version;
+
+        __be16 xfer_buf[16] ____cacheline_aligned;
+
+};
 
 int ad714x_disable(struct ad714x_chip *ad714x);
 int ad714x_enable(struct ad714x_chip *ad714x);
diff --git a/drivers/input/misc/cm109.c b/drivers/input/misc/cm109.c
index b09c7d127219..ab860511f016 100644
--- a/drivers/input/misc/cm109.c
+++ b/drivers/input/misc/cm109.c
@@ -475,7 +475,7 @@ static void cm109_toggle_buzzer_sync(struct cm109_dev *dev, int on)
                                 le16_to_cpu(dev->ctl_req->wIndex),
                                 dev->ctl_data,
                                 USB_PKT_LEN, USB_CTRL_SET_TIMEOUT);
-        if (error && error != EINTR)
+        if (error < 0 && error != -EINTR)
                 err("%s: usb_control_msg() failed %d", __func__, error);
 }
 
diff --git a/drivers/input/misc/mma8450.c b/drivers/input/misc/mma8450.c
index 6c76cf792991..0794778295fc 100644
--- a/drivers/input/misc/mma8450.c
+++ b/drivers/input/misc/mma8450.c
@@ -234,7 +234,7 @@ static const struct of_device_id mma8450_dt_ids[] = {
         { .compatible = "fsl,mma8450", },
         { /* sentinel */ }
 };
-MODULE_DEVICE_TABLE(i2c, mma8450_dt_ids);
+MODULE_DEVICE_TABLE(of, mma8450_dt_ids);
 
 static struct i2c_driver mma8450_driver = {
         .driver = {
diff --git a/drivers/input/misc/mpu3050.c b/drivers/input/misc/mpu3050.c
index b95fac15b2ea..f71dc728da58 100644
--- a/drivers/input/misc/mpu3050.c
+++ b/drivers/input/misc/mpu3050.c
@@ -282,7 +282,7 @@ err_free_irq:
 err_pm_set_suspended:
         pm_runtime_set_suspended(&client->dev);
 err_free_mem:
-        input_unregister_device(idev);
+        input_free_device(idev);
         kfree(sensor);
         return error;
 }
diff --git a/drivers/input/mouse/bcm5974.c b/drivers/input/mouse/bcm5974.c
index 3126983c004a..5ec617e28f7e 100644
--- a/drivers/input/mouse/bcm5974.c
+++ b/drivers/input/mouse/bcm5974.c
@@ -67,6 +67,18 @@
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI    0x0245
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_ISO     0x0246
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_JIS     0x0247
+/* MacbookAir4,1 (unibody, July 2011) */
+#define USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI   0x0249
+#define USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO    0x024a
+#define USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS    0x024b
+/* MacbookAir4,2 (unibody, July 2011) */
+#define USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI    0x024c
+#define USB_DEVICE_ID_APPLE_WELLSPRING6_ISO     0x024d
+#define USB_DEVICE_ID_APPLE_WELLSPRING6_JIS     0x024e
+/* Macbook8,2 (unibody) */
+#define USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI   0x0252
+#define USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO    0x0253
+#define USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS    0x0254
 
 #define BCM5974_DEVICE(prod) {                                  \
         .match_flags = (USB_DEVICE_ID_MATCH_DEVICE |            \
@@ -104,6 +116,18 @@ static const struct usb_device_id bcm5974_table[] = {
         BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI),
         BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5_ISO),
         BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5_JIS),
+        /* MacbookAir4,1 */
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS),
+        /* MacbookAir4,2 */
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING6_ISO),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING6_JIS),
+        /* MacbookPro8,2 */
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS),
         /* Terminating entry */
         {}
 };
@@ -294,6 +318,42 @@ static const struct bcm5974_config bcm5974_config_table[] = {
                 { DIM_X, DIM_X / SN_COORD, -4415, 5050 },
                 { DIM_Y, DIM_Y / SN_COORD, -55, 6680 }
         },
+        {
+                USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI,
+                USB_DEVICE_ID_APPLE_WELLSPRING6_ISO,
+                USB_DEVICE_ID_APPLE_WELLSPRING6_JIS,
+                HAS_INTEGRATED_BUTTON,
+                0x84, sizeof(struct bt_data),
+                0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
+                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
+                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
+                { DIM_X, DIM_X / SN_COORD, -4620, 5140 },
+                { DIM_Y, DIM_Y / SN_COORD, -150, 6600 }
+        },
+        {
+                USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI,
+                USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO,
+                USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS,
+                HAS_INTEGRATED_BUTTON,
+                0x84, sizeof(struct bt_data),
+                0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
+                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
+                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
+                { DIM_X, DIM_X / SN_COORD, -4750, 5280 },
+                { DIM_Y, DIM_Y / SN_COORD, -150, 6730 }
+        },
+        {
+                USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI,
+                USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO,
+                USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS,
+                HAS_INTEGRATED_BUTTON,
+                0x84, sizeof(struct bt_data),
+                0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
+                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
+                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
+                { DIM_X, DIM_X / SN_COORD, -4620, 5140 },
+                { DIM_Y, DIM_Y / SN_COORD, -150, 6600 }
+        },
         {}
 };
 
diff --git a/drivers/input/tablet/wacom_sys.c b/drivers/input/tablet/wacom_sys.c
index 449c0a46dbac..958b4eb6369d 100644
--- a/drivers/input/tablet/wacom_sys.c
+++ b/drivers/input/tablet/wacom_sys.c
@@ -49,6 +49,7 @@ struct hid_descriptor {
 #define USB_REQ_GET_REPORT      0x01
 #define USB_REQ_SET_REPORT      0x09
 #define WAC_HID_FEATURE_REPORT  0x03
+#define WAC_MSG_RETRIES         5
 
 static int usb_get_report(struct usb_interface *intf, unsigned char type,
                                 unsigned char id, void *buf, int size)
@@ -165,7 +166,7 @@ static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hi
                         report,
                         hid_desc->wDescriptorLength,
                         5000); /* 5 secs */
-        } while (result < 0 && limit++ < 5);
+        } while (result < 0 && limit++ < WAC_MSG_RETRIES);
 
         /* No need to parse the Descriptor. It isn't an error though */
         if (result < 0)
@@ -228,13 +229,6 @@ static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hi
                                                         get_unaligned_le16(&report[i + 3]);
                                                 i += 4;
                                         }
-                                } else if (usage == WCM_DIGITIZER) {
-                                        /* max pressure isn't reported
-                                        features->pressure_max = (unsigned short)
-                                                        (report[i+4] << 8  | report[i + 3]);
-                                        */
-                                        features->pressure_max = 255;
-                                        i += 4;
                                 }
                                 break;
 
@@ -290,13 +284,6 @@ static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hi
                                 pen = 1;
                                 i++;
                                 break;
-
-                        case HID_USAGE_UNDEFINED:
-                                if (usage == WCM_DESKTOP && finger) /* capacity */
-                                        features->pressure_max =
-                                                get_unaligned_le16(&report[i + 3]);
-                                i += 4;
-                                break;
                         }
                         break;
 
@@ -319,24 +306,26 @@ static int wacom_query_tablet_data(struct usb_interface *intf, struct wacom_feat
         int limit = 0, report_id = 2;
         int error = -ENOMEM;
 
-        rep_data = kmalloc(2, GFP_KERNEL);
+        rep_data = kmalloc(4, GFP_KERNEL);
         if (!rep_data)
                 return error;
 
-        /* ask to report tablet data if it is 2FGT Tablet PC or
+        /* ask to report tablet data if it is MT Tablet PC or
          * not a Tablet PC */
         if (features->type == TABLETPC2FG) {
                 do {
                         rep_data[0] = 3;
                         rep_data[1] = 4;
+                        rep_data[2] = 0;
+                        rep_data[3] = 0;
                         report_id = 3;
                         error = usb_set_report(intf, WAC_HID_FEATURE_REPORT,
-                                report_id, rep_data, 2);
+                                report_id, rep_data, 4);
                         if (error >= 0)
                                 error = usb_get_report(intf,
                                         WAC_HID_FEATURE_REPORT, report_id,
-                                        rep_data, 3);
-                } while ((error < 0 || rep_data[1] != 4) && limit++ < 5);
+                                        rep_data, 4);
+                } while ((error < 0 || rep_data[1] != 4) && limit++ < WAC_MSG_RETRIES);
         } else if (features->type != TABLETPC) {
                 do {
                         rep_data[0] = 2;
@@ -347,7 +336,7 @@ static int wacom_query_tablet_data(struct usb_interface *intf, struct wacom_feat
                                 error = usb_get_report(intf,
                                         WAC_HID_FEATURE_REPORT, report_id,
                                         rep_data, 2);
-                } while ((error < 0 || rep_data[1] != 2) && limit++ < 5);
+                } while ((error < 0 || rep_data[1] != 2) && limit++ < WAC_MSG_RETRIES);
         }
 
         kfree(rep_data);
diff --git a/drivers/input/tablet/wacom_wac.c b/drivers/input/tablet/wacom_wac.c
index 03ebcc8b24b5..0dc97ec15c28 100644
--- a/drivers/input/tablet/wacom_wac.c
+++ b/drivers/input/tablet/wacom_wac.c
@@ -800,25 +800,26 @@ static int wacom_bpt_touch(struct wacom_wac *wacom)
         int i;
 
         for (i = 0; i < 2; i++) {
-                int p = data[9 * i + 2];
-                bool touch = p && !wacom->shared->stylus_in_proximity;
+                int offset = (data[1] & 0x80) ? (8 * i) : (9 * i);
+                bool touch = data[offset + 3] & 0x80;
 
-                input_mt_slot(input, i);
-                input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
                 /*
                  * Touch events need to be disabled while stylus is
                  * in proximity because user's hand is resting on touchpad
                  * and sending unwanted events.  User expects tablet buttons
                  * to continue working though.
                  */
+                touch = touch && !wacom->shared->stylus_in_proximity;
+
+                input_mt_slot(input, i);
+                input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
                 if (touch) {
-                        int x = get_unaligned_be16(&data[9 * i + 3]) & 0x7ff;
-                        int y = get_unaligned_be16(&data[9 * i + 5]) & 0x7ff;
+                        int x = get_unaligned_be16(&data[offset + 3]) & 0x7ff;
+                        int y = get_unaligned_be16(&data[offset + 5]) & 0x7ff;
                         if (features->quirks & WACOM_QUIRK_BBTOUCH_LOWRES) {
                                 x <<= 5;
                                 y <<= 5;
                         }
-                        input_report_abs(input, ABS_MT_PRESSURE, p);
                         input_report_abs(input, ABS_MT_POSITION_X, x);
                         input_report_abs(input, ABS_MT_POSITION_Y, y);
                 }
@@ -1056,10 +1057,11 @@ void wacom_setup_input_capabilities(struct input_dev *input_dev,
                              features->x_fuzz, 0);
         input_set_abs_params(input_dev, ABS_Y, 0, features->y_max,
                              features->y_fuzz, 0);
-        input_set_abs_params(input_dev, ABS_PRESSURE, 0, features->pressure_max,
-                             features->pressure_fuzz, 0);
 
         if (features->device_type == BTN_TOOL_PEN) {
+                input_set_abs_params(input_dev, ABS_PRESSURE, 0, features->pressure_max,
+                             features->pressure_fuzz, 0);
+
                 /* penabled devices have fixed resolution for each model */
                 input_abs_set_res(input_dev, ABS_X, features->x_resolution);
                 input_abs_set_res(input_dev, ABS_Y, features->y_resolution);
@@ -1098,6 +1100,8 @@ void wacom_setup_input_capabilities(struct input_dev *input_dev,
                 __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
                 __set_bit(BTN_STYLUS, input_dev->keybit);
                 __set_bit(BTN_STYLUS2, input_dev->keybit);
+
+                __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
                 break;
 
         case WACOM_21UX2:
@@ -1126,6 +1130,9 @@ void wacom_setup_input_capabilities(struct input_dev *input_dev,
                 }
 
                 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
+
+                __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
+
                 wacom_setup_cintiq(wacom_wac);
                 break;
 
@@ -1150,6 +1157,8 @@ void wacom_setup_input_capabilities(struct input_dev *input_dev,
                 /* fall through */
 
         case INTUOS:
+                __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
+
                 wacom_setup_intuos(wacom_wac);
                 break;
 
@@ -1165,6 +1174,8 @@ void wacom_setup_input_capabilities(struct input_dev *input_dev,
 
                 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
                 wacom_setup_intuos(wacom_wac);
+
+                __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
                 break;
 
         case TABLETPC2FG:
@@ -1183,26 +1194,40 @@ void wacom_setup_input_capabilities(struct input_dev *input_dev,
         case TABLETPC:
                 __clear_bit(ABS_MISC, input_dev->absbit);
 
+                __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
+
                 if (features->device_type != BTN_TOOL_PEN)
                         break;  /* no need to process stylus stuff */
 
                 /* fall through */
 
         case PL:
-        case PTU:
         case DTU:
                 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
+                __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
                 __set_bit(BTN_STYLUS, input_dev->keybit);
                 __set_bit(BTN_STYLUS2, input_dev->keybit);
+
+                __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
+                break;
+
+        case PTU:
+                __set_bit(BTN_STYLUS2, input_dev->keybit);
                 /* fall through */
 
         case PENPARTNER:
+                __set_bit(BTN_TOOL_PEN, input_dev->keybit);
                 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
+                __set_bit(BTN_STYLUS, input_dev->keybit);
+
+                __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
                 break;
 
         case BAMBOO_PT:
                 __clear_bit(ABS_MISC, input_dev->absbit);
 
+                __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
+
                 if (features->device_type == BTN_TOOL_DOUBLETAP) {
                         __set_bit(BTN_LEFT, input_dev->keybit);
                         __set_bit(BTN_FORWARD, input_dev->keybit);
@@ -1460,6 +1485,9 @@ static const struct wacom_features wacom_features_0xD3 =
 static const struct wacom_features wacom_features_0xD4 =
         { "Wacom Bamboo Pen",     WACOM_PKGLEN_BBFUN,     14720,  9200, 1023,
           63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static const struct wacom_features wacom_features_0xD5 =
+        { "Wacom Bamboo Pen 6x8",     WACOM_PKGLEN_BBFUN, 21648, 13530, 1023,
+          63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0xD6 =
         { "Wacom BambooPT 2FG 4x5", WACOM_PKGLEN_BBFUN,   14720,  9200, 1023,
           63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
@@ -1564,6 +1592,7 @@ const struct usb_device_id wacom_ids[] = {
         { USB_DEVICE_WACOM(0xD2) },
         { USB_DEVICE_WACOM(0xD3) },
         { USB_DEVICE_WACOM(0xD4) },
+        { USB_DEVICE_WACOM(0xD5) },
         { USB_DEVICE_WACOM(0xD6) },
         { USB_DEVICE_WACOM(0xD7) },
         { USB_DEVICE_WACOM(0xD8) },
diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
index ae00604a6a81..f5d66859f232 100644
--- a/drivers/input/touchscreen/atmel_mxt_ts.c
+++ b/drivers/input/touchscreen/atmel_mxt_ts.c
@@ -244,6 +244,7 @@ struct mxt_finger {
         int x;
         int y;
         int area;
+        int pressure;
 };
 
 /* Each client has this additional data */
@@ -536,6 +537,8 @@ static void mxt_input_report(struct mxt_data *data, int single_id)
                                         finger[id].x);
                         input_report_abs(input_dev, ABS_MT_POSITION_Y,
                                         finger[id].y);
+                        input_report_abs(input_dev, ABS_MT_PRESSURE,
+                                        finger[id].pressure);
                 } else {
                         finger[id].status = 0;
                 }
@@ -546,6 +549,8 @@ static void mxt_input_report(struct mxt_data *data, int single_id)
         if (status != MXT_RELEASE) {
                 input_report_abs(input_dev, ABS_X, finger[single_id].x);
                 input_report_abs(input_dev, ABS_Y, finger[single_id].y);
+                input_report_abs(input_dev,
+                                 ABS_PRESSURE, finger[single_id].pressure);
         }
 
         input_sync(input_dev);
@@ -560,6 +565,7 @@ static void mxt_input_touchevent(struct mxt_data *data,
         int x;
         int y;
         int area;
+        int pressure;
 
         /* Check the touch is present on the screen */
         if (!(status & MXT_DETECT)) {
@@ -584,6 +590,7 @@ static void mxt_input_touchevent(struct mxt_data *data,
                 y = y >> 2;
 
         area = message->message[4];
+        pressure = message->message[5];
 
         dev_dbg(dev, "[%d] %s x: %d, y: %d, area: %d\n", id,
                 status & MXT_MOVE ? "moved" : "pressed",
@@ -594,6 +601,7 @@ static void mxt_input_touchevent(struct mxt_data *data,
         finger[id].x = x;
         finger[id].y = y;
         finger[id].area = area;
+        finger[id].pressure = pressure;
 
         mxt_input_report(data, id);
 }
@@ -1116,6 +1124,8 @@ static int __devinit mxt_probe(struct i2c_client *client,
                              0, data->max_x, 0, 0);
         input_set_abs_params(input_dev, ABS_Y,
                              0, data->max_y, 0, 0);
+        input_set_abs_params(input_dev, ABS_PRESSURE,
+                             0, 255, 0, 0);
 
         /* For multi touch */
         input_mt_init_slots(input_dev, MXT_MAX_FINGER);
@@ -1125,6 +1135,8 @@ static int __devinit mxt_probe(struct i2c_client *client,
                              0, data->max_x, 0, 0);
         input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
                              0, data->max_y, 0, 0);
+        input_set_abs_params(input_dev, ABS_MT_PRESSURE,
+                             0, 255, 0, 0);
 
         input_set_drvdata(input_dev, data);
         i2c_set_clientdata(client, data);
diff --git a/drivers/input/touchscreen/max11801_ts.c b/drivers/input/touchscreen/max11801_ts.c
index 4f2713d92791..4627fe55b401 100644
--- a/drivers/input/touchscreen/max11801_ts.c
+++ b/drivers/input/touchscreen/max11801_ts.c
@@ -9,7 +9,8 @@
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License.
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
  */
 
 /*
diff --git a/drivers/input/touchscreen/tnetv107x-ts.c b/drivers/input/touchscreen/tnetv107x-ts.c
index 089b0a0f3d8c..0e8f63e5b36f 100644
--- a/drivers/input/touchscreen/tnetv107x-ts.c
+++ b/drivers/input/touchscreen/tnetv107x-ts.c
@@ -13,6 +13,7 @@
  * GNU General Public License for more details.
  */
 
+#include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/err.h>
 #include <linux/errno.h>
diff --git a/drivers/input/touchscreen/wacom_w8001.c b/drivers/input/touchscreen/wacom_w8001.c
index c14412ef4648..9941d39df43d 100644
--- a/drivers/input/touchscreen/wacom_w8001.c
+++ b/drivers/input/touchscreen/wacom_w8001.c
@@ -383,6 +383,8 @@ static int w8001_setup(struct w8001 *w8001)
         dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
         strlcat(w8001->name, "Wacom Serial", sizeof(w8001->name));
 
+        __set_bit(INPUT_PROP_DIRECT, dev->propbit);
+
         /* penabled? */
         error = w8001_command(w8001, W8001_CMD_QUERY, true);
         if (!error) {
diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c
index a14f8dc23462..0e4227f457af 100644
--- a/drivers/iommu/amd_iommu.c
+++ b/drivers/iommu/amd_iommu.c
@@ -605,7 +605,9 @@ static void build_inv_all(struct iommu_cmd *cmd)
  * Writes the command to the IOMMUs command buffer and informs the
  * hardware about the new command.
  */
-static int iommu_queue_command(struct amd_iommu *iommu, struct iommu_cmd *cmd)
+static int iommu_queue_command_sync(struct amd_iommu *iommu,
+                                    struct iommu_cmd *cmd,
+                                    bool sync)
 {
         u32 left, tail, head, next_tail;
         unsigned long flags;
@@ -639,13 +641,18 @@ again:
         copy_cmd_to_buffer(iommu, cmd, tail);
 
         /* We need to sync now to make sure all commands are processed */
-        iommu->need_sync = true;
+        iommu->need_sync = sync;
 
         spin_unlock_irqrestore(&iommu->lock, flags);
 
         return 0;
 }
 
+static int iommu_queue_command(struct amd_iommu *iommu, struct iommu_cmd *cmd)
+{
+        return iommu_queue_command_sync(iommu, cmd, true);
+}
+
 /*
  * This function queues a completion wait command into the command
  * buffer of an IOMMU
@@ -661,7 +668,7 @@ static int iommu_completion_wait(struct amd_iommu *iommu)
 
         build_completion_wait(&cmd, (u64)&sem);
 
-        ret = iommu_queue_command(iommu, &cmd);
+        ret = iommu_queue_command_sync(iommu, &cmd, false);
         if (ret)
                 return ret;
 
@@ -840,14 +847,9 @@ static void domain_flush_complete(struct protection_domain *domain)
 static void domain_flush_devices(struct protection_domain *domain)
 {
         struct iommu_dev_data *dev_data;
-        unsigned long flags;
-
-        spin_lock_irqsave(&domain->lock, flags);
 
         list_for_each_entry(dev_data, &domain->dev_list, list)
                 device_flush_dte(dev_data);
-
-        spin_unlock_irqrestore(&domain->lock, flags);
 }
 
 /****************************************************************************
diff --git a/drivers/iommu/dmar.c b/drivers/iommu/dmar.c
index 3dc9befa5aec..6dcc7e2d54de 100644
--- a/drivers/iommu/dmar.c
+++ b/drivers/iommu/dmar.c
@@ -1388,7 +1388,7 @@ int dmar_set_interrupt(struct intel_iommu *iommu)
                 return ret;
         }
 
-        ret = request_irq(irq, dmar_fault, 0, iommu->name, iommu);
+        ret = request_irq(irq, dmar_fault, IRQF_NO_THREAD, iommu->name, iommu);
         if (ret)
                 printk(KERN_ERR "IOMMU: can't request irq\n");
         return ret;
diff --git a/drivers/leds/leds-ams-delta.c b/drivers/leds/leds-ams-delta.c
index b9826032450b..8c00937bf7e7 100644
--- a/drivers/leds/leds-ams-delta.c
+++ b/drivers/leds/leds-ams-delta.c
@@ -8,6 +8,7 @@
  * published by the Free Software Foundation.
  */
 
+#include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/platform_device.h>
diff --git a/drivers/leds/leds-bd2802.c b/drivers/leds/leds-bd2802.c
index 3ebe3824662d..ea2185531f82 100644
--- a/drivers/leds/leds-bd2802.c
+++ b/drivers/leds/leds-bd2802.c
@@ -662,6 +662,11 @@ failed_unregister_led1_R:
 static void bd2802_unregister_led_classdev(struct bd2802_led *led)
 {
         cancel_work_sync(&led->work);
+        led_classdev_unregister(&led->cdev_led2b);
+        led_classdev_unregister(&led->cdev_led2g);
+        led_classdev_unregister(&led->cdev_led2r);
+        led_classdev_unregister(&led->cdev_led1b);
+        led_classdev_unregister(&led->cdev_led1g);
         led_classdev_unregister(&led->cdev_led1r);
 }
 
diff --git a/drivers/leds/leds-hp6xx.c b/drivers/leds/leds-hp6xx.c
index e4ce1fd46338..bcfbd3a60eab 100644
--- a/drivers/leds/leds-hp6xx.c
+++ b/drivers/leds/leds-hp6xx.c
@@ -10,6 +10,7 @@
  * published by the Free Software Foundation.
  */
 
+#include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/platform_device.h>
diff --git a/drivers/leds/ledtrig-timer.c b/drivers/leds/ledtrig-timer.c
index d87c9d02f786..328c64c0841c 100644
--- a/drivers/leds/ledtrig-timer.c
+++ b/drivers/leds/ledtrig-timer.c
@@ -41,6 +41,7 @@ static ssize_t led_delay_on_store(struct device *dev,
 
         if (count == size) {
                 led_blink_set(led_cdev, &state, &led_cdev->blink_delay_off);
+                led_cdev->blink_delay_on = state;
                 ret = count;
         }
 
@@ -69,6 +70,7 @@ static ssize_t led_delay_off_store(struct device *dev,
 
         if (count == size) {
                 led_blink_set(led_cdev, &led_cdev->blink_delay_on, &state);
+                led_cdev->blink_delay_off = state;
                 ret = count;
         }
 
diff --git a/drivers/md/linear.h b/drivers/md/linear.h
index 0ce29b61605a..2f2da05b2ce9 100644
--- a/drivers/md/linear.h
+++ b/drivers/md/linear.h
@@ -10,9 +10,9 @@ typedef struct dev_info dev_info_t;
 
 struct linear_private_data
 {
+        struct rcu_head         rcu;
         sector_t                array_sectors;
         dev_info_t              disks[0];
-        struct rcu_head         rcu;
 };
 
 
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 8e221a20f5d9..5404b2295820 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -848,7 +848,7 @@ void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
         bio->bi_end_io = super_written;
 
         atomic_inc(&mddev->pending_writes);
-        submit_bio(REQ_WRITE | REQ_SYNC | REQ_FLUSH | REQ_FUA, bio);
+        submit_bio(WRITE_FLUSH_FUA, bio);
 }
 
 void md_super_wait(mddev_t *mddev)
@@ -1138,8 +1138,11 @@ static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version
                         ret = 0;
         }
         rdev->sectors = rdev->sb_start;
+        /* Limit to 4TB as metadata cannot record more than that */
+        if (rdev->sectors >= (2ULL << 32))
+                rdev->sectors = (2ULL << 32) - 2;
 
-        if (rdev->sectors < sb->size * 2 && sb->level > 1)
+        if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
                 /* "this cannot possibly happen" ... */
                 ret = -EINVAL;
 
@@ -1173,7 +1176,7 @@ static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
                 mddev->clevel[0] = 0;
                 mddev->layout = sb->layout;
                 mddev->raid_disks = sb->raid_disks;
-                mddev->dev_sectors = sb->size * 2;
+                mddev->dev_sectors = ((sector_t)sb->size) * 2;
                 mddev->events = ev1;
                 mddev->bitmap_info.offset = 0;
                 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
@@ -1415,6 +1418,11 @@ super_90_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors)
         rdev->sb_start = calc_dev_sboffset(rdev);
         if (!num_sectors || num_sectors > rdev->sb_start)
                 num_sectors = rdev->sb_start;
+        /* Limit to 4TB as metadata cannot record more than that.
+         * 4TB == 2^32 KB, or 2*2^32 sectors.
+         */
+        if (num_sectors >= (2ULL << 32))
+                num_sectors = (2ULL << 32) - 2;
         md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
                        rdev->sb_page);
         md_super_wait(rdev->mddev);
@@ -1738,6 +1746,11 @@ static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
         sb->level = cpu_to_le32(mddev->level);
         sb->layout = cpu_to_le32(mddev->layout);
 
+        if (test_bit(WriteMostly, &rdev->flags))
+                sb->devflags |= WriteMostly1;
+        else
+                sb->devflags &= ~WriteMostly1;
+
         if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
                 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
                 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
@@ -2561,7 +2574,10 @@ state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
         int err = -EINVAL;
         if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
                 md_error(rdev->mddev, rdev);
-                err = 0;
+                if (test_bit(Faulty, &rdev->flags))
+                        err = 0;
+                else
+                        err = -EBUSY;
         } else if (cmd_match(buf, "remove")) {
                 if (rdev->raid_disk >= 0)
                         err = -EBUSY;
@@ -2584,7 +2600,7 @@ state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                 err = 0;
         } else if (cmd_match(buf, "-blocked")) {
                 if (!test_bit(Faulty, &rdev->flags) &&
-                    test_bit(BlockedBadBlocks, &rdev->flags)) {
+                    rdev->badblocks.unacked_exist) {
                         /* metadata handler doesn't understand badblocks,
                          * so we need to fail the device
                          */
@@ -5983,6 +5999,8 @@ static int set_disk_faulty(mddev_t *mddev, dev_t dev)
                 return -ENODEV;
 
         md_error(mddev, rdev);
+        if (!test_bit(Faulty, &rdev->flags))
+                return -EBUSY;
         return 0;
 }
 
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 32323f0afd89..f4622dd8fc59 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1099,12 +1099,11 @@ read_again:
                 bio_list_add(&conf->pending_bio_list, mbio);
                 spin_unlock_irqrestore(&conf->device_lock, flags);
         }
-        r1_bio_write_done(r1_bio);
-
-        /* In case raid1d snuck in to freeze_array */
-        wake_up(&conf->wait_barrier);
-
+        /* Mustn't call r1_bio_write_done before this next test,
+         * as it could result in the bio being freed.
+         */
         if (sectors_handled < (bio->bi_size >> 9)) {
+                r1_bio_write_done(r1_bio);
                 /* We need another r1_bio.  It has already been counted
                  * in bio->bi_phys_segments
                  */
@@ -1117,6 +1116,11 @@ read_again:
                 goto retry_write;
         }
 
+        r1_bio_write_done(r1_bio);
+
+        /* In case raid1d snuck in to freeze_array */
+        wake_up(&conf->wait_barrier);
+
         if (do_sync || !bitmap || !plugged)
                 md_wakeup_thread(mddev->thread);
 
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 8b29cd4f01c8..d7a8468ddeab 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -337,6 +337,21 @@ static void close_write(r10bio_t *r10_bio)
         md_write_end(r10_bio->mddev);
 }
 
+static void one_write_done(r10bio_t *r10_bio)
+{
+        if (atomic_dec_and_test(&r10_bio->remaining)) {
+                if (test_bit(R10BIO_WriteError, &r10_bio->state))
+                        reschedule_retry(r10_bio);
+                else {
+                        close_write(r10_bio);
+                        if (test_bit(R10BIO_MadeGood, &r10_bio->state))
+                                reschedule_retry(r10_bio);
+                        else
+                                raid_end_bio_io(r10_bio);
+                }
+        }
+}
+
 static void raid10_end_write_request(struct bio *bio, int error)
 {
         int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
@@ -387,17 +402,7 @@ static void raid10_end_write_request(struct bio *bio, int error)
          * Let's see if all mirrored write operations have finished
          * already.
          */
-        if (atomic_dec_and_test(&r10_bio->remaining)) {
-                if (test_bit(R10BIO_WriteError, &r10_bio->state))
-                        reschedule_retry(r10_bio);
-                else {
-                        close_write(r10_bio);
-                        if (test_bit(R10BIO_MadeGood, &r10_bio->state))
-                                reschedule_retry(r10_bio);
-                        else
-                                raid_end_bio_io(r10_bio);
-                }
-        }
+        one_write_done(r10_bio);
         if (dec_rdev)
                 rdev_dec_pending(conf->mirrors[dev].rdev, conf->mddev);
 }
@@ -1127,20 +1132,12 @@ retry_write:
                 spin_unlock_irqrestore(&conf->device_lock, flags);
         }
 
-        if (atomic_dec_and_test(&r10_bio->remaining)) {
-                /* This matches the end of raid10_end_write_request() */
-                bitmap_endwrite(r10_bio->mddev->bitmap, r10_bio->sector,
-                                r10_bio->sectors,
-                                !test_bit(R10BIO_Degraded, &r10_bio->state),
-                                0);
-                md_write_end(mddev);
-                raid_end_bio_io(r10_bio);
-        }
-
-        /* In case raid10d snuck in to freeze_array */
-        wake_up(&conf->wait_barrier);
+        /* Don't remove the bias on 'remaining' (one_write_done) until
+         * after checking if we need to go around again.
+         */
 
         if (sectors_handled < (bio->bi_size >> 9)) {
+                one_write_done(r10_bio);
                 /* We need another r10_bio.  It has already been counted
                  * in bio->bi_phys_segments.
                  */
@@ -1154,6 +1151,10 @@ retry_write:
                 r10_bio->state = 0;
                 goto retry_write;
         }
+        one_write_done(r10_bio);
+
+        /* In case raid10d snuck in to freeze_array */
+        wake_up(&conf->wait_barrier);
 
         if (do_sync || !mddev->bitmap || !plugged)
                 md_wakeup_thread(mddev->thread);
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index dbae459fb02d..43709fa6b6df 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -3336,7 +3336,7 @@ static void handle_stripe(struct stripe_head *sh)
 
 finish:
         /* wait for this device to become unblocked */
-        if (unlikely(s.blocked_rdev))
+        if (conf->mddev->external && unlikely(s.blocked_rdev))
                 md_wait_for_blocked_rdev(s.blocked_rdev, conf->mddev);
 
         if (s.handle_bad_blocks)
diff --git a/drivers/media/dvb/dvb-usb/vp7045.c b/drivers/media/dvb/dvb-usb/vp7045.c
index 3db89e3cb0bb..536c16c943bd 100644
--- a/drivers/media/dvb/dvb-usb/vp7045.c
+++ b/drivers/media/dvb/dvb-usb/vp7045.c
@@ -224,26 +224,8 @@ static struct dvb_usb_device_properties vp7045_properties;
 static int vp7045_usb_probe(struct usb_interface *intf,
                 const struct usb_device_id *id)
 {
-        struct dvb_usb_device *d;
-        int ret = dvb_usb_device_init(intf, &vp7045_properties,
-                                   THIS_MODULE, &d, adapter_nr);
-        if (ret)
-                return ret;
-
-        d->priv = kmalloc(20, GFP_KERNEL);
-        if (!d->priv) {
-                dvb_usb_device_exit(intf);
-                return -ENOMEM;
-        }
-
-        return ret;
-}
-
-static void vp7045_usb_disconnect(struct usb_interface *intf)
-{
-        struct dvb_usb_device *d = usb_get_intfdata(intf);
-        kfree(d->priv);
-        dvb_usb_device_exit(intf);
+        return dvb_usb_device_init(intf, &vp7045_properties,
+                                   THIS_MODULE, NULL, adapter_nr);
 }
 
 static struct usb_device_id vp7045_usb_table [] = {
@@ -258,7 +240,7 @@ MODULE_DEVICE_TABLE(usb, vp7045_usb_table);
 static struct dvb_usb_device_properties vp7045_properties = {
         .usb_ctrl = CYPRESS_FX2,
         .firmware = "dvb-usb-vp7045-01.fw",
-        .size_of_priv = sizeof(u8 *),
+        .size_of_priv = 20,
 
         .num_adapters = 1,
         .adapter = {
@@ -305,7 +287,7 @@ static struct dvb_usb_device_properties vp7045_properties = {
 static struct usb_driver vp7045_usb_driver = {
         .name           = "dvb_usb_vp7045",
         .probe          = vp7045_usb_probe,
-        .disconnect     = vp7045_usb_disconnect,
+        .disconnect     = dvb_usb_device_exit,
         .id_table       = vp7045_usb_table,
 };
 
diff --git a/drivers/media/rc/nuvoton-cir.c b/drivers/media/rc/nuvoton-cir.c
index eae05b500476..144f3f55d765 100644
--- a/drivers/media/rc/nuvoton-cir.c
+++ b/drivers/media/rc/nuvoton-cir.c
@@ -618,7 +618,6 @@ static void nvt_dump_rx_buf(struct nvt_dev *nvt)
 static void nvt_process_rx_ir_data(struct nvt_dev *nvt)
 {
         DEFINE_IR_RAW_EVENT(rawir);
-        unsigned int count;
         u32 carrier;
         u8 sample;
         int i;
@@ -631,65 +630,38 @@ static void nvt_process_rx_ir_data(struct nvt_dev *nvt)
         if (nvt->carrier_detect_enabled)
                 carrier = nvt_rx_carrier_detect(nvt);
 
-        count = nvt->pkts;
-        nvt_dbg_verbose("Processing buffer of len %d", count);
+        nvt_dbg_verbose("Processing buffer of len %d", nvt->pkts);
 
         init_ir_raw_event(&rawir);
 
-        for (i = 0; i < count; i++) {
-                nvt->pkts--;
+        for (i = 0; i < nvt->pkts; i++) {
                 sample = nvt->buf[i];
 
                 rawir.pulse = ((sample & BUF_PULSE_BIT) != 0);
                 rawir.duration = US_TO_NS((sample & BUF_LEN_MASK)
                                           * SAMPLE_PERIOD);
 
-                if ((sample & BUF_LEN_MASK) == BUF_LEN_MASK) {
-                        if (nvt->rawir.pulse == rawir.pulse)
-                                nvt->rawir.duration += rawir.duration;
-                        else {
-                                nvt->rawir.duration = rawir.duration;
-                                nvt->rawir.pulse = rawir.pulse;
-                        }
-                        continue;
-                }
-
-                rawir.duration += nvt->rawir.duration;
+                nvt_dbg("Storing %s with duration %d",
+                        rawir.pulse ? "pulse" : "space", rawir.duration);
 
-                init_ir_raw_event(&nvt->rawir);
-                nvt->rawir.duration = 0;
-                nvt->rawir.pulse = rawir.pulse;
-
-                if (sample == BUF_PULSE_BIT)
-                        rawir.pulse = false;
-
-                if (rawir.duration) {
-                        nvt_dbg("Storing %s with duration %d",
-                                rawir.pulse ? "pulse" : "space",
-                                rawir.duration);
-
-                        ir_raw_event_store_with_filter(nvt->rdev, &rawir);
-                }
+                ir_raw_event_store_with_filter(nvt->rdev, &rawir);
 
                 /*
                  * BUF_PULSE_BIT indicates end of IR data, BUF_REPEAT_BYTE
                  * indicates end of IR signal, but new data incoming. In both
                  * cases, it means we're ready to call ir_raw_event_handle
                  */
-                if ((sample == BUF_PULSE_BIT) && nvt->pkts) {
+                if ((sample == BUF_PULSE_BIT) && (i + 1 < nvt->pkts)) {
                         nvt_dbg("Calling ir_raw_event_handle (signal end)\n");
                         ir_raw_event_handle(nvt->rdev);
                 }
         }
 
+        nvt->pkts = 0;
+
         nvt_dbg("Calling ir_raw_event_handle (buffer empty)\n");
         ir_raw_event_handle(nvt->rdev);
 
-        if (nvt->pkts) {
-                nvt_dbg("Odd, pkts should be 0 now... (its %u)", nvt->pkts);
-                nvt->pkts = 0;
-        }
-
         nvt_dbg_verbose("%s done", __func__);
 }
 
@@ -1048,7 +1020,6 @@ static int nvt_probe(struct pnp_dev *pdev, const struct pnp_device_id *dev_id)
 
         spin_lock_init(&nvt->nvt_lock);
         spin_lock_init(&nvt->tx.lock);
-        init_ir_raw_event(&nvt->rawir);
 
         ret = -EBUSY;
         /* now claim resources */
diff --git a/drivers/media/rc/nuvoton-cir.h b/drivers/media/rc/nuvoton-cir.h
index 1241fc89a36c..0d5e0872a2ea 100644
--- a/drivers/media/rc/nuvoton-cir.h
+++ b/drivers/media/rc/nuvoton-cir.h
@@ -67,7 +67,6 @@ static int debug;
 struct nvt_dev {
         struct pnp_dev *pdev;
         struct rc_dev *rdev;
-        struct ir_raw_event rawir;
 
         spinlock_t nvt_lock;
 
diff --git a/drivers/media/video/gspca/ov519.c b/drivers/media/video/gspca/ov519.c
index 0800433b2092..18305c89083c 100644
--- a/drivers/media/video/gspca/ov519.c
+++ b/drivers/media/video/gspca/ov519.c
@@ -2858,7 +2858,6 @@ static void ov7xx0_configure(struct sd *sd)
                         case 0x60:
                                 PDEBUG(D_PROBE, "Sensor is a OV7660");
                                 sd->sensor = SEN_OV7660;
-                                sd->invert_led = 0;
                                 break;
                         default:
                                 PDEBUG(D_PROBE, "Unknown sensor: 0x76%x", low);
@@ -3337,7 +3336,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
         case BRIDGE_OV519:
                 cam->cam_mode = ov519_vga_mode;
                 cam->nmodes = ARRAY_SIZE(ov519_vga_mode);
-                sd->invert_led = !sd->invert_led;
                 break;
         case BRIDGE_OVFX2:
                 cam->cam_mode = ov519_vga_mode;
@@ -5005,24 +5003,24 @@ static const struct sd_desc sd_desc = {
 /* -- module initialisation -- */
 static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x041e, 0x4003), .driver_info = BRIDGE_W9968CF },
-        {USB_DEVICE(0x041e, 0x4052), .driver_info = BRIDGE_OV519 },
-        {USB_DEVICE(0x041e, 0x405f),
+        {USB_DEVICE(0x041e, 0x4052),
                 .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
+        {USB_DEVICE(0x041e, 0x405f), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x041e, 0x4060), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x041e, 0x4061), .driver_info = BRIDGE_OV519 },
-        {USB_DEVICE(0x041e, 0x4064),
-                .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
+        {USB_DEVICE(0x041e, 0x4064), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x041e, 0x4067), .driver_info = BRIDGE_OV519 },
-        {USB_DEVICE(0x041e, 0x4068),
+        {USB_DEVICE(0x041e, 0x4068), .driver_info = BRIDGE_OV519 },
+        {USB_DEVICE(0x045e, 0x028c),
                 .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
-        {USB_DEVICE(0x045e, 0x028c), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x054c, 0x0154), .driver_info = BRIDGE_OV519 },
-        {USB_DEVICE(0x054c, 0x0155),
-                .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
+        {USB_DEVICE(0x054c, 0x0155), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x05a9, 0x0511), .driver_info = BRIDGE_OV511 },
         {USB_DEVICE(0x05a9, 0x0518), .driver_info = BRIDGE_OV518 },
-        {USB_DEVICE(0x05a9, 0x0519), .driver_info = BRIDGE_OV519 },
-        {USB_DEVICE(0x05a9, 0x0530), .driver_info = BRIDGE_OV519 },
+        {USB_DEVICE(0x05a9, 0x0519),
+                .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
+        {USB_DEVICE(0x05a9, 0x0530),
+                .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
         {USB_DEVICE(0x05a9, 0x2800), .driver_info = BRIDGE_OVFX2 },
         {USB_DEVICE(0x05a9, 0x4519), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x05a9, 0x8519), .driver_info = BRIDGE_OV519 },
diff --git a/drivers/media/video/gspca/sonixj.c b/drivers/media/video/gspca/sonixj.c
index 81b8a600783b..c477ad11f103 100644
--- a/drivers/media/video/gspca/sonixj.c
+++ b/drivers/media/video/gspca/sonixj.c
@@ -2386,7 +2386,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 reg_w1(gspca_dev, 0x01, 0x22);
                 msleep(100);
                 reg01 = SCL_SEL_OD | S_PDN_INV;
-                reg17 &= MCK_SIZE_MASK;
+                reg17 &= ~MCK_SIZE_MASK;
                 reg17 |= 0x04;          /* clock / 4 */
                 break;
         }
@@ -2532,6 +2532,10 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 if (!mode) {                    /* if 640x480 */
                         reg17 &= ~MCK_SIZE_MASK;
                         reg17 |= 0x04;          /* clock / 4 */
+                } else {
+                        reg01 &= ~SYS_SEL_48M;  /* clk 24Mz */
+                        reg17 &= ~MCK_SIZE_MASK;
+                        reg17 |= 0x02;          /* clock / 2 */
                 }
                 break;
         case SENSOR_OV7630:
diff --git a/drivers/media/video/omap/omap_vout.c b/drivers/media/video/omap/omap_vout.c
index b5ef36222440..b3a5ecdb33ac 100644
--- a/drivers/media/video/omap/omap_vout.c
+++ b/drivers/media/video/omap/omap_vout.c
@@ -2194,19 +2194,6 @@ static int __init omap_vout_probe(struct platform_device *pdev)
                                         "'%s' Display already enabled\n",
                                         def_display->name);
                         }
-                        /* set the update mode */
-                        if (def_display->caps &
-                                        OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE) {
-                                if (dssdrv->enable_te)
-                                        dssdrv->enable_te(def_display, 0);
-                                if (dssdrv->set_update_mode)
-                                        dssdrv->set_update_mode(def_display,
-                                                        OMAP_DSS_UPDATE_MANUAL);
-                        } else {
-                                if (dssdrv->set_update_mode)
-                                        dssdrv->set_update_mode(def_display,
-                                                        OMAP_DSS_UPDATE_AUTO);
-                        }
                 }
         }
 
diff --git a/drivers/media/video/omap3isp/ispccdc.c b/drivers/media/video/omap3isp/ispccdc.c
index 9d3459de04b2..80796eb0c53e 100644
--- a/drivers/media/video/omap3isp/ispccdc.c
+++ b/drivers/media/video/omap3isp/ispccdc.c
@@ -31,6 +31,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/mm.h>
 #include <linux/sched.h>
+#include <linux/slab.h>
 #include <media/v4l2-event.h>
 
 #include "isp.h"
diff --git a/drivers/media/video/pwc/pwc-v4l.c b/drivers/media/video/pwc/pwc-v4l.c
index e9a0e94b9995..8c70e64444e7 100644
--- a/drivers/media/video/pwc/pwc-v4l.c
+++ b/drivers/media/video/pwc/pwc-v4l.c
@@ -338,7 +338,7 @@ int pwc_init_controls(struct pwc_device *pdev)
         if (pdev->restore_factory)
                 pdev->restore_factory->flags = V4L2_CTRL_FLAG_UPDATE;
 
-        if (!pdev->features & FEATURE_MOTOR_PANTILT)
+        if (!(pdev->features & FEATURE_MOTOR_PANTILT))
                 return hdl->error;
 
         /* Motor pan / tilt / reset */
diff --git a/drivers/media/video/uvc/uvc_driver.c b/drivers/media/video/uvc/uvc_driver.c
index d29f9c2d0854..e4100b1f68df 100644
--- a/drivers/media/video/uvc/uvc_driver.c
+++ b/drivers/media/video/uvc/uvc_driver.c
@@ -1961,7 +1961,7 @@ static int __uvc_resume(struct usb_interface *intf, int reset)
 
         list_for_each_entry(stream, &dev->streams, list) {
                 if (stream->intf == intf)
-                        return uvc_video_resume(stream);
+                        return uvc_video_resume(stream, reset);
         }
 
         uvc_trace(UVC_TRACE_SUSPEND, "Resume: video streaming USB interface "
diff --git a/drivers/media/video/uvc/uvc_entity.c b/drivers/media/video/uvc/uvc_entity.c
index 48fea373c25a..29e239911d0e 100644
--- a/drivers/media/video/uvc/uvc_entity.c
+++ b/drivers/media/video/uvc/uvc_entity.c
@@ -49,7 +49,7 @@ static int uvc_mc_register_entity(struct uvc_video_chain *chain,
                 if (remote == NULL)
                         return -EINVAL;
 
-                source = (UVC_ENTITY_TYPE(remote) != UVC_TT_STREAMING)
+                source = (UVC_ENTITY_TYPE(remote) == UVC_TT_STREAMING)
                        ? (remote->vdev ? &remote->vdev->entity : NULL)
                        : &remote->subdev.entity;
                 if (source == NULL)
diff --git a/drivers/media/video/uvc/uvc_video.c b/drivers/media/video/uvc/uvc_video.c
index 8244167c8915..ffd1158628b6 100644
--- a/drivers/media/video/uvc/uvc_video.c
+++ b/drivers/media/video/uvc/uvc_video.c
@@ -1104,10 +1104,18 @@ int uvc_video_suspend(struct uvc_streaming *stream)
  * buffers, making sure userspace applications are notified of the problem
  * instead of waiting forever.
  */
-int uvc_video_resume(struct uvc_streaming *stream)
+int uvc_video_resume(struct uvc_streaming *stream, int reset)
 {
         int ret;
 
+        /* If the bus has been reset on resume, set the alternate setting to 0.
+         * This should be the default value, but some devices crash or otherwise
+         * misbehave if they don't receive a SET_INTERFACE request before any
+         * other video control request.
+         */
+        if (reset)
+                usb_set_interface(stream->dev->udev, stream->intfnum, 0);
+
         stream->frozen = 0;
 
         ret = uvc_commit_video(stream, &stream->ctrl);
diff --git a/drivers/media/video/uvc/uvcvideo.h b/drivers/media/video/uvc/uvcvideo.h
index df32a43ca86a..cbdd49bf8b67 100644
--- a/drivers/media/video/uvc/uvcvideo.h
+++ b/drivers/media/video/uvc/uvcvideo.h
@@ -638,7 +638,7 @@ extern void uvc_mc_cleanup_entity(struct uvc_entity *entity);
 /* Video */
 extern int uvc_video_init(struct uvc_streaming *stream);
 extern int uvc_video_suspend(struct uvc_streaming *stream);
-extern int uvc_video_resume(struct uvc_streaming *stream);
+extern int uvc_video_resume(struct uvc_streaming *stream, int reset);
 extern int uvc_video_enable(struct uvc_streaming *stream, int enable);
 extern int uvc_probe_video(struct uvc_streaming *stream,
                 struct uvc_streaming_control *probe);
diff --git a/drivers/media/video/v4l2-dev.c b/drivers/media/video/v4l2-dev.c
index 06f14008b346..d72156517726 100644
--- a/drivers/media/video/v4l2-dev.c
+++ b/drivers/media/video/v4l2-dev.c
@@ -173,6 +173,17 @@ static void v4l2_device_release(struct device *cd)
                 media_device_unregister_entity(&vdev->entity);
 #endif
 
+        /* Do not call v4l2_device_put if there is no release callback set.
+         * Drivers that have no v4l2_device release callback might free the
+         * v4l2_dev instance in the video_device release callback below, so we
+         * must perform this check here.
+         *
+         * TODO: In the long run all drivers that use v4l2_device should use the
+         * v4l2_device release callback. This check will then be unnecessary.
+         */
+        if (v4l2_dev->release == NULL)
+                v4l2_dev = NULL;
+
         /* Release video_device and perform other
            cleanups as needed. */
         vdev->release(vdev);
diff --git a/drivers/media/video/v4l2-device.c b/drivers/media/video/v4l2-device.c
index c72856c41434..e6a2c3b302d4 100644
--- a/drivers/media/video/v4l2-device.c
+++ b/drivers/media/video/v4l2-device.c
@@ -38,6 +38,7 @@ int v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev)
         mutex_init(&v4l2_dev->ioctl_lock);
         v4l2_prio_init(&v4l2_dev->prio);
         kref_init(&v4l2_dev->ref);
+        get_device(dev);
         v4l2_dev->dev = dev;
         if (dev == NULL) {
                 /* If dev == NULL, then name must be filled in by the caller */
@@ -93,6 +94,7 @@ void v4l2_device_disconnect(struct v4l2_device *v4l2_dev)
 
         if (dev_get_drvdata(v4l2_dev->dev) == v4l2_dev)
                 dev_set_drvdata(v4l2_dev->dev, NULL);
+        put_device(v4l2_dev->dev);
         v4l2_dev->dev = NULL;
 }
 EXPORT_SYMBOL_GPL(v4l2_device_disconnect);
diff --git a/drivers/media/video/via-camera.c b/drivers/media/video/via-camera.c
index 85d3048c1d67..bb7f17f2a33c 100644
--- a/drivers/media/video/via-camera.c
+++ b/drivers/media/video/via-camera.c
@@ -1332,6 +1332,8 @@ static __devinit bool viacam_serial_is_enabled(void)
         struct pci_bus *pbus = pci_find_bus(0, 0);
         u8 cbyte;
 
+        if (!pbus)
+                return false;
         pci_bus_read_config_byte(pbus, VIACAM_SERIAL_DEVFN,
                         VIACAM_SERIAL_CREG, &cbyte);
         if ((cbyte & VIACAM_SERIAL_BIT) == 0)
diff --git a/drivers/mfd/jz4740-adc.c b/drivers/mfd/jz4740-adc.c
index 21131c7b0f1e..563654c9b19e 100644
--- a/drivers/mfd/jz4740-adc.c
+++ b/drivers/mfd/jz4740-adc.c
@@ -273,7 +273,7 @@ static int __devinit jz4740_adc_probe(struct platform_device *pdev)
         ct->regs.ack = JZ_REG_ADC_STATUS;
         ct->chip.irq_mask = irq_gc_mask_set_bit;
         ct->chip.irq_unmask = irq_gc_mask_clr_bit;
-        ct->chip.irq_ack = irq_gc_ack;
+        ct->chip.irq_ack = irq_gc_ack_set_bit;
 
         irq_setup_generic_chip(gc, IRQ_MSK(5), 0, 0, IRQ_NOPROBE | IRQ_LEVEL);
 
diff --git a/drivers/mfd/max8997.c b/drivers/mfd/max8997.c
index 5d1fca0277ef..f83103b8970d 100644
--- a/drivers/mfd/max8997.c
+++ b/drivers/mfd/max8997.c
@@ -135,10 +135,13 @@ static int max8997_i2c_probe(struct i2c_client *i2c,
         max8997->dev = &i2c->dev;
         max8997->i2c = i2c;
         max8997->type = id->driver_data;
+        max8997->irq = i2c->irq;
 
         if (!pdata)
                 goto err;
 
+        max8997->irq_base = pdata->irq_base;
+        max8997->ono = pdata->ono;
         max8997->wakeup = pdata->wakeup;
 
         mutex_init(&max8997->iolock);
@@ -152,6 +155,8 @@ static int max8997_i2c_probe(struct i2c_client *i2c,
 
         pm_runtime_set_active(max8997->dev);
 
+        max8997_irq_init(max8997);
+
         mfd_add_devices(max8997->dev, -1, max8997_devs,
                         ARRAY_SIZE(max8997_devs),
                         NULL, 0);
diff --git a/drivers/mfd/menelaus.c b/drivers/mfd/menelaus.c
index 9cee8e7f0bcb..af5d9d061371 100644
--- a/drivers/mfd/menelaus.c
+++ b/drivers/mfd/menelaus.c
@@ -44,7 +44,7 @@
 
 #include <asm/mach/irq.h>
 
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include <plat/menelaus.h>
 
 #define DRIVER_NAME                     "menelaus"
diff --git a/drivers/mfd/omap-usb-host.c b/drivers/mfd/omap-usb-host.c
index 29601e7d606d..86e14583a082 100644
--- a/drivers/mfd/omap-usb-host.c
+++ b/drivers/mfd/omap-usb-host.c
@@ -17,6 +17,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
@@ -676,7 +677,6 @@ static void usbhs_omap_tll_init(struct device *dev, u8 tll_channel_count)
                                 | OMAP_TLL_CHANNEL_CONF_ULPINOBITSTUFF
                                 | OMAP_TLL_CHANNEL_CONF_ULPIDDRMODE);
 
-                        reg |= (1 << (i + 1));
                 } else
                         continue;
 
diff --git a/drivers/mfd/tps65910-irq.c b/drivers/mfd/tps65910-irq.c
index 2bfad5c86cc7..a56be931551c 100644
--- a/drivers/mfd/tps65910-irq.c
+++ b/drivers/mfd/tps65910-irq.c
@@ -178,8 +178,10 @@ int tps65910_irq_init(struct tps65910 *tps65910, int irq,
         switch (tps65910_chip_id(tps65910)) {
         case TPS65910:
                 tps65910->irq_num = TPS65910_NUM_IRQ;
+                break;
         case TPS65911:
                 tps65910->irq_num = TPS65911_NUM_IRQ;
+                break;
         }
 
         /* Register with genirq */
diff --git a/drivers/mfd/twl4030-madc.c b/drivers/mfd/twl4030-madc.c
index b5d598c3aa71..7cbf2aa9e64f 100644
--- a/drivers/mfd/twl4030-madc.c
+++ b/drivers/mfd/twl4030-madc.c
@@ -510,8 +510,9 @@ int twl4030_madc_conversion(struct twl4030_madc_request *req)
         u8 ch_msb, ch_lsb;
         int ret;
 
-        if (!req)
+        if (!req || !twl4030_madc)
                 return -EINVAL;
+
         mutex_lock(&twl4030_madc->lock);
         if (req->method < TWL4030_MADC_RT || req->method > TWL4030_MADC_SW2) {
                 ret = -EINVAL;
@@ -706,6 +707,8 @@ static int __devinit twl4030_madc_probe(struct platform_device *pdev)
         if (!madc)
                 return -ENOMEM;
 
+        madc->dev = &pdev->dev;
+
         /*
          * Phoenix provides 2 interrupt lines. The first one is connected to
          * the OMAP. The other one can be connected to the other processor such
diff --git a/drivers/mfd/wm8350-gpio.c b/drivers/mfd/wm8350-gpio.c
index ebf99bef392f..d584f6b4d6e2 100644
--- a/drivers/mfd/wm8350-gpio.c
+++ b/drivers/mfd/wm8350-gpio.c
@@ -37,7 +37,7 @@ static int gpio_set_dir(struct wm8350 *wm8350, int gpio, int dir)
         return ret;
 }
 
-static int gpio_set_debounce(struct wm8350 *wm8350, int gpio, int db)
+static int wm8350_gpio_set_debounce(struct wm8350 *wm8350, int gpio, int db)
 {
         if (db == WM8350_GPIO_DEBOUNCE_ON)
                 return wm8350_set_bits(wm8350, WM8350_GPIO_DEBOUNCE,
@@ -210,7 +210,7 @@ int wm8350_gpio_config(struct wm8350 *wm8350, int gpio, int dir, int func,
                 goto err;
         if (gpio_set_polarity(wm8350, gpio, pol))
                 goto err;
-        if (gpio_set_debounce(wm8350, gpio, debounce))
+        if (wm8350_gpio_set_debounce(wm8350, gpio, debounce))
                 goto err;
         if (gpio_set_dir(wm8350, gpio, dir))
                 goto err;
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 0a4d86c6c4a4..2d6423c2d193 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -146,6 +146,7 @@ config PHANTOM
 
 config INTEL_MID_PTI
         tristate "Parallel Trace Interface for MIPI P1149.7 cJTAG standard"
+        depends on PCI
         default n
         help
           The PTI (Parallel Trace Interface) driver directs
diff --git a/drivers/misc/ab8500-pwm.c b/drivers/misc/ab8500-pwm.c
index 54e3d05b63cc..35903154ca2e 100644
--- a/drivers/misc/ab8500-pwm.c
+++ b/drivers/misc/ab8500-pwm.c
@@ -164,5 +164,5 @@ subsys_initcall(ab8500_pwm_init);
 module_exit(ab8500_pwm_exit);
 MODULE_AUTHOR("Arun MURTHY <arun.murthy@stericsson.com>");
 MODULE_DESCRIPTION("AB8500 Pulse Width Modulation Driver");
-MODULE_ALIAS("AB8500 PWM driver");
+MODULE_ALIAS("platform:ab8500-pwm");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/misc/cb710/core.c b/drivers/misc/cb710/core.c
index efec4139c3f6..68cd05b6d829 100644
--- a/drivers/misc/cb710/core.c
+++ b/drivers/misc/cb710/core.c
@@ -33,7 +33,7 @@ EXPORT_SYMBOL_GPL(cb710_pci_update_config_reg);
 static int __devinit cb710_pci_configure(struct pci_dev *pdev)
 {
         unsigned int devfn = PCI_DEVFN(PCI_SLOT(pdev->devfn), 0);
-        struct pci_dev *pdev0 = pci_get_slot(pdev->bus, devfn);
+        struct pci_dev *pdev0;
         u32 val;
 
         cb710_pci_update_config_reg(pdev, 0x48,
@@ -43,6 +43,7 @@ static int __devinit cb710_pci_configure(struct pci_dev *pdev)
         if (val & 0x80000000)
                 return 0;
 
+        pdev0 = pci_get_slot(pdev->bus, devfn);
         if (!pdev0)
                 return -ENODEV;
 
diff --git a/drivers/misc/fsa9480.c b/drivers/misc/fsa9480.c
index 5325a7e70dcf..27dc0d21aafa 100644
--- a/drivers/misc/fsa9480.c
+++ b/drivers/misc/fsa9480.c
@@ -455,7 +455,7 @@ static int __devinit fsa9480_probe(struct i2c_client *client,
 
 fail2:
         if (client->irq)
-                free_irq(client->irq, NULL);
+                free_irq(client->irq, usbsw);
 fail1:
         i2c_set_clientdata(client, NULL);
         kfree(usbsw);
@@ -466,7 +466,7 @@ static int __devexit fsa9480_remove(struct i2c_client *client)
 {
         struct fsa9480_usbsw *usbsw = i2c_get_clientdata(client);
         if (client->irq)
-                free_irq(client->irq, NULL);
+                free_irq(client->irq, usbsw);
         i2c_set_clientdata(client, NULL);
 
         sysfs_remove_group(&client->dev.kobj, &fsa9480_group);
diff --git a/drivers/misc/lis3lv02d/lis3lv02d.c b/drivers/misc/lis3lv02d/lis3lv02d.c
index b928bc14e97b..8b51cd62d067 100644
--- a/drivers/misc/lis3lv02d/lis3lv02d.c
+++ b/drivers/misc/lis3lv02d/lis3lv02d.c
@@ -375,12 +375,14 @@ void lis3lv02d_poweron(struct lis3lv02d *lis3)
          *      both have been read. So the value read will always be correct.
          * Set BOOT bit to refresh factory tuning values.
          */
-        lis3->read(lis3, CTRL_REG2, &reg);
-        if (lis3->whoami ==  WAI_12B)
-                reg |= CTRL2_BDU | CTRL2_BOOT;
-        else
-                reg |= CTRL2_BOOT_8B;
-        lis3->write(lis3, CTRL_REG2, reg);
+        if (lis3->pdata) {
+                lis3->read(lis3, CTRL_REG2, &reg);
+                if (lis3->whoami ==  WAI_12B)
+                        reg |= CTRL2_BDU | CTRL2_BOOT;
+                else
+                        reg |= CTRL2_BOOT_8B;
+                lis3->write(lis3, CTRL_REG2, reg);
+        }
 
         /* LIS3 power on delay is quite long */
         msleep(lis3->pwron_delay / lis3lv02d_get_odr());
diff --git a/drivers/misc/pti.c b/drivers/misc/pti.c
index 8653bd0b1a33..0b56e3f43573 100644
--- a/drivers/misc/pti.c
+++ b/drivers/misc/pti.c
@@ -33,6 +33,8 @@
 #include <linux/mutex.h>
 #include <linux/miscdevice.h>
 #include <linux/pti.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
 
 #define DRIVERNAME              "pti"
 #define PCINAME                 "pciPTI"
@@ -163,6 +165,11 @@ static void pti_write_to_aperture(struct pti_masterchannel *mc,
 static void pti_control_frame_built_and_sent(struct pti_masterchannel *mc,
                                              const char *thread_name)
 {
+        /*
+         * Since we access the comm member in current's task_struct, we only
+         * need to be as large as what 'comm' in that structure is.
+         */
+        char comm[TASK_COMM_LEN];
         struct pti_masterchannel mccontrol = {.master = CONTROL_ID,
                                               .channel = 0};
         const char *thread_name_p;
@@ -170,13 +177,6 @@ static void pti_control_frame_built_and_sent(struct pti_masterchannel *mc,
         u8 control_frame[CONTROL_FRAME_LEN];
 
         if (!thread_name) {
-                /*
-                 * Since we access the comm member in current's task_struct,
-                 * we only need to be as large as what 'comm' in that
-                 * structure is.
-                 */
-                char comm[TASK_COMM_LEN];
-
                 if (!in_interrupt())
                         get_task_comm(comm, current);
                 else
diff --git a/drivers/misc/ti-st/st_core.c b/drivers/misc/ti-st/st_core.c
index 54c91ffe4a91..ba168a7d54d4 100644
--- a/drivers/misc/ti-st/st_core.c
+++ b/drivers/misc/ti-st/st_core.c
@@ -338,6 +338,12 @@ void st_int_recv(void *disc_data,
                         /* Unknow packet? */
                 default:
                         type = *ptr;
+                        if (st_gdata->list[type] == NULL) {
+                                pr_err("chip/interface misbehavior dropping"
+                                        " frame starting with 0x%02x", type);
+                                goto done;
+
+                        }
                         st_gdata->rx_skb = alloc_skb(
                                         st_gdata->list[type]->max_frame_size,
                                         GFP_ATOMIC);
@@ -354,6 +360,7 @@ void st_int_recv(void *disc_data,
                 ptr++;
                 count--;
         }
+done:
         spin_unlock_irqrestore(&st_gdata->lock, flags);
         pr_debug("done %s", __func__);
         return;
@@ -717,9 +724,10 @@ static void st_tty_close(struct tty_struct *tty)
          */
         spin_lock_irqsave(&st_gdata->lock, flags);
         for (i = ST_BT; i < ST_MAX_CHANNELS; i++) {
-                if (st_gdata->list[i] != NULL)
+                if (st_gdata->is_registered[i] == true)
                         pr_err("%d not un-registered", i);
                 st_gdata->list[i] = NULL;
+                st_gdata->is_registered[i] = false;
         }
         st_gdata->protos_registered = 0;
         spin_unlock_irqrestore(&st_gdata->lock, flags);
diff --git a/drivers/misc/ti-st/st_kim.c b/drivers/misc/ti-st/st_kim.c
index 38fd2f04c07e..3a3580566dfc 100644
--- a/drivers/misc/ti-st/st_kim.c
+++ b/drivers/misc/ti-st/st_kim.c
@@ -68,6 +68,7 @@ void validate_firmware_response(struct kim_data_s *kim_gdata)
         if (unlikely(skb->data[5] != 0)) {
                 pr_err("no proper response during fw download");
                 pr_err("data6 %x", skb->data[5]);
+                kfree_skb(skb);
                 return;         /* keep waiting for the proper response */
         }
         /* becos of all the script being downloaded */
@@ -210,6 +211,7 @@ static long read_local_version(struct kim_data_s *kim_gdata, char *bts_scr_name)
                 pr_err(" waiting for ver info- timed out ");
                 return -ETIMEDOUT;
         }
+        INIT_COMPLETION(kim_gdata->kim_rcvd);
 
         version =
                 MAKEWORD(kim_gdata->resp_buffer[13],
@@ -298,6 +300,7 @@ static long download_firmware(struct kim_data_s *kim_gdata)
 
                 switch (((struct bts_action *)ptr)->type) {
                 case ACTION_SEND_COMMAND:       /* action send */
+                        pr_debug("S");
                         action_ptr = &(((struct bts_action *)ptr)->data[0]);
                         if (unlikely
                             (((struct hci_command *)action_ptr)->opcode ==
@@ -335,6 +338,10 @@ static long download_firmware(struct kim_data_s *kim_gdata)
                                 release_firmware(kim_gdata->fw_entry);
                                 return -ETIMEDOUT;
                         }
+                        /* reinit completion before sending for the
+                         * relevant wait
+                         */
+                        INIT_COMPLETION(kim_gdata->kim_rcvd);
 
                         /*
                          * Free space found in uart buffer, call st_int_write
@@ -361,6 +368,7 @@ static long download_firmware(struct kim_data_s *kim_gdata)
                         }
                         break;
                 case ACTION_WAIT_EVENT:  /* wait */
+                        pr_debug("W");
                         if (!wait_for_completion_timeout
                                         (&kim_gdata->kim_rcvd,
                                          msecs_to_jiffies(CMD_RESP_TIME))) {
@@ -434,11 +442,17 @@ long st_kim_start(void *kim_data)
 {
         long err = 0;
         long retry = POR_RETRY_COUNT;
+        struct ti_st_plat_data  *pdata;
         struct kim_data_s       *kim_gdata = (struct kim_data_s *)kim_data;
 
         pr_info(" %s", __func__);
+        pdata = kim_gdata->kim_pdev->dev.platform_data;
 
         do {
+                /* platform specific enabling code here */
+                if (pdata->chip_enable)
+                        pdata->chip_enable(kim_gdata);
+
                 /* Configure BT nShutdown to HIGH state */
                 gpio_set_value(kim_gdata->nshutdown, GPIO_LOW);
                 mdelay(5);      /* FIXME: a proper toggle */
@@ -460,6 +474,12 @@ long st_kim_start(void *kim_data)
                         pr_info("ldisc_install = 0");
                         sysfs_notify(&kim_gdata->kim_pdev->dev.kobj,
                                         NULL, "install");
+                        /* the following wait is never going to be completed,
+                         * since the ldisc was never installed, hence serving
+                         * as a mdelay of LDISC_TIME msecs */
+                        err = wait_for_completion_timeout
+                                (&kim_gdata->ldisc_installed,
+                                 msecs_to_jiffies(LDISC_TIME));
                         err = -ETIMEDOUT;
                         continue;
                 } else {
@@ -472,6 +492,13 @@ long st_kim_start(void *kim_data)
                                 pr_info("ldisc_install = 0");
                                 sysfs_notify(&kim_gdata->kim_pdev->dev.kobj,
                                                 NULL, "install");
+                                /* this wait might be completed, though in the
+                                 * tty_close() since the ldisc is already
+                                 * installed */
+                                err = wait_for_completion_timeout
+                                        (&kim_gdata->ldisc_installed,
+                                         msecs_to_jiffies(LDISC_TIME));
+                                err = -EINVAL;
                                 continue;
                         } else {        /* on success don't retry */
                                 break;
@@ -489,6 +516,8 @@ long st_kim_stop(void *kim_data)
 {
         long err = 0;
         struct kim_data_s       *kim_gdata = (struct kim_data_s *)kim_data;
+        struct ti_st_plat_data  *pdata =
+                kim_gdata->kim_pdev->dev.platform_data;
 
         INIT_COMPLETION(kim_gdata->ldisc_installed);
 
@@ -515,6 +544,10 @@ long st_kim_stop(void *kim_data)
         gpio_set_value(kim_gdata->nshutdown, GPIO_HIGH);
         mdelay(1);
         gpio_set_value(kim_gdata->nshutdown, GPIO_LOW);
+
+        /* platform specific disable */
+        if (pdata->chip_disable)
+                pdata->chip_disable(kim_gdata);
         return err;
 }
 
diff --git a/drivers/misc/ti-st/st_ll.c b/drivers/misc/ti-st/st_ll.c
index 3f2495138855..1ff460a8e9c7 100644
--- a/drivers/misc/ti-st/st_ll.c
+++ b/drivers/misc/ti-st/st_ll.c
@@ -22,6 +22,7 @@
 #define pr_fmt(fmt) "(stll) :" fmt
 #include <linux/skbuff.h>
 #include <linux/module.h>
+#include <linux/platform_device.h>
 #include <linux/ti_wilink_st.h>
 
 /**********************************************************************/
@@ -37,6 +38,9 @@ static void send_ll_cmd(struct st_data_s *st_data,
 
 static void ll_device_want_to_sleep(struct st_data_s *st_data)
 {
+        struct kim_data_s       *kim_data;
+        struct ti_st_plat_data  *pdata;
+
         pr_debug("%s", __func__);
         /* sanity check */
         if (st_data->ll_state != ST_LL_AWAKE)
@@ -46,10 +50,19 @@ static void ll_device_want_to_sleep(struct st_data_s *st_data)
         send_ll_cmd(st_data, LL_SLEEP_ACK);
         /* update state */
         st_data->ll_state = ST_LL_ASLEEP;
+
+        /* communicate to platform about chip asleep */
+        kim_data = st_data->kim_data;
+        pdata = kim_data->kim_pdev->dev.platform_data;
+        if (pdata->chip_asleep)
+                pdata->chip_asleep(NULL);
 }
 
 static void ll_device_want_to_wakeup(struct st_data_s *st_data)
 {
+        struct kim_data_s       *kim_data;
+        struct ti_st_plat_data  *pdata;
+
         /* diff actions in diff states */
         switch (st_data->ll_state) {
         case ST_LL_ASLEEP:
@@ -70,6 +83,12 @@ static void ll_device_want_to_wakeup(struct st_data_s *st_data)
         }
         /* update state */
         st_data->ll_state = ST_LL_AWAKE;
+
+        /* communicate to platform about chip wakeup */
+        kim_data = st_data->kim_data;
+        pdata = kim_data->kim_pdev->dev.platform_data;
+        if (pdata->chip_asleep)
+                pdata->chip_awake(NULL);
 }
 
 /**********************************************************************/
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 1ff5486213fb..4c1a648d00fc 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -926,6 +926,9 @@ static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq,
         /*
          * Reliable writes are used to implement Forced Unit Access and
          * REQ_META accesses, and are supported only on MMCs.
+         *
+         * XXX: this really needs a good explanation of why REQ_META
+         * is treated special.
          */
         bool do_rel_wr = ((req->cmd_flags & REQ_FUA) ||
                           (req->cmd_flags & REQ_META)) &&
diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
index 006a5e9f8ab8..2bf229acd3b8 100644
--- a/drivers/mmc/card/mmc_test.c
+++ b/drivers/mmc/card/mmc_test.c
@@ -224,7 +224,7 @@ static void mmc_test_prepare_mrq(struct mmc_test_card *test,
 static int mmc_test_busy(struct mmc_command *cmd)
 {
         return !(cmd->resp[0] & R1_READY_FOR_DATA) ||
-                (R1_CURRENT_STATE(cmd->resp[0]) == 7);
+                (R1_CURRENT_STATE(cmd->resp[0]) == R1_STATE_PRG);
 }
 
 /*
@@ -2900,7 +2900,7 @@ static const struct file_operations mmc_test_fops_testlist = {
         .release        = single_release,
 };
 
-static void mmc_test_free_file_test(struct mmc_card *card)
+static void mmc_test_free_dbgfs_file(struct mmc_card *card)
 {
         struct mmc_test_dbgfs_file *df, *dfs;
 
@@ -2917,34 +2917,21 @@ static void mmc_test_free_file_test(struct mmc_card *card)
         mutex_unlock(&mmc_test_lock);
 }
 
-static int mmc_test_register_file_test(struct mmc_card *card)
+static int __mmc_test_register_dbgfs_file(struct mmc_card *card,
+        const char *name, mode_t mode, const struct file_operations *fops)
 {
         struct dentry *file = NULL;
         struct mmc_test_dbgfs_file *df;
-        int ret = 0;
-
-        mutex_lock(&mmc_test_lock);
-
-        if (card->debugfs_root)
-                file = debugfs_create_file("test", S_IWUSR | S_IRUGO,
-                        card->debugfs_root, card, &mmc_test_fops_test);
-
-        if (IS_ERR_OR_NULL(file)) {
-                dev_err(&card->dev,
-                        "Can't create test. Perhaps debugfs is disabled.\n");
-                ret = -ENODEV;
-                goto err;
-        }
 
         if (card->debugfs_root)
-                file = debugfs_create_file("testlist", S_IRUGO,
-                        card->debugfs_root, card, &mmc_test_fops_testlist);
+                file = debugfs_create_file(name, mode, card->debugfs_root,
+                        card, fops);
 
         if (IS_ERR_OR_NULL(file)) {
                 dev_err(&card->dev,
-                        "Can't create testlist. Perhaps debugfs is disabled.\n");
-                ret = -ENODEV;
-                goto err;
+                        "Can't create %s. Perhaps debugfs is disabled.\n",
+                        name);
+                return -ENODEV;
         }
 
         df = kmalloc(sizeof(struct mmc_test_dbgfs_file), GFP_KERNEL);
@@ -2952,14 +2939,31 @@ static int mmc_test_register_file_test(struct mmc_card *card)
                 debugfs_remove(file);
                 dev_err(&card->dev,
                         "Can't allocate memory for internal usage.\n");
-                ret = -ENOMEM;
-                goto err;
+                return -ENOMEM;
         }
 
         df->card = card;
         df->file = file;
 
         list_add(&df->link, &mmc_test_file_test);
+        return 0;
+}
+
+static int mmc_test_register_dbgfs_file(struct mmc_card *card)
+{
+        int ret;
+
+        mutex_lock(&mmc_test_lock);
+
+        ret = __mmc_test_register_dbgfs_file(card, "test", S_IWUSR | S_IRUGO,
+                &mmc_test_fops_test);
+        if (ret)
+                goto err;
+
+        ret = __mmc_test_register_dbgfs_file(card, "testlist", S_IRUGO,
+                &mmc_test_fops_testlist);
+        if (ret)
+                goto err;
 
 err:
         mutex_unlock(&mmc_test_lock);
@@ -2974,7 +2978,7 @@ static int mmc_test_probe(struct mmc_card *card)
         if (!mmc_card_mmc(card) && !mmc_card_sd(card))
                 return -ENODEV;
 
-        ret = mmc_test_register_file_test(card);
+        ret = mmc_test_register_dbgfs_file(card);
         if (ret)
                 return ret;
 
@@ -2986,7 +2990,7 @@ static int mmc_test_probe(struct mmc_card *card)
 static void mmc_test_remove(struct mmc_card *card)
 {
         mmc_test_free_result(card);
-        mmc_test_free_file_test(card);
+        mmc_test_free_dbgfs_file(card);
 }
 
 static struct mmc_driver mmc_driver = {
@@ -3006,7 +3010,7 @@ static void __exit mmc_test_exit(void)
 {
         /* Clear stalled data if card is still plugged */
         mmc_test_free_result(NULL);
-        mmc_test_free_file_test(NULL);
+        mmc_test_free_dbgfs_file(NULL);
 
         mmc_unregister_driver(&mmc_driver);
 }
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 89bdeaec7182..b27b94078c21 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -133,7 +133,7 @@ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
                 if (mrq->done)
                         mrq->done(mrq);
 
-                mmc_host_clk_gate(host);
+                mmc_host_clk_release(host);
         }
 }
 
@@ -192,7 +192,7 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
                         mrq->stop->mrq = mrq;
                 }
         }
-        mmc_host_clk_ungate(host);
+        mmc_host_clk_hold(host);
         led_trigger_event(host->led, LED_FULL);
         host->ops->request(host, mrq);
 }
@@ -728,15 +728,17 @@ static inline void mmc_set_ios(struct mmc_host *host)
  */
 void mmc_set_chip_select(struct mmc_host *host, int mode)
 {
+        mmc_host_clk_hold(host);
         host->ios.chip_select = mode;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
  * Sets the host clock to the highest possible frequency that
  * is below "hz".
  */
-void mmc_set_clock(struct mmc_host *host, unsigned int hz)
+static void __mmc_set_clock(struct mmc_host *host, unsigned int hz)
 {
         WARN_ON(hz < host->f_min);
 
@@ -747,6 +749,13 @@ void mmc_set_clock(struct mmc_host *host, unsigned int hz)
         mmc_set_ios(host);
 }
 
+void mmc_set_clock(struct mmc_host *host, unsigned int hz)
+{
+        mmc_host_clk_hold(host);
+        __mmc_set_clock(host, hz);
+        mmc_host_clk_release(host);
+}
+
 #ifdef CONFIG_MMC_CLKGATE
 /*
  * This gates the clock by setting it to 0 Hz.
@@ -779,7 +788,7 @@ void mmc_ungate_clock(struct mmc_host *host)
         if (host->clk_old) {
                 BUG_ON(host->ios.clock);
                 /* This call will also set host->clk_gated to false */
-                mmc_set_clock(host, host->clk_old);
+                __mmc_set_clock(host, host->clk_old);
         }
 }
 
@@ -807,8 +816,10 @@ void mmc_set_ungated(struct mmc_host *host)
  */
 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
 {
+        mmc_host_clk_hold(host);
         host->ios.bus_mode = mode;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -816,8 +827,10 @@ void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
  */
 void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
 {
+        mmc_host_clk_hold(host);
         host->ios.bus_width = width;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /**
@@ -1015,8 +1028,10 @@ u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
 
                 ocr &= 3 << bit;
 
+                mmc_host_clk_hold(host);
                 host->ios.vdd = bit;
                 mmc_set_ios(host);
+                mmc_host_clk_release(host);
         } else {
                 pr_warning("%s: host doesn't support card's voltages\n",
                                 mmc_hostname(host));
@@ -1063,8 +1078,10 @@ int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, bool cmd11
  */
 void mmc_set_timing(struct mmc_host *host, unsigned int timing)
 {
+        mmc_host_clk_hold(host);
         host->ios.timing = timing;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -1072,8 +1089,10 @@ void mmc_set_timing(struct mmc_host *host, unsigned int timing)
  */
 void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
 {
+        mmc_host_clk_hold(host);
         host->ios.drv_type = drv_type;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -1091,6 +1110,8 @@ static void mmc_power_up(struct mmc_host *host)
 {
         int bit;
 
+        mmc_host_clk_hold(host);
+
         /* If ocr is set, we use it */
         if (host->ocr)
                 bit = ffs(host->ocr) - 1;
@@ -1126,10 +1147,14 @@ static void mmc_power_up(struct mmc_host *host)
          * time required to reach a stable voltage.
          */
         mmc_delay(10);
+
+        mmc_host_clk_release(host);
 }
 
 static void mmc_power_off(struct mmc_host *host)
 {
+        mmc_host_clk_hold(host);
+
         host->ios.clock = 0;
         host->ios.vdd = 0;
 
@@ -1147,6 +1172,8 @@ static void mmc_power_off(struct mmc_host *host)
         host->ios.bus_width = MMC_BUS_WIDTH_1;
         host->ios.timing = MMC_TIMING_LEGACY;
         mmc_set_ios(host);
+
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -1502,7 +1529,7 @@ static int mmc_do_erase(struct mmc_card *card, unsigned int from,
                         goto out;
                 }
         } while (!(cmd.resp[0] & R1_READY_FOR_DATA) ||
-                 R1_CURRENT_STATE(cmd.resp[0]) == 7);
+                 R1_CURRENT_STATE(cmd.resp[0]) == R1_STATE_PRG);
 out:
         return err;
 }
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index b29d3e8fd3a2..793d0a0dad8d 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -119,14 +119,14 @@ static void mmc_host_clk_gate_work(struct work_struct *work)
 }
 
 /**
- *      mmc_host_clk_ungate - ungate hardware MCI clocks
+ *      mmc_host_clk_hold - ungate hardware MCI clocks
  *      @host: host to ungate.
  *
  *      Makes sure the host ios.clock is restored to a non-zero value
  *      past this call. Increase clock reference count and ungate clock
  *      if we're the first user.
  */
-void mmc_host_clk_ungate(struct mmc_host *host)
+void mmc_host_clk_hold(struct mmc_host *host)
 {
         unsigned long flags;
 
@@ -164,14 +164,14 @@ static bool mmc_host_may_gate_card(struct mmc_card *card)
 }
 
 /**
- *      mmc_host_clk_gate - gate off hardware MCI clocks
+ *      mmc_host_clk_release - gate off hardware MCI clocks
  *      @host: host to gate.
  *
  *      Calls the host driver with ios.clock set to zero as often as possible
  *      in order to gate off hardware MCI clocks. Decrease clock reference
  *      count and schedule disabling of clock.
  */
-void mmc_host_clk_gate(struct mmc_host *host)
+void mmc_host_clk_release(struct mmc_host *host)
 {
         unsigned long flags;
 
@@ -179,7 +179,7 @@ void mmc_host_clk_gate(struct mmc_host *host)
         host->clk_requests--;
         if (mmc_host_may_gate_card(host->card) &&
             !host->clk_requests)
-                schedule_work(&host->clk_gate_work);
+                queue_work(system_nrt_wq, &host->clk_gate_work);
         spin_unlock_irqrestore(&host->clk_lock, flags);
 }
 
@@ -231,7 +231,7 @@ static inline void mmc_host_clk_exit(struct mmc_host *host)
         if (cancel_work_sync(&host->clk_gate_work))
                 mmc_host_clk_gate_delayed(host);
         if (host->clk_gated)
-                mmc_host_clk_ungate(host);
+                mmc_host_clk_hold(host);
         /* There should be only one user now */
         WARN_ON(host->clk_requests > 1);
 }
diff --git a/drivers/mmc/core/host.h b/drivers/mmc/core/host.h
index de199f911928..fb8a5cd2e4a1 100644
--- a/drivers/mmc/core/host.h
+++ b/drivers/mmc/core/host.h
@@ -16,16 +16,16 @@ int mmc_register_host_class(void);
 void mmc_unregister_host_class(void);
 
 #ifdef CONFIG_MMC_CLKGATE
-void mmc_host_clk_ungate(struct mmc_host *host);
-void mmc_host_clk_gate(struct mmc_host *host);
+void mmc_host_clk_hold(struct mmc_host *host);
+void mmc_host_clk_release(struct mmc_host *host);
 unsigned int mmc_host_clk_rate(struct mmc_host *host);
 
 #else
-static inline void mmc_host_clk_ungate(struct mmc_host *host)
+static inline void mmc_host_clk_hold(struct mmc_host *host)
 {
 }
 
-static inline void mmc_host_clk_gate(struct mmc_host *host)
+static inline void mmc_host_clk_release(struct mmc_host *host)
 {
 }
 
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index aa7d1d79b8c5..5700b1cbdfec 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -259,7 +259,7 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
         }
 
         card->ext_csd.rev = ext_csd[EXT_CSD_REV];
-        if (card->ext_csd.rev > 5) {
+        if (card->ext_csd.rev > 6) {
                 printk(KERN_ERR "%s: unrecognised EXT_CSD revision %d\n",
                         mmc_hostname(card->host), card->ext_csd.rev);
                 err = -EINVAL;
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index 845ce7c533b9..770c3d06f5dc 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -407,7 +407,7 @@ int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
                         break;
                 if (mmc_host_is_spi(card->host))
                         break;
-        } while (R1_CURRENT_STATE(status) == 7);
+        } while (R1_CURRENT_STATE(status) == R1_STATE_PRG);
 
         if (mmc_host_is_spi(card->host)) {
                 if (status & R1_SPI_ILLEGAL_COMMAND)
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index 633975ff2bb3..0370e03e3142 100644
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -469,56 +469,75 @@ static int sd_select_driver_type(struct mmc_card *card, u8 *status)
         return 0;
 }
 
-static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
+static void sd_update_bus_speed_mode(struct mmc_card *card)
 {
-        unsigned int bus_speed = 0, timing = 0;
-        int err;
-
         /*
          * If the host doesn't support any of the UHS-I modes, fallback on
          * default speed.
          */
         if (!(card->host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
-            MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50)))
-                return 0;
+            MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50))) {
+                card->sd_bus_speed = 0;
+                return;
+        }
 
         if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
             (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
-                        bus_speed = UHS_SDR104_BUS_SPEED;
-                        timing = MMC_TIMING_UHS_SDR104;
-                        card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
+                        card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
         } else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
                    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
-                        bus_speed = UHS_DDR50_BUS_SPEED;
-                        timing = MMC_TIMING_UHS_DDR50;
-                        card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
+                        card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
                     MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
                     SD_MODE_UHS_SDR50)) {
-                        bus_speed = UHS_SDR50_BUS_SPEED;
-                        timing = MMC_TIMING_UHS_SDR50;
-                        card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
+                        card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
                     MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
                    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
-                        bus_speed = UHS_SDR25_BUS_SPEED;
-                        timing = MMC_TIMING_UHS_SDR25;
-                        card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
+                        card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
                     MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
                     MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
                     SD_MODE_UHS_SDR12)) {
-                        bus_speed = UHS_SDR12_BUS_SPEED;
-                        timing = MMC_TIMING_UHS_SDR12;
-                        card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
+                        card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
+        }
+}
+
+static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
+{
+        int err;
+        unsigned int timing = 0;
+
+        switch (card->sd_bus_speed) {
+        case UHS_SDR104_BUS_SPEED:
+                timing = MMC_TIMING_UHS_SDR104;
+                card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
+                break;
+        case UHS_DDR50_BUS_SPEED:
+                timing = MMC_TIMING_UHS_DDR50;
+                card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
+                break;
+        case UHS_SDR50_BUS_SPEED:
+                timing = MMC_TIMING_UHS_SDR50;
+                card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
+                break;
+        case UHS_SDR25_BUS_SPEED:
+                timing = MMC_TIMING_UHS_SDR25;
+                card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
+                break;
+        case UHS_SDR12_BUS_SPEED:
+                timing = MMC_TIMING_UHS_SDR12;
+                card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
+                break;
+        default:
+                return 0;
         }
 
-        card->sd_bus_speed = bus_speed;
-        err = mmc_sd_switch(card, 1, 0, bus_speed, status);
+        err = mmc_sd_switch(card, 1, 0, card->sd_bus_speed, status);
         if (err)
                 return err;
 
-        if ((status[16] & 0xF) != bus_speed)
+        if ((status[16] & 0xF) != card->sd_bus_speed)
                 printk(KERN_WARNING "%s: Problem setting bus speed mode!\n",
                         mmc_hostname(card->host));
         else {
@@ -618,18 +637,24 @@ static int mmc_sd_init_uhs_card(struct mmc_card *card)
                 mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
         }
 
+        /*
+         * Select the bus speed mode depending on host
+         * and card capability.
+         */
+        sd_update_bus_speed_mode(card);
+
         /* Set the driver strength for the card */
         err = sd_select_driver_type(card, status);
         if (err)
                 goto out;
 
-        /* Set bus speed mode of the card */
-        err = sd_set_bus_speed_mode(card, status);
+        /* Set current limit for the card */
+        err = sd_set_current_limit(card, status);
         if (err)
                 goto out;
 
-        /* Set current limit for the card */
-        err = sd_set_current_limit(card, status);
+        /* Set bus speed mode of the card */
+        err = sd_set_bus_speed_mode(card, status);
         if (err)
                 goto out;
 
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
index 77f0b6b1681d..ff0f714b012c 100644
--- a/drivers/mmc/host/dw_mmc.c
+++ b/drivers/mmc/host/dw_mmc.c
@@ -62,7 +62,7 @@ struct idmac_desc {
 
         u32             des1;   /* Buffer sizes */
 #define IDMAC_SET_BUFFER1_SIZE(d, s) \
-        ((d)->des1 = ((d)->des1 & 0x03ffc000) | ((s) & 0x3fff))
+        ((d)->des1 = ((d)->des1 & 0x03ffe000) | ((s) & 0x1fff))
 
         u32             des2;   /* buffer 1 physical address */
 
@@ -699,7 +699,7 @@ static void dw_mci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         }
 
         /* DDR mode set */
-        if (ios->ddr) {
+        if (ios->timing == MMC_TIMING_UHS_DDR50) {
                 regs = mci_readl(slot->host, UHS_REG);
                 regs |= (0x1 << slot->id) << 16;
                 mci_writel(slot->host, UHS_REG, regs);
@@ -1646,7 +1646,7 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
                         mmc->caps |= MMC_CAP_4_BIT_DATA;
 
         if (host->pdata->quirks & DW_MCI_QUIRK_HIGHSPEED)
-                mmc->caps |= MMC_CAP_SD_HIGHSPEED;
+                mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
 
 #ifdef CONFIG_MMC_DW_IDMAC
         mmc->max_segs = host->ring_size;
diff --git a/drivers/mmc/host/omap.c b/drivers/mmc/host/omap.c
index a6c329040140..2dba999caf2c 100644
--- a/drivers/mmc/host/omap.c
+++ b/drivers/mmc/host/omap.c
@@ -33,7 +33,7 @@
 
 #include <plat/board.h>
 #include <plat/mmc.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include <plat/dma.h>
 #include <plat/mux.h>
 #include <plat/fpga.h>
diff --git a/drivers/mmc/host/sdhci-esdhc-imx.c b/drivers/mmc/host/sdhci-esdhc-imx.c
index 9ebfb4b482f5..4dc0028086a3 100644
--- a/drivers/mmc/host/sdhci-esdhc-imx.c
+++ b/drivers/mmc/host/sdhci-esdhc-imx.c
@@ -16,6 +16,7 @@
 #include <linux/err.h>
 #include <linux/clk.h>
 #include <linux/gpio.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/mmc.h>
@@ -27,6 +28,7 @@
 #include "sdhci-pltfm.h"
 #include "sdhci-esdhc.h"
 
+#define SDHCI_CTRL_D3CD                 0x08
 /* VENDOR SPEC register */
 #define SDHCI_VENDOR_SPEC               0xC0
 #define  SDHCI_VENDOR_SPEC_SDIO_QUIRK   0x00000002
@@ -141,13 +143,32 @@ static void esdhc_writel_le(struct sdhci_host *host, u32 val, int reg)
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
         struct pltfm_imx_data *imx_data = pltfm_host->priv;
         struct esdhc_platform_data *boarddata = &imx_data->boarddata;
-
-        if (unlikely((reg == SDHCI_INT_ENABLE || reg == SDHCI_SIGNAL_ENABLE)
-                        && (boarddata->cd_type == ESDHC_CD_GPIO)))
-                /*
-                 * these interrupts won't work with a custom card_detect gpio
-                 */
-                val &= ~(SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT);
+        u32 data;
+
+        if (unlikely(reg == SDHCI_INT_ENABLE || reg == SDHCI_SIGNAL_ENABLE)) {
+                if (boarddata->cd_type == ESDHC_CD_GPIO)
+                        /*
+                         * These interrupts won't work with a custom
+                         * card_detect gpio (only applied to mx25/35)
+                         */
+                        val &= ~(SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT);
+
+                if (val & SDHCI_INT_CARD_INT) {
+                        /*
+                         * Clear and then set D3CD bit to avoid missing the
+                         * card interrupt.  This is a eSDHC controller problem
+                         * so we need to apply the following workaround: clear
+                         * and set D3CD bit will make eSDHC re-sample the card
+                         * interrupt. In case a card interrupt was lost,
+                         * re-sample it by the following steps.
+                         */
+                        data = readl(host->ioaddr + SDHCI_HOST_CONTROL);
+                        data &= ~SDHCI_CTRL_D3CD;
+                        writel(data, host->ioaddr + SDHCI_HOST_CONTROL);
+                        data |= SDHCI_CTRL_D3CD;
+                        writel(data, host->ioaddr + SDHCI_HOST_CONTROL);
+                }
+        }
 
         if (unlikely((imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT)
                                 && (reg == SDHCI_INT_STATUS)
@@ -217,8 +238,10 @@ static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg)
                  */
                 return;
         case SDHCI_HOST_CONTROL:
-                /* FSL messed up here, so we can just keep those two */
-                new_val = val & (SDHCI_CTRL_LED | SDHCI_CTRL_4BITBUS);
+                /* FSL messed up here, so we can just keep those three */
+                new_val = val & (SDHCI_CTRL_LED | \
+                                SDHCI_CTRL_4BITBUS | \
+                                SDHCI_CTRL_D3CD);
                 /* ensure the endianess */
                 new_val |= ESDHC_HOST_CONTROL_LE;
                 /* DMA mode bits are shifted */
diff --git a/drivers/mmc/host/sdhci-pxav3.c b/drivers/mmc/host/sdhci-pxav3.c
index 4198dbbc5c20..fc7e4a515629 100644
--- a/drivers/mmc/host/sdhci-pxav3.c
+++ b/drivers/mmc/host/sdhci-pxav3.c
@@ -195,7 +195,8 @@ static int __devinit sdhci_pxav3_probe(struct platform_device *pdev)
         clk_enable(clk);
 
         host->quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL
-                | SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC;
+                | SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
+                | SDHCI_QUIRK_32BIT_ADMA_SIZE;
 
         /* enable 1/8V DDR capable */
         host->mmc->caps |= MMC_CAP_1_8V_DDR;
diff --git a/drivers/mmc/host/sdhci-s3c.c b/drivers/mmc/host/sdhci-s3c.c
index 460ffaf0f6d7..fe886d6c474a 100644
--- a/drivers/mmc/host/sdhci-s3c.c
+++ b/drivers/mmc/host/sdhci-s3c.c
@@ -19,6 +19,7 @@
 #include <linux/clk.h>
 #include <linux/io.h>
 #include <linux/gpio.h>
+#include <linux/module.h>
 
 #include <linux/mmc/host.h>
 
@@ -301,6 +302,8 @@ static int sdhci_s3c_platform_8bit_width(struct sdhci_host *host, int width)
                 ctrl &= ~SDHCI_CTRL_8BITBUS;
                 break;
         default:
+                ctrl &= ~SDHCI_CTRL_4BITBUS;
+                ctrl &= ~SDHCI_CTRL_8BITBUS;
                 break;
         }
 
@@ -502,6 +505,9 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
         /* This host supports the Auto CMD12 */
         host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12;
 
+        /* Samsung SoCs need BROKEN_ADMA_ZEROLEN_DESC */
+        host->quirks |= SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC;
+
         if (pdata->cd_type == S3C_SDHCI_CD_NONE ||
             pdata->cd_type == S3C_SDHCI_CD_PERMANENT)
                 host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION;
diff --git a/drivers/mmc/host/sdhci-tegra.c b/drivers/mmc/host/sdhci-tegra.c
index 18b0bd31de78..21b00cefae63 100644
--- a/drivers/mmc/host/sdhci-tegra.c
+++ b/drivers/mmc/host/sdhci-tegra.c
@@ -21,7 +21,9 @@
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
 
-#include <mach/gpio.h>
+#include <asm/gpio.h>
+
+#include <mach/gpio-tegra.h>
 #include <mach/sdhci.h>
 
 #include "sdhci-pltfm.h"
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index c31a3343340d..0e02cc1df12e 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -628,12 +628,11 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd)
         /* timeout in us */
         if (!data)
                 target_timeout = cmd->cmd_timeout_ms * 1000;
-        else
-                target_timeout = data->timeout_ns / 1000 +
-                        data->timeout_clks / host->clock;
-
-        if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)
-                host->timeout_clk = host->clock / 1000;
+        else {
+                target_timeout = data->timeout_ns / 1000;
+                if (host->clock)
+                        target_timeout += data->timeout_clks / host->clock;
+        }
 
         /*
          * Figure out needed cycles.
@@ -645,7 +644,6 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd)
          *     =>
          *     (1) / (2) > 2^6
          */
-        BUG_ON(!host->timeout_clk);
         count = 0;
         current_timeout = (1 << 13) * 1000 / host->timeout_clk;
         while (current_timeout < target_timeout) {
@@ -1867,9 +1865,6 @@ static void sdhci_tasklet_finish(unsigned long param)
 
         del_timer(&host->timer);
 
-        if (host->version >= SDHCI_SPEC_300)
-                del_timer(&host->tuning_timer);
-
         mrq = host->mrq;
 
         /*
@@ -2461,22 +2456,6 @@ int sdhci_add_host(struct sdhci_host *host)
                 host->max_clk = host->ops->get_max_clock(host);
         }
 
-        host->timeout_clk =
-                (caps[0] & SDHCI_TIMEOUT_CLK_MASK) >> SDHCI_TIMEOUT_CLK_SHIFT;
-        if (host->timeout_clk == 0) {
-                if (host->ops->get_timeout_clock) {
-                        host->timeout_clk = host->ops->get_timeout_clock(host);
-                } else if (!(host->quirks &
-                                SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)) {
-                        printk(KERN_ERR
-                               "%s: Hardware doesn't specify timeout clock "
-                               "frequency.\n", mmc_hostname(mmc));
-                        return -ENODEV;
-                }
-        }
-        if (caps[0] & SDHCI_TIMEOUT_CLK_UNIT)
-                host->timeout_clk *= 1000;
-
         /*
          * In case of Host Controller v3.00, find out whether clock
          * multiplier is supported.
@@ -2509,10 +2488,26 @@ int sdhci_add_host(struct sdhci_host *host)
         } else
                 mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_200;
 
+        host->timeout_clk =
+                (caps[0] & SDHCI_TIMEOUT_CLK_MASK) >> SDHCI_TIMEOUT_CLK_SHIFT;
+        if (host->timeout_clk == 0) {
+                if (host->ops->get_timeout_clock) {
+                        host->timeout_clk = host->ops->get_timeout_clock(host);
+                } else if (!(host->quirks &
+                                SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)) {
+                        printk(KERN_ERR
+                               "%s: Hardware doesn't specify timeout clock "
+                               "frequency.\n", mmc_hostname(mmc));
+                        return -ENODEV;
+                }
+        }
+        if (caps[0] & SDHCI_TIMEOUT_CLK_UNIT)
+                host->timeout_clk *= 1000;
+
         if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)
-                mmc->max_discard_to = (1 << 27) / (mmc->f_max / 1000);
-        else
-                mmc->max_discard_to = (1 << 27) / host->timeout_clk;
+                host->timeout_clk = mmc->f_max / 1000;
+
+        mmc->max_discard_to = (1 << 27) / host->timeout_clk;
 
         mmc->caps |= MMC_CAP_SDIO_IRQ | MMC_CAP_ERASE | MMC_CAP_CMD23;
 
diff --git a/drivers/mmc/host/sh_mobile_sdhi.c b/drivers/mmc/host/sh_mobile_sdhi.c
index 774f6439d7ce..0c4a672f5db6 100644
--- a/drivers/mmc/host/sh_mobile_sdhi.c
+++ b/drivers/mmc/host/sh_mobile_sdhi.c
@@ -120,11 +120,11 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
         mmc_data->hclk = clk_get_rate(priv->clk);
         mmc_data->set_pwr = sh_mobile_sdhi_set_pwr;
         mmc_data->get_cd = sh_mobile_sdhi_get_cd;
-        if (mmc_data->flags & TMIO_MMC_HAS_IDLE_WAIT)
-                mmc_data->write16_hook = sh_mobile_sdhi_write16_hook;
         mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED;
         if (p) {
                 mmc_data->flags = p->tmio_flags;
+                if (mmc_data->flags & TMIO_MMC_HAS_IDLE_WAIT)
+                        mmc_data->write16_hook = sh_mobile_sdhi_write16_hook;
                 mmc_data->ocr_mask = p->tmio_ocr_mask;
                 mmc_data->capabilities |= p->tmio_caps;
 
diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index 8d185de90d20..44a9668c4b7a 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -27,7 +27,6 @@
 static int tmio_mmc_suspend(struct platform_device *dev, pm_message_t state)
 {
         const struct mfd_cell *cell = mfd_get_cell(dev);
-        struct mmc_host *mmc = platform_get_drvdata(dev);
         int ret;
 
         ret = tmio_mmc_host_suspend(&dev->dev);
@@ -42,7 +41,6 @@ static int tmio_mmc_suspend(struct platform_device *dev, pm_message_t state)
 static int tmio_mmc_resume(struct platform_device *dev)
 {
         const struct mfd_cell *cell = mfd_get_cell(dev);
-        struct mmc_host *mmc = platform_get_drvdata(dev);
         int ret = 0;
 
         /* Tell the MFD core we are ready to be enabled */
diff --git a/drivers/mtd/nand/ams-delta.c b/drivers/mtd/nand/ams-delta.c
index 78017eb9318e..9e6b498c9beb 100644
--- a/drivers/mtd/nand/ams-delta.c
+++ b/drivers/mtd/nand/ams-delta.c
@@ -26,7 +26,7 @@
 #include <asm/io.h>
 #include <mach/hardware.h>
 #include <asm/sizes.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include <plat/board-ams-delta.h>
 
 /*
diff --git a/drivers/mtd/onenand/omap2.c b/drivers/mtd/onenand/omap2.c
index a916dec29215..6a1d6d9a2df9 100644
--- a/drivers/mtd/onenand/omap2.c
+++ b/drivers/mtd/onenand/omap2.c
@@ -40,7 +40,7 @@
 #include <asm/mach/flash.h>
 #include <plat/gpmc.h>
 #include <plat/onenand.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 
 #include <plat/dma.h>
 
diff --git a/drivers/mtd/ubi/debug.h b/drivers/mtd/ubi/debug.h
index 65b5b76cc379..64fbb0021825 100644
--- a/drivers/mtd/ubi/debug.h
+++ b/drivers/mtd/ubi/debug.h
@@ -181,7 +181,7 @@ static inline int ubi_dbg_is_erase_failure(const struct ubi_device *ubi)
 
 #define ubi_dbg_msg(fmt, ...) do {                                           \
         if (0)                                                               \
-                pr_debug(fmt "\n", ##__VA_ARGS__);                           \
+                printk(KERN_DEBUG fmt "\n", ##__VA_ARGS__);                  \
 } while (0)
 
 #define dbg_msg(fmt, ...)  ubi_dbg_msg(fmt, ##__VA_ARGS__)
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 8d0314dbd946..a44874e24f2a 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -2535,7 +2535,7 @@ config S6GMAC
 source "drivers/net/stmmac/Kconfig"
 
 config PCH_GBE
-        tristate "Intel EG20T PCH / OKI SEMICONDUCTOR ML7223 IOH GbE"
+        tristate "Intel EG20T PCH/OKI SEMICONDUCTOR IOH(ML7223/ML7831) GbE"
         depends on PCI
         select MII
         ---help---
@@ -2548,10 +2548,11 @@ config PCH_GBE
           This driver enables Gigabit Ethernet function.
 
           This driver also can be used for OKI SEMICONDUCTOR IOH(Input/
-          Output Hub), ML7223.
-          ML7223 IOH is for MP(Media Phone) use.
-          ML7223 is companion chip for Intel Atom E6xx series.
-          ML7223 is completely compatible for Intel EG20T PCH.
+          Output Hub), ML7223/ML7831.
+          ML7223 IOH is for MP(Media Phone) use. ML7831 IOH is for general
+          purpose use.
+          ML7223/ML7831 is companion chip for Intel Atom E6xx series.
+          ML7223/ML7831 is completely compatible for Intel EG20T PCH.
 
 config FTGMAC100
         tristate "Faraday FTGMAC100 Gigabit Ethernet support"
diff --git a/drivers/net/arm/am79c961a.c b/drivers/net/arm/am79c961a.c
index 52fe21e1e2cd..3b1416e3d217 100644
--- a/drivers/net/arm/am79c961a.c
+++ b/drivers/net/arm/am79c961a.c
@@ -308,8 +308,11 @@ static void am79c961_timer(unsigned long data)
         struct net_device *dev = (struct net_device *)data;
         struct dev_priv *priv = netdev_priv(dev);
         unsigned int lnkstat, carrier;
+        unsigned long flags;
 
+        spin_lock_irqsave(&priv->chip_lock, flags);
         lnkstat = read_ireg(dev->base_addr, ISALED0) & ISALED0_LNKST;
+        spin_unlock_irqrestore(&priv->chip_lock, flags);
         carrier = netif_carrier_ok(dev);
 
         if (lnkstat && !carrier) {
diff --git a/drivers/net/arm/at91_ether.c b/drivers/net/arm/at91_ether.c
index 29dc43523cec..48b4ec121f7f 100644
--- a/drivers/net/arm/at91_ether.c
+++ b/drivers/net/arm/at91_ether.c
@@ -35,7 +35,7 @@
 #include <asm/mach-types.h>
 
 #include <mach/at91rm9200_emac.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include <mach/board.h>
 
 #include "at91_ether.h"
diff --git a/drivers/net/bnx2x/bnx2x.h b/drivers/net/bnx2x/bnx2x.h
index c423504a755f..e46df5331c55 100644
--- a/drivers/net/bnx2x/bnx2x.h
+++ b/drivers/net/bnx2x/bnx2x.h
@@ -315,6 +315,14 @@ union db_prod {
         u32             raw;
 };
 
+/* dropless fc FW/HW related params */
+#define BRB_SIZE(bp)            (CHIP_IS_E3(bp) ? 1024 : 512)
+#define MAX_AGG_QS(bp)          (CHIP_IS_E1(bp) ? \
+                                        ETH_MAX_AGGREGATION_QUEUES_E1 :\
+                                        ETH_MAX_AGGREGATION_QUEUES_E1H_E2)
+#define FW_DROP_LEVEL(bp)       (3 + MAX_SPQ_PENDING + MAX_AGG_QS(bp))
+#define FW_PREFETCH_CNT         16
+#define DROPLESS_FC_HEADROOM    100
 
 /* MC hsi */
 #define BCM_PAGE_SHIFT          12
@@ -331,15 +339,35 @@ union db_prod {
 /* SGE ring related macros */
 #define NUM_RX_SGE_PAGES        2
 #define RX_SGE_CNT              (BCM_PAGE_SIZE / sizeof(struct eth_rx_sge))
-#define MAX_RX_SGE_CNT          (RX_SGE_CNT - 2)
+#define NEXT_PAGE_SGE_DESC_CNT  2
+#define MAX_RX_SGE_CNT          (RX_SGE_CNT - NEXT_PAGE_SGE_DESC_CNT)
 /* RX_SGE_CNT is promised to be a power of 2 */
 #define RX_SGE_MASK             (RX_SGE_CNT - 1)
 #define NUM_RX_SGE              (RX_SGE_CNT * NUM_RX_SGE_PAGES)
 #define MAX_RX_SGE              (NUM_RX_SGE - 1)
 #define NEXT_SGE_IDX(x)         ((((x) & RX_SGE_MASK) == \
-                                  (MAX_RX_SGE_CNT - 1)) ? (x) + 3 : (x) + 1)
+                                  (MAX_RX_SGE_CNT - 1)) ? \
+                                        (x) + 1 + NEXT_PAGE_SGE_DESC_CNT : \
+                                        (x) + 1)
 #define RX_SGE(x)               ((x) & MAX_RX_SGE)
 
+/*
+ * Number of required  SGEs is the sum of two:
+ * 1. Number of possible opened aggregations (next packet for
+ *    these aggregations will probably consume SGE immidiatelly)
+ * 2. Rest of BRB blocks divided by 2 (block will consume new SGE only
+ *    after placement on BD for new TPA aggregation)
+ *
+ * Takes into account NEXT_PAGE_SGE_DESC_CNT "next" elements on each page
+ */
+#define NUM_SGE_REQ             (MAX_AGG_QS(bp) + \
+                                        (BRB_SIZE(bp) - MAX_AGG_QS(bp)) / 2)
+#define NUM_SGE_PG_REQ          ((NUM_SGE_REQ + MAX_RX_SGE_CNT - 1) / \
+                                                MAX_RX_SGE_CNT)
+#define SGE_TH_LO(bp)           (NUM_SGE_REQ + \
+                                 NUM_SGE_PG_REQ * NEXT_PAGE_SGE_DESC_CNT)
+#define SGE_TH_HI(bp)           (SGE_TH_LO(bp) + DROPLESS_FC_HEADROOM)
+
 /* Manipulate a bit vector defined as an array of u64 */
 
 /* Number of bits in one sge_mask array element */
@@ -551,24 +579,43 @@ struct bnx2x_fastpath {
 
 #define NUM_TX_RINGS            16
 #define TX_DESC_CNT             (BCM_PAGE_SIZE / sizeof(union eth_tx_bd_types))
-#define MAX_TX_DESC_CNT         (TX_DESC_CNT - 1)
+#define NEXT_PAGE_TX_DESC_CNT   1
+#define MAX_TX_DESC_CNT         (TX_DESC_CNT - NEXT_PAGE_TX_DESC_CNT)
 #define NUM_TX_BD               (TX_DESC_CNT * NUM_TX_RINGS)
 #define MAX_TX_BD               (NUM_TX_BD - 1)
 #define MAX_TX_AVAIL            (MAX_TX_DESC_CNT * NUM_TX_RINGS - 2)
 #define NEXT_TX_IDX(x)          ((((x) & MAX_TX_DESC_CNT) == \
-                                  (MAX_TX_DESC_CNT - 1)) ? (x) + 2 : (x) + 1)
+                                  (MAX_TX_DESC_CNT - 1)) ? \
+                                        (x) + 1 + NEXT_PAGE_TX_DESC_CNT : \
+                                        (x) + 1)
 #define TX_BD(x)                ((x) & MAX_TX_BD)
 #define TX_BD_POFF(x)           ((x) & MAX_TX_DESC_CNT)
 
 /* The RX BD ring is special, each bd is 8 bytes but the last one is 16 */
 #define NUM_RX_RINGS            8
 #define RX_DESC_CNT             (BCM_PAGE_SIZE / sizeof(struct eth_rx_bd))
-#define MAX_RX_DESC_CNT         (RX_DESC_CNT - 2)
+#define NEXT_PAGE_RX_DESC_CNT   2
+#define MAX_RX_DESC_CNT         (RX_DESC_CNT - NEXT_PAGE_RX_DESC_CNT)
 #define RX_DESC_MASK            (RX_DESC_CNT - 1)
 #define NUM_RX_BD               (RX_DESC_CNT * NUM_RX_RINGS)
 #define MAX_RX_BD               (NUM_RX_BD - 1)
 #define MAX_RX_AVAIL            (MAX_RX_DESC_CNT * NUM_RX_RINGS - 2)
-#define MIN_RX_AVAIL            128
+
+/* dropless fc calculations for BDs
+ *
+ * Number of BDs should as number of buffers in BRB:
+ * Low threshold takes into account NEXT_PAGE_RX_DESC_CNT
+ * "next" elements on each page
+ */
+#define NUM_BD_REQ              BRB_SIZE(bp)
+#define NUM_BD_PG_REQ           ((NUM_BD_REQ + MAX_RX_DESC_CNT - 1) / \
+                                              MAX_RX_DESC_CNT)
+#define BD_TH_LO(bp)            (NUM_BD_REQ + \
+                                 NUM_BD_PG_REQ * NEXT_PAGE_RX_DESC_CNT + \
+                                 FW_DROP_LEVEL(bp))
+#define BD_TH_HI(bp)            (BD_TH_LO(bp) + DROPLESS_FC_HEADROOM)
+
+#define MIN_RX_AVAIL            ((bp)->dropless_fc ? BD_TH_HI(bp) + 128 : 128)
 
 #define MIN_RX_SIZE_TPA_HW      (CHIP_IS_E1(bp) ? \
                                         ETH_MIN_RX_CQES_WITH_TPA_E1 : \
@@ -579,7 +626,9 @@ struct bnx2x_fastpath {
                                                                 MIN_RX_AVAIL))
 
 #define NEXT_RX_IDX(x)          ((((x) & RX_DESC_MASK) == \
-                                  (MAX_RX_DESC_CNT - 1)) ? (x) + 3 : (x) + 1)
+                                  (MAX_RX_DESC_CNT - 1)) ? \
+                                        (x) + 1 + NEXT_PAGE_RX_DESC_CNT : \
+                                        (x) + 1)
 #define RX_BD(x)                ((x) & MAX_RX_BD)
 
 /*
@@ -589,14 +638,31 @@ struct bnx2x_fastpath {
 #define CQE_BD_REL      (sizeof(union eth_rx_cqe) / sizeof(struct eth_rx_bd))
 #define NUM_RCQ_RINGS           (NUM_RX_RINGS * CQE_BD_REL)
 #define RCQ_DESC_CNT            (BCM_PAGE_SIZE / sizeof(union eth_rx_cqe))
-#define MAX_RCQ_DESC_CNT        (RCQ_DESC_CNT - 1)
+#define NEXT_PAGE_RCQ_DESC_CNT  1
+#define MAX_RCQ_DESC_CNT        (RCQ_DESC_CNT - NEXT_PAGE_RCQ_DESC_CNT)
 #define NUM_RCQ_BD              (RCQ_DESC_CNT * NUM_RCQ_RINGS)
 #define MAX_RCQ_BD              (NUM_RCQ_BD - 1)
 #define MAX_RCQ_AVAIL           (MAX_RCQ_DESC_CNT * NUM_RCQ_RINGS - 2)
 #define NEXT_RCQ_IDX(x)         ((((x) & MAX_RCQ_DESC_CNT) == \
-                                  (MAX_RCQ_DESC_CNT - 1)) ? (x) + 2 : (x) + 1)
+                                  (MAX_RCQ_DESC_CNT - 1)) ? \
+                                        (x) + 1 + NEXT_PAGE_RCQ_DESC_CNT : \
+                                        (x) + 1)
 #define RCQ_BD(x)               ((x) & MAX_RCQ_BD)
 
+/* dropless fc calculations for RCQs
+ *
+ * Number of RCQs should be as number of buffers in BRB:
+ * Low threshold takes into account NEXT_PAGE_RCQ_DESC_CNT
+ * "next" elements on each page
+ */
+#define NUM_RCQ_REQ             BRB_SIZE(bp)
+#define NUM_RCQ_PG_REQ          ((NUM_BD_REQ + MAX_RCQ_DESC_CNT - 1) / \
+                                              MAX_RCQ_DESC_CNT)
+#define RCQ_TH_LO(bp)           (NUM_RCQ_REQ + \
+                                 NUM_RCQ_PG_REQ * NEXT_PAGE_RCQ_DESC_CNT + \
+                                 FW_DROP_LEVEL(bp))
+#define RCQ_TH_HI(bp)           (RCQ_TH_LO(bp) + DROPLESS_FC_HEADROOM)
+
 
 /* This is needed for determining of last_max */
 #define SUB_S16(a, b)           (s16)((s16)(a) - (s16)(b))
@@ -685,24 +751,17 @@ struct bnx2x_fastpath {
 #define FP_CSB_FUNC_OFF \
                         offsetof(struct cstorm_status_block_c, func)
 
-#define HC_INDEX_TOE_RX_CQ_CONS         0 /* Formerly Ustorm TOE CQ index */
-                                          /* (HC_INDEX_U_TOE_RX_CQ_CONS)  */
-#define HC_INDEX_ETH_RX_CQ_CONS         1 /* Formerly Ustorm ETH CQ index */
-                                          /* (HC_INDEX_U_ETH_RX_CQ_CONS)  */
-#define HC_INDEX_ETH_RX_BD_CONS         2 /* Formerly Ustorm ETH BD index */
-                                          /* (HC_INDEX_U_ETH_RX_BD_CONS)  */
-
-#define HC_INDEX_TOE_TX_CQ_CONS         4 /* Formerly Cstorm TOE CQ index   */
-                                          /* (HC_INDEX_C_TOE_TX_CQ_CONS)    */
-#define HC_INDEX_ETH_TX_CQ_CONS_COS0    5 /* Formerly Cstorm ETH CQ index   */
-                                          /* (HC_INDEX_C_ETH_TX_CQ_CONS)    */
-#define HC_INDEX_ETH_TX_CQ_CONS_COS1    6 /* Formerly Cstorm ETH CQ index   */
-                                          /* (HC_INDEX_C_ETH_TX_CQ_CONS)    */
-#define HC_INDEX_ETH_TX_CQ_CONS_COS2    7 /* Formerly Cstorm ETH CQ index   */
-                                          /* (HC_INDEX_C_ETH_TX_CQ_CONS)    */
+#define HC_INDEX_ETH_RX_CQ_CONS         1
 
-#define HC_INDEX_ETH_FIRST_TX_CQ_CONS   HC_INDEX_ETH_TX_CQ_CONS_COS0
+#define HC_INDEX_OOO_TX_CQ_CONS         4
 
+#define HC_INDEX_ETH_TX_CQ_CONS_COS0    5
+
+#define HC_INDEX_ETH_TX_CQ_CONS_COS1    6
+
+#define HC_INDEX_ETH_TX_CQ_CONS_COS2    7
+
+#define HC_INDEX_ETH_FIRST_TX_CQ_CONS   HC_INDEX_ETH_TX_CQ_CONS_COS0
 
 #define BNX2X_RX_SB_INDEX \
         (&fp->sb_index_values[HC_INDEX_ETH_RX_CQ_CONS])
@@ -1100,11 +1159,12 @@ struct bnx2x {
 #define BP_PORT(bp)                     (bp->pfid & 1)
 #define BP_FUNC(bp)                     (bp->pfid)
 #define BP_ABS_FUNC(bp)                 (bp->pf_num)
-#define BP_E1HVN(bp)                    (bp->pfid >> 1)
-#define BP_VN(bp)                       (BP_E1HVN(bp)) /*remove when approved*/
-#define BP_L_ID(bp)                     (BP_E1HVN(bp) << 2)
-#define BP_FW_MB_IDX(bp)                (BP_PORT(bp) +\
-          BP_VN(bp) * ((CHIP_IS_E1x(bp) || (CHIP_MODE_IS_4_PORT(bp))) ? 2  : 1))
+#define BP_VN(bp)                       ((bp)->pfid >> 1)
+#define BP_MAX_VN_NUM(bp)               (CHIP_MODE_IS_4_PORT(bp) ? 2 : 4)
+#define BP_L_ID(bp)                     (BP_VN(bp) << 2)
+#define BP_FW_MB_IDX_VN(bp, vn)         (BP_PORT(bp) +\
+          (vn) * ((CHIP_IS_E1x(bp) || (CHIP_MODE_IS_4_PORT(bp))) ? 2  : 1))
+#define BP_FW_MB_IDX(bp)                BP_FW_MB_IDX_VN(bp, BP_VN(bp))
 
         struct net_device       *dev;
         struct pci_dev          *pdev;
@@ -1767,7 +1827,7 @@ static inline u32 reg_poll(struct bnx2x *bp, u32 reg, u32 expected, int ms,
 
 #define MAX_DMAE_C_PER_PORT             8
 #define INIT_DMAE_C(bp)                 (BP_PORT(bp) * MAX_DMAE_C_PER_PORT + \
-                                         BP_E1HVN(bp))
+                                         BP_VN(bp))
 #define PMF_DMAE_C(bp)                  (BP_PORT(bp) * MAX_DMAE_C_PER_PORT + \
                                          E1HVN_MAX)
 
@@ -1793,7 +1853,7 @@ static inline u32 reg_poll(struct bnx2x *bp, u32 reg, u32 expected, int ms,
 
 /* must be used on a CID before placing it on a HW ring */
 #define HW_CID(bp, x)                   ((BP_PORT(bp) << 23) | \
-                                         (BP_E1HVN(bp) << BNX2X_SWCID_SHIFT) | \
+                                         (BP_VN(bp) << BNX2X_SWCID_SHIFT) | \
                                          (x))
 
 #define SP_DESC_CNT             (BCM_PAGE_SIZE / sizeof(struct eth_spe))
diff --git a/drivers/net/bnx2x/bnx2x_cmn.c b/drivers/net/bnx2x/bnx2x_cmn.c
index d724a18b5285..c4cbf9736414 100644
--- a/drivers/net/bnx2x/bnx2x_cmn.c
+++ b/drivers/net/bnx2x/bnx2x_cmn.c
@@ -63,8 +63,9 @@ static inline void bnx2x_bz_fp(struct bnx2x *bp, int index)
         fp->disable_tpa = ((bp->flags & TPA_ENABLE_FLAG) == 0);
 
 #ifdef BCM_CNIC
-        /* We don't want TPA on FCoE, FWD and OOO L2 rings */
-        bnx2x_fcoe(bp, disable_tpa) = 1;
+        /* We don't want TPA on an FCoE L2 ring */
+        if (IS_FCOE_FP(fp))
+                fp->disable_tpa = 1;
 #endif
 }
 
@@ -986,8 +987,6 @@ void __bnx2x_link_report(struct bnx2x *bp)
 void bnx2x_init_rx_rings(struct bnx2x *bp)
 {
         int func = BP_FUNC(bp);
-        int max_agg_queues = CHIP_IS_E1(bp) ? ETH_MAX_AGGREGATION_QUEUES_E1 :
-                                              ETH_MAX_AGGREGATION_QUEUES_E1H_E2;
         u16 ring_prod;
         int i, j;
 
@@ -1000,7 +999,7 @@ void bnx2x_init_rx_rings(struct bnx2x *bp)
 
                 if (!fp->disable_tpa) {
                         /* Fill the per-aggregtion pool */
-                        for (i = 0; i < max_agg_queues; i++) {
+                        for (i = 0; i < MAX_AGG_QS(bp); i++) {
                                 struct bnx2x_agg_info *tpa_info =
                                         &fp->tpa_info[i];
                                 struct sw_rx_bd *first_buf =
@@ -1040,7 +1039,7 @@ void bnx2x_init_rx_rings(struct bnx2x *bp)
                                         bnx2x_free_rx_sge_range(bp, fp,
                                                                 ring_prod);
                                         bnx2x_free_tpa_pool(bp, fp,
-                                                            max_agg_queues);
+                                                            MAX_AGG_QS(bp));
                                         fp->disable_tpa = 1;
                                         ring_prod = 0;
                                         break;
@@ -1136,9 +1135,7 @@ static void bnx2x_free_rx_skbs(struct bnx2x *bp)
                 bnx2x_free_rx_bds(fp);
 
                 if (!fp->disable_tpa)
-                        bnx2x_free_tpa_pool(bp, fp, CHIP_IS_E1(bp) ?
-                                            ETH_MAX_AGGREGATION_QUEUES_E1 :
-                                            ETH_MAX_AGGREGATION_QUEUES_E1H_E2);
+                        bnx2x_free_tpa_pool(bp, fp, MAX_AGG_QS(bp));
         }
 }
 
@@ -1404,10 +1401,9 @@ void bnx2x_netif_stop(struct bnx2x *bp, int disable_hw)
 u16 bnx2x_select_queue(struct net_device *dev, struct sk_buff *skb)
 {
         struct bnx2x *bp = netdev_priv(dev);
+
 #ifdef BCM_CNIC
-        if (NO_FCOE(bp))
-                return skb_tx_hash(dev, skb);
-        else {
+        if (!NO_FCOE(bp)) {
                 struct ethhdr *hdr = (struct ethhdr *)skb->data;
                 u16 ether_type = ntohs(hdr->h_proto);
 
@@ -1424,8 +1420,7 @@ u16 bnx2x_select_queue(struct net_device *dev, struct sk_buff *skb)
                         return bnx2x_fcoe_tx(bp, txq_index);
         }
 #endif
-        /* Select a none-FCoE queue:  if FCoE is enabled, exclude FCoE L2 ring
-         */
+        /* select a non-FCoE queue */
         return __skb_tx_hash(dev, skb, BNX2X_NUM_ETH_QUEUES(bp));
 }
 
@@ -1448,6 +1443,28 @@ void bnx2x_set_num_queues(struct bnx2x *bp)
         bp->num_queues += NON_ETH_CONTEXT_USE;
 }
 
+/**
+ * bnx2x_set_real_num_queues - configure netdev->real_num_[tx,rx]_queues
+ *
+ * @bp:         Driver handle
+ *
+ * We currently support for at most 16 Tx queues for each CoS thus we will
+ * allocate a multiple of 16 for ETH L2 rings according to the value of the
+ * bp->max_cos.
+ *
+ * If there is an FCoE L2 queue the appropriate Tx queue will have the next
+ * index after all ETH L2 indices.
+ *
+ * If the actual number of Tx queues (for each CoS) is less than 16 then there
+ * will be the holes at the end of each group of 16 ETh L2 indices (0..15,
+ * 16..31,...) with indicies that are not coupled with any real Tx queue.
+ *
+ * The proper configuration of skb->queue_mapping is handled by
+ * bnx2x_select_queue() and __skb_tx_hash().
+ *
+ * bnx2x_setup_tc() takes care of the proper TC mappings so that __skb_tx_hash()
+ * will return a proper Tx index if TC is enabled (netdev->num_tc > 0).
+ */
 static inline int bnx2x_set_real_num_queues(struct bnx2x *bp)
 {
         int rc, tx, rx;
@@ -3074,15 +3091,20 @@ static int bnx2x_alloc_fp_mem_at(struct bnx2x *bp, int index)
         struct bnx2x_fastpath *fp = &bp->fp[index];
         int ring_size = 0;
         u8 cos;
+        int rx_ring_size = 0;
 
         /* if rx_ring_size specified - use it */
-        int rx_ring_size = bp->rx_ring_size ? bp->rx_ring_size :
-                           MAX_RX_AVAIL/BNX2X_NUM_RX_QUEUES(bp);
+        if (!bp->rx_ring_size) {
 
-        /* allocate at least number of buffers required by FW */
-        rx_ring_size = max_t(int, bp->disable_tpa ? MIN_RX_SIZE_NONTPA :
-                                                    MIN_RX_SIZE_TPA,
-                                  rx_ring_size);
+                rx_ring_size = MAX_RX_AVAIL/BNX2X_NUM_RX_QUEUES(bp);
+
+                /* allocate at least number of buffers required by FW */
+                rx_ring_size = max_t(int, bp->disable_tpa ? MIN_RX_SIZE_NONTPA :
+                                     MIN_RX_SIZE_TPA, rx_ring_size);
+
+                bp->rx_ring_size = rx_ring_size;
+        } else
+                rx_ring_size = bp->rx_ring_size;
 
         /* Common */
         sb = &bnx2x_fp(bp, index, status_blk);
diff --git a/drivers/net/bnx2x/bnx2x_dcb.c b/drivers/net/bnx2x/bnx2x_dcb.c
index a4ea35f6a456..0b4acf67e0c6 100644
--- a/drivers/net/bnx2x/bnx2x_dcb.c
+++ b/drivers/net/bnx2x/bnx2x_dcb.c
@@ -920,7 +920,7 @@ static void bnx2x_dcbx_admin_mib_updated_params(struct bnx2x *bp,
 
 void bnx2x_dcbx_set_state(struct bnx2x *bp, bool dcb_on, u32 dcbx_enabled)
 {
-        if (!CHIP_IS_E1x(bp)) {
+        if (!CHIP_IS_E1x(bp) && !CHIP_IS_E3(bp)) {
                 bp->dcb_state = dcb_on;
                 bp->dcbx_enabled = dcbx_enabled;
         } else {
@@ -2120,6 +2120,7 @@ static u8 bnx2x_dcbnl_get_cap(struct net_device *netdev, int capid, u8 *cap)
                         break;
                 case DCB_CAP_ATTR_DCBX:
                         *cap = BNX2X_DCBX_CAPS;
+                        break;
                 default:
                         rval = -EINVAL;
                         break;
diff --git a/drivers/net/bnx2x/bnx2x_ethtool.c b/drivers/net/bnx2x/bnx2x_ethtool.c
index 221863059dae..cf3e47914dd7 100644
--- a/drivers/net/bnx2x/bnx2x_ethtool.c
+++ b/drivers/net/bnx2x/bnx2x_ethtool.c
@@ -363,13 +363,50 @@ static int bnx2x_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                 }
 
                 /* advertise the requested speed and duplex if supported */
-                cmd->advertising &= bp->port.supported[cfg_idx];
+                if (cmd->advertising & ~(bp->port.supported[cfg_idx])) {
+                        DP(NETIF_MSG_LINK, "Advertisement parameters "
+                                           "are not supported\n");
+                        return -EINVAL;
+                }
 
                 bp->link_params.req_line_speed[cfg_idx] = SPEED_AUTO_NEG;
-                bp->link_params.req_duplex[cfg_idx] = DUPLEX_FULL;
-                bp->port.advertising[cfg_idx] |= (ADVERTISED_Autoneg |
+                bp->link_params.req_duplex[cfg_idx] = cmd->duplex;
+                bp->port.advertising[cfg_idx] = (ADVERTISED_Autoneg |
                                          cmd->advertising);
+                if (cmd->advertising) {
+
+                        bp->link_params.speed_cap_mask[cfg_idx] = 0;
+                        if (cmd->advertising & ADVERTISED_10baseT_Half) {
+                                bp->link_params.speed_cap_mask[cfg_idx] |=
+                                PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF;
+                        }
+                        if (cmd->advertising & ADVERTISED_10baseT_Full)
+                                bp->link_params.speed_cap_mask[cfg_idx] |=
+                                PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL;
 
+                        if (cmd->advertising & ADVERTISED_100baseT_Full)
+                                bp->link_params.speed_cap_mask[cfg_idx] |=
+                                PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL;
+
+                        if (cmd->advertising & ADVERTISED_100baseT_Half) {
+                                bp->link_params.speed_cap_mask[cfg_idx] |=
+                                     PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF;
+                        }
+                        if (cmd->advertising & ADVERTISED_1000baseT_Half) {
+                                bp->link_params.speed_cap_mask[cfg_idx] |=
+                                        PORT_HW_CFG_SPEED_CAPABILITY_D0_1G;
+                        }
+                        if (cmd->advertising & (ADVERTISED_1000baseT_Full |
+                                                ADVERTISED_1000baseKX_Full))
+                                bp->link_params.speed_cap_mask[cfg_idx] |=
+                                        PORT_HW_CFG_SPEED_CAPABILITY_D0_1G;
+
+                        if (cmd->advertising & (ADVERTISED_10000baseT_Full |
+                                                ADVERTISED_10000baseKX4_Full |
+                                                ADVERTISED_10000baseKR_Full))
+                                bp->link_params.speed_cap_mask[cfg_idx] |=
+                                        PORT_HW_CFG_SPEED_CAPABILITY_D0_10G;
+                }
         } else { /* forced speed */
                 /* advertise the requested speed and duplex if supported */
                 switch (speed) {
@@ -1310,10 +1347,7 @@ static void bnx2x_get_ringparam(struct net_device *dev,
         if (bp->rx_ring_size)
                 ering->rx_pending = bp->rx_ring_size;
         else
-                if (bp->state == BNX2X_STATE_OPEN && bp->num_queues)
-                        ering->rx_pending = MAX_RX_AVAIL/bp->num_queues;
-                else
-                        ering->rx_pending = MAX_RX_AVAIL;
+                ering->rx_pending = MAX_RX_AVAIL;
 
         ering->rx_mini_pending = 0;
         ering->rx_jumbo_pending = 0;
diff --git a/drivers/net/bnx2x/bnx2x_link.c b/drivers/net/bnx2x/bnx2x_link.c
index d45b1555a602..ba15bdc5a1a9 100644
--- a/drivers/net/bnx2x/bnx2x_link.c
+++ b/drivers/net/bnx2x/bnx2x_link.c
@@ -778,9 +778,9 @@ static int bnx2x_ets_e3b0_set_cos_bw(struct bnx2x *bp,
 {
         u32 nig_reg_adress_crd_weight = 0;
         u32 pbf_reg_adress_crd_weight = 0;
-        /* Calculate and set BW for this COS*/
-        const u32 cos_bw_nig = (bw * min_w_val_nig) / total_bw;
-        const u32 cos_bw_pbf = (bw * min_w_val_pbf) / total_bw;
+        /* Calculate and set BW for this COS - use 1 instead of 0 for BW */
+        const u32 cos_bw_nig = ((bw ? bw : 1) * min_w_val_nig) / total_bw;
+        const u32 cos_bw_pbf = ((bw ? bw : 1) * min_w_val_pbf) / total_bw;
 
         switch (cos_entry) {
         case 0:
@@ -852,18 +852,12 @@ static int bnx2x_ets_e3b0_get_total_bw(
         /* Calculate total BW requested */
         for (cos_idx = 0; cos_idx < ets_params->num_of_cos; cos_idx++) {
                 if (bnx2x_cos_state_bw == ets_params->cos[cos_idx].state) {
-
-                        if (0 == ets_params->cos[cos_idx].params.bw_params.bw) {
-                                DP(NETIF_MSG_LINK, "bnx2x_ets_E3B0_config BW"
-                                                   "was set to 0\n");
-                        return -EINVAL;
+                        *total_bw +=
+                                ets_params->cos[cos_idx].params.bw_params.bw;
                 }
-                *total_bw +=
-                    ets_params->cos[cos_idx].params.bw_params.bw;
-            }
         }
 
-        /*Check taotl BW is valid */
+        /* Check total BW is valid */
         if ((100 != *total_bw) || (0 == *total_bw)) {
                 if (0 == *total_bw) {
                         DP(NETIF_MSG_LINK, "bnx2x_ets_E3B0_config toatl BW"
@@ -1726,7 +1720,7 @@ static int bnx2x_xmac_enable(struct link_params *params,
 
         /* Check loopback mode */
         if (lb)
-                val |= XMAC_CTRL_REG_CORE_LOCAL_LPBK;
+                val |= XMAC_CTRL_REG_LINE_LOCAL_LPBK;
         REG_WR(bp, xmac_base + XMAC_REG_CTRL, val);
         bnx2x_set_xumac_nig(params,
                             ((vars->flow_ctrl & BNX2X_FLOW_CTRL_TX) != 0), 1);
@@ -3630,6 +3624,12 @@ static void bnx2x_warpcore_enable_AN_KR(struct bnx2x_phy *phy,
         bnx2x_cl45_write(bp, phy, MDIO_AN_DEVAD,
                          MDIO_WC_REG_AN_IEEE1BLK_AN_ADVERTISEMENT1, val16);
 
+        /* Advertised and set FEC (Forward Error Correction) */
+        bnx2x_cl45_write(bp, phy, MDIO_AN_DEVAD,
+                         MDIO_WC_REG_AN_IEEE1BLK_AN_ADVERTISEMENT2,
+                         (MDIO_WC_REG_AN_IEEE1BLK_AN_ADV2_FEC_ABILITY |
+                          MDIO_WC_REG_AN_IEEE1BLK_AN_ADV2_FEC_REQ));
+
         /* Enable CL37 BAM */
         if (REG_RD(bp, params->shmem_base +
                    offsetof(struct shmem_region, dev_info.
@@ -5924,7 +5924,7 @@ int bnx2x_set_led(struct link_params *params,
                                         (tmp | EMAC_LED_OVERRIDE));
                                 /*
                                  * return here without enabling traffic
-                                 * LED blink andsetting rate in ON mode.
+                                 * LED blink and setting rate in ON mode.
                                  * In oper mode, enabling LED blink
                                  * and setting rate is needed.
                                  */
@@ -5936,7 +5936,11 @@ int bnx2x_set_led(struct link_params *params,
                          * This is a work-around for HW issue found when link
                          * is up in CL73
                          */
-                        REG_WR(bp, NIG_REG_LED_10G_P0 + port*4, 1);
+                        if ((!CHIP_IS_E3(bp)) ||
+                            (CHIP_IS_E3(bp) &&
+                             mode == LED_MODE_ON))
+                                REG_WR(bp, NIG_REG_LED_10G_P0 + port*4, 1);
+
                         if (CHIP_IS_E1x(bp) ||
                             CHIP_IS_E2(bp) ||
                             (mode == LED_MODE_ON))
@@ -10638,8 +10642,7 @@ static struct bnx2x_phy phy_warpcore = {
         .type           = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT,
         .addr           = 0xff,
         .def_md_devad   = 0,
-        .flags          = (FLAGS_HW_LOCK_REQUIRED |
-                           FLAGS_TX_ERROR_CHECK),
+        .flags          = FLAGS_HW_LOCK_REQUIRED,
         .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .mdio_ctrl      = 0,
@@ -10765,8 +10768,7 @@ static struct bnx2x_phy phy_8706 = {
         .type           = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706,
         .addr           = 0xff,
         .def_md_devad   = 0,
-        .flags          = (FLAGS_INIT_XGXS_FIRST |
-                           FLAGS_TX_ERROR_CHECK),
+        .flags          = FLAGS_INIT_XGXS_FIRST,
         .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .mdio_ctrl      = 0,
@@ -10797,8 +10799,7 @@ static struct bnx2x_phy phy_8726 = {
         .addr           = 0xff,
         .def_md_devad   = 0,
         .flags          = (FLAGS_HW_LOCK_REQUIRED |
-                           FLAGS_INIT_XGXS_FIRST |
-                           FLAGS_TX_ERROR_CHECK),
+                           FLAGS_INIT_XGXS_FIRST),
         .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .mdio_ctrl      = 0,
@@ -10829,8 +10830,7 @@ static struct bnx2x_phy phy_8727 = {
         .type           = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
         .addr           = 0xff,
         .def_md_devad   = 0,
-        .flags          = (FLAGS_FAN_FAILURE_DET_REQ |
-                           FLAGS_TX_ERROR_CHECK),
+        .flags          = FLAGS_FAN_FAILURE_DET_REQ,
         .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .mdio_ctrl      = 0,
diff --git a/drivers/net/bnx2x/bnx2x_main.c b/drivers/net/bnx2x/bnx2x_main.c
index 150709111548..15f800085bb2 100644
--- a/drivers/net/bnx2x/bnx2x_main.c
+++ b/drivers/net/bnx2x/bnx2x_main.c
@@ -407,8 +407,8 @@ u32 bnx2x_dmae_opcode(struct bnx2x *bp, u8 src_type, u8 dst_type,
         opcode |= (DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET);
 
         opcode |= (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0);
-        opcode |= ((BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT) |
-                   (BP_E1HVN(bp) << DMAE_COMMAND_DST_VN_SHIFT));
+        opcode |= ((BP_VN(bp) << DMAE_CMD_E1HVN_SHIFT) |
+                   (BP_VN(bp) << DMAE_COMMAND_DST_VN_SHIFT));
         opcode |= (DMAE_COM_SET_ERR << DMAE_COMMAND_ERR_POLICY_SHIFT);
 
 #ifdef __BIG_ENDIAN
@@ -1419,7 +1419,7 @@ static void bnx2x_hc_int_enable(struct bnx2x *bp)
         if (!CHIP_IS_E1(bp)) {
                 /* init leading/trailing edge */
                 if (IS_MF(bp)) {
-                        val = (0xee0f | (1 << (BP_E1HVN(bp) + 4)));
+                        val = (0xee0f | (1 << (BP_VN(bp) + 4)));
                         if (bp->port.pmf)
                                 /* enable nig and gpio3 attention */
                                 val |= 0x1100;
@@ -1471,7 +1471,7 @@ static void bnx2x_igu_int_enable(struct bnx2x *bp)
 
         /* init leading/trailing edge */
         if (IS_MF(bp)) {
-                val = (0xee0f | (1 << (BP_E1HVN(bp) + 4)));
+                val = (0xee0f | (1 << (BP_VN(bp) + 4)));
                 if (bp->port.pmf)
                         /* enable nig and gpio3 attention */
                         val |= 0x1100;
@@ -2287,7 +2287,7 @@ static void bnx2x_calc_vn_weight_sum(struct bnx2x *bp)
         int vn;
 
         bp->vn_weight_sum = 0;
-        for (vn = VN_0; vn < E1HVN_MAX; vn++) {
+        for (vn = VN_0; vn < BP_MAX_VN_NUM(bp); vn++) {
                 u32 vn_cfg = bp->mf_config[vn];
                 u32 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
                                    FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
@@ -2320,12 +2320,18 @@ static void bnx2x_calc_vn_weight_sum(struct bnx2x *bp)
                                         CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
 }
 
+/* returns func by VN for current port */
+static inline int func_by_vn(struct bnx2x *bp, int vn)
+{
+        return 2 * vn + BP_PORT(bp);
+}
+
 static void bnx2x_init_vn_minmax(struct bnx2x *bp, int vn)
 {
         struct rate_shaping_vars_per_vn m_rs_vn;
         struct fairness_vars_per_vn m_fair_vn;
         u32 vn_cfg = bp->mf_config[vn];
-        int func = 2*vn + BP_PORT(bp);
+        int func = func_by_vn(bp, vn);
         u16 vn_min_rate, vn_max_rate;
         int i;
 
@@ -2422,7 +2428,7 @@ void bnx2x_read_mf_cfg(struct bnx2x *bp)
          *
          *      and there are 2 functions per port
          */
-        for (vn = VN_0; vn < E1HVN_MAX; vn++) {
+        for (vn = VN_0; vn < BP_MAX_VN_NUM(bp); vn++) {
                 int /*abs*/func = n * (2 * vn + BP_PORT(bp)) + BP_PATH(bp);
 
                 if (func >= E1H_FUNC_MAX)
@@ -2454,7 +2460,7 @@ static void bnx2x_cmng_fns_init(struct bnx2x *bp, u8 read_cfg, u8 cmng_type)
 
                 /* calculate and set min-max rate for each vn */
                 if (bp->port.pmf)
-                        for (vn = VN_0; vn < E1HVN_MAX; vn++)
+                        for (vn = VN_0; vn < BP_MAX_VN_NUM(bp); vn++)
                                 bnx2x_init_vn_minmax(bp, vn);
 
                 /* always enable rate shaping and fairness */
@@ -2473,16 +2479,15 @@ static void bnx2x_cmng_fns_init(struct bnx2x *bp, u8 read_cfg, u8 cmng_type)
 
 static inline void bnx2x_link_sync_notify(struct bnx2x *bp)
 {
-        int port = BP_PORT(bp);
         int func;
         int vn;
 
         /* Set the attention towards other drivers on the same port */
-        for (vn = VN_0; vn < E1HVN_MAX; vn++) {
-                if (vn == BP_E1HVN(bp))
+        for (vn = VN_0; vn < BP_MAX_VN_NUM(bp); vn++) {
+                if (vn == BP_VN(bp))
                         continue;
 
-                func = ((vn << 1) | port);
+                func = func_by_vn(bp, vn);
                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_0 +
                        (LINK_SYNC_ATTENTION_BIT_FUNC_0 + func)*4, 1);
         }
@@ -2577,7 +2582,7 @@ static void bnx2x_pmf_update(struct bnx2x *bp)
         bnx2x_dcbx_pmf_update(bp);
 
         /* enable nig attention */
-        val = (0xff0f | (1 << (BP_E1HVN(bp) + 4)));
+        val = (0xff0f | (1 << (BP_VN(bp) + 4)));
         if (bp->common.int_block == INT_BLOCK_HC) {
                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
@@ -2756,8 +2761,14 @@ static void bnx2x_pf_rx_q_prep(struct bnx2x *bp,
         u16 tpa_agg_size = 0;
 
         if (!fp->disable_tpa) {
-                pause->sge_th_hi = 250;
-                pause->sge_th_lo = 150;
+                pause->sge_th_lo = SGE_TH_LO(bp);
+                pause->sge_th_hi = SGE_TH_HI(bp);
+
+                /* validate SGE ring has enough to cross high threshold */
+                WARN_ON(bp->dropless_fc &&
+                                pause->sge_th_hi + FW_PREFETCH_CNT >
+                                MAX_RX_SGE_CNT * NUM_RX_SGE_PAGES);
+
                 tpa_agg_size = min_t(u32,
                         (min_t(u32, 8, MAX_SKB_FRAGS) *
                         SGE_PAGE_SIZE * PAGES_PER_SGE), 0xffff);
@@ -2771,10 +2782,21 @@ static void bnx2x_pf_rx_q_prep(struct bnx2x *bp,
 
         /* pause - not for e1 */
         if (!CHIP_IS_E1(bp)) {
-                pause->bd_th_hi = 350;
-                pause->bd_th_lo = 250;
-                pause->rcq_th_hi = 350;
-                pause->rcq_th_lo = 250;
+                pause->bd_th_lo = BD_TH_LO(bp);
+                pause->bd_th_hi = BD_TH_HI(bp);
+
+                pause->rcq_th_lo = RCQ_TH_LO(bp);
+                pause->rcq_th_hi = RCQ_TH_HI(bp);
+                /*
+                 * validate that rings have enough entries to cross
+                 * high thresholds
+                 */
+                WARN_ON(bp->dropless_fc &&
+                                pause->bd_th_hi + FW_PREFETCH_CNT >
+                                bp->rx_ring_size);
+                WARN_ON(bp->dropless_fc &&
+                                pause->rcq_th_hi + FW_PREFETCH_CNT >
+                                NUM_RCQ_RINGS * MAX_RCQ_DESC_CNT);
 
                 pause->pri_map = 1;
         }
@@ -2802,9 +2824,7 @@ static void bnx2x_pf_rx_q_prep(struct bnx2x *bp,
          * For PF Clients it should be the maximum avaliable number.
          * VF driver(s) may want to define it to a smaller value.
          */
-        rxq_init->max_tpa_queues =
-                (CHIP_IS_E1(bp) ? ETH_MAX_AGGREGATION_QUEUES_E1 :
-                ETH_MAX_AGGREGATION_QUEUES_E1H_E2);
+        rxq_init->max_tpa_queues = MAX_AGG_QS(bp);
 
         rxq_init->cache_line_log = BNX2X_RX_ALIGN_SHIFT;
         rxq_init->fw_sb_id = fp->fw_sb_id;
@@ -4808,6 +4828,37 @@ void bnx2x_setup_ndsb_state_machine(struct hc_status_block_sm *hc_sm,
         hc_sm->time_to_expire = 0xFFFFFFFF;
 }
 
+
+/* allocates state machine ids. */
+static inline
+void bnx2x_map_sb_state_machines(struct hc_index_data *index_data)
+{
+        /* zero out state machine indices */
+        /* rx indices */
+        index_data[HC_INDEX_ETH_RX_CQ_CONS].flags &= ~HC_INDEX_DATA_SM_ID;
+
+        /* tx indices */
+        index_data[HC_INDEX_OOO_TX_CQ_CONS].flags &= ~HC_INDEX_DATA_SM_ID;
+        index_data[HC_INDEX_ETH_TX_CQ_CONS_COS0].flags &= ~HC_INDEX_DATA_SM_ID;
+        index_data[HC_INDEX_ETH_TX_CQ_CONS_COS1].flags &= ~HC_INDEX_DATA_SM_ID;
+        index_data[HC_INDEX_ETH_TX_CQ_CONS_COS2].flags &= ~HC_INDEX_DATA_SM_ID;
+
+        /* map indices */
+        /* rx indices */
+        index_data[HC_INDEX_ETH_RX_CQ_CONS].flags |=
+                SM_RX_ID << HC_INDEX_DATA_SM_ID_SHIFT;
+
+        /* tx indices */
+        index_data[HC_INDEX_OOO_TX_CQ_CONS].flags |=
+                SM_TX_ID << HC_INDEX_DATA_SM_ID_SHIFT;
+        index_data[HC_INDEX_ETH_TX_CQ_CONS_COS0].flags |=
+                SM_TX_ID << HC_INDEX_DATA_SM_ID_SHIFT;
+        index_data[HC_INDEX_ETH_TX_CQ_CONS_COS1].flags |=
+                SM_TX_ID << HC_INDEX_DATA_SM_ID_SHIFT;
+        index_data[HC_INDEX_ETH_TX_CQ_CONS_COS2].flags |=
+                SM_TX_ID << HC_INDEX_DATA_SM_ID_SHIFT;
+}
+
 static void bnx2x_init_sb(struct bnx2x *bp, dma_addr_t mapping, int vfid,
                           u8 vf_valid, int fw_sb_id, int igu_sb_id)
 {
@@ -4839,6 +4890,7 @@ static void bnx2x_init_sb(struct bnx2x *bp, dma_addr_t mapping, int vfid,
                 hc_sm_p = sb_data_e2.common.state_machine;
                 sb_data_p = (u32 *)&sb_data_e2;
                 data_size = sizeof(struct hc_status_block_data_e2)/sizeof(u32);
+                bnx2x_map_sb_state_machines(sb_data_e2.index_data);
         } else {
                 memset(&sb_data_e1x, 0,
                        sizeof(struct hc_status_block_data_e1x));
@@ -4853,6 +4905,7 @@ static void bnx2x_init_sb(struct bnx2x *bp, dma_addr_t mapping, int vfid,
                 hc_sm_p = sb_data_e1x.common.state_machine;
                 sb_data_p = (u32 *)&sb_data_e1x;
                 data_size = sizeof(struct hc_status_block_data_e1x)/sizeof(u32);
+                bnx2x_map_sb_state_machines(sb_data_e1x.index_data);
         }
 
         bnx2x_setup_ndsb_state_machine(&hc_sm_p[SM_RX_ID],
@@ -4890,7 +4943,7 @@ static void bnx2x_init_def_sb(struct bnx2x *bp)
         int igu_seg_id;
         int port = BP_PORT(bp);
         int func = BP_FUNC(bp);
-        int reg_offset;
+        int reg_offset, reg_offset_en5;
         u64 section;
         int index;
         struct hc_sp_status_block_data sp_sb_data;
@@ -4913,6 +4966,8 @@ static void bnx2x_init_def_sb(struct bnx2x *bp)
 
         reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
                              MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
+        reg_offset_en5 = (port ? MISC_REG_AEU_ENABLE5_FUNC_1_OUT_0 :
+                                 MISC_REG_AEU_ENABLE5_FUNC_0_OUT_0);
         for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
                 int sindex;
                 /* take care of sig[0]..sig[4] */
@@ -4927,7 +4982,7 @@ static void bnx2x_init_def_sb(struct bnx2x *bp)
                          * and not 16 between the different groups
                          */
                         bp->attn_group[index].sig[4] = REG_RD(bp,
-                                        reg_offset + 0x10 + 0x4*index);
+                                        reg_offset_en5 + 0x4*index);
                 else
                         bp->attn_group[index].sig[4] = 0;
         }
@@ -5798,6 +5853,12 @@ static int bnx2x_init_hw_common(struct bnx2x *bp)
 
         DP(BNX2X_MSG_MCP, "starting common init  func %d\n", BP_ABS_FUNC(bp));
 
+        /*
+         * take the UNDI lock to protect undi_unload flow from accessing
+         * registers while we're resetting the chip
+         */
+        bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_RESET);
+
         bnx2x_reset_common(bp);
         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0xffffffff);
 
@@ -5808,6 +5869,8 @@ static int bnx2x_init_hw_common(struct bnx2x *bp)
         }
         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET, val);
 
+        bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_RESET);
+
         bnx2x_init_block(bp, BLOCK_MISC, PHASE_COMMON);
 
         if (!CHIP_IS_E1x(bp)) {
@@ -6663,12 +6726,16 @@ static int bnx2x_init_hw_func(struct bnx2x *bp)
                         if (CHIP_MODE_IS_4_PORT(bp))
                                 dsb_idx = BP_FUNC(bp);
                         else
-                                dsb_idx = BP_E1HVN(bp);
+                                dsb_idx = BP_VN(bp);
 
                         prod_offset = (CHIP_INT_MODE_IS_BC(bp) ?
                                        IGU_BC_BASE_DSB_PROD + dsb_idx :
                                        IGU_NORM_BASE_DSB_PROD + dsb_idx);
 
+                        /*
+                         * igu prods come in chunks of E1HVN_MAX (4) -
+                         * does not matters what is the current chip mode
+                         */
                         for (i = 0; i < (num_segs * E1HVN_MAX);
                              i += E1HVN_MAX) {
                                 addr = IGU_REG_PROD_CONS_MEMORY +
@@ -7560,9 +7627,12 @@ u32 bnx2x_send_unload_req(struct bnx2x *bp, int unload_mode)
                 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
                 u8 *mac_addr = bp->dev->dev_addr;
                 u32 val;
+                u16 pmc;
+
                 /* The mac address is written to entries 1-4 to
-                   preserve entry 0 which is used by the PMF */
-                u8 entry = (BP_E1HVN(bp) + 1)*8;
+                 * preserve entry 0 which is used by the PMF
+                 */
+                u8 entry = (BP_VN(bp) + 1)*8;
 
                 val = (mac_addr[0] << 8) | mac_addr[1];
                 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry, val);
@@ -7571,6 +7641,11 @@ u32 bnx2x_send_unload_req(struct bnx2x *bp, int unload_mode)
                       (mac_addr[4] << 8) | mac_addr[5];
                 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry + 4, val);
 
+                /* Enable the PME and clear the status */
+                pci_read_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL, &pmc);
+                pmc |= PCI_PM_CTRL_PME_ENABLE | PCI_PM_CTRL_PME_STATUS;
+                pci_write_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL, pmc);
+
                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_EN;
 
         } else
@@ -8538,10 +8613,12 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
         /* Check if there is any driver already loaded */
         val = REG_RD(bp, MISC_REG_UNPREPARED);
         if (val == 0x1) {
-                /* Check if it is the UNDI driver
+
+                bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_RESET);
+                /*
+                 * Check if it is the UNDI driver
                  * UNDI driver initializes CID offset for normal bell to 0x7
                  */
-                bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
                 val = REG_RD(bp, DORQ_REG_NORM_CID_OFST);
                 if (val == 0x7) {
                         u32 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
@@ -8579,9 +8656,6 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
                                 bnx2x_fw_command(bp, reset_code, 0);
                         }
 
-                        /* now it's safe to release the lock */
-                        bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
-
                         bnx2x_undi_int_disable(bp);
                         port = BP_PORT(bp);
 
@@ -8631,8 +8705,10 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
                         bp->fw_seq =
                               (SHMEM_RD(bp, func_mb[bp->pf_num].drv_mb_header) &
                                 DRV_MSG_SEQ_NUMBER_MASK);
-                } else
-                        bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
+                }
+
+                /* now it's safe to release the lock */
+                bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_RESET);
         }
 }
 
@@ -8769,13 +8845,13 @@ static void __devinit bnx2x_get_common_hwinfo(struct bnx2x *bp)
 static void __devinit bnx2x_get_igu_cam_info(struct bnx2x *bp)
 {
         int pfid = BP_FUNC(bp);
-        int vn = BP_E1HVN(bp);
         int igu_sb_id;
         u32 val;
         u8 fid, igu_sb_cnt = 0;
 
         bp->igu_base_sb = 0xff;
         if (CHIP_INT_MODE_IS_BC(bp)) {
+                int vn = BP_VN(bp);
                 igu_sb_cnt = bp->igu_sb_cnt;
                 bp->igu_base_sb = (CHIP_MODE_IS_4_PORT(bp) ? pfid : vn) *
                         FP_SB_MAX_E1x;
@@ -9408,6 +9484,10 @@ static int __devinit bnx2x_get_hwinfo(struct bnx2x *bp)
                 bp->igu_base_sb = 0;
         } else {
                 bp->common.int_block = INT_BLOCK_IGU;
+
+                /* do not allow device reset during IGU info preocessing */
+                bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_RESET);
+
                 val = REG_RD(bp, IGU_REG_BLOCK_CONFIGURATION);
 
                 if (val & IGU_BLOCK_CONFIGURATION_REG_BACKWARD_COMP_EN) {
@@ -9439,6 +9519,7 @@ static int __devinit bnx2x_get_hwinfo(struct bnx2x *bp)
 
                 bnx2x_get_igu_cam_info(bp);
 
+                bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_RESET);
         }
 
         /*
@@ -9465,7 +9546,7 @@ static int __devinit bnx2x_get_hwinfo(struct bnx2x *bp)
 
         bp->mf_ov = 0;
         bp->mf_mode = 0;
-        vn = BP_E1HVN(bp);
+        vn = BP_VN(bp);
 
         if (!CHIP_IS_E1(bp) && !BP_NOMCP(bp)) {
                 BNX2X_DEV_INFO("shmem2base 0x%x, size %d, mfcfg offset %d\n",
@@ -9585,13 +9666,6 @@ static int __devinit bnx2x_get_hwinfo(struct bnx2x *bp)
         /* port info */
         bnx2x_get_port_hwinfo(bp);
 
-        if (!BP_NOMCP(bp)) {
-                bp->fw_seq =
-                        (SHMEM_RD(bp, func_mb[BP_FW_MB_IDX(bp)].drv_mb_header) &
-                         DRV_MSG_SEQ_NUMBER_MASK);
-                BNX2X_DEV_INFO("fw_seq 0x%08x\n", bp->fw_seq);
-        }
-
         /* Get MAC addresses */
         bnx2x_get_mac_hwinfo(bp);
 
@@ -9757,6 +9831,14 @@ static int __devinit bnx2x_init_bp(struct bnx2x *bp)
         if (!BP_NOMCP(bp))
                 bnx2x_undi_unload(bp);
 
+        /* init fw_seq after undi_unload! */
+        if (!BP_NOMCP(bp)) {
+                bp->fw_seq =
+                        (SHMEM_RD(bp, func_mb[BP_FW_MB_IDX(bp)].drv_mb_header) &
+                         DRV_MSG_SEQ_NUMBER_MASK);
+                BNX2X_DEV_INFO("fw_seq 0x%08x\n", bp->fw_seq);
+        }
+
         if (CHIP_REV_IS_FPGA(bp))
                 dev_err(&bp->pdev->dev, "FPGA detected\n");
 
@@ -10251,10 +10333,21 @@ static int __devinit bnx2x_init_dev(struct pci_dev *pdev,
         /* clean indirect addresses */
         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
                                PCICFG_VENDOR_ID_OFFSET);
-        REG_WR(bp, PXP2_REG_PGL_ADDR_88_F0 + BP_PORT(bp)*16, 0);
-        REG_WR(bp, PXP2_REG_PGL_ADDR_8C_F0 + BP_PORT(bp)*16, 0);
-        REG_WR(bp, PXP2_REG_PGL_ADDR_90_F0 + BP_PORT(bp)*16, 0);
-        REG_WR(bp, PXP2_REG_PGL_ADDR_94_F0 + BP_PORT(bp)*16, 0);
+        /*
+         * Clean the following indirect addresses for all functions since it
+         * is not used by the driver.
+         */
+        REG_WR(bp, PXP2_REG_PGL_ADDR_88_F0, 0);
+        REG_WR(bp, PXP2_REG_PGL_ADDR_8C_F0, 0);
+        REG_WR(bp, PXP2_REG_PGL_ADDR_90_F0, 0);
+        REG_WR(bp, PXP2_REG_PGL_ADDR_94_F0, 0);
+
+        if (CHIP_IS_E1x(bp)) {
+                REG_WR(bp, PXP2_REG_PGL_ADDR_88_F1, 0);
+                REG_WR(bp, PXP2_REG_PGL_ADDR_8C_F1, 0);
+                REG_WR(bp, PXP2_REG_PGL_ADDR_90_F1, 0);
+                REG_WR(bp, PXP2_REG_PGL_ADDR_94_F1, 0);
+        }
 
         /*
          * Enable internal target-read (in case we are probed after PF FLR).
diff --git a/drivers/net/bnx2x/bnx2x_reg.h b/drivers/net/bnx2x/bnx2x_reg.h
index 27b5ecb11830..fc7bd0f23c0b 100644
--- a/drivers/net/bnx2x/bnx2x_reg.h
+++ b/drivers/net/bnx2x/bnx2x_reg.h
@@ -1384,6 +1384,18 @@
    Latched ump_tx_parity; [31] MCP Latched scpad_parity; */
 #define MISC_REG_AEU_ENABLE4_PXP_0                               0xa108
 #define MISC_REG_AEU_ENABLE4_PXP_1                               0xa1a8
+/* [RW 32] fifth 32b for enabling the output for function 0 output0. Mapped
+ * as follows: [0] PGLUE config_space; [1] PGLUE misc_flr; [2] PGLUE B RBC
+ * attention [3] PGLUE B RBC parity; [4] ATC attention; [5] ATC parity; [6]
+ * mstat0 attention; [7] mstat0 parity; [8] mstat1 attention; [9] mstat1
+ * parity; [31-10] Reserved; */
+#define MISC_REG_AEU_ENABLE5_FUNC_0_OUT_0                        0xa688
+/* [RW 32] Fifth 32b for enabling the output for function 1 output0. Mapped
+ * as follows: [0] PGLUE config_space; [1] PGLUE misc_flr; [2] PGLUE B RBC
+ * attention [3] PGLUE B RBC parity; [4] ATC attention; [5] ATC parity; [6]
+ * mstat0 attention; [7] mstat0 parity; [8] mstat1 attention; [9] mstat1
+ * parity; [31-10] Reserved; */
+#define MISC_REG_AEU_ENABLE5_FUNC_1_OUT_0                        0xa6b0
 /* [RW 1] set/clr general attention 0; this will set/clr bit 94 in the aeu
    128 bit vector */
 #define MISC_REG_AEU_GENERAL_ATTN_0                              0xa000
@@ -3007,11 +3019,27 @@
 /* [R 6] Debug only: Number of used entries in the data FIFO */
 #define PXP2_REG_HST_DATA_FIFO_STATUS                            0x12047c
 /* [R 7] Debug only: Number of used entries in the header FIFO */
-#define PXP2_REG_HST_HEADER_FIFO_STATUS                          0x120478
-#define PXP2_REG_PGL_ADDR_88_F0                                  0x120534
-#define PXP2_REG_PGL_ADDR_8C_F0                                  0x120538
-#define PXP2_REG_PGL_ADDR_90_F0                                  0x12053c
-#define PXP2_REG_PGL_ADDR_94_F0                                  0x120540
+#define PXP2_REG_HST_HEADER_FIFO_STATUS                          0x120478
+#define PXP2_REG_PGL_ADDR_88_F0                                  0x120534
+/* [R 32] GRC address for configuration access to PCIE config address 0x88.
+ * any write to this PCIE address will cause a GRC write access to the
+ * address that's in t this register */
+#define PXP2_REG_PGL_ADDR_88_F1                                  0x120544
+#define PXP2_REG_PGL_ADDR_8C_F0                                  0x120538
+/* [R 32] GRC address for configuration access to PCIE config address 0x8c.
+ * any write to this PCIE address will cause a GRC write access to the
+ * address that's in t this register */
+#define PXP2_REG_PGL_ADDR_8C_F1                                  0x120548
+#define PXP2_REG_PGL_ADDR_90_F0                                  0x12053c
+/* [R 32] GRC address for configuration access to PCIE config address 0x90.
+ * any write to this PCIE address will cause a GRC write access to the
+ * address that's in t this register */
+#define PXP2_REG_PGL_ADDR_90_F1                                  0x12054c
+#define PXP2_REG_PGL_ADDR_94_F0                                  0x120540
+/* [R 32] GRC address for configuration access to PCIE config address 0x94.
+ * any write to this PCIE address will cause a GRC write access to the
+ * address that's in t this register */
+#define PXP2_REG_PGL_ADDR_94_F1                                  0x120550
 #define PXP2_REG_PGL_CONTROL0                                    0x120490
 #define PXP2_REG_PGL_CONTROL1                                    0x120514
 #define PXP2_REG_PGL_DEBUG                                       0x120520
@@ -5304,7 +5332,7 @@
 #define XCM_REG_XX_OVFL_EVNT_ID                                  0x20058
 #define XMAC_CLEAR_RX_LSS_STATUS_REG_CLEAR_LOCAL_FAULT_STATUS    (0x1<<0)
 #define XMAC_CLEAR_RX_LSS_STATUS_REG_CLEAR_REMOTE_FAULT_STATUS   (0x1<<1)
-#define XMAC_CTRL_REG_CORE_LOCAL_LPBK                            (0x1<<3)
+#define XMAC_CTRL_REG_LINE_LOCAL_LPBK                            (0x1<<2)
 #define XMAC_CTRL_REG_RX_EN                                      (0x1<<1)
 #define XMAC_CTRL_REG_SOFT_RESET                                 (0x1<<6)
 #define XMAC_CTRL_REG_TX_EN                                      (0x1<<0)
@@ -5750,7 +5778,7 @@
 #define HW_LOCK_RESOURCE_RECOVERY_LEADER_0                       8
 #define HW_LOCK_RESOURCE_RECOVERY_LEADER_1                       9
 #define HW_LOCK_RESOURCE_SPIO                                    2
-#define HW_LOCK_RESOURCE_UNDI                                    5
+#define HW_LOCK_RESOURCE_RESET                                   5
 #define AEU_INPUTS_ATTN_BITS_ATC_HW_INTERRUPT                    (0x1<<4)
 #define AEU_INPUTS_ATTN_BITS_ATC_PARITY_ERROR                    (0x1<<5)
 #define AEU_INPUTS_ATTN_BITS_BRB_PARITY_ERROR                    (0x1<<18)
@@ -6837,6 +6865,9 @@ Theotherbitsarereservedandshouldbezero*/
 #define MDIO_WC_REG_IEEE0BLK_AUTONEGNP                  0x7
 #define MDIO_WC_REG_AN_IEEE1BLK_AN_ADVERTISEMENT0       0x10
 #define MDIO_WC_REG_AN_IEEE1BLK_AN_ADVERTISEMENT1       0x11
+#define MDIO_WC_REG_AN_IEEE1BLK_AN_ADVERTISEMENT2       0x12
+#define MDIO_WC_REG_AN_IEEE1BLK_AN_ADV2_FEC_ABILITY     0x4000
+#define MDIO_WC_REG_AN_IEEE1BLK_AN_ADV2_FEC_REQ         0x8000
 #define MDIO_WC_REG_PMD_IEEE9BLK_TENGBASE_KR_PMD_CONTROL_REGISTER_150  0x96
 #define MDIO_WC_REG_XGXSBLK0_XGXSCONTROL                0x8000
 #define MDIO_WC_REG_XGXSBLK0_MISCCONTROL1               0x800e
diff --git a/drivers/net/bnx2x/bnx2x_stats.c b/drivers/net/bnx2x/bnx2x_stats.c
index 771f6803b238..9908f2bbcf73 100644
--- a/drivers/net/bnx2x/bnx2x_stats.c
+++ b/drivers/net/bnx2x/bnx2x_stats.c
@@ -710,7 +710,8 @@ static int bnx2x_hw_stats_update(struct bnx2x *bp)
                 break;
 
         case MAC_TYPE_NONE: /* unreached */
-                BNX2X_ERR("stats updated by DMAE but no MAC active\n");
+                DP(BNX2X_MSG_STATS,
+                   "stats updated by DMAE but no MAC active\n");
                 return -1;
 
         default: /* unreached */
@@ -1391,7 +1392,7 @@ static void bnx2x_port_stats_base_init(struct bnx2x *bp)
 
 static void bnx2x_func_stats_base_init(struct bnx2x *bp)
 {
-        int vn, vn_max = IS_MF(bp) ? E1HVN_MAX : E1VN_MAX;
+        int vn, vn_max = IS_MF(bp) ? BP_MAX_VN_NUM(bp) : E1VN_MAX;
         u32 func_stx;
 
         /* sanity */
@@ -1404,7 +1405,7 @@ static void bnx2x_func_stats_base_init(struct bnx2x *bp)
         func_stx = bp->func_stx;
 
         for (vn = VN_0; vn < vn_max; vn++) {
-                int mb_idx = CHIP_IS_E1x(bp) ? 2*vn + BP_PORT(bp) : vn;
+                int mb_idx = BP_FW_MB_IDX_VN(bp, vn);
 
                 bp->func_stx = SHMEM_RD(bp, func_mb[mb_idx].fw_mb_param);
                 bnx2x_func_stats_init(bp);
diff --git a/drivers/net/bonding/bond_3ad.c b/drivers/net/bonding/bond_3ad.c
index a047eb973e3b..47b928ed08f8 100644
--- a/drivers/net/bonding/bond_3ad.c
+++ b/drivers/net/bonding/bond_3ad.c
@@ -2168,7 +2168,8 @@ void bond_3ad_state_machine_handler(struct work_struct *work)
         }
 
 re_arm:
-        queue_delayed_work(bond->wq, &bond->ad_work, ad_delta_in_ticks);
+        if (!bond->kill_timers)
+                queue_delayed_work(bond->wq, &bond->ad_work, ad_delta_in_ticks);
 out:
         read_unlock(&bond->lock);
 }
diff --git a/drivers/net/bonding/bond_alb.c b/drivers/net/bonding/bond_alb.c
index 7f8b20a34ee3..d4fbd2e62616 100644
--- a/drivers/net/bonding/bond_alb.c
+++ b/drivers/net/bonding/bond_alb.c
@@ -1440,7 +1440,8 @@ void bond_alb_monitor(struct work_struct *work)
         }
 
 re_arm:
-        queue_delayed_work(bond->wq, &bond->alb_work, alb_delta_in_ticks);
+        if (!bond->kill_timers)
+                queue_delayed_work(bond->wq, &bond->alb_work, alb_delta_in_ticks);
 out:
         read_unlock(&bond->lock);
 }
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 38a83acd502e..6d79b78cfc75 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -777,6 +777,9 @@ static void bond_resend_igmp_join_requests(struct bonding *bond)
 
         read_lock(&bond->lock);
 
+        if (bond->kill_timers)
+                goto out;
+
         /* rejoin all groups on bond device */
         __bond_resend_igmp_join_requests(bond->dev);
 
@@ -790,9 +793,9 @@ static void bond_resend_igmp_join_requests(struct bonding *bond)
                         __bond_resend_igmp_join_requests(vlan_dev);
         }
 
-        if (--bond->igmp_retrans > 0)
+        if ((--bond->igmp_retrans > 0) && !bond->kill_timers)
                 queue_delayed_work(bond->wq, &bond->mcast_work, HZ/5);
-
+out:
         read_unlock(&bond->lock);
 }
 
@@ -2538,7 +2541,7 @@ void bond_mii_monitor(struct work_struct *work)
         }
 
 re_arm:
-        if (bond->params.miimon)
+        if (bond->params.miimon && !bond->kill_timers)
                 queue_delayed_work(bond->wq, &bond->mii_work,
                                    msecs_to_jiffies(bond->params.miimon));
 out:
@@ -2886,7 +2889,7 @@ void bond_loadbalance_arp_mon(struct work_struct *work)
         }
 
 re_arm:
-        if (bond->params.arp_interval)
+        if (bond->params.arp_interval && !bond->kill_timers)
                 queue_delayed_work(bond->wq, &bond->arp_work, delta_in_ticks);
 out:
         read_unlock(&bond->lock);
@@ -3154,7 +3157,7 @@ void bond_activebackup_arp_mon(struct work_struct *work)
         bond_ab_arp_probe(bond);
 
 re_arm:
-        if (bond->params.arp_interval)
+        if (bond->params.arp_interval && !bond->kill_timers)
                 queue_delayed_work(bond->wq, &bond->arp_work, delta_in_ticks);
 out:
         read_unlock(&bond->lock);
@@ -3419,9 +3422,27 @@ static int bond_xmit_hash_policy_l2(struct sk_buff *skb, int count)
 static int bond_open(struct net_device *bond_dev)
 {
         struct bonding *bond = netdev_priv(bond_dev);
+        struct slave *slave;
+        int i;
 
         bond->kill_timers = 0;
 
+        /* reset slave->backup and slave->inactive */
+        read_lock(&bond->lock);
+        if (bond->slave_cnt > 0) {
+                read_lock(&bond->curr_slave_lock);
+                bond_for_each_slave(bond, slave, i) {
+                        if ((bond->params.mode == BOND_MODE_ACTIVEBACKUP)
+                                && (slave != bond->curr_active_slave)) {
+                                bond_set_slave_inactive_flags(slave);
+                        } else {
+                                bond_set_slave_active_flags(slave);
+                        }
+                }
+                read_unlock(&bond->curr_slave_lock);
+        }
+        read_unlock(&bond->lock);
+
         INIT_DELAYED_WORK(&bond->mcast_work, bond_resend_igmp_join_requests_delayed);
 
         if (bond_is_lb(bond)) {
diff --git a/drivers/net/can/sja1000/plx_pci.c b/drivers/net/can/sja1000/plx_pci.c
index 231385b8e08f..c7f3d4ea1167 100644
--- a/drivers/net/can/sja1000/plx_pci.c
+++ b/drivers/net/can/sja1000/plx_pci.c
@@ -408,7 +408,7 @@ static void plx_pci_del_card(struct pci_dev *pdev)
         struct sja1000_priv *priv;
         int i = 0;
 
-        for (i = 0; i < card->channels; i++) {
+        for (i = 0; i < PLX_PCI_MAX_CHAN; i++) {
                 dev = card->net_dev[i];
                 if (!dev)
                         continue;
@@ -536,7 +536,6 @@ static int __devinit plx_pci_add_card(struct pci_dev *pdev,
                         if (err) {
                                 dev_err(&pdev->dev, "Registering device failed "
                                         "(err=%d)\n", err);
-                                free_sja1000dev(dev);
                                 goto failure_cleanup;
                         }
 
@@ -549,6 +548,7 @@ static int __devinit plx_pci_add_card(struct pci_dev *pdev,
                         dev_err(&pdev->dev, "Channel #%d not detected\n",
                                 i + 1);
                         free_sja1000dev(dev);
+                        card->net_dev[i] = NULL;
                 }
         }
 
diff --git a/drivers/net/can/slcan.c b/drivers/net/can/slcan.c
index f523f1cc5142..4b70b7e8bdeb 100644
--- a/drivers/net/can/slcan.c
+++ b/drivers/net/can/slcan.c
@@ -197,7 +197,7 @@ static void slc_bump(struct slcan *sl)
         skb->ip_summed = CHECKSUM_UNNECESSARY;
         memcpy(skb_put(skb, sizeof(struct can_frame)),
                &cf, sizeof(struct can_frame));
-        netif_rx(skb);
+        netif_rx_ni(skb);
 
         sl->dev->stats.rx_packets++;
         sl->dev->stats.rx_bytes += cf.can_dlc;
diff --git a/drivers/net/can/ti_hecc.c b/drivers/net/can/ti_hecc.c
index f7bbde9eb2cb..2adc294f512a 100644
--- a/drivers/net/can/ti_hecc.c
+++ b/drivers/net/can/ti_hecc.c
@@ -46,6 +46,7 @@
 #include <linux/skbuff.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
+#include <linux/io.h>
 
 #include <linux/can/dev.h>
 #include <linux/can/error.h>
@@ -503,9 +504,9 @@ static netdev_tx_t ti_hecc_xmit(struct sk_buff *skb, struct net_device *ndev)
         spin_unlock_irqrestore(&priv->mbx_lock, flags);
 
         /* Prepare mailbox for transmission */
+        data = cf->can_dlc | (get_tx_head_prio(priv) << 8);
         if (cf->can_id & CAN_RTR_FLAG) /* Remote transmission request */
                 data |= HECC_CANMCF_RTR;
-        data |= get_tx_head_prio(priv) << 8;
         hecc_write_mbx(priv, mbxno, HECC_CANMCF, data);
 
         if (cf->can_id & CAN_EFF_FLAG) /* Extended frame format */
@@ -923,6 +924,7 @@ static int ti_hecc_probe(struct platform_device *pdev)
         priv->can.do_get_state = ti_hecc_get_state;
         priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;
 
+        spin_lock_init(&priv->mbx_lock);
         ndev->irq = irq->start;
         ndev->flags |= IFF_ECHO;
         platform_set_drvdata(pdev, ndev);
diff --git a/drivers/net/cassini.c b/drivers/net/cassini.c
index 646c86bcc545..fdb7a1756409 100644
--- a/drivers/net/cassini.c
+++ b/drivers/net/cassini.c
@@ -2452,14 +2452,13 @@ static irqreturn_t cas_interruptN(int irq, void *dev_id)
         struct net_device *dev = dev_id;
         struct cas *cp = netdev_priv(dev);
         unsigned long flags;
-        int ring;
+        int ring = (irq == cp->pci_irq_INTC) ? 2 : 3;
         u32 status = readl(cp->regs + REG_PLUS_INTRN_STATUS(ring));
 
         /* check for shared irq */
         if (status == 0)
                 return IRQ_NONE;
 
-        ring = (irq == cp->pci_irq_INTC) ? 2 : 3;
         spin_lock_irqsave(&cp->lock, flags);
         if (status & INTR_RX_DONE_ALT) { /* handle rx separately */
 #ifdef USE_NAPI
diff --git a/drivers/net/cxgb3/cxgb3_offload.c b/drivers/net/cxgb3/cxgb3_offload.c
index 805076c54f1b..da5a5d9b8aff 100644
--- a/drivers/net/cxgb3/cxgb3_offload.c
+++ b/drivers/net/cxgb3/cxgb3_offload.c
@@ -1146,12 +1146,14 @@ static void cxgb_redirect(struct dst_entry *old, struct dst_entry *new)
                 if (te && te->ctx && te->client && te->client->redirect) {
                         update_tcb = te->client->redirect(te->ctx, old, new, e);
                         if (update_tcb) {
+                                rcu_read_lock();
                                 l2t_hold(L2DATA(tdev), e);
+                                rcu_read_unlock();
                                 set_l2t_ix(tdev, tid, e);
                         }
                 }
         }
-        l2t_release(L2DATA(tdev), e);
+        l2t_release(tdev, e);
 }
 
 /*
@@ -1264,7 +1266,7 @@ int cxgb3_offload_activate(struct adapter *adapter)
                 goto out_free;
 
         err = -ENOMEM;
-        L2DATA(dev) = t3_init_l2t(l2t_capacity);
+        RCU_INIT_POINTER(dev->l2opt, t3_init_l2t(l2t_capacity));
         if (!L2DATA(dev))
                 goto out_free;
 
@@ -1298,16 +1300,24 @@ int cxgb3_offload_activate(struct adapter *adapter)
 
 out_free_l2t:
         t3_free_l2t(L2DATA(dev));
-        L2DATA(dev) = NULL;
+        rcu_assign_pointer(dev->l2opt, NULL);
 out_free:
         kfree(t);
         return err;
 }
 
+static void clean_l2_data(struct rcu_head *head)
+{
+        struct l2t_data *d = container_of(head, struct l2t_data, rcu_head);
+        t3_free_l2t(d);
+}
+
+
 void cxgb3_offload_deactivate(struct adapter *adapter)
 {
         struct t3cdev *tdev = &adapter->tdev;
         struct t3c_data *t = T3C_DATA(tdev);
+        struct l2t_data *d;
 
         remove_adapter(adapter);
         if (list_empty(&adapter_list))
@@ -1315,8 +1325,11 @@ void cxgb3_offload_deactivate(struct adapter *adapter)
 
         free_tid_maps(&t->tid_maps);
         T3C_DATA(tdev) = NULL;
-        t3_free_l2t(L2DATA(tdev));
-        L2DATA(tdev) = NULL;
+        rcu_read_lock();
+        d = L2DATA(tdev);
+        rcu_read_unlock();
+        rcu_assign_pointer(tdev->l2opt, NULL);
+        call_rcu(&d->rcu_head, clean_l2_data);
         if (t->nofail_skb)
                 kfree_skb(t->nofail_skb);
         kfree(t);
diff --git a/drivers/net/cxgb3/l2t.c b/drivers/net/cxgb3/l2t.c
index f452c4003253..41540978a173 100644
--- a/drivers/net/cxgb3/l2t.c
+++ b/drivers/net/cxgb3/l2t.c
@@ -300,14 +300,21 @@ static inline void reuse_entry(struct l2t_entry *e, struct neighbour *neigh)
 struct l2t_entry *t3_l2t_get(struct t3cdev *cdev, struct neighbour *neigh,
                              struct net_device *dev)
 {
-        struct l2t_entry *e;
-        struct l2t_data *d = L2DATA(cdev);
+        struct l2t_entry *e = NULL;
+        struct l2t_data *d;
+        int hash;
         u32 addr = *(u32 *) neigh->primary_key;
         int ifidx = neigh->dev->ifindex;
-        int hash = arp_hash(addr, ifidx, d);
         struct port_info *p = netdev_priv(dev);
         int smt_idx = p->port_id;
 
+        rcu_read_lock();
+        d = L2DATA(cdev);
+        if (!d)
+                goto done_rcu;
+
+        hash = arp_hash(addr, ifidx, d);
+
         write_lock_bh(&d->lock);
         for (e = d->l2tab[hash].first; e; e = e->next)
                 if (e->addr == addr && e->ifindex == ifidx &&
@@ -338,6 +345,8 @@ struct l2t_entry *t3_l2t_get(struct t3cdev *cdev, struct neighbour *neigh,
         }
 done:
         write_unlock_bh(&d->lock);
+done_rcu:
+        rcu_read_unlock();
         return e;
 }
 
diff --git a/drivers/net/cxgb3/l2t.h b/drivers/net/cxgb3/l2t.h
index 7a12d52ed4fc..c5f54796e2cb 100644
--- a/drivers/net/cxgb3/l2t.h
+++ b/drivers/net/cxgb3/l2t.h
@@ -76,6 +76,7 @@ struct l2t_data {
         atomic_t nfree;         /* number of free entries */
         rwlock_t lock;
         struct l2t_entry l2tab[0];
+        struct rcu_head rcu_head;       /* to handle rcu cleanup */
 };
 
 typedef void (*arp_failure_handler_func)(struct t3cdev * dev,
@@ -99,7 +100,7 @@ static inline void set_arp_failure_handler(struct sk_buff *skb,
 /*
  * Getting to the L2 data from an offload device.
  */
-#define L2DATA(dev) ((dev)->l2opt)
+#define L2DATA(cdev) (rcu_dereference((cdev)->l2opt))
 
 #define W_TCB_L2T_IX    0
 #define S_TCB_L2T_IX    7
@@ -126,15 +127,22 @@ static inline int l2t_send(struct t3cdev *dev, struct sk_buff *skb,
         return t3_l2t_send_slow(dev, skb, e);
 }
 
-static inline void l2t_release(struct l2t_data *d, struct l2t_entry *e)
+static inline void l2t_release(struct t3cdev *t, struct l2t_entry *e)
 {
-        if (atomic_dec_and_test(&e->refcnt))
+        struct l2t_data *d;
+
+        rcu_read_lock();
+        d = L2DATA(t);
+
+        if (atomic_dec_and_test(&e->refcnt) && d)
                 t3_l2e_free(d, e);
+
+        rcu_read_unlock();
 }
 
 static inline void l2t_hold(struct l2t_data *d, struct l2t_entry *e)
 {
-        if (atomic_add_return(1, &e->refcnt) == 1)      /* 0 -> 1 transition */
+        if (d && atomic_add_return(1, &e->refcnt) == 1) /* 0 -> 1 transition */
                 atomic_dec(&d->nfree);
 }
 
diff --git a/drivers/net/cxgb4/cxgb4_main.c b/drivers/net/cxgb4/cxgb4_main.c
index c9957b7f17b5..b4efa292fd6f 100644
--- a/drivers/net/cxgb4/cxgb4_main.c
+++ b/drivers/net/cxgb4/cxgb4_main.c
@@ -3712,6 +3712,9 @@ static int __devinit init_one(struct pci_dev *pdev,
                 setup_debugfs(adapter);
         }
 
+        /* PCIe EEH recovery on powerpc platforms needs fundamental reset */
+        pdev->needs_freset = 1;
+
         if (is_offload(adapter))
                 attach_ulds(adapter);
 
diff --git a/drivers/net/e1000/e1000_hw.c b/drivers/net/e1000/e1000_hw.c
index 8545c7aa93eb..a5a89ecb6f36 100644
--- a/drivers/net/e1000/e1000_hw.c
+++ b/drivers/net/e1000/e1000_hw.c
@@ -4026,6 +4026,12 @@ s32 e1000_validate_eeprom_checksum(struct e1000_hw *hw)
                 checksum += eeprom_data;
         }
 
+#ifdef CONFIG_PARISC
+        /* This is a signature and not a checksum on HP c8000 */
+        if ((hw->subsystem_vendor_id == 0x103C) && (eeprom_data == 0x16d6))
+                return E1000_SUCCESS;
+
+#endif
         if (checksum == (u16) EEPROM_SUM)
                 return E1000_SUCCESS;
         else {
diff --git a/drivers/net/e1000e/82571.c b/drivers/net/e1000e/82571.c
index 480f2592f8a5..536b3a55c45f 100644
--- a/drivers/net/e1000e/82571.c
+++ b/drivers/net/e1000e/82571.c
@@ -2085,7 +2085,8 @@ struct e1000_info e1000_82574_info = {
                                   | FLAG_HAS_AMT
                                   | FLAG_HAS_CTRLEXT_ON_LOAD,
         .flags2                   = FLAG2_CHECK_PHY_HANG
-                                  | FLAG2_DISABLE_ASPM_L0S,
+                                  | FLAG2_DISABLE_ASPM_L0S
+                                  | FLAG2_NO_DISABLE_RX,
         .pba                    = 32,
         .max_hw_frame_size      = DEFAULT_JUMBO,
         .get_variants           = e1000_get_variants_82571,
@@ -2104,7 +2105,8 @@ struct e1000_info e1000_82583_info = {
                                   | FLAG_HAS_AMT
                                   | FLAG_HAS_JUMBO_FRAMES
                                   | FLAG_HAS_CTRLEXT_ON_LOAD,
-        .flags2                 = FLAG2_DISABLE_ASPM_L0S,
+        .flags2                 = FLAG2_DISABLE_ASPM_L0S
+                                  | FLAG2_NO_DISABLE_RX,
         .pba                    = 32,
         .max_hw_frame_size      = DEFAULT_JUMBO,
         .get_variants           = e1000_get_variants_82571,
diff --git a/drivers/net/e1000e/e1000.h b/drivers/net/e1000e/e1000.h
index 638d175792cf..8533ad7f3559 100644
--- a/drivers/net/e1000e/e1000.h
+++ b/drivers/net/e1000e/e1000.h
@@ -155,6 +155,9 @@ struct e1000_info;
 #define HV_M_STATUS_SPEED_1000            0x0200
 #define HV_M_STATUS_LINK_UP               0x0040
 
+#define E1000_ICH_FWSM_PCIM2PCI         0x01000000 /* ME PCIm-to-PCI active */
+#define E1000_ICH_FWSM_PCIM2PCI_COUNT   2000
+
 /* Time to wait before putting the device into D3 if there's no link (in ms). */
 #define LINK_TIMEOUT            100
 
@@ -453,6 +456,8 @@ struct e1000_info {
 #define FLAG2_DISABLE_ASPM_L0S            (1 << 7)
 #define FLAG2_DISABLE_AIM                 (1 << 8)
 #define FLAG2_CHECK_PHY_HANG              (1 << 9)
+#define FLAG2_NO_DISABLE_RX               (1 << 10)
+#define FLAG2_PCIM2PCI_ARBITER_WA         (1 << 11)
 
 #define E1000_RX_DESC_PS(R, i)      \
         (&(((union e1000_rx_desc_packet_split *)((R).desc))[i]))
diff --git a/drivers/net/e1000e/ethtool.c b/drivers/net/e1000e/ethtool.c
index 06d88f316dce..6a0526a59a8a 100644
--- a/drivers/net/e1000e/ethtool.c
+++ b/drivers/net/e1000e/ethtool.c
@@ -1206,7 +1206,8 @@ static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
         rx_ring->next_to_clean = 0;
 
         rctl = er32(RCTL);
-        ew32(RCTL, rctl & ~E1000_RCTL_EN);
+        if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX))
+                ew32(RCTL, rctl & ~E1000_RCTL_EN);
         ew32(RDBAL, ((u64) rx_ring->dma & 0xFFFFFFFF));
         ew32(RDBAH, ((u64) rx_ring->dma >> 32));
         ew32(RDLEN, rx_ring->size);
diff --git a/drivers/net/e1000e/ich8lan.c b/drivers/net/e1000e/ich8lan.c
index 4e36978b8fd8..54add27c8f76 100644
--- a/drivers/net/e1000e/ich8lan.c
+++ b/drivers/net/e1000e/ich8lan.c
@@ -137,8 +137,9 @@
 #define HV_PM_CTRL              PHY_REG(770, 17)
 
 /* PHY Low Power Idle Control */
-#define I82579_LPI_CTRL                 PHY_REG(772, 20)
-#define I82579_LPI_CTRL_ENABLE_MASK     0x6000
+#define I82579_LPI_CTRL                         PHY_REG(772, 20)
+#define I82579_LPI_CTRL_ENABLE_MASK             0x6000
+#define I82579_LPI_CTRL_FORCE_PLL_LOCK_COUNT    0x80
 
 /* EMI Registers */
 #define I82579_EMI_ADDR         0x10
@@ -163,6 +164,11 @@
 #define HV_KMRN_MODE_CTRL      PHY_REG(769, 16)
 #define HV_KMRN_MDIO_SLOW      0x0400
 
+/* KMRN FIFO Control and Status */
+#define HV_KMRN_FIFO_CTRLSTA                  PHY_REG(770, 16)
+#define HV_KMRN_FIFO_CTRLSTA_PREAMBLE_MASK    0x7000
+#define HV_KMRN_FIFO_CTRLSTA_PREAMBLE_SHIFT   12
+
 /* ICH GbE Flash Hardware Sequencing Flash Status Register bit breakdown */
 /* Offset 04h HSFSTS */
 union ich8_hws_flash_status {
@@ -657,6 +663,7 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
         struct e1000_mac_info *mac = &hw->mac;
         s32 ret_val;
         bool link;
+        u16 phy_reg;
 
         /*
          * We only want to go out to the PHY registers to see if Auto-Neg
@@ -689,16 +696,35 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
 
         mac->get_link_status = false;
 
-        if (hw->phy.type == e1000_phy_82578) {
-                ret_val = e1000_link_stall_workaround_hv(hw);
-                if (ret_val)
-                        goto out;
-        }
-
-        if (hw->mac.type == e1000_pch2lan) {
+        switch (hw->mac.type) {
+        case e1000_pch2lan:
                 ret_val = e1000_k1_workaround_lv(hw);
                 if (ret_val)
                         goto out;
+                /* fall-thru */
+        case e1000_pchlan:
+                if (hw->phy.type == e1000_phy_82578) {
+                        ret_val = e1000_link_stall_workaround_hv(hw);
+                        if (ret_val)
+                                goto out;
+                }
+
+                /*
+                 * Workaround for PCHx parts in half-duplex:
+                 * Set the number of preambles removed from the packet
+                 * when it is passed from the PHY to the MAC to prevent
+                 * the MAC from misinterpreting the packet type.
+                 */
+                e1e_rphy(hw, HV_KMRN_FIFO_CTRLSTA, &phy_reg);
+                phy_reg &= ~HV_KMRN_FIFO_CTRLSTA_PREAMBLE_MASK;
+
+                if ((er32(STATUS) & E1000_STATUS_FD) != E1000_STATUS_FD)
+                        phy_reg |= (1 << HV_KMRN_FIFO_CTRLSTA_PREAMBLE_SHIFT);
+
+                e1e_wphy(hw, HV_KMRN_FIFO_CTRLSTA, phy_reg);
+                break;
+        default:
+                break;
         }
 
         /*
@@ -788,6 +814,11 @@ static s32 e1000_get_variants_ich8lan(struct e1000_adapter *adapter)
             (adapter->hw.phy.type == e1000_phy_igp_3))
                 adapter->flags |= FLAG_LSC_GIG_SPEED_DROP;
 
+        /* Enable workaround for 82579 w/ ME enabled */
+        if ((adapter->hw.mac.type == e1000_pch2lan) &&
+            (er32(FWSM) & E1000_ICH_FWSM_FW_VALID))
+                adapter->flags2 |= FLAG2_PCIM2PCI_ARBITER_WA;
+
         /* Disable EEE by default until IEEE802.3az spec is finalized */
         if (adapter->flags2 & FLAG2_HAS_EEE)
                 adapter->hw.dev_spec.ich8lan.eee_disable = true;
@@ -1355,7 +1386,7 @@ static s32 e1000_hv_phy_workarounds_ich8lan(struct e1000_hw *hw)
                         return ret_val;
 
                 /* Preamble tuning for SSC */
-                ret_val = e1e_wphy(hw, PHY_REG(770, 16), 0xA204);
+                ret_val = e1e_wphy(hw, HV_KMRN_FIFO_CTRLSTA, 0xA204);
                 if (ret_val)
                         return ret_val;
         }
@@ -1645,6 +1676,7 @@ static s32 e1000_k1_workaround_lv(struct e1000_hw *hw)
         s32 ret_val = 0;
         u16 status_reg = 0;
         u32 mac_reg;
+        u16 phy_reg;
 
         if (hw->mac.type != e1000_pch2lan)
                 goto out;
@@ -1659,12 +1691,19 @@ static s32 e1000_k1_workaround_lv(struct e1000_hw *hw)
                 mac_reg = er32(FEXTNVM4);
                 mac_reg &= ~E1000_FEXTNVM4_BEACON_DURATION_MASK;
 
-                if (status_reg & HV_M_STATUS_SPEED_1000)
+                ret_val = e1e_rphy(hw, I82579_LPI_CTRL, &phy_reg);
+                if (ret_val)
+                        goto out;
+
+                if (status_reg & HV_M_STATUS_SPEED_1000) {
                         mac_reg |= E1000_FEXTNVM4_BEACON_DURATION_8USEC;
-                else
+                        phy_reg &= ~I82579_LPI_CTRL_FORCE_PLL_LOCK_COUNT;
+                } else {
                         mac_reg |= E1000_FEXTNVM4_BEACON_DURATION_16USEC;
-
+                        phy_reg |= I82579_LPI_CTRL_FORCE_PLL_LOCK_COUNT;
+                }
                 ew32(FEXTNVM4, mac_reg);
+                ret_val = e1e_wphy(hw, I82579_LPI_CTRL, phy_reg);
         }
 
 out:
diff --git a/drivers/net/e1000e/lib.c b/drivers/net/e1000e/lib.c
index 7898a67d6505..0893ab107adf 100644
--- a/drivers/net/e1000e/lib.c
+++ b/drivers/net/e1000e/lib.c
@@ -190,7 +190,8 @@ s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw)
         /* Check for LOM (vs. NIC) or one of two valid mezzanine cards */
         if (!((nvm_data & NVM_COMPAT_LOM) ||
               (hw->adapter->pdev->device == E1000_DEV_ID_82571EB_SERDES_DUAL) ||
-              (hw->adapter->pdev->device == E1000_DEV_ID_82571EB_SERDES_QUAD)))
+              (hw->adapter->pdev->device == E1000_DEV_ID_82571EB_SERDES_QUAD) ||
+              (hw->adapter->pdev->device == E1000_DEV_ID_82571EB_SERDES)))
                 goto out;
 
         ret_val = e1000_read_nvm(hw, NVM_ALT_MAC_ADDR_PTR, 1,
@@ -200,10 +201,10 @@ s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw)
                 goto out;
         }
 
-        if (nvm_alt_mac_addr_offset == 0xFFFF) {
+        if ((nvm_alt_mac_addr_offset == 0xFFFF) ||
+            (nvm_alt_mac_addr_offset == 0x0000))
                 /* There is no Alternate MAC Address */
                 goto out;
-        }
 
         if (hw->bus.func == E1000_FUNC_1)
                 nvm_alt_mac_addr_offset += E1000_ALT_MAC_ADDRESS_OFFSET_LAN1;
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index ab4be80f7ab5..2198e615f241 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -56,7 +56,7 @@
 
 #define DRV_EXTRAVERSION "-k"
 
-#define DRV_VERSION "1.3.16" DRV_EXTRAVERSION
+#define DRV_VERSION "1.4.4" DRV_EXTRAVERSION
 char e1000e_driver_name[] = "e1000e";
 const char e1000e_driver_version[] = DRV_VERSION;
 
@@ -519,6 +519,63 @@ static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
 }
 
 /**
+ * e1000e_update_tail_wa - helper function for e1000e_update_[rt]dt_wa()
+ * @hw: pointer to the HW structure
+ * @tail: address of tail descriptor register
+ * @i: value to write to tail descriptor register
+ *
+ * When updating the tail register, the ME could be accessing Host CSR
+ * registers at the same time.  Normally, this is handled in h/w by an
+ * arbiter but on some parts there is a bug that acknowledges Host accesses
+ * later than it should which could result in the descriptor register to
+ * have an incorrect value.  Workaround this by checking the FWSM register
+ * which has bit 24 set while ME is accessing Host CSR registers, wait
+ * if it is set and try again a number of times.
+ **/
+static inline s32 e1000e_update_tail_wa(struct e1000_hw *hw, u8 __iomem * tail,
+                                        unsigned int i)
+{
+        unsigned int j = 0;
+
+        while ((j++ < E1000_ICH_FWSM_PCIM2PCI_COUNT) &&
+               (er32(FWSM) & E1000_ICH_FWSM_PCIM2PCI))
+                udelay(50);
+
+        writel(i, tail);
+
+        if ((j == E1000_ICH_FWSM_PCIM2PCI_COUNT) && (i != readl(tail)))
+                return E1000_ERR_SWFW_SYNC;
+
+        return 0;
+}
+
+static void e1000e_update_rdt_wa(struct e1000_adapter *adapter, unsigned int i)
+{
+        u8 __iomem *tail = (adapter->hw.hw_addr + adapter->rx_ring->tail);
+        struct e1000_hw *hw = &adapter->hw;
+
+        if (e1000e_update_tail_wa(hw, tail, i)) {
+                u32 rctl = er32(RCTL);
+                ew32(RCTL, rctl & ~E1000_RCTL_EN);
+                e_err("ME firmware caused invalid RDT - resetting\n");
+                schedule_work(&adapter->reset_task);
+        }
+}
+
+static void e1000e_update_tdt_wa(struct e1000_adapter *adapter, unsigned int i)
+{
+        u8 __iomem *tail = (adapter->hw.hw_addr + adapter->tx_ring->tail);
+        struct e1000_hw *hw = &adapter->hw;
+
+        if (e1000e_update_tail_wa(hw, tail, i)) {
+                u32 tctl = er32(TCTL);
+                ew32(TCTL, tctl & ~E1000_TCTL_EN);
+                e_err("ME firmware caused invalid TDT - resetting\n");
+                schedule_work(&adapter->reset_task);
+        }
+}
+
+/**
  * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended
  * @adapter: address of board private structure
  **/
@@ -573,7 +630,10 @@ map_skb:
                          * such as IA-64).
                          */
                         wmb();
-                        writel(i, adapter->hw.hw_addr + rx_ring->tail);
+                        if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
+                                e1000e_update_rdt_wa(adapter, i);
+                        else
+                                writel(i, adapter->hw.hw_addr + rx_ring->tail);
                 }
                 i++;
                 if (i == rx_ring->count)
@@ -673,7 +733,11 @@ static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
                          * such as IA-64).
                          */
                         wmb();
-                        writel(i << 1, adapter->hw.hw_addr + rx_ring->tail);
+                        if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
+                                e1000e_update_rdt_wa(adapter, i << 1);
+                        else
+                                writel(i << 1,
+                                       adapter->hw.hw_addr + rx_ring->tail);
                 }
 
                 i++;
@@ -756,7 +820,10 @@ check_page:
                  * applicable for weak-ordered memory model archs,
                  * such as IA-64). */
                 wmb();
-                writel(i, adapter->hw.hw_addr + rx_ring->tail);
+                if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
+                        e1000e_update_rdt_wa(adapter, i);
+                else
+                        writel(i, adapter->hw.hw_addr + rx_ring->tail);
         }
 }
 
@@ -2915,7 +2982,8 @@ static void e1000_configure_rx(struct e1000_adapter *adapter)
 
         /* disable receives while setting up the descriptors */
         rctl = er32(RCTL);
-        ew32(RCTL, rctl & ~E1000_RCTL_EN);
+        if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX))
+                ew32(RCTL, rctl & ~E1000_RCTL_EN);
         e1e_flush();
         usleep_range(10000, 20000);
 
@@ -3394,7 +3462,8 @@ void e1000e_down(struct e1000_adapter *adapter)
 
         /* disable receives in the hardware */
         rctl = er32(RCTL);
-        ew32(RCTL, rctl & ~E1000_RCTL_EN);
+        if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX))
+                ew32(RCTL, rctl & ~E1000_RCTL_EN);
         /* flush and sleep below */
 
         netif_stop_queue(netdev);
@@ -3403,6 +3472,7 @@ void e1000e_down(struct e1000_adapter *adapter)
         tctl = er32(TCTL);
         tctl &= ~E1000_TCTL_EN;
         ew32(TCTL, tctl);
+
         /* flush both disables and wait for them to finish */
         e1e_flush();
         usleep_range(10000, 20000);
@@ -4686,7 +4756,12 @@ static void e1000_tx_queue(struct e1000_adapter *adapter,
         wmb();
 
         tx_ring->next_to_use = i;
-        writel(i, adapter->hw.hw_addr + tx_ring->tail);
+
+        if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
+                e1000e_update_tdt_wa(adapter, i);
+        else
+                writel(i, adapter->hw.hw_addr + tx_ring->tail);
+
         /*
          * we need this if more than one processor can write to our tail
          * at a time, it synchronizes IO on IA64/Altix systems
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index e55df308a3af..6d5fbd4d4256 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -5615,7 +5615,8 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
                 goto out_error;
         }
 
-        nv_vlan_mode(dev, dev->features);
+        if (id->driver_data & DEV_HAS_VLAN)
+                nv_vlan_mode(dev, dev->features);
 
         netif_carrier_off(dev);
 
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 2659daad783d..31d5c574e5a9 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -2710,8 +2710,13 @@ static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
         /* Tell the skb what kind of packet this is */
         skb->protocol = eth_type_trans(skb, dev);
 
-        /* Set vlan tag */
-        if (fcb->flags & RXFCB_VLN)
+        /*
+         * There's need to check for NETIF_F_HW_VLAN_RX here.
+         * Even if vlan rx accel is disabled, on some chips
+         * RXFCB_VLN is pseudo randomly set.
+         */
+        if (dev->features & NETIF_F_HW_VLAN_RX &&
+            fcb->flags & RXFCB_VLN)
                 __vlan_hwaccel_put_tag(skb, fcb->vlctl);
 
         /* Send the packet up the stack */
diff --git a/drivers/net/gianfar_ethtool.c b/drivers/net/gianfar_ethtool.c
index 6e350692d118..0caf3c323ec0 100644
--- a/drivers/net/gianfar_ethtool.c
+++ b/drivers/net/gianfar_ethtool.c
@@ -686,10 +686,21 @@ static int gfar_ethflow_to_filer_table(struct gfar_private *priv, u64 ethflow, u
 {
         unsigned int last_rule_idx = priv->cur_filer_idx;
         unsigned int cmp_rqfpr;
-        unsigned int local_rqfpr[MAX_FILER_IDX + 1];
-        unsigned int local_rqfcr[MAX_FILER_IDX + 1];
+        unsigned int *local_rqfpr;
+        unsigned int *local_rqfcr;
         int i = 0x0, k = 0x0;
         int j = MAX_FILER_IDX, l = 0x0;
+        int ret = 1;
+
+        local_rqfpr = kmalloc(sizeof(unsigned int) * (MAX_FILER_IDX + 1),
+                GFP_KERNEL);
+        local_rqfcr = kmalloc(sizeof(unsigned int) * (MAX_FILER_IDX + 1),
+                GFP_KERNEL);
+        if (!local_rqfpr || !local_rqfcr) {
+                pr_err("Out of memory\n");
+                ret = 0;
+                goto err;
+        }
 
         switch (class) {
         case TCP_V4_FLOW:
@@ -706,7 +717,8 @@ static int gfar_ethflow_to_filer_table(struct gfar_private *priv, u64 ethflow, u
                 break;
         default:
                 pr_err("Right now this class is not supported\n");
-                return 0;
+                ret = 0;
+                goto err;
         }
 
         for (i = 0; i < MAX_FILER_IDX + 1; i++) {
@@ -721,7 +733,8 @@ static int gfar_ethflow_to_filer_table(struct gfar_private *priv, u64 ethflow, u
 
         if (i == MAX_FILER_IDX + 1) {
                 pr_err("No parse rule found, can't create hash rules\n");
-                return 0;
+                ret = 0;
+                goto err;
         }
 
         /* If a match was found, then it begins the starting of a cluster rule
@@ -765,7 +778,10 @@ static int gfar_ethflow_to_filer_table(struct gfar_private *priv, u64 ethflow, u
                 priv->cur_filer_idx = priv->cur_filer_idx - 1;
         }
 
-        return 1;
+err:
+        kfree(local_rqfcr);
+        kfree(local_rqfpr);
+        return ret;
 }
 
 static int gfar_set_hash_opts(struct gfar_private *priv, struct ethtool_rxnfc *cmd)
@@ -1653,10 +1669,10 @@ static int gfar_get_cls_all(struct gfar_private *priv,
         u32 i = 0;
 
         list_for_each_entry(comp, &priv->rx_list.list, list) {
-                if (i <= cmd->rule_cnt) {
-                        rule_locs[i] = comp->fs.location;
-                        i++;
-                }
+                if (i == cmd->rule_cnt)
+                        return -EMSGSIZE;
+                rule_locs[i] = comp->fs.location;
+                i++;
         }
 
         cmd->data = MAX_FILER_IDX;
diff --git a/drivers/net/gianfar_ptp.c b/drivers/net/gianfar_ptp.c
index 1c97861596f0..f67b8aebc89c 100644
--- a/drivers/net/gianfar_ptp.c
+++ b/drivers/net/gianfar_ptp.c
@@ -193,14 +193,9 @@ static void set_alarm(struct etsects *etsects)
 /* Caller must hold etsects->lock. */
 static void set_fipers(struct etsects *etsects)
 {
-        u32 tmr_ctrl = gfar_read(&etsects->regs->tmr_ctrl);
-
-        gfar_write(&etsects->regs->tmr_ctrl,   tmr_ctrl & (~TE));
-        gfar_write(&etsects->regs->tmr_prsc,   etsects->tmr_prsc);
+        set_alarm(etsects);
         gfar_write(&etsects->regs->tmr_fiper1, etsects->tmr_fiper1);
         gfar_write(&etsects->regs->tmr_fiper2, etsects->tmr_fiper2);
-        set_alarm(etsects);
-        gfar_write(&etsects->regs->tmr_ctrl,   tmr_ctrl|TE);
 }
 
 /*
@@ -511,7 +506,7 @@ static int gianfar_ptp_probe(struct platform_device *dev)
         gfar_write(&etsects->regs->tmr_fiper1, etsects->tmr_fiper1);
         gfar_write(&etsects->regs->tmr_fiper2, etsects->tmr_fiper2);
         set_alarm(etsects);
-        gfar_write(&etsects->regs->tmr_ctrl,   tmr_ctrl|FS|RTPE|TE);
+        gfar_write(&etsects->regs->tmr_ctrl,   tmr_ctrl|FS|RTPE|TE|FRD);
 
         spin_unlock_irqrestore(&etsects->lock, flags);
 
diff --git a/drivers/net/greth.c b/drivers/net/greth.c
index 16ce45c11934..52a39000c42c 100644
--- a/drivers/net/greth.c
+++ b/drivers/net/greth.c
@@ -428,6 +428,7 @@ greth_start_xmit(struct sk_buff *skb, struct net_device *dev)
         dma_sync_single_for_device(greth->dev, dma_addr, skb->len, DMA_TO_DEVICE);
 
         status = GRETH_BD_EN | GRETH_BD_IE | (skb->len & GRETH_BD_LEN);
+        greth->tx_bufs_length[greth->tx_next] = skb->len & GRETH_BD_LEN;
 
         /* Wrap around descriptor ring */
         if (greth->tx_next == GRETH_TXBD_NUM_MASK) {
@@ -490,7 +491,8 @@ greth_start_xmit_gbit(struct sk_buff *skb, struct net_device *dev)
         if (nr_frags != 0)
                 status = GRETH_TXBD_MORE;
 
-        status |= GRETH_TXBD_CSALL;
+        if (skb->ip_summed == CHECKSUM_PARTIAL)
+                status |= GRETH_TXBD_CSALL;
         status |= skb_headlen(skb) & GRETH_BD_LEN;
         if (greth->tx_next == GRETH_TXBD_NUM_MASK)
                 status |= GRETH_BD_WR;
@@ -513,7 +515,9 @@ greth_start_xmit_gbit(struct sk_buff *skb, struct net_device *dev)
                 greth->tx_skbuff[curr_tx] = NULL;
                 bdp = greth->tx_bd_base + curr_tx;
 
-                status = GRETH_TXBD_CSALL | GRETH_BD_EN;
+                status = GRETH_BD_EN;
+                if (skb->ip_summed == CHECKSUM_PARTIAL)
+                        status |= GRETH_TXBD_CSALL;
                 status |= frag->size & GRETH_BD_LEN;
 
                 /* Wrap around descriptor ring */
@@ -641,6 +645,7 @@ static void greth_clean_tx(struct net_device *dev)
                                 dev->stats.tx_fifo_errors++;
                 }
                 dev->stats.tx_packets++;
+                dev->stats.tx_bytes += greth->tx_bufs_length[greth->tx_last];
                 greth->tx_last = NEXT_TX(greth->tx_last);
                 greth->tx_free++;
         }
@@ -695,6 +700,7 @@ static void greth_clean_tx_gbit(struct net_device *dev)
                 greth->tx_skbuff[greth->tx_last] = NULL;
 
                 greth_update_tx_stats(dev, stat);
+                dev->stats.tx_bytes += skb->len;
 
                 bdp = greth->tx_bd_base + greth->tx_last;
 
@@ -796,6 +802,7 @@ static int greth_rx(struct net_device *dev, int limit)
                                 memcpy(skb_put(skb, pkt_len), phys_to_virt(dma_addr), pkt_len);
 
                                 skb->protocol = eth_type_trans(skb, dev);
+                                dev->stats.rx_bytes += pkt_len;
                                 dev->stats.rx_packets++;
                                 netif_receive_skb(skb);
                         }
@@ -910,6 +917,7 @@ static int greth_rx_gbit(struct net_device *dev, int limit)
 
                                 skb->protocol = eth_type_trans(skb, dev);
                                 dev->stats.rx_packets++;
+                                dev->stats.rx_bytes += pkt_len;
                                 netif_receive_skb(skb);
 
                                 greth->rx_skbuff[greth->rx_cur] = newskb;
diff --git a/drivers/net/greth.h b/drivers/net/greth.h
index 9a0040dee4da..232a622a85b7 100644
--- a/drivers/net/greth.h
+++ b/drivers/net/greth.h
@@ -103,6 +103,7 @@ struct greth_private {
 
         unsigned char *tx_bufs[GRETH_TXBD_NUM];
         unsigned char *rx_bufs[GRETH_RXBD_NUM];
+        u16 tx_bufs_length[GRETH_TXBD_NUM];
 
         u16 tx_next;
         u16 tx_last;
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index ba99af05bf62..d393f1e764ed 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -395,7 +395,7 @@ static inline struct sk_buff *ibmveth_rxq_get_buffer(struct ibmveth_adapter *ada
 }
 
 /* recycle the current buffer on the rx queue */
-static void ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
+static int ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
 {
         u32 q_index = adapter->rx_queue.index;
         u64 correlator = adapter->rx_queue.queue_addr[q_index].correlator;
@@ -403,6 +403,7 @@ static void ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
         unsigned int index = correlator & 0xffffffffUL;
         union ibmveth_buf_desc desc;
         unsigned long lpar_rc;
+        int ret = 1;
 
         BUG_ON(pool >= IBMVETH_NUM_BUFF_POOLS);
         BUG_ON(index >= adapter->rx_buff_pool[pool].size);
@@ -410,7 +411,7 @@ static void ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
         if (!adapter->rx_buff_pool[pool].active) {
                 ibmveth_rxq_harvest_buffer(adapter);
                 ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[pool]);
-                return;
+                goto out;
         }
 
         desc.fields.flags_len = IBMVETH_BUF_VALID |
@@ -423,12 +424,16 @@ static void ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
                 netdev_dbg(adapter->netdev, "h_add_logical_lan_buffer failed "
                            "during recycle rc=%ld", lpar_rc);
                 ibmveth_remove_buffer_from_pool(adapter, adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator);
+                ret = 0;
         }
 
         if (++adapter->rx_queue.index == adapter->rx_queue.num_slots) {
                 adapter->rx_queue.index = 0;
                 adapter->rx_queue.toggle = !adapter->rx_queue.toggle;
         }
+
+out:
+        return ret;
 }
 
 static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter)
@@ -631,8 +636,8 @@ static int ibmveth_open(struct net_device *netdev)
                 netdev_err(netdev, "unable to request irq 0x%x, rc %d\n",
                            netdev->irq, rc);
                 do {
-                        rc = h_free_logical_lan(adapter->vdev->unit_address);
-                } while (H_IS_LONG_BUSY(rc) || (rc == H_BUSY));
+                        lpar_rc = h_free_logical_lan(adapter->vdev->unit_address);
+                } while (H_IS_LONG_BUSY(lpar_rc) || (lpar_rc == H_BUSY));
 
                 goto err_out;
         }
@@ -752,7 +757,7 @@ static int ibmveth_set_csum_offload(struct net_device *dev, u32 data)
         struct ibmveth_adapter *adapter = netdev_priv(dev);
         unsigned long set_attr, clr_attr, ret_attr;
         unsigned long set_attr6, clr_attr6;
-        long ret, ret6;
+        long ret, ret4, ret6;
         int rc1 = 0, rc2 = 0;
         int restart = 0;
 
@@ -765,6 +770,8 @@ static int ibmveth_set_csum_offload(struct net_device *dev, u32 data)
 
         set_attr = 0;
         clr_attr = 0;
+        set_attr6 = 0;
+        clr_attr6 = 0;
 
         if (data) {
                 set_attr = IBMVETH_ILLAN_IPV4_TCP_CSUM;
@@ -779,16 +786,20 @@ static int ibmveth_set_csum_offload(struct net_device *dev, u32 data)
         if (ret == H_SUCCESS && !(ret_attr & IBMVETH_ILLAN_ACTIVE_TRUNK) &&
             !(ret_attr & IBMVETH_ILLAN_TRUNK_PRI_MASK) &&
             (ret_attr & IBMVETH_ILLAN_PADDED_PKT_CSUM)) {
-                ret = h_illan_attributes(adapter->vdev->unit_address, clr_attr,
+                ret4 = h_illan_attributes(adapter->vdev->unit_address, clr_attr,
                                          set_attr, &ret_attr);
 
-                if (ret != H_SUCCESS) {
+                if (ret4 != H_SUCCESS) {
                         netdev_err(dev, "unable to change IPv4 checksum "
                                         "offload settings. %d rc=%ld\n",
-                                        data, ret);
+                                        data, ret4);
+
+                        h_illan_attributes(adapter->vdev->unit_address,
+                                           set_attr, clr_attr, &ret_attr);
+
+                        if (data == 1)
+                                dev->features &= ~NETIF_F_IP_CSUM;
 
-                        ret = h_illan_attributes(adapter->vdev->unit_address,
-                                                 set_attr, clr_attr, &ret_attr);
                 } else {
                         adapter->fw_ipv4_csum_support = data;
                 }
@@ -799,15 +810,18 @@ static int ibmveth_set_csum_offload(struct net_device *dev, u32 data)
                 if (ret6 != H_SUCCESS) {
                         netdev_err(dev, "unable to change IPv6 checksum "
                                         "offload settings. %d rc=%ld\n",
-                                        data, ret);
+                                        data, ret6);
+
+                        h_illan_attributes(adapter->vdev->unit_address,
+                                           set_attr6, clr_attr6, &ret_attr);
+
+                        if (data == 1)
+                                dev->features &= ~NETIF_F_IPV6_CSUM;
 
-                        ret = h_illan_attributes(adapter->vdev->unit_address,
-                                                 set_attr6, clr_attr6,
-                                                 &ret_attr);
                 } else
                         adapter->fw_ipv6_csum_support = data;
 
-                if (ret != H_SUCCESS || ret6 != H_SUCCESS)
+                if (ret4 == H_SUCCESS || ret6 == H_SUCCESS)
                         adapter->rx_csum = data;
                 else
                         rc1 = -EIO;
@@ -925,6 +939,7 @@ static netdev_tx_t ibmveth_start_xmit(struct sk_buff *skb,
         union ibmveth_buf_desc descs[6];
         int last, i;
         int force_bounce = 0;
+        dma_addr_t dma_addr;
 
         /*
          * veth handles a maximum of 6 segments including the header, so
@@ -989,17 +1004,16 @@ retry_bounce:
         }
 
         /* Map the header */
-        descs[0].fields.address = dma_map_single(&adapter->vdev->dev, skb->data,
-                                                 skb_headlen(skb),
-                                                 DMA_TO_DEVICE);
-        if (dma_mapping_error(&adapter->vdev->dev, descs[0].fields.address))
+        dma_addr = dma_map_single(&adapter->vdev->dev, skb->data,
+                                  skb_headlen(skb), DMA_TO_DEVICE);
+        if (dma_mapping_error(&adapter->vdev->dev, dma_addr))
                 goto map_failed;
 
         descs[0].fields.flags_len = desc_flags | skb_headlen(skb);
+        descs[0].fields.address = dma_addr;
 
         /* Map the frags */
         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
-                unsigned long dma_addr;
                 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
 
                 dma_addr = dma_map_page(&adapter->vdev->dev, frag->page,
@@ -1021,7 +1035,12 @@ retry_bounce:
                 netdev->stats.tx_bytes += skb->len;
         }
 
-        for (i = 0; i < skb_shinfo(skb)->nr_frags + 1; i++)
+        dma_unmap_single(&adapter->vdev->dev,
+                         descs[0].fields.address,
+                         descs[0].fields.flags_len & IBMVETH_BUF_LEN_MASK,
+                         DMA_TO_DEVICE);
+
+        for (i = 1; i < skb_shinfo(skb)->nr_frags + 1; i++)
                 dma_unmap_page(&adapter->vdev->dev, descs[i].fields.address,
                                descs[i].fields.flags_len & IBMVETH_BUF_LEN_MASK,
                                DMA_TO_DEVICE);
@@ -1084,8 +1103,9 @@ restart_poll:
                                 if (rx_flush)
                                         ibmveth_flush_buffer(skb->data,
                                                 length + offset);
+                                if (!ibmveth_rxq_recycle_buffer(adapter))
+                                        kfree_skb(skb);
                                 skb = new_skb;
-                                ibmveth_rxq_recycle_buffer(adapter);
                         } else {
                                 ibmveth_rxq_harvest_buffer(adapter);
                                 skb_reserve(skb, offset);
diff --git a/drivers/net/irda/sh_irda.c b/drivers/net/irda/sh_irda.c
index 4488bd581eca..82660672dcd9 100644
--- a/drivers/net/irda/sh_irda.c
+++ b/drivers/net/irda/sh_irda.c
@@ -22,6 +22,8 @@
  *  - DMA transfer support
  *  - FIFO mode support
  */
+#include <linux/io.h>
+#include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
diff --git a/drivers/net/irda/sh_sir.c b/drivers/net/irda/sh_sir.c
index 52a7c86af663..ed7d7d62bf68 100644
--- a/drivers/net/irda/sh_sir.c
+++ b/drivers/net/irda/sh_sir.c
@@ -12,6 +12,8 @@
  * published by the Free Software Foundation.
  */
 
+#include <linux/io.h>
+#include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
@@ -511,7 +513,7 @@ static void sh_sir_tx(struct sh_sir_self *self, int phase)
 
 static int sh_sir_read_data(struct sh_sir_self *self)
 {
-        u16 val;
+        u16 val = 0;
         int timeout = 1024;
 
         while (timeout--) {
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index e86297b32733..e1fcc9589278 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -1321,8 +1321,8 @@ static void ixgbe_clean_rx_irq(struct ixgbe_q_vector *q_vector,
                 if (ring_is_rsc_enabled(rx_ring))
                         pkt_is_rsc = ixgbe_get_rsc_state(rx_desc);
 
-                /* if this is a skb from previous receive DMA will be 0 */
-                if (rx_buffer_info->dma) {
+                /* linear means we are building an skb from multiple pages */
+                if (!skb_is_nonlinear(skb)) {
                         u16 hlen;
                         if (pkt_is_rsc &&
                             !(staterr & IXGBE_RXD_STAT_EOP) &&
@@ -1459,8 +1459,10 @@ static void ixgbe_clean_rx_irq(struct ixgbe_q_vector *q_vector,
                 if (ixgbe_rx_is_fcoe(adapter, rx_desc)) {
                         ddp_bytes = ixgbe_fcoe_ddp(adapter, rx_desc, skb,
                                                    staterr);
-                        if (!ddp_bytes)
+                        if (!ddp_bytes) {
+                                dev_kfree_skb_any(skb);
                                 goto next_desc;
+                        }
                 }
 #endif /* IXGBE_FCOE */
                 ixgbe_receive_skb(q_vector, skb, staterr, rx_ring, rx_desc);
diff --git a/drivers/net/netconsole.c b/drivers/net/netconsole.c
index dfc82720065a..ed2a3977c6e7 100644
--- a/drivers/net/netconsole.c
+++ b/drivers/net/netconsole.c
@@ -799,5 +799,11 @@ static void __exit cleanup_netconsole(void)
         }
 }
 
-module_init(init_netconsole);
+/*
+ * Use late_initcall to ensure netconsole is
+ * initialized after network device driver if built-in.
+ *
+ * late_initcall() and module_init() are identical if built as module.
+ */
+late_initcall(init_netconsole);
 module_exit(cleanup_netconsole);
diff --git a/drivers/net/pch_gbe/pch_gbe.h b/drivers/net/pch_gbe/pch_gbe.h
index 59fac77d0dbb..a09a07197eb5 100644
--- a/drivers/net/pch_gbe/pch_gbe.h
+++ b/drivers/net/pch_gbe/pch_gbe.h
@@ -127,8 +127,8 @@ struct pch_gbe_regs {
 
 /* Reset */
 #define PCH_GBE_ALL_RST         0x80000000  /* All reset */
-#define PCH_GBE_TX_RST          0x40000000  /* TX MAC, TX FIFO, TX DMA reset */
-#define PCH_GBE_RX_RST          0x04000000  /* RX MAC, RX FIFO, RX DMA reset */
+#define PCH_GBE_TX_RST          0x00008000  /* TX MAC, TX FIFO, TX DMA reset */
+#define PCH_GBE_RX_RST          0x00004000  /* RX MAC, RX FIFO, RX DMA reset */
 
 /* TCP/IP Accelerator Control */
 #define PCH_GBE_EX_LIST_EN      0x00000008  /* External List Enable */
@@ -276,6 +276,9 @@ struct pch_gbe_regs {
 #define PCH_GBE_RX_DMA_EN       0x00000002   /* Enables Receive DMA */
 #define PCH_GBE_TX_DMA_EN       0x00000001   /* Enables Transmission DMA */
 
+/* RX DMA STATUS */
+#define PCH_GBE_IDLE_CHECK       0xFFFFFFFE
+
 /* Wake On LAN Status */
 #define PCH_GBE_WLS_BR          0x00000008 /* Broadcas Address */
 #define PCH_GBE_WLS_MLT         0x00000004 /* Multicast Address */
@@ -471,6 +474,7 @@ struct pch_gbe_tx_desc {
 struct pch_gbe_buffer {
         struct sk_buff *skb;
         dma_addr_t dma;
+        unsigned char *rx_buffer;
         unsigned long time_stamp;
         u16 length;
         bool mapped;
@@ -511,6 +515,9 @@ struct pch_gbe_tx_ring {
 struct pch_gbe_rx_ring {
         struct pch_gbe_rx_desc *desc;
         dma_addr_t dma;
+        unsigned char *rx_buff_pool;
+        dma_addr_t rx_buff_pool_logic;
+        unsigned int rx_buff_pool_size;
         unsigned int size;
         unsigned int count;
         unsigned int next_to_use;
@@ -622,6 +629,7 @@ struct pch_gbe_adapter {
         unsigned long rx_buffer_len;
         unsigned long tx_queue_len;
         bool have_msi;
+        bool rx_stop_flag;
 };
 
 extern const char pch_driver_version[];
diff --git a/drivers/net/pch_gbe/pch_gbe_main.c b/drivers/net/pch_gbe/pch_gbe_main.c
index eac3c5ca9731..b8b4ba27b0e7 100644
--- a/drivers/net/pch_gbe/pch_gbe_main.c
+++ b/drivers/net/pch_gbe/pch_gbe_main.c
@@ -20,7 +20,6 @@
 
 #include "pch_gbe.h"
 #include "pch_gbe_api.h"
-#include <linux/prefetch.h>
 
 #define DRV_VERSION     "1.00"
 const char pch_driver_version[] = DRV_VERSION;
@@ -34,11 +33,15 @@ const char pch_driver_version[] = DRV_VERSION;
 #define PCH_GBE_WATCHDOG_PERIOD         (1 * HZ)        /* watchdog time */
 #define PCH_GBE_COPYBREAK_DEFAULT       256
 #define PCH_GBE_PCI_BAR                 1
+#define PCH_GBE_RESERVE_MEMORY          0x200000        /* 2MB */
 
 /* Macros for ML7223 */
 #define PCI_VENDOR_ID_ROHM                      0x10db
 #define PCI_DEVICE_ID_ROHM_ML7223_GBE           0x8013
 
+/* Macros for ML7831 */
+#define PCI_DEVICE_ID_ROHM_ML7831_GBE           0x8802
+
 #define PCH_GBE_TX_WEIGHT         64
 #define PCH_GBE_RX_WEIGHT         64
 #define PCH_GBE_RX_BUFFER_WRITE   16
@@ -52,6 +55,7 @@ const char pch_driver_version[] = DRV_VERSION;
         )
 
 /* Ethertype field values */
+#define PCH_GBE_MAX_RX_BUFFER_SIZE      0x2880
 #define PCH_GBE_MAX_JUMBO_FRAME_SIZE    10318
 #define PCH_GBE_FRAME_SIZE_2048         2048
 #define PCH_GBE_FRAME_SIZE_4096         4096
@@ -83,10 +87,12 @@ const char pch_driver_version[] = DRV_VERSION;
 #define PCH_GBE_INT_ENABLE_MASK ( \
         PCH_GBE_INT_RX_DMA_CMPLT |    \
         PCH_GBE_INT_RX_DSC_EMP   |    \
+        PCH_GBE_INT_RX_FIFO_ERR  |    \
         PCH_GBE_INT_WOL_DET      |    \
         PCH_GBE_INT_TX_CMPLT          \
         )
 
+#define PCH_GBE_INT_DISABLE_ALL         0
 
 static unsigned int copybreak __read_mostly = PCH_GBE_COPYBREAK_DEFAULT;
 
@@ -138,6 +144,27 @@ static void pch_gbe_wait_clr_bit(void *reg, u32 bit)
         if (!tmp)
                 pr_err("Error: busy bit is not cleared\n");
 }
+
+/**
+ * pch_gbe_wait_clr_bit_irq - Wait to clear a bit for interrupt context
+ * @reg:        Pointer of register
+ * @busy:       Busy bit
+ */
+static int pch_gbe_wait_clr_bit_irq(void *reg, u32 bit)
+{
+        u32 tmp;
+        int ret = -1;
+        /* wait busy */
+        tmp = 20;
+        while ((ioread32(reg) & bit) && --tmp)
+                udelay(5);
+        if (!tmp)
+                pr_err("Error: busy bit is not cleared\n");
+        else
+                ret = 0;
+        return ret;
+}
+
 /**
  * pch_gbe_mac_mar_set - Set MAC address register
  * @hw:     Pointer to the HW structure
@@ -189,6 +216,17 @@ static void pch_gbe_mac_reset_hw(struct pch_gbe_hw *hw)
         return;
 }
 
+static void pch_gbe_mac_reset_rx(struct pch_gbe_hw *hw)
+{
+        /* Read the MAC address. and store to the private data */
+        pch_gbe_mac_read_mac_addr(hw);
+        iowrite32(PCH_GBE_RX_RST, &hw->reg->RESET);
+        pch_gbe_wait_clr_bit_irq(&hw->reg->RESET, PCH_GBE_RX_RST);
+        /* Setup the MAC address */
+        pch_gbe_mac_mar_set(hw, hw->mac.addr, 0);
+        return;
+}
+
 /**
  * pch_gbe_mac_init_rx_addrs - Initialize receive address's
  * @hw: Pointer to the HW structure
@@ -671,13 +709,8 @@ static void pch_gbe_setup_rctl(struct pch_gbe_adapter *adapter)
 
         tcpip = ioread32(&hw->reg->TCPIP_ACC);
 
-        if (netdev->features & NETIF_F_RXCSUM) {
-                tcpip &= ~PCH_GBE_RX_TCPIPACC_OFF;
-                tcpip |= PCH_GBE_RX_TCPIPACC_EN;
-        } else {
-                tcpip |= PCH_GBE_RX_TCPIPACC_OFF;
-                tcpip &= ~PCH_GBE_RX_TCPIPACC_EN;
-        }
+        tcpip |= PCH_GBE_RX_TCPIPACC_OFF;
+        tcpip &= ~PCH_GBE_RX_TCPIPACC_EN;
         iowrite32(tcpip, &hw->reg->TCPIP_ACC);
         return;
 }
@@ -717,13 +750,6 @@ static void pch_gbe_configure_rx(struct pch_gbe_adapter *adapter)
         iowrite32(rdba, &hw->reg->RX_DSC_BASE);
         iowrite32(rdlen, &hw->reg->RX_DSC_SIZE);
         iowrite32((rdba + rdlen), &hw->reg->RX_DSC_SW_P);
-
-        /* Enables Receive DMA */
-        rxdma = ioread32(&hw->reg->DMA_CTRL);
-        rxdma |= PCH_GBE_RX_DMA_EN;
-        iowrite32(rxdma, &hw->reg->DMA_CTRL);
-        /* Enables Receive */
-        iowrite32(PCH_GBE_MRE_MAC_RX_EN, &hw->reg->MAC_RX_EN);
 }
 
 /**
@@ -1097,6 +1123,48 @@ void pch_gbe_update_stats(struct pch_gbe_adapter *adapter)
         spin_unlock_irqrestore(&adapter->stats_lock, flags);
 }
 
+static void pch_gbe_stop_receive(struct pch_gbe_adapter *adapter)
+{
+        struct pch_gbe_hw *hw = &adapter->hw;
+        u32 rxdma;
+        u16 value;
+        int ret;
+
+        /* Disable Receive DMA */
+        rxdma = ioread32(&hw->reg->DMA_CTRL);
+        rxdma &= ~PCH_GBE_RX_DMA_EN;
+        iowrite32(rxdma, &hw->reg->DMA_CTRL);
+        /* Wait Rx DMA BUS is IDLE */
+        ret = pch_gbe_wait_clr_bit_irq(&hw->reg->RX_DMA_ST, PCH_GBE_IDLE_CHECK);
+        if (ret) {
+                /* Disable Bus master */
+                pci_read_config_word(adapter->pdev, PCI_COMMAND, &value);
+                value &= ~PCI_COMMAND_MASTER;
+                pci_write_config_word(adapter->pdev, PCI_COMMAND, value);
+                /* Stop Receive */
+                pch_gbe_mac_reset_rx(hw);
+                /* Enable Bus master */
+                value |= PCI_COMMAND_MASTER;
+                pci_write_config_word(adapter->pdev, PCI_COMMAND, value);
+        } else {
+                /* Stop Receive */
+                pch_gbe_mac_reset_rx(hw);
+        }
+}
+
+static void pch_gbe_start_receive(struct pch_gbe_hw *hw)
+{
+        u32 rxdma;
+
+        /* Enables Receive DMA */
+        rxdma = ioread32(&hw->reg->DMA_CTRL);
+        rxdma |= PCH_GBE_RX_DMA_EN;
+        iowrite32(rxdma, &hw->reg->DMA_CTRL);
+        /* Enables Receive */
+        iowrite32(PCH_GBE_MRE_MAC_RX_EN, &hw->reg->MAC_RX_EN);
+        return;
+}
+
 /**
  * pch_gbe_intr - Interrupt Handler
  * @irq:   Interrupt number
@@ -1123,7 +1191,17 @@ static irqreturn_t pch_gbe_intr(int irq, void *data)
         if (int_st & PCH_GBE_INT_RX_FRAME_ERR)
                 adapter->stats.intr_rx_frame_err_count++;
         if (int_st & PCH_GBE_INT_RX_FIFO_ERR)
-                adapter->stats.intr_rx_fifo_err_count++;
+                if (!adapter->rx_stop_flag) {
+                        adapter->stats.intr_rx_fifo_err_count++;
+                        pr_debug("Rx fifo over run\n");
+                        adapter->rx_stop_flag = true;
+                        int_en = ioread32(&hw->reg->INT_EN);
+                        iowrite32((int_en & ~PCH_GBE_INT_RX_FIFO_ERR),
+                                  &hw->reg->INT_EN);
+                        pch_gbe_stop_receive(adapter);
+                        int_st |= ioread32(&hw->reg->INT_ST);
+                        int_st = int_st & ioread32(&hw->reg->INT_EN);
+                }
         if (int_st & PCH_GBE_INT_RX_DMA_ERR)
                 adapter->stats.intr_rx_dma_err_count++;
         if (int_st & PCH_GBE_INT_TX_FIFO_ERR)
@@ -1135,21 +1213,18 @@ static irqreturn_t pch_gbe_intr(int irq, void *data)
         /* When Rx descriptor is empty  */
         if ((int_st & PCH_GBE_INT_RX_DSC_EMP)) {
                 adapter->stats.intr_rx_dsc_empty_count++;
-                pr_err("Rx descriptor is empty\n");
+                pr_debug("Rx descriptor is empty\n");
                 int_en = ioread32(&hw->reg->INT_EN);
                 iowrite32((int_en & ~PCH_GBE_INT_RX_DSC_EMP), &hw->reg->INT_EN);
                 if (hw->mac.tx_fc_enable) {
                         /* Set Pause packet */
                         pch_gbe_mac_set_pause_packet(hw);
                 }
-                if ((int_en & (PCH_GBE_INT_RX_DMA_CMPLT | PCH_GBE_INT_TX_CMPLT))
-                    == 0) {
-                        return IRQ_HANDLED;
-                }
         }
 
         /* When request status is Receive interruption */
-        if ((int_st & (PCH_GBE_INT_RX_DMA_CMPLT | PCH_GBE_INT_TX_CMPLT))) {
+        if ((int_st & (PCH_GBE_INT_RX_DMA_CMPLT | PCH_GBE_INT_TX_CMPLT)) ||
+            (adapter->rx_stop_flag == true)) {
                 if (likely(napi_schedule_prep(&adapter->napi))) {
                         /* Enable only Rx Descriptor empty */
                         atomic_inc(&adapter->irq_sem);
@@ -1185,29 +1260,23 @@ pch_gbe_alloc_rx_buffers(struct pch_gbe_adapter *adapter,
         unsigned int i;
         unsigned int bufsz;
 
-        bufsz = adapter->rx_buffer_len + PCH_GBE_DMA_ALIGN;
+        bufsz = adapter->rx_buffer_len + NET_IP_ALIGN;
         i = rx_ring->next_to_use;
 
         while ((cleaned_count--)) {
                 buffer_info = &rx_ring->buffer_info[i];
-                skb = buffer_info->skb;
-                if (skb) {
-                        skb_trim(skb, 0);
-                } else {
-                        skb = netdev_alloc_skb(netdev, bufsz);
-                        if (unlikely(!skb)) {
-                                /* Better luck next round */
-                                adapter->stats.rx_alloc_buff_failed++;
-                                break;
-                        }
-                        /* 64byte align */
-                        skb_reserve(skb, PCH_GBE_DMA_ALIGN);
-
-                        buffer_info->skb = skb;
-                        buffer_info->length = adapter->rx_buffer_len;
+                skb = netdev_alloc_skb(netdev, bufsz);
+                if (unlikely(!skb)) {
+                        /* Better luck next round */
+                        adapter->stats.rx_alloc_buff_failed++;
+                        break;
                 }
+                /* align */
+                skb_reserve(skb, NET_IP_ALIGN);
+                buffer_info->skb = skb;
+
                 buffer_info->dma = dma_map_single(&pdev->dev,
-                                                  skb->data,
+                                                  buffer_info->rx_buffer,
                                                   buffer_info->length,
                                                   DMA_FROM_DEVICE);
                 if (dma_mapping_error(&adapter->pdev->dev, buffer_info->dma)) {
@@ -1240,6 +1309,36 @@ pch_gbe_alloc_rx_buffers(struct pch_gbe_adapter *adapter,
         return;
 }
 
+static int
+pch_gbe_alloc_rx_buffers_pool(struct pch_gbe_adapter *adapter,
+                         struct pch_gbe_rx_ring *rx_ring, int cleaned_count)
+{
+        struct pci_dev *pdev = adapter->pdev;
+        struct pch_gbe_buffer *buffer_info;
+        unsigned int i;
+        unsigned int bufsz;
+        unsigned int size;
+
+        bufsz = adapter->rx_buffer_len;
+
+        size = rx_ring->count * bufsz + PCH_GBE_RESERVE_MEMORY;
+        rx_ring->rx_buff_pool = dma_alloc_coherent(&pdev->dev, size,
+                                                &rx_ring->rx_buff_pool_logic,
+                                                GFP_KERNEL);
+        if (!rx_ring->rx_buff_pool) {
+                pr_err("Unable to allocate memory for the receive poll buffer\n");
+                return -ENOMEM;
+        }
+        memset(rx_ring->rx_buff_pool, 0, size);
+        rx_ring->rx_buff_pool_size = size;
+        for (i = 0; i < rx_ring->count; i++) {
+                buffer_info = &rx_ring->buffer_info[i];
+                buffer_info->rx_buffer = rx_ring->rx_buff_pool + bufsz * i;
+                buffer_info->length = bufsz;
+        }
+        return 0;
+}
+
 /**
  * pch_gbe_alloc_tx_buffers - Allocate transmit buffers
  * @adapter:   Board private structure
@@ -1285,7 +1384,7 @@ pch_gbe_clean_tx(struct pch_gbe_adapter *adapter,
         struct sk_buff *skb;
         unsigned int i;
         unsigned int cleaned_count = 0;
-        bool cleaned = false;
+        bool cleaned = true;
 
         pr_debug("next_to_clean : %d\n", tx_ring->next_to_clean);
 
@@ -1296,7 +1395,6 @@ pch_gbe_clean_tx(struct pch_gbe_adapter *adapter,
 
         while ((tx_desc->gbec_status & DSC_INIT16) == 0x0000) {
                 pr_debug("gbec_status:0x%04x\n", tx_desc->gbec_status);
-                cleaned = true;
                 buffer_info = &tx_ring->buffer_info[i];
                 skb = buffer_info->skb;
 
@@ -1339,8 +1437,10 @@ pch_gbe_clean_tx(struct pch_gbe_adapter *adapter,
                 tx_desc = PCH_GBE_TX_DESC(*tx_ring, i);
 
                 /* weight of a sort for tx, to avoid endless transmit cleanup */
-                if (cleaned_count++ == PCH_GBE_TX_WEIGHT)
+                if (cleaned_count++ == PCH_GBE_TX_WEIGHT) {
+                        cleaned = false;
                         break;
+                }
         }
         pr_debug("called pch_gbe_unmap_and_free_tx_resource() %d count\n",
                  cleaned_count);
@@ -1380,7 +1480,7 @@ pch_gbe_clean_rx(struct pch_gbe_adapter *adapter,
         unsigned int i;
         unsigned int cleaned_count = 0;
         bool cleaned = false;
-        struct sk_buff *skb, *new_skb;
+        struct sk_buff *skb;
         u8 dma_status;
         u16 gbec_status;
         u32 tcp_ip_status;
@@ -1401,13 +1501,12 @@ pch_gbe_clean_rx(struct pch_gbe_adapter *adapter,
                 rx_desc->gbec_status = DSC_INIT16;
                 buffer_info = &rx_ring->buffer_info[i];
                 skb = buffer_info->skb;
+                buffer_info->skb = NULL;
 
                 /* unmap dma */
                 dma_unmap_single(&pdev->dev, buffer_info->dma,
                                    buffer_info->length, DMA_FROM_DEVICE);
                 buffer_info->mapped = false;
-                /* Prefetch the packet */
-                prefetch(skb->data);
 
                 pr_debug("RxDecNo = 0x%04x  Status[DMA:0x%02x GBE:0x%04x "
                          "TCP:0x%08x]  BufInf = 0x%p\n",
@@ -1427,70 +1526,16 @@ pch_gbe_clean_rx(struct pch_gbe_adapter *adapter,
                         pr_err("Receive CRC Error\n");
                 } else {
                         /* get receive length */
-                        /* length convert[-3] */
-                        length = (rx_desc->rx_words_eob) - 3;
-
-                        /* Decide the data conversion method */
-                        if (!(netdev->features & NETIF_F_RXCSUM)) {
-                                /* [Header:14][payload] */
-                                if (NET_IP_ALIGN) {
-                                        /* Because alignment differs,
-                                         * the new_skb is newly allocated,
-                                         * and data is copied to new_skb.*/
-                                        new_skb = netdev_alloc_skb(netdev,
-                                                         length + NET_IP_ALIGN);
-                                        if (!new_skb) {
-                                                /* dorrop error */
-                                                pr_err("New skb allocation "
-                                                        "Error\n");
-                                                goto dorrop;
-                                        }
-                                        skb_reserve(new_skb, NET_IP_ALIGN);
-                                        memcpy(new_skb->data, skb->data,
-                                               length);
-                                        skb = new_skb;
-                                } else {
-                                        /* DMA buffer is used as SKB as it is.*/
-                                        buffer_info->skb = NULL;
-                                }
-                        } else {
-                                /* [Header:14][padding:2][payload] */
-                                /* The length includes padding length */
-                                length = length - PCH_GBE_DMA_PADDING;
-                                if ((length < copybreak) ||
-                                    (NET_IP_ALIGN != PCH_GBE_DMA_PADDING)) {
-                                        /* Because alignment differs,
-                                         * the new_skb is newly allocated,
-                                         * and data is copied to new_skb.
-                                         * Padding data is deleted
-                                         * at the time of a copy.*/
-                                        new_skb = netdev_alloc_skb(netdev,
-                                                         length + NET_IP_ALIGN);
-                                        if (!new_skb) {
-                                                /* dorrop error */
-                                                pr_err("New skb allocation "
-                                                        "Error\n");
-                                                goto dorrop;
-                                        }
-                                        skb_reserve(new_skb, NET_IP_ALIGN);
-                                        memcpy(new_skb->data, skb->data,
-                                               ETH_HLEN);
-                                        memcpy(&new_skb->data[ETH_HLEN],
-                                               &skb->data[ETH_HLEN +
-                                               PCH_GBE_DMA_PADDING],
-                                               length - ETH_HLEN);
-                                        skb = new_skb;
-                                } else {
-                                        /* Padding data is deleted
-                                         * by moving header data.*/
-                                        memmove(&skb->data[PCH_GBE_DMA_PADDING],
-                                                &skb->data[0], ETH_HLEN);
-                                        skb_reserve(skb, NET_IP_ALIGN);
-                                        buffer_info->skb = NULL;
-                                }
-                        }
-                        /* The length includes FCS length */
-                        length = length - ETH_FCS_LEN;
+                        /* length convert[-3], length includes FCS length */
+                        length = (rx_desc->rx_words_eob) - 3 - ETH_FCS_LEN;
+                        if (rx_desc->rx_words_eob & 0x02)
+                                length = length - 4;
+                        /*
+                         * buffer_info->rx_buffer: [Header:14][payload]
+                         * skb->data: [Reserve:2][Header:14][payload]
+                         */
+                        memcpy(skb->data, buffer_info->rx_buffer, length);
+
                         /* update status of driver */
                         adapter->stats.rx_bytes += length;
                         adapter->stats.rx_packets++;
@@ -1509,7 +1554,6 @@ pch_gbe_clean_rx(struct pch_gbe_adapter *adapter,
                         pr_debug("Receive skb->ip_summed: %d length: %d\n",
                                  skb->ip_summed, length);
                 }
-dorrop:
                 /* return some buffers to hardware, one at a time is too slow */
                 if (unlikely(cleaned_count >= PCH_GBE_RX_BUFFER_WRITE)) {
                         pch_gbe_alloc_rx_buffers(adapter, rx_ring,
@@ -1714,9 +1758,15 @@ int pch_gbe_up(struct pch_gbe_adapter *adapter)
                 pr_err("Error: can't bring device up\n");
                 return err;
         }
+        err = pch_gbe_alloc_rx_buffers_pool(adapter, rx_ring, rx_ring->count);
+        if (err) {
+                pr_err("Error: can't bring device up\n");
+                return err;
+        }
         pch_gbe_alloc_tx_buffers(adapter, tx_ring);
         pch_gbe_alloc_rx_buffers(adapter, rx_ring, rx_ring->count);
         adapter->tx_queue_len = netdev->tx_queue_len;
+        pch_gbe_start_receive(&adapter->hw);
 
         mod_timer(&adapter->watchdog_timer, jiffies);
 
@@ -1734,6 +1784,7 @@ int pch_gbe_up(struct pch_gbe_adapter *adapter)
 void pch_gbe_down(struct pch_gbe_adapter *adapter)
 {
         struct net_device *netdev = adapter->netdev;
+        struct pch_gbe_rx_ring *rx_ring = adapter->rx_ring;
 
         /* signal that we're down so the interrupt handler does not
          * reschedule our watchdog timer */
@@ -1752,6 +1803,12 @@ void pch_gbe_down(struct pch_gbe_adapter *adapter)
         pch_gbe_reset(adapter);
         pch_gbe_clean_tx_ring(adapter, adapter->tx_ring);
         pch_gbe_clean_rx_ring(adapter, adapter->rx_ring);
+
+        pci_free_consistent(adapter->pdev, rx_ring->rx_buff_pool_size,
+                            rx_ring->rx_buff_pool, rx_ring->rx_buff_pool_logic);
+        rx_ring->rx_buff_pool_logic = 0;
+        rx_ring->rx_buff_pool_size = 0;
+        rx_ring->rx_buff_pool = NULL;
 }
 
 /**
@@ -2004,6 +2061,8 @@ static int pch_gbe_change_mtu(struct net_device *netdev, int new_mtu)
 {
         struct pch_gbe_adapter *adapter = netdev_priv(netdev);
         int max_frame;
+        unsigned long old_rx_buffer_len = adapter->rx_buffer_len;
+        int err;
 
         max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN;
         if ((max_frame < ETH_ZLEN + ETH_FCS_LEN) ||
@@ -2018,14 +2077,24 @@ static int pch_gbe_change_mtu(struct net_device *netdev, int new_mtu)
         else if (max_frame <= PCH_GBE_FRAME_SIZE_8192)
                 adapter->rx_buffer_len = PCH_GBE_FRAME_SIZE_8192;
         else
-                adapter->rx_buffer_len = PCH_GBE_MAX_JUMBO_FRAME_SIZE;
-        netdev->mtu = new_mtu;
-        adapter->hw.mac.max_frame_size = max_frame;
+                adapter->rx_buffer_len = PCH_GBE_MAX_RX_BUFFER_SIZE;
 
-        if (netif_running(netdev))
-                pch_gbe_reinit_locked(adapter);
-        else
+        if (netif_running(netdev)) {
+                pch_gbe_down(adapter);
+                err = pch_gbe_up(adapter);
+                if (err) {
+                        adapter->rx_buffer_len = old_rx_buffer_len;
+                        pch_gbe_up(adapter);
+                        return -ENOMEM;
+                } else {
+                        netdev->mtu = new_mtu;
+                        adapter->hw.mac.max_frame_size = max_frame;
+                }
+        } else {
                 pch_gbe_reset(adapter);
+                netdev->mtu = new_mtu;
+                adapter->hw.mac.max_frame_size = max_frame;
+        }
 
         pr_debug("max_frame : %d  rx_buffer_len : %d  mtu : %d  max_frame_size : %d\n",
                  max_frame, (u32) adapter->rx_buffer_len, netdev->mtu,
@@ -2099,33 +2168,39 @@ static int pch_gbe_napi_poll(struct napi_struct *napi, int budget)
 {
         struct pch_gbe_adapter *adapter =
             container_of(napi, struct pch_gbe_adapter, napi);
-        struct net_device *netdev = adapter->netdev;
         int work_done = 0;
         bool poll_end_flag = false;
         bool cleaned = false;
+        u32 int_en;
 
         pr_debug("budget : %d\n", budget);
 
-        /* Keep link state information with original netdev */
-        if (!netif_carrier_ok(netdev)) {
-                poll_end_flag = true;
-        } else {
-                cleaned = pch_gbe_clean_tx(adapter, adapter->tx_ring);
-                pch_gbe_clean_rx(adapter, adapter->rx_ring, &work_done, budget);
+        pch_gbe_clean_rx(adapter, adapter->rx_ring, &work_done, budget);
+        cleaned = pch_gbe_clean_tx(adapter, adapter->tx_ring);
 
-                if (cleaned)
-                        work_done = budget;
-                /* If no Tx and not enough Rx work done,
-                 * exit the polling mode
-                 */
-                if ((work_done < budget) || !netif_running(netdev))
-                        poll_end_flag = true;
-        }
+        if (!cleaned)
+                work_done = budget;
+        /* If no Tx and not enough Rx work done,
+         * exit the polling mode
+         */
+        if (work_done < budget)
+                poll_end_flag = true;
 
         if (poll_end_flag) {
                 napi_complete(napi);
+                if (adapter->rx_stop_flag) {
+                        adapter->rx_stop_flag = false;
+                        pch_gbe_start_receive(&adapter->hw);
+                }
                 pch_gbe_irq_enable(adapter);
-        }
+        } else
+                if (adapter->rx_stop_flag) {
+                        adapter->rx_stop_flag = false;
+                        pch_gbe_start_receive(&adapter->hw);
+                        int_en = ioread32(&adapter->hw.reg->INT_EN);
+                        iowrite32((int_en | PCH_GBE_INT_RX_FIFO_ERR),
+                                &adapter->hw.reg->INT_EN);
+                }
 
         pr_debug("poll_end_flag : %d  work_done : %d  budget : %d\n",
                  poll_end_flag, work_done, budget);
@@ -2452,6 +2527,13 @@ static DEFINE_PCI_DEVICE_TABLE(pch_gbe_pcidev_id) = {
          .class = (PCI_CLASS_NETWORK_ETHERNET << 8),
          .class_mask = (0xFFFF00)
          },
+        {.vendor = PCI_VENDOR_ID_ROHM,
+         .device = PCI_DEVICE_ID_ROHM_ML7831_GBE,
+         .subvendor = PCI_ANY_ID,
+         .subdevice = PCI_ANY_ID,
+         .class = (PCI_CLASS_NETWORK_ETHERNET << 8),
+         .class_mask = (0xFFFF00)
+         },
         /* required last entry */
         {0}
 };
diff --git a/drivers/net/pcnet32.c b/drivers/net/pcnet32.c
index 8b3090dc4bcd..80b6f36a8074 100644
--- a/drivers/net/pcnet32.c
+++ b/drivers/net/pcnet32.c
@@ -82,7 +82,7 @@ static int cards_found;
 /*
  * VLB I/O addresses
  */
-static unsigned int pcnet32_portlist[] __initdata =
+static unsigned int pcnet32_portlist[] =
     { 0x300, 0x320, 0x340, 0x360, 0 };
 
 static int pcnet32_debug;
diff --git a/drivers/net/phy/dp83640.c b/drivers/net/phy/dp83640.c
index 2cd8dc5847b4..edd7304773eb 100644
--- a/drivers/net/phy/dp83640.c
+++ b/drivers/net/phy/dp83640.c
@@ -34,8 +34,7 @@
 #define PAGESEL         0x13
 #define LAYER4          0x02
 #define LAYER2          0x01
-#define MAX_RXTS        4
-#define MAX_TXTS        4
+#define MAX_RXTS        64
 #define N_EXT_TS        1
 #define PSF_PTPVER      2
 #define PSF_EVNT        0x4000
@@ -218,7 +217,7 @@ static void phy2rxts(struct phy_rxts *p, struct rxts *rxts)
         rxts->seqid = p->seqid;
         rxts->msgtype = (p->msgtype >> 12) & 0xf;
         rxts->hash = p->msgtype & 0x0fff;
-        rxts->tmo = jiffies + HZ;
+        rxts->tmo = jiffies + 2;
 }
 
 static u64 phy2txts(struct phy_txts *p)
@@ -590,7 +589,7 @@ static void decode_rxts(struct dp83640_private *dp83640,
         prune_rx_ts(dp83640);
 
         if (list_empty(&dp83640->rxpool)) {
-                pr_warning("dp83640: rx timestamp pool is empty\n");
+                pr_debug("dp83640: rx timestamp pool is empty\n");
                 goto out;
         }
         rxts = list_first_entry(&dp83640->rxpool, struct rxts, list);
@@ -613,7 +612,7 @@ static void decode_txts(struct dp83640_private *dp83640,
         skb = skb_dequeue(&dp83640->tx_queue);
 
         if (!skb) {
-                pr_warning("dp83640: have timestamp but tx_queue empty\n");
+                pr_debug("dp83640: have timestamp but tx_queue empty\n");
                 return;
         }
         ns = phy2txts(phy_txts);
diff --git a/drivers/net/phy/national.c b/drivers/net/phy/national.c
index 0620ba963508..04bb8fcc0cb5 100644
--- a/drivers/net/phy/national.c
+++ b/drivers/net/phy/national.c
@@ -25,8 +25,9 @@
 /* DP83865 phy identifier values */
 #define DP83865_PHY_ID  0x20005c7a
 
-#define DP83865_INT_MASK_REG 0x15
-#define DP83865_INT_MASK_STATUS 0x14
+#define DP83865_INT_STATUS      0x14
+#define DP83865_INT_MASK        0x15
+#define DP83865_INT_CLEAR       0x17
 
 #define DP83865_INT_REMOTE_FAULT 0x0008
 #define DP83865_INT_ANE_COMPLETED 0x0010
@@ -68,21 +69,25 @@ static int ns_config_intr(struct phy_device *phydev)
         int err;
 
         if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
-                err = phy_write(phydev, DP83865_INT_MASK_REG,
+                err = phy_write(phydev, DP83865_INT_MASK,
                                 DP83865_INT_MASK_DEFAULT);
         else
-                err = phy_write(phydev, DP83865_INT_MASK_REG, 0);
+                err = phy_write(phydev, DP83865_INT_MASK, 0);
 
         return err;
 }
 
 static int ns_ack_interrupt(struct phy_device *phydev)
 {
-        int ret = phy_read(phydev, DP83865_INT_MASK_STATUS);
+        int ret = phy_read(phydev, DP83865_INT_STATUS);
         if (ret < 0)
                 return ret;
 
-        return 0;
+        /* Clear the interrupt status bit by writing a “1”
+         * to the corresponding bit in INT_CLEAR (2:0 are reserved) */
+        ret = phy_write(phydev, DP83865_INT_CLEAR, ret & ~0x7);
+
+        return ret;
 }
 
 static void ns_giga_speed_fallback(struct phy_device *phydev, int mode)
diff --git a/drivers/net/ppp_generic.c b/drivers/net/ppp_generic.c
index 10e5d985afa3..edfa15d2e795 100644
--- a/drivers/net/ppp_generic.c
+++ b/drivers/net/ppp_generic.c
@@ -1465,7 +1465,12 @@ static int ppp_mp_explode(struct ppp *ppp, struct sk_buff *skb)
                         continue;
                 }
 
-                mtu = pch->chan->mtu - hdrlen;
+                /*
+                 * hdrlen includes the 2-byte PPP protocol field, but the
+                 * MTU counts only the payload excluding the protocol field.
+                 * (RFC1661 Section 2)
+                 */
+                mtu = pch->chan->mtu - (hdrlen - 2);
                 if (mtu < 4)
                         mtu = 4;
                 if (flen > mtu)
diff --git a/drivers/net/pxa168_eth.c b/drivers/net/pxa168_eth.c
index 1a3033d8e7ed..d17d0624c5e6 100644
--- a/drivers/net/pxa168_eth.c
+++ b/drivers/net/pxa168_eth.c
@@ -40,6 +40,7 @@
 #include <linux/clk.h>
 #include <linux/phy.h>
 #include <linux/io.h>
+#include <linux/interrupt.h>
 #include <linux/types.h>
 #include <asm/pgtable.h>
 #include <asm/system.h>
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index 02339b3352e7..c23667017922 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -407,6 +407,7 @@ enum rtl_register_content {
         RxOK            = 0x0001,
 
         /* RxStatusDesc */
+        RxBOVF  = (1 << 24),
         RxFOVF  = (1 << 23),
         RxRWT   = (1 << 22),
         RxRES   = (1 << 21),
@@ -682,6 +683,7 @@ struct rtl8169_private {
         struct mii_if_info mii;
         struct rtl8169_counters counters;
         u32 saved_wolopts;
+        u32 opts1_mask;
 
         struct rtl_fw {
                 const struct firmware *fw;
@@ -710,6 +712,7 @@ MODULE_FIRMWARE(FIRMWARE_8168D_1);
 MODULE_FIRMWARE(FIRMWARE_8168D_2);
 MODULE_FIRMWARE(FIRMWARE_8168E_1);
 MODULE_FIRMWARE(FIRMWARE_8168E_2);
+MODULE_FIRMWARE(FIRMWARE_8168E_3);
 MODULE_FIRMWARE(FIRMWARE_8105E_1);
 
 static int rtl8169_open(struct net_device *dev);
@@ -3077,6 +3080,14 @@ static void rtl8169_phy_reset(struct net_device *dev,
         netif_err(tp, link, dev, "PHY reset failed\n");
 }
 
+static bool rtl_tbi_enabled(struct rtl8169_private *tp)
+{
+        void __iomem *ioaddr = tp->mmio_addr;
+
+        return (tp->mac_version == RTL_GIGA_MAC_VER_01) &&
+            (RTL_R8(PHYstatus) & TBI_Enable);
+}
+
 static void rtl8169_init_phy(struct net_device *dev, struct rtl8169_private *tp)
 {
         void __iomem *ioaddr = tp->mmio_addr;
@@ -3109,7 +3120,7 @@ static void rtl8169_init_phy(struct net_device *dev, struct rtl8169_private *tp)
                            ADVERTISED_1000baseT_Half |
                            ADVERTISED_1000baseT_Full : 0));
 
-        if (RTL_R8(PHYstatus) & TBI_Enable)
+        if (rtl_tbi_enabled(tp))
                 netif_info(tp, link, dev, "TBI auto-negotiating\n");
 }
 
@@ -3319,9 +3330,16 @@ static void r810x_phy_power_up(struct rtl8169_private *tp)
 
 static void r810x_pll_power_down(struct rtl8169_private *tp)
 {
+        void __iomem *ioaddr = tp->mmio_addr;
+
         if (__rtl8169_get_wol(tp) & WAKE_ANY) {
                 rtl_writephy(tp, 0x1f, 0x0000);
                 rtl_writephy(tp, MII_BMCR, 0x0000);
+
+                if (tp->mac_version == RTL_GIGA_MAC_VER_29 ||
+                    tp->mac_version == RTL_GIGA_MAC_VER_30)
+                        RTL_W32(RxConfig, RTL_R32(RxConfig) | AcceptBroadcast |
+                                AcceptMulticast | AcceptMyPhys);
                 return;
         }
 
@@ -3417,7 +3435,8 @@ static void r8168_pll_power_down(struct rtl8169_private *tp)
                 rtl_writephy(tp, MII_BMCR, 0x0000);
 
                 if (tp->mac_version == RTL_GIGA_MAC_VER_32 ||
-                    tp->mac_version == RTL_GIGA_MAC_VER_33)
+                    tp->mac_version == RTL_GIGA_MAC_VER_33 ||
+                    tp->mac_version == RTL_GIGA_MAC_VER_34)
                         RTL_W32(RxConfig, RTL_R32(RxConfig) | AcceptBroadcast |
                                 AcceptMulticast | AcceptMyPhys);
                 return;
@@ -3727,8 +3746,7 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         tp->features |= rtl_try_msi(pdev, ioaddr, cfg);
         RTL_W8(Cfg9346, Cfg9346_Lock);
 
-        if ((tp->mac_version <= RTL_GIGA_MAC_VER_06) &&
-            (RTL_R8(PHYstatus) & TBI_Enable)) {
+        if (rtl_tbi_enabled(tp)) {
                 tp->set_speed = rtl8169_set_speed_tbi;
                 tp->get_settings = rtl8169_gset_tbi;
                 tp->phy_reset_enable = rtl8169_tbi_reset_enable;
@@ -3777,6 +3795,9 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         tp->intr_event = cfg->intr_event;
         tp->napi_event = cfg->napi_event;
 
+        tp->opts1_mask = (tp->mac_version != RTL_GIGA_MAC_VER_01) ?
+                ~(RxBOVF | RxFOVF) : ~0;
+
         init_timer(&tp->timer);
         tp->timer.data = (unsigned long) dev;
         tp->timer.function = rtl8169_phy_timer;
@@ -3988,6 +4009,7 @@ static void rtl8169_hw_reset(struct rtl8169_private *tp)
                 while (RTL_R8(TxPoll) & NPQ)
                         udelay(20);
         } else if (tp->mac_version == RTL_GIGA_MAC_VER_34) {
+                RTL_W8(ChipCmd, RTL_R8(ChipCmd) | StopReq);
                 while (!(RTL_R32(TxConfig) & TXCFG_EMPTY))
                         udelay(100);
         } else {
@@ -5314,7 +5336,7 @@ static int rtl8169_rx_interrupt(struct net_device *dev,
                 u32 status;
 
                 rmb();
-                status = le32_to_cpu(desc->opts1);
+                status = le32_to_cpu(desc->opts1) & tp->opts1_mask;
 
                 if (status & DescOwn)
                         break;
diff --git a/drivers/net/rionet.c b/drivers/net/rionet.c
index 86ac38c96bcf..3bb131137033 100644
--- a/drivers/net/rionet.c
+++ b/drivers/net/rionet.c
@@ -80,13 +80,13 @@ static int rionet_capable = 1;
  */
 static struct rio_dev **rionet_active;
 
-#define is_rionet_capable(pef, src_ops, dst_ops)                \
-                        ((pef & RIO_PEF_INB_MBOX) &&            \
-                         (pef & RIO_PEF_INB_DOORBELL) &&        \
+#define is_rionet_capable(src_ops, dst_ops)                     \
+                        ((src_ops & RIO_SRC_OPS_DATA_MSG) &&    \
+                         (dst_ops & RIO_DST_OPS_DATA_MSG) &&    \
                          (src_ops & RIO_SRC_OPS_DOORBELL) &&    \
                          (dst_ops & RIO_DST_OPS_DOORBELL))
 #define dev_rionet_capable(dev) \
-        is_rionet_capable(dev->pef, dev->src_ops, dev->dst_ops)
+        is_rionet_capable(dev->src_ops, dev->dst_ops)
 
 #define RIONET_MAC_MATCH(x)     (*(u32 *)x == 0x00010001)
 #define RIONET_GET_DESTID(x)    (*(u16 *)(x + 4))
@@ -282,7 +282,6 @@ static int rionet_open(struct net_device *ndev)
 {
         int i, rc = 0;
         struct rionet_peer *peer, *tmp;
-        u32 pwdcsr;
         struct rionet_private *rnet = netdev_priv(ndev);
 
         if (netif_msg_ifup(rnet))
@@ -332,13 +331,8 @@ static int rionet_open(struct net_device *ndev)
                         continue;
                 }
 
-                /*
-                 * If device has initialized inbound doorbells,
-                 * send a join message
-                 */
-                rio_read_config_32(peer->rdev, RIO_WRITE_PORT_CSR, &pwdcsr);
-                if (pwdcsr & RIO_DOORBELL_AVAIL)
-                        rio_send_doorbell(peer->rdev, RIONET_DOORBELL_JOIN);
+                /* Send a join message */
+                rio_send_doorbell(peer->rdev, RIONET_DOORBELL_JOIN);
         }
 
       out:
@@ -492,7 +486,7 @@ static int rionet_setup_netdev(struct rio_mport *mport, struct net_device *ndev)
 static int rionet_probe(struct rio_dev *rdev, const struct rio_device_id *id)
 {
         int rc = -ENODEV;
-        u32 lpef, lsrc_ops, ldst_ops;
+        u32 lsrc_ops, ldst_ops;
         struct rionet_peer *peer;
         struct net_device *ndev = NULL;
 
@@ -515,12 +509,11 @@ static int rionet_probe(struct rio_dev *rdev, const struct rio_device_id *id)
          * on later probes
          */
         if (!rionet_check) {
-                rio_local_read_config_32(rdev->net->hport, RIO_PEF_CAR, &lpef);
                 rio_local_read_config_32(rdev->net->hport, RIO_SRC_OPS_CAR,
                                          &lsrc_ops);
                 rio_local_read_config_32(rdev->net->hport, RIO_DST_OPS_CAR,
                                          &ldst_ops);
-                if (!is_rionet_capable(lpef, lsrc_ops, ldst_ops)) {
+                if (!is_rionet_capable(lsrc_ops, ldst_ops)) {
                         printk(KERN_ERR
                                "%s: local device is not network capable\n",
                                DRV_NAME);
diff --git a/drivers/net/sfc/efx.c b/drivers/net/sfc/efx.c
index faca764aa21b..b59abc706d93 100644
--- a/drivers/net/sfc/efx.c
+++ b/drivers/net/sfc/efx.c
@@ -1050,7 +1050,6 @@ static int efx_init_io(struct efx_nic *efx)
 {
         struct pci_dev *pci_dev = efx->pci_dev;
         dma_addr_t dma_mask = efx->type->max_dma_mask;
-        bool use_wc;
         int rc;
 
         netif_dbg(efx, probe, efx->net_dev, "initialising I/O\n");
@@ -1101,21 +1100,8 @@ static int efx_init_io(struct efx_nic *efx)
                 rc = -EIO;
                 goto fail3;
         }
-
-        /* bug22643: If SR-IOV is enabled then tx push over a write combined
-         * mapping is unsafe. We need to disable write combining in this case.
-         * MSI is unsupported when SR-IOV is enabled, and the firmware will
-         * have removed the MSI capability. So write combining is safe if
-         * there is an MSI capability.
-         */
-        use_wc = (!EFX_WORKAROUND_22643(efx) ||
-                  pci_find_capability(pci_dev, PCI_CAP_ID_MSI));
-        if (use_wc)
-                efx->membase = ioremap_wc(efx->membase_phys,
-                                          efx->type->mem_map_size);
-        else
-                efx->membase = ioremap_nocache(efx->membase_phys,
-                                               efx->type->mem_map_size);
+        efx->membase = ioremap_nocache(efx->membase_phys,
+                                       efx->type->mem_map_size);
         if (!efx->membase) {
                 netif_err(efx, probe, efx->net_dev,
                           "could not map memory BAR at %llx+%x\n",
diff --git a/drivers/net/sfc/io.h b/drivers/net/sfc/io.h
index cc978803d484..751d1ec112cc 100644
--- a/drivers/net/sfc/io.h
+++ b/drivers/net/sfc/io.h
@@ -103,7 +103,6 @@ static inline void efx_writeo(struct efx_nic *efx, efx_oword_t *value,
         _efx_writed(efx, value->u32[2], reg + 8);
         _efx_writed(efx, value->u32[3], reg + 12);
 #endif
-        wmb();
         mmiowb();
         spin_unlock_irqrestore(&efx->biu_lock, flags);
 }
@@ -126,7 +125,6 @@ static inline void efx_sram_writeq(struct efx_nic *efx, void __iomem *membase,
         __raw_writel((__force u32)value->u32[0], membase + addr);
         __raw_writel((__force u32)value->u32[1], membase + addr + 4);
 #endif
-        wmb();
         mmiowb();
         spin_unlock_irqrestore(&efx->biu_lock, flags);
 }
@@ -141,7 +139,6 @@ static inline void efx_writed(struct efx_nic *efx, efx_dword_t *value,
 
         /* No lock required */
         _efx_writed(efx, value->u32[0], reg);
-        wmb();
 }
 
 /* Read a 128-bit CSR, locking as appropriate. */
@@ -152,7 +149,6 @@ static inline void efx_reado(struct efx_nic *efx, efx_oword_t *value,
 
         spin_lock_irqsave(&efx->biu_lock, flags);
         value->u32[0] = _efx_readd(efx, reg + 0);
-        rmb();
         value->u32[1] = _efx_readd(efx, reg + 4);
         value->u32[2] = _efx_readd(efx, reg + 8);
         value->u32[3] = _efx_readd(efx, reg + 12);
@@ -175,7 +171,6 @@ static inline void efx_sram_readq(struct efx_nic *efx, void __iomem *membase,
         value->u64[0] = (__force __le64)__raw_readq(membase + addr);
 #else
         value->u32[0] = (__force __le32)__raw_readl(membase + addr);
-        rmb();
         value->u32[1] = (__force __le32)__raw_readl(membase + addr + 4);
 #endif
         spin_unlock_irqrestore(&efx->biu_lock, flags);
@@ -249,7 +244,6 @@ static inline void _efx_writeo_page(struct efx_nic *efx, efx_oword_t *value,
         _efx_writed(efx, value->u32[2], reg + 8);
         _efx_writed(efx, value->u32[3], reg + 12);
 #endif
-        wmb();
 }
 #define efx_writeo_page(efx, value, reg, page)                          \
         _efx_writeo_page(efx, value,                                    \
diff --git a/drivers/net/sfc/mcdi.c b/drivers/net/sfc/mcdi.c
index 3dd45ed61f0a..81a425397468 100644
--- a/drivers/net/sfc/mcdi.c
+++ b/drivers/net/sfc/mcdi.c
@@ -50,20 +50,6 @@ static inline struct efx_mcdi_iface *efx_mcdi(struct efx_nic *efx)
         return &nic_data->mcdi;
 }
 
-static inline void
-efx_mcdi_readd(struct efx_nic *efx, efx_dword_t *value, unsigned reg)
-{
-        struct siena_nic_data *nic_data = efx->nic_data;
-        value->u32[0] = (__force __le32)__raw_readl(nic_data->mcdi_smem + reg);
-}
-
-static inline void
-efx_mcdi_writed(struct efx_nic *efx, const efx_dword_t *value, unsigned reg)
-{
-        struct siena_nic_data *nic_data = efx->nic_data;
-        __raw_writel((__force u32)value->u32[0], nic_data->mcdi_smem + reg);
-}
-
 void efx_mcdi_init(struct efx_nic *efx)
 {
         struct efx_mcdi_iface *mcdi;
@@ -84,8 +70,8 @@ static void efx_mcdi_copyin(struct efx_nic *efx, unsigned cmd,
                             const u8 *inbuf, size_t inlen)
 {
         struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
-        unsigned pdu = MCDI_PDU(efx);
-        unsigned doorbell = MCDI_DOORBELL(efx);
+        unsigned pdu = FR_CZ_MC_TREG_SMEM + MCDI_PDU(efx);
+        unsigned doorbell = FR_CZ_MC_TREG_SMEM + MCDI_DOORBELL(efx);
         unsigned int i;
         efx_dword_t hdr;
         u32 xflags, seqno;
@@ -106,28 +92,29 @@ static void efx_mcdi_copyin(struct efx_nic *efx, unsigned cmd,
                              MCDI_HEADER_SEQ, seqno,
                              MCDI_HEADER_XFLAGS, xflags);
 
-        efx_mcdi_writed(efx, &hdr, pdu);
+        efx_writed(efx, &hdr, pdu);
 
         for (i = 0; i < inlen; i += 4)
-                efx_mcdi_writed(efx, (const efx_dword_t *)(inbuf + i),
-                                pdu + 4 + i);
+                _efx_writed(efx, *((__le32 *)(inbuf + i)), pdu + 4 + i);
+
+        /* Ensure the payload is written out before the header */
+        wmb();
 
         /* ring the doorbell with a distinctive value */
-        EFX_POPULATE_DWORD_1(hdr, EFX_DWORD_0, 0x45789abc);
-        efx_mcdi_writed(efx, &hdr, doorbell);
+        _efx_writed(efx, (__force __le32) 0x45789abc, doorbell);
 }
 
 static void efx_mcdi_copyout(struct efx_nic *efx, u8 *outbuf, size_t outlen)
 {
         struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
-        unsigned int pdu = MCDI_PDU(efx);
+        unsigned int pdu = FR_CZ_MC_TREG_SMEM + MCDI_PDU(efx);
         int i;
 
         BUG_ON(atomic_read(&mcdi->state) == MCDI_STATE_QUIESCENT);
         BUG_ON(outlen & 3 || outlen >= 0x100);
 
         for (i = 0; i < outlen; i += 4)
-                efx_mcdi_readd(efx, (efx_dword_t *)(outbuf + i), pdu + 4 + i);
+                *((__le32 *)(outbuf + i)) = _efx_readd(efx, pdu + 4 + i);
 }
 
 static int efx_mcdi_poll(struct efx_nic *efx)
@@ -135,7 +122,7 @@ static int efx_mcdi_poll(struct efx_nic *efx)
         struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
         unsigned int time, finish;
         unsigned int respseq, respcmd, error;
-        unsigned int pdu = MCDI_PDU(efx);
+        unsigned int pdu = FR_CZ_MC_TREG_SMEM + MCDI_PDU(efx);
         unsigned int rc, spins;
         efx_dword_t reg;
 
@@ -161,7 +148,8 @@ static int efx_mcdi_poll(struct efx_nic *efx)
 
                 time = get_seconds();
 
-                efx_mcdi_readd(efx, &reg, pdu);
+                rmb();
+                efx_readd(efx, &reg, pdu);
 
                 /* All 1's indicates that shared memory is in reset (and is
                  * not a valid header). Wait for it to come out reset before
@@ -188,7 +176,7 @@ static int efx_mcdi_poll(struct efx_nic *efx)
                           respseq, mcdi->seqno);
                 rc = EIO;
         } else if (error) {
-                efx_mcdi_readd(efx, &reg, pdu + 4);
+                efx_readd(efx, &reg, pdu + 4);
                 switch (EFX_DWORD_FIELD(reg, EFX_DWORD_0)) {
 #define TRANSLATE_ERROR(name)                                   \
                 case MC_CMD_ERR_ ## name:                       \
@@ -222,21 +210,21 @@ out:
 /* Test and clear MC-rebooted flag for this port/function */
 int efx_mcdi_poll_reboot(struct efx_nic *efx)
 {
-        unsigned int addr = MCDI_REBOOT_FLAG(efx);
+        unsigned int addr = FR_CZ_MC_TREG_SMEM + MCDI_REBOOT_FLAG(efx);
         efx_dword_t reg;
         uint32_t value;
 
         if (efx_nic_rev(efx) < EFX_REV_SIENA_A0)
                 return false;
 
-        efx_mcdi_readd(efx, &reg, addr);
+        efx_readd(efx, &reg, addr);
         value = EFX_DWORD_FIELD(reg, EFX_DWORD_0);
 
         if (value == 0)
                 return 0;
 
         EFX_ZERO_DWORD(reg);
-        efx_mcdi_writed(efx, &reg, addr);
+        efx_writed(efx, &reg, addr);
 
         if (value == MC_STATUS_DWORD_ASSERT)
                 return -EINTR;
diff --git a/drivers/net/sfc/nic.c b/drivers/net/sfc/nic.c
index bafa23a6874c..3edfbaf5f022 100644
--- a/drivers/net/sfc/nic.c
+++ b/drivers/net/sfc/nic.c
@@ -1936,13 +1936,6 @@ void efx_nic_get_regs(struct efx_nic *efx, void *buf)
 
                 size = min_t(size_t, table->step, 16);
 
-                if (table->offset >= efx->type->mem_map_size) {
-                        /* No longer mapped; return dummy data */
-                        memcpy(buf, "\xde\xc0\xad\xde", 4);
-                        buf += table->rows * size;
-                        continue;
-                }
-
                 for (i = 0; i < table->rows; i++) {
                         switch (table->step) {
                         case 4: /* 32-bit register or SRAM */
diff --git a/drivers/net/sfc/nic.h b/drivers/net/sfc/nic.h
index 4bd1f2839dfe..7443f99c977f 100644
--- a/drivers/net/sfc/nic.h
+++ b/drivers/net/sfc/nic.h
@@ -143,12 +143,10 @@ static inline struct falcon_board *falcon_board(struct efx_nic *efx)
 /**
  * struct siena_nic_data - Siena NIC state
  * @mcdi: Management-Controller-to-Driver Interface
- * @mcdi_smem: MCDI shared memory mapping. The mapping is always uncacheable.
  * @wol_filter_id: Wake-on-LAN packet filter id
  */
 struct siena_nic_data {
         struct efx_mcdi_iface mcdi;
-        void __iomem *mcdi_smem;
         int wol_filter_id;
 };
 
diff --git a/drivers/net/sfc/siena.c b/drivers/net/sfc/siena.c
index 5735e84c69de..2c3bd93fab54 100644
--- a/drivers/net/sfc/siena.c
+++ b/drivers/net/sfc/siena.c
@@ -250,26 +250,12 @@ static int siena_probe_nic(struct efx_nic *efx)
         efx_reado(efx, &reg, FR_AZ_CS_DEBUG);
         efx->net_dev->dev_id = EFX_OWORD_FIELD(reg, FRF_CZ_CS_PORT_NUM) - 1;
 
-        /* Initialise MCDI */
-        nic_data->mcdi_smem = ioremap_nocache(efx->membase_phys +
-                                              FR_CZ_MC_TREG_SMEM,
-                                              FR_CZ_MC_TREG_SMEM_STEP *
-                                              FR_CZ_MC_TREG_SMEM_ROWS);
-        if (!nic_data->mcdi_smem) {
-                netif_err(efx, probe, efx->net_dev,
-                          "could not map MCDI at %llx+%x\n",
-                          (unsigned long long)efx->membase_phys +
-                          FR_CZ_MC_TREG_SMEM,
-                          FR_CZ_MC_TREG_SMEM_STEP * FR_CZ_MC_TREG_SMEM_ROWS);
-                rc = -ENOMEM;
-                goto fail1;
-        }
         efx_mcdi_init(efx);
 
         /* Recover from a failed assertion before probing */
         rc = efx_mcdi_handle_assertion(efx);
         if (rc)
-                goto fail2;
+                goto fail1;
 
         /* Let the BMC know that the driver is now in charge of link and
          * filter settings. We must do this before we reset the NIC */
@@ -324,7 +310,6 @@ fail4:
 fail3:
         efx_mcdi_drv_attach(efx, false, NULL);
 fail2:
-        iounmap(nic_data->mcdi_smem);
 fail1:
         kfree(efx->nic_data);
         return rc;
@@ -404,8 +389,6 @@ static int siena_init_nic(struct efx_nic *efx)
 
 static void siena_remove_nic(struct efx_nic *efx)
 {
-        struct siena_nic_data *nic_data = efx->nic_data;
-
         efx_nic_free_buffer(efx, &efx->irq_status);
 
         siena_reset_hw(efx, RESET_TYPE_ALL);
@@ -415,8 +398,7 @@ static void siena_remove_nic(struct efx_nic *efx)
                 efx_mcdi_drv_attach(efx, false, NULL);
 
         /* Tear down the private nic state */
-        iounmap(nic_data->mcdi_smem);
-        kfree(nic_data);
+        kfree(efx->nic_data);
         efx->nic_data = NULL;
 }
 
@@ -656,7 +638,8 @@ const struct efx_nic_type siena_a0_nic_type = {
         .default_mac_ops = &efx_mcdi_mac_operations,
 
         .revision = EFX_REV_SIENA_A0,
-        .mem_map_size = FR_CZ_MC_TREG_SMEM, /* MC_TREG_SMEM mapped separately */
+        .mem_map_size = (FR_CZ_MC_TREG_SMEM +
+                         FR_CZ_MC_TREG_SMEM_STEP * FR_CZ_MC_TREG_SMEM_ROWS),
         .txd_ptr_tbl_base = FR_BZ_TX_DESC_PTR_TBL,
         .rxd_ptr_tbl_base = FR_BZ_RX_DESC_PTR_TBL,
         .buf_tbl_base = FR_BZ_BUF_FULL_TBL,
diff --git a/drivers/net/sfc/workarounds.h b/drivers/net/sfc/workarounds.h
index 99ff11400cef..e4dd3a7f304b 100644
--- a/drivers/net/sfc/workarounds.h
+++ b/drivers/net/sfc/workarounds.h
@@ -38,8 +38,6 @@
 #define EFX_WORKAROUND_15783 EFX_WORKAROUND_ALWAYS
 /* Legacy interrupt storm when interrupt fifo fills */
 #define EFX_WORKAROUND_17213 EFX_WORKAROUND_SIENA
-/* Write combining and sriov=enabled are incompatible */
-#define EFX_WORKAROUND_22643 EFX_WORKAROUND_SIENA
 
 /* Spurious parity errors in TSORT buffers */
 #define EFX_WORKAROUND_5129 EFX_WORKAROUND_FALCON_A
diff --git a/drivers/net/sh_eth.c b/drivers/net/sh_eth.c
index ad35c210b839..1c1666e99106 100644
--- a/drivers/net/sh_eth.c
+++ b/drivers/net/sh_eth.c
@@ -21,6 +21,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/dma-mapping.h>
 #include <linux/etherdevice.h>
 #include <linux/delay.h>
@@ -30,6 +31,7 @@
 #include <linux/phy.h>
 #include <linux/cache.h>
 #include <linux/io.h>
+#include <linux/interrupt.h>
 #include <linux/pm_runtime.h>
 #include <linux/slab.h>
 #include <linux/ethtool.h>
diff --git a/drivers/net/slip.c b/drivers/net/slip.c
index f11b3f3df24f..4c617534f937 100644
--- a/drivers/net/slip.c
+++ b/drivers/net/slip.c
@@ -367,7 +367,7 @@ static void sl_bump(struct slip *sl)
         memcpy(skb_put(skb, count), sl->rbuff, count);
         skb_reset_mac_header(skb);
         skb->protocol = htons(ETH_P_IP);
-        netif_rx(skb);
+        netif_rx_ni(skb);
         dev->stats.rx_packets++;
 }
 
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index dc3fbf61910b..4a1374df6084 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -6234,12 +6234,10 @@ static netdev_tx_t tg3_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 }
         }
 
-#ifdef BCM_KERNEL_SUPPORTS_8021Q
         if (vlan_tx_tag_present(skb)) {
                 base_flags |= TXD_FLAG_VLAN;
                 vlan = vlan_tx_tag_get(skb);
         }
-#endif
 
         if (tg3_flag(tp, USE_JUMBO_BDFLAG) &&
             !mss && skb->len > VLAN_ETH_FRAME_LEN)
diff --git a/drivers/net/usb/cdc_ncm.c b/drivers/net/usb/cdc_ncm.c
index a03336e086d5..f06fb78383a1 100644
--- a/drivers/net/usb/cdc_ncm.c
+++ b/drivers/net/usb/cdc_ncm.c
@@ -228,23 +228,40 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
         if (ctx->rx_max != le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize)) {
 
                 if (flags & USB_CDC_NCM_NCAP_NTB_INPUT_SIZE) {
-                        struct usb_cdc_ncm_ndp_input_size ndp_in_sz;
+                        struct usb_cdc_ncm_ndp_input_size *ndp_in_sz;
+
+                        ndp_in_sz = kzalloc(sizeof(*ndp_in_sz), GFP_KERNEL);
+                        if (!ndp_in_sz) {
+                                err = -ENOMEM;
+                                goto size_err;
+                        }
+
                         err = usb_control_msg(ctx->udev,
                                         usb_sndctrlpipe(ctx->udev, 0),
                                         USB_CDC_SET_NTB_INPUT_SIZE,
                                         USB_TYPE_CLASS | USB_DIR_OUT
                                          | USB_RECIP_INTERFACE,
-                                        0, iface_no, &ndp_in_sz, 8, 1000);
+                                        0, iface_no, ndp_in_sz, 8, 1000);
+                        kfree(ndp_in_sz);
                 } else {
-                        __le32 dwNtbInMaxSize = cpu_to_le32(ctx->rx_max);
+                        __le32 *dwNtbInMaxSize;
+                        dwNtbInMaxSize = kzalloc(sizeof(*dwNtbInMaxSize),
+                                        GFP_KERNEL);
+                        if (!dwNtbInMaxSize) {
+                                err = -ENOMEM;
+                                goto size_err;
+                        }
+                        *dwNtbInMaxSize = cpu_to_le32(ctx->rx_max);
+
                         err = usb_control_msg(ctx->udev,
                                         usb_sndctrlpipe(ctx->udev, 0),
                                         USB_CDC_SET_NTB_INPUT_SIZE,
                                         USB_TYPE_CLASS | USB_DIR_OUT
                                          | USB_RECIP_INTERFACE,
-                                        0, iface_no, &dwNtbInMaxSize, 4, 1000);
+                                        0, iface_no, dwNtbInMaxSize, 4, 1000);
+                        kfree(dwNtbInMaxSize);
                 }
-
+size_err:
                 if (err < 0)
                         pr_debug("Setting NTB Input Size failed\n");
         }
@@ -325,19 +342,29 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
 
         /* set Max Datagram Size (MTU) */
         if (flags & USB_CDC_NCM_NCAP_MAX_DATAGRAM_SIZE) {
-                __le16 max_datagram_size;
+                __le16 *max_datagram_size;
                 u16 eth_max_sz = le16_to_cpu(ctx->ether_desc->wMaxSegmentSize);
+
+                max_datagram_size = kzalloc(sizeof(*max_datagram_size),
+                                GFP_KERNEL);
+                if (!max_datagram_size) {
+                        err = -ENOMEM;
+                        goto max_dgram_err;
+                }
+
                 err = usb_control_msg(ctx->udev, usb_rcvctrlpipe(ctx->udev, 0),
                                 USB_CDC_GET_MAX_DATAGRAM_SIZE,
                                 USB_TYPE_CLASS | USB_DIR_IN
                                  | USB_RECIP_INTERFACE,
-                                0, iface_no, &max_datagram_size,
+                                0, iface_no, max_datagram_size,
                                 2, 1000);
                 if (err < 0) {
                         pr_debug("GET_MAX_DATAGRAM_SIZE failed, use size=%u\n",
                                                 CDC_NCM_MIN_DATAGRAM_SIZE);
+                        kfree(max_datagram_size);
                 } else {
-                        ctx->max_datagram_size = le16_to_cpu(max_datagram_size);
+                        ctx->max_datagram_size =
+                                le16_to_cpu(*max_datagram_size);
                         /* Check Eth descriptor value */
                         if (eth_max_sz < CDC_NCM_MAX_DATAGRAM_SIZE) {
                                 if (ctx->max_datagram_size > eth_max_sz)
@@ -360,8 +387,10 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
                                                 USB_TYPE_CLASS | USB_DIR_OUT
                                                  | USB_RECIP_INTERFACE,
                                                 0,
-                                                iface_no, &max_datagram_size,
+                                                iface_no, max_datagram_size,
                                                 2, 1000);
+                        kfree(max_datagram_size);
+max_dgram_err:
                         if (err < 0)
                                 pr_debug("SET_MAX_DATAGRAM_SIZE failed\n");
                 }
diff --git a/drivers/net/usb/ipheth.c b/drivers/net/usb/ipheth.c
index 15772b1b6a91..13c1f044b40d 100644
--- a/drivers/net/usb/ipheth.c
+++ b/drivers/net/usb/ipheth.c
@@ -59,6 +59,7 @@
 #define USB_PRODUCT_IPHONE_3G   0x1292
 #define USB_PRODUCT_IPHONE_3GS  0x1294
 #define USB_PRODUCT_IPHONE_4    0x1297
+#define USB_PRODUCT_IPHONE_4_VZW 0x129c
 
 #define IPHETH_USBINTF_CLASS    255
 #define IPHETH_USBINTF_SUBCLASS 253
@@ -98,6 +99,10 @@ static struct usb_device_id ipheth_table[] = {
                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_4,
                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
                 IPHETH_USBINTF_PROTO) },
+        { USB_DEVICE_AND_INTERFACE_INFO(
+                USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_4_VZW,
+                IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
+                IPHETH_USBINTF_PROTO) },
         { }
 };
 MODULE_DEVICE_TABLE(usb, ipheth_table);
diff --git a/drivers/net/usb/rtl8150.c b/drivers/net/usb/rtl8150.c
index 041fb7d43c4f..ef3b236b5145 100644
--- a/drivers/net/usb/rtl8150.c
+++ b/drivers/net/usb/rtl8150.c
@@ -977,7 +977,6 @@ static void rtl8150_disconnect(struct usb_interface *intf)
         usb_set_intfdata(intf, NULL);
         if (dev) {
                 set_bit(RTL8150_UNPLUG, &dev->flags);
-                tasklet_disable(&dev->tl);
                 tasklet_kill(&dev->tl);
                 unregister_netdev(dev->netdev);
                 unlink_all_urbs(dev);
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index deb1eca13c9f..7c5336c5c37f 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -515,10 +515,6 @@ static void velocity_init_cam_filter(struct velocity_info *vptr)
         mac_set_cam_mask(regs, vptr->mCAMmask);
 
         /* Enable VCAMs */
-
-        if (test_bit(0, vptr->active_vlans))
-                WORD_REG_BITS_ON(MCFG_RTGOPT, &regs->MCFG);
-
         for_each_set_bit(vid, vptr->active_vlans, VLAN_N_VID) {
                 mac_set_vlan_cam(regs, i, (u8 *) &vid);
                 vptr->vCAMmask[i / 8] |= 0x1 << (i % 8);
diff --git a/drivers/net/vmxnet3/vmxnet3_drv.c b/drivers/net/vmxnet3/vmxnet3_drv.c
index 1cbacb389652..0959583feb27 100644
--- a/drivers/net/vmxnet3/vmxnet3_drv.c
+++ b/drivers/net/vmxnet3/vmxnet3_drv.c
@@ -1929,14 +1929,17 @@ static void
 vmxnet3_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
 {
         struct vmxnet3_adapter *adapter = netdev_priv(netdev);
-        u32 *vfTable = adapter->shared->devRead.rxFilterConf.vfTable;
-        unsigned long flags;
 
-        VMXNET3_SET_VFTABLE_ENTRY(vfTable, vid);
-        spin_lock_irqsave(&adapter->cmd_lock, flags);
-        VMXNET3_WRITE_BAR1_REG(adapter, VMXNET3_REG_CMD,
-                               VMXNET3_CMD_UPDATE_VLAN_FILTERS);
-        spin_unlock_irqrestore(&adapter->cmd_lock, flags);
+        if (!(netdev->flags & IFF_PROMISC)) {
+                u32 *vfTable = adapter->shared->devRead.rxFilterConf.vfTable;
+                unsigned long flags;
+
+                VMXNET3_SET_VFTABLE_ENTRY(vfTable, vid);
+                spin_lock_irqsave(&adapter->cmd_lock, flags);
+                VMXNET3_WRITE_BAR1_REG(adapter, VMXNET3_REG_CMD,
+                                       VMXNET3_CMD_UPDATE_VLAN_FILTERS);
+                spin_unlock_irqrestore(&adapter->cmd_lock, flags);
+        }
 
         set_bit(vid, adapter->active_vlans);
 }
@@ -1946,14 +1949,17 @@ static void
 vmxnet3_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
 {
         struct vmxnet3_adapter *adapter = netdev_priv(netdev);
-        u32 *vfTable = adapter->shared->devRead.rxFilterConf.vfTable;
-        unsigned long flags;
 
-        VMXNET3_CLEAR_VFTABLE_ENTRY(vfTable, vid);
-        spin_lock_irqsave(&adapter->cmd_lock, flags);
-        VMXNET3_WRITE_BAR1_REG(adapter, VMXNET3_REG_CMD,
-                               VMXNET3_CMD_UPDATE_VLAN_FILTERS);
-        spin_unlock_irqrestore(&adapter->cmd_lock, flags);
+        if (!(netdev->flags & IFF_PROMISC)) {
+                u32 *vfTable = adapter->shared->devRead.rxFilterConf.vfTable;
+                unsigned long flags;
+
+                VMXNET3_CLEAR_VFTABLE_ENTRY(vfTable, vid);
+                spin_lock_irqsave(&adapter->cmd_lock, flags);
+                VMXNET3_WRITE_BAR1_REG(adapter, VMXNET3_REG_CMD,
+                                       VMXNET3_CMD_UPDATE_VLAN_FILTERS);
+                spin_unlock_irqrestore(&adapter->cmd_lock, flags);
+        }
 
         clear_bit(vid, adapter->active_vlans);
 }
diff --git a/drivers/net/wireless/ath/ath5k/base.c b/drivers/net/wireless/ath/ath5k/base.c
index f54dff44ed50..c3119a6caace 100644
--- a/drivers/net/wireless/ath/ath5k/base.c
+++ b/drivers/net/wireless/ath/ath5k/base.c
@@ -1735,6 +1735,8 @@ ath5k_beacon_setup(struct ath5k_hw *ah, struct ath5k_buf *bf)
 
         if (dma_mapping_error(ah->dev, bf->skbaddr)) {
                 ATH5K_ERR(ah, "beacon DMA mapping failed\n");
+                dev_kfree_skb_any(skb);
+                bf->skb = NULL;
                 return -EIO;
         }
 
@@ -1819,8 +1821,6 @@ ath5k_beacon_update(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
         ath5k_txbuf_free_skb(ah, avf->bbuf);
         avf->bbuf->skb = skb;
         ret = ath5k_beacon_setup(ah, avf->bbuf);
-        if (ret)
-                avf->bbuf->skb = NULL;
 out:
         return ret;
 }
@@ -1840,6 +1840,7 @@ ath5k_beacon_send(struct ath5k_hw *ah)
         struct ath5k_vif *avf;
         struct ath5k_buf *bf;
         struct sk_buff *skb;
+        int err;
 
         ATH5K_DBG_UNLIMIT(ah, ATH5K_DEBUG_BEACON, "in beacon_send\n");
 
@@ -1888,11 +1889,6 @@ ath5k_beacon_send(struct ath5k_hw *ah)
 
         avf = (void *)vif->drv_priv;
         bf = avf->bbuf;
-        if (unlikely(bf->skb == NULL || ah->opmode == NL80211_IFTYPE_STATION ||
-                     ah->opmode == NL80211_IFTYPE_MONITOR)) {
-                ATH5K_WARN(ah, "bf=%p bf_skb=%p\n", bf, bf ? bf->skb : NULL);
-                return;
-        }
 
         /*
          * Stop any current dma and put the new frame on the queue.
@@ -1906,8 +1902,17 @@ ath5k_beacon_send(struct ath5k_hw *ah)
 
         /* refresh the beacon for AP or MESH mode */
         if (ah->opmode == NL80211_IFTYPE_AP ||
-            ah->opmode == NL80211_IFTYPE_MESH_POINT)
-                ath5k_beacon_update(ah->hw, vif);
+            ah->opmode == NL80211_IFTYPE_MESH_POINT) {
+                err = ath5k_beacon_update(ah->hw, vif);
+                if (err)
+                        return;
+        }
+
+        if (unlikely(bf->skb == NULL || ah->opmode == NL80211_IFTYPE_STATION ||
+                     ah->opmode == NL80211_IFTYPE_MONITOR)) {
+                ATH5K_WARN(ah, "bf=%p bf_skb=%p\n", bf, bf->skb);
+                return;
+        }
 
         trace_ath5k_tx(ah, bf->skb, &ah->txqs[ah->bhalq]);
 
diff --git a/drivers/net/wireless/ath/ath9k/ar9002_calib.c b/drivers/net/wireless/ath/ath9k/ar9002_calib.c
index 2d4c0910295b..2d394af82171 100644
--- a/drivers/net/wireless/ath/ath9k/ar9002_calib.c
+++ b/drivers/net/wireless/ath/ath9k/ar9002_calib.c
@@ -41,7 +41,8 @@ static bool ar9002_hw_is_cal_supported(struct ath_hw *ah,
         case ADC_DC_CAL:
                 /* Run ADC Gain Cal for non-CCK & non 2GHz-HT20 only */
                 if (!IS_CHAN_B(chan) &&
-                    !(IS_CHAN_2GHZ(chan) && IS_CHAN_HT20(chan)))
+                    !((IS_CHAN_2GHZ(chan) || IS_CHAN_A_FAST_CLOCK(ah, chan)) &&
+                      IS_CHAN_HT20(chan)))
                         supported = true;
                 break;
         }
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_2p2_initvals.h b/drivers/net/wireless/ath/ath9k/ar9003_2p2_initvals.h
index 2339728a7306..3e69c631ebb4 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_2p2_initvals.h
+++ b/drivers/net/wireless/ath/ath9k/ar9003_2p2_initvals.h
@@ -1514,7 +1514,7 @@ static const u32 ar9300_2p2_mac_core[][2] = {
         {0x00008258, 0x00000000},
         {0x0000825c, 0x40000000},
         {0x00008260, 0x00080922},
-        {0x00008264, 0x9bc00010},
+        {0x00008264, 0x9d400010},
         {0x00008268, 0xffffffff},
         {0x0000826c, 0x0000ffff},
         {0x00008270, 0x00000000},
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
index d109c25417f4..1b9400371eaf 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
@@ -69,7 +69,7 @@ static int ar9003_hw_power_interpolate(int32_t x,
 static const struct ar9300_eeprom ar9300_default = {
         .eepromVersion = 2,
         .templateVersion = 2,
-        .macAddr = {1, 2, 3, 4, 5, 6},
+        .macAddr = {0, 2, 3, 4, 5, 6},
         .custData = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
         .baseEepHeader = {
@@ -307,7 +307,7 @@ static const struct ar9300_eeprom ar9300_default = {
                  { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
                  { { CTL(60, 1), CTL(60, 0), CTL(60, 0), CTL(60, 1) } },
 
-                 { { CTL(60, 1), CTL(60, 0), CTL(0, 0), CTL(0, 0) } },
+                 { { CTL(60, 1), CTL(60, 0), CTL(60, 0), CTL(60, 0) } },
                  { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
                  { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
 
@@ -884,7 +884,7 @@ static const struct ar9300_eeprom ar9300_x113 = {
                  { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
                  { { CTL(60, 1), CTL(60, 0), CTL(60, 0), CTL(60, 1) } },
 
-                 { { CTL(60, 1), CTL(60, 0), CTL(0, 0), CTL(0, 0) } },
+                 { { CTL(60, 1), CTL(60, 0), CTL(60, 0), CTL(60, 0) } },
                  { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
                  { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
 
@@ -2040,7 +2040,7 @@ static const struct ar9300_eeprom ar9300_x112 = {
                 { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
                 { { CTL(60, 1), CTL(60, 0), CTL(60, 0), CTL(60, 1) } },
 
-                { { CTL(60, 1), CTL(60, 0), CTL(0, 0), CTL(0, 0) } },
+                { { CTL(60, 1), CTL(60, 0), CTL(60, 0), CTL(60, 0) } },
                 { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
                 { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
 
@@ -3734,7 +3734,7 @@ static void ar9003_hw_internal_regulator_apply(struct ath_hw *ah)
                                 }
                         } else {
                                 reg_pmu_set = (5 << 1) | (7 << 4) |
-                                              (1 << 8) | (2 << 14) |
+                                              (2 << 8) | (2 << 14) |
                                               (6 << 17) | (1 << 20) |
                                               (3 << 24) | (1 << 28);
                         }
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_phy.c b/drivers/net/wireless/ath/ath9k/ar9003_phy.c
index 1baca8e4715d..fcafec0605f4 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_phy.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_phy.c
@@ -671,7 +671,7 @@ static int ar9003_hw_process_ini(struct ath_hw *ah,
                 REG_WRITE_ARRAY(&ah->iniModesAdditional,
                                 modesIndex, regWrites);
 
-        if (AR_SREV_9300(ah))
+        if (AR_SREV_9330(ah))
                 REG_WRITE_ARRAY(&ah->iniModesAdditional, 1, regWrites);
 
         if (AR_SREV_9340(ah) && !ah->is_clk_25mhz)
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_phy.h b/drivers/net/wireless/ath/ath9k/ar9003_phy.h
index 6de3f0bc18e6..5c590429f120 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_phy.h
+++ b/drivers/net/wireless/ath/ath9k/ar9003_phy.h
@@ -850,7 +850,7 @@
 #define AR_PHY_TPC_11_B1         (AR_SM1_BASE + 0x220)
 #define AR_PHY_PDADC_TAB_1       (AR_SM1_BASE + 0x240)
 #define AR_PHY_TX_IQCAL_STATUS_B1   (AR_SM1_BASE + 0x48c)
-#define AR_PHY_TX_IQCAL_CORR_COEFF_B1(_i)    (AR_SM_BASE + 0x450 + ((_i) << 2))
+#define AR_PHY_TX_IQCAL_CORR_COEFF_B1(_i)    (AR_SM1_BASE + 0x450 + ((_i) << 2))
 
 /*
  * Channel 2 Register Map
diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c
index 9098aaad97a9..722967b86cf1 100644
--- a/drivers/net/wireless/ath/ath9k/main.c
+++ b/drivers/net/wireless/ath/ath9k/main.c
@@ -2283,7 +2283,11 @@ static void ath9k_set_coverage_class(struct ieee80211_hw *hw, u8 coverage_class)
 
         mutex_lock(&sc->mutex);
         ah->coverage_class = coverage_class;
+
+        ath9k_ps_wakeup(sc);
         ath9k_hw_init_global_settings(ah);
+        ath9k_ps_restore(sc);
+
         mutex_unlock(&sc->mutex);
 }
 
@@ -2299,6 +2303,12 @@ static void ath9k_flush(struct ieee80211_hw *hw, bool drop)
         mutex_lock(&sc->mutex);
         cancel_delayed_work_sync(&sc->tx_complete_work);
 
+        if (ah->ah_flags & AH_UNPLUGGED) {
+                ath_dbg(common, ATH_DBG_ANY, "Device has been unplugged!\n");
+                mutex_unlock(&sc->mutex);
+                return;
+        }
+
         if (sc->sc_flags & SC_OP_INVALID) {
                 ath_dbg(common, ATH_DBG_ANY, "Device not present\n");
                 mutex_unlock(&sc->mutex);
diff --git a/drivers/net/wireless/ath/ath9k/recv.c b/drivers/net/wireless/ath/ath9k/recv.c
index 9a4850154fb2..4c21f8cbdeb5 100644
--- a/drivers/net/wireless/ath/ath9k/recv.c
+++ b/drivers/net/wireless/ath/ath9k/recv.c
@@ -205,14 +205,22 @@ static void ath_rx_remove_buffer(struct ath_softc *sc,
 
 static void ath_rx_edma_cleanup(struct ath_softc *sc)
 {
+        struct ath_hw *ah = sc->sc_ah;
+        struct ath_common *common = ath9k_hw_common(ah);
         struct ath_buf *bf;
 
         ath_rx_remove_buffer(sc, ATH9K_RX_QUEUE_LP);
         ath_rx_remove_buffer(sc, ATH9K_RX_QUEUE_HP);
 
         list_for_each_entry(bf, &sc->rx.rxbuf, list) {
-                if (bf->bf_mpdu)
+                if (bf->bf_mpdu) {
+                        dma_unmap_single(sc->dev, bf->bf_buf_addr,
+                                        common->rx_bufsize,
+                                        DMA_BIDIRECTIONAL);
                         dev_kfree_skb_any(bf->bf_mpdu);
+                        bf->bf_buf_addr = 0;
+                        bf->bf_mpdu = NULL;
+                }
         }
 
         INIT_LIST_HEAD(&sc->rx.rxbuf);
diff --git a/drivers/net/wireless/ath/carl9170/main.c b/drivers/net/wireless/ath/carl9170/main.c
index 0122930b14c7..0474e6638d21 100644
--- a/drivers/net/wireless/ath/carl9170/main.c
+++ b/drivers/net/wireless/ath/carl9170/main.c
@@ -1066,8 +1066,10 @@ static int carl9170_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
          * the high througput speed in 802.11n networks.
          */
 
-        if (!is_main_vif(ar, vif))
+        if (!is_main_vif(ar, vif)) {
+                mutex_lock(&ar->mutex);
                 goto err_softw;
+        }
 
         /*
          * While the hardware supports *catch-all* key, for offloading
diff --git a/drivers/net/wireless/b43/dma.c b/drivers/net/wireless/b43/dma.c
index 83cba22ac6e8..481e534534eb 100644
--- a/drivers/net/wireless/b43/dma.c
+++ b/drivers/net/wireless/b43/dma.c
@@ -795,9 +795,23 @@ static u64 supported_dma_mask(struct b43_wldev *dev)
         u32 tmp;
         u16 mmio_base;
 
-        tmp = b43_read32(dev, SSB_TMSHIGH);
-        if (tmp & SSB_TMSHIGH_DMA64)
-                return DMA_BIT_MASK(64);
+        switch (dev->dev->bus_type) {
+#ifdef CONFIG_B43_BCMA
+        case B43_BUS_BCMA:
+                tmp = bcma_aread32(dev->dev->bdev, BCMA_IOST);
+                if (tmp & BCMA_IOST_DMA64)
+                        return DMA_BIT_MASK(64);
+                break;
+#endif
+#ifdef CONFIG_B43_SSB
+        case B43_BUS_SSB:
+                tmp = ssb_read32(dev->dev->sdev, SSB_TMSHIGH);
+                if (tmp & SSB_TMSHIGH_DMA64)
+                        return DMA_BIT_MASK(64);
+                break;
+#endif
+        }
+
         mmio_base = b43_dmacontroller_base(0, 0);
         b43_write32(dev, mmio_base + B43_DMA32_TXCTL, B43_DMA32_TXADDREXT_MASK);
         tmp = b43_read32(dev, mmio_base + B43_DMA32_TXCTL);
diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index 26f1ab840cc7..e293a7921bf0 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -1632,7 +1632,8 @@ static void handle_irq_beacon(struct b43_wldev *dev)
         u32 cmd, beacon0_valid, beacon1_valid;
 
         if (!b43_is_mode(wl, NL80211_IFTYPE_AP) &&
-            !b43_is_mode(wl, NL80211_IFTYPE_MESH_POINT))
+            !b43_is_mode(wl, NL80211_IFTYPE_MESH_POINT) &&
+            !b43_is_mode(wl, NL80211_IFTYPE_ADHOC))
                 return;
 
         /* This is the bottom half of the asynchronous beacon update. */
diff --git a/drivers/net/wireless/ipw2x00/ipw2100.c b/drivers/net/wireless/ipw2x00/ipw2100.c
index 3774dd034746..ef9ad79d1bfd 100644
--- a/drivers/net/wireless/ipw2x00/ipw2100.c
+++ b/drivers/net/wireless/ipw2x00/ipw2100.c
@@ -1903,15 +1903,17 @@ static void ipw2100_down(struct ipw2100_priv *priv)
 static int ipw2100_net_init(struct net_device *dev)
 {
         struct ipw2100_priv *priv = libipw_priv(dev);
+
+        return ipw2100_up(priv, 1);
+}
+
+static int ipw2100_wdev_init(struct net_device *dev)
+{
+        struct ipw2100_priv *priv = libipw_priv(dev);
         const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
         struct wireless_dev *wdev = &priv->ieee->wdev;
-        int ret;
         int i;
 
-        ret = ipw2100_up(priv, 1);
-        if (ret)
-                return ret;
-
         memcpy(wdev->wiphy->perm_addr, priv->mac_addr, ETH_ALEN);
 
         /* fill-out priv->ieee->bg_band */
@@ -6350,9 +6352,13 @@ static int ipw2100_pci_init_one(struct pci_dev *pci_dev,
                        "Error calling register_netdev.\n");
                 goto fail;
         }
+        registered = 1;
+
+        err = ipw2100_wdev_init(dev);
+        if (err)
+                goto fail;
 
         mutex_lock(&priv->action_mutex);
-        registered = 1;
 
         IPW_DEBUG_INFO("%s: Bound to %s\n", dev->name, pci_name(pci_dev));
 
@@ -6389,7 +6395,8 @@ static int ipw2100_pci_init_one(struct pci_dev *pci_dev,
 
       fail_unlock:
         mutex_unlock(&priv->action_mutex);
-
+        wiphy_unregister(priv->ieee->wdev.wiphy);
+        kfree(priv->ieee->bg_band.channels);
       fail:
         if (dev) {
                 if (registered)
diff --git a/drivers/net/wireless/ipw2x00/ipw2200.c b/drivers/net/wireless/ipw2x00/ipw2200.c
index 87813c33bdc2..4ffebede5e03 100644
--- a/drivers/net/wireless/ipw2x00/ipw2200.c
+++ b/drivers/net/wireless/ipw2x00/ipw2200.c
@@ -11425,16 +11425,23 @@ static void ipw_bg_down(struct work_struct *work)
 /* Called by register_netdev() */
 static int ipw_net_init(struct net_device *dev)
 {
+        int rc = 0;
+        struct ipw_priv *priv = libipw_priv(dev);
+
+        mutex_lock(&priv->mutex);
+        if (ipw_up(priv))
+                rc = -EIO;
+        mutex_unlock(&priv->mutex);
+
+        return rc;
+}
+
+static int ipw_wdev_init(struct net_device *dev)
+{
         int i, rc = 0;
         struct ipw_priv *priv = libipw_priv(dev);
         const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
         struct wireless_dev *wdev = &priv->ieee->wdev;
-        mutex_lock(&priv->mutex);
-
-        if (ipw_up(priv)) {
-                rc = -EIO;
-                goto out;
-        }
 
         memcpy(wdev->wiphy->perm_addr, priv->mac_addr, ETH_ALEN);
 
@@ -11519,13 +11526,9 @@ static int ipw_net_init(struct net_device *dev)
         set_wiphy_dev(wdev->wiphy, &priv->pci_dev->dev);
 
         /* With that information in place, we can now register the wiphy... */
-        if (wiphy_register(wdev->wiphy)) {
+        if (wiphy_register(wdev->wiphy))
                 rc = -EIO;
-                goto out;
-        }
-
 out:
-        mutex_unlock(&priv->mutex);
         return rc;
 }
 
@@ -11832,14 +11835,22 @@ static int __devinit ipw_pci_probe(struct pci_dev *pdev,
                 goto out_remove_sysfs;
         }
 
+        err = ipw_wdev_init(net_dev);
+        if (err) {
+                IPW_ERROR("failed to register wireless device\n");
+                goto out_unregister_netdev;
+        }
+
 #ifdef CONFIG_IPW2200_PROMISCUOUS
         if (rtap_iface) {
                 err = ipw_prom_alloc(priv);
                 if (err) {
                         IPW_ERROR("Failed to register promiscuous network "
                                   "device (error %d).\n", err);
-                        unregister_netdev(priv->net_dev);
-                        goto out_remove_sysfs;
+                        wiphy_unregister(priv->ieee->wdev.wiphy);
+                        kfree(priv->ieee->a_band.channels);
+                        kfree(priv->ieee->bg_band.channels);
+                        goto out_unregister_netdev;
                 }
         }
 #endif
@@ -11851,6 +11862,8 @@ static int __devinit ipw_pci_probe(struct pci_dev *pdev,
 
         return 0;
 
+      out_unregister_netdev:
+        unregister_netdev(priv->net_dev);
       out_remove_sysfs:
         sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
       out_release_irq:
diff --git a/drivers/net/wireless/iwlegacy/iwl-3945-rs.c b/drivers/net/wireless/iwlegacy/iwl-3945-rs.c
index 977bd2477c6a..164bcae821f8 100644
--- a/drivers/net/wireless/iwlegacy/iwl-3945-rs.c
+++ b/drivers/net/wireless/iwlegacy/iwl-3945-rs.c
@@ -822,12 +822,15 @@ static void iwl3945_rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
 
  out:
 
-        rs_sta->last_txrate_idx = index;
-        if (sband->band == IEEE80211_BAND_5GHZ)
-                info->control.rates[0].idx = rs_sta->last_txrate_idx -
-                                IWL_FIRST_OFDM_RATE;
-        else
+        if (sband->band == IEEE80211_BAND_5GHZ) {
+                if (WARN_ON_ONCE(index < IWL_FIRST_OFDM_RATE))
+                        index = IWL_FIRST_OFDM_RATE;
+                rs_sta->last_txrate_idx = index;
+                info->control.rates[0].idx = index - IWL_FIRST_OFDM_RATE;
+        } else {
+                rs_sta->last_txrate_idx = index;
                 info->control.rates[0].idx = rs_sta->last_txrate_idx;
+        }
 
         IWL_DEBUG_RATE(priv, "leave: %d\n", index);
 }
diff --git a/drivers/net/wireless/iwlegacy/iwl-core.c b/drivers/net/wireless/iwlegacy/iwl-core.c
index 35cd2537e7fd..e5971fe9d169 100644
--- a/drivers/net/wireless/iwlegacy/iwl-core.c
+++ b/drivers/net/wireless/iwlegacy/iwl-core.c
@@ -937,7 +937,7 @@ void iwl_legacy_irq_handle_error(struct iwl_priv *priv)
                                         &priv->contexts[IWL_RXON_CTX_BSS]);
 #endif
 
-        wake_up_interruptible(&priv->wait_command_queue);
+        wake_up(&priv->wait_command_queue);
 
         /* Keep the restart process from trying to send host
          * commands by clearing the INIT status bit */
@@ -1746,7 +1746,7 @@ int iwl_legacy_force_reset(struct iwl_priv *priv, bool external)
 
         /* Set the FW error flag -- cleared on iwl_down */
         set_bit(STATUS_FW_ERROR, &priv->status);
-        wake_up_interruptible(&priv->wait_command_queue);
+        wake_up(&priv->wait_command_queue);
         /*
          * Keep the restart process from trying to send host
          * commands by clearing the INIT status bit
diff --git a/drivers/net/wireless/iwlegacy/iwl-hcmd.c b/drivers/net/wireless/iwlegacy/iwl-hcmd.c
index 62b4b09122cb..ce1fc9feb61f 100644
--- a/drivers/net/wireless/iwlegacy/iwl-hcmd.c
+++ b/drivers/net/wireless/iwlegacy/iwl-hcmd.c
@@ -167,7 +167,7 @@ int iwl_legacy_send_cmd_sync(struct iwl_priv *priv, struct iwl_host_cmd *cmd)
                 goto out;
         }
 
-        ret = wait_event_interruptible_timeout(priv->wait_command_queue,
+        ret = wait_event_timeout(priv->wait_command_queue,
                         !test_bit(STATUS_HCMD_ACTIVE, &priv->status),
                         HOST_COMPLETE_TIMEOUT);
         if (!ret) {
diff --git a/drivers/net/wireless/iwlegacy/iwl-tx.c b/drivers/net/wireless/iwlegacy/iwl-tx.c
index 4fff995c6f3e..ef9e268bf8a0 100644
--- a/drivers/net/wireless/iwlegacy/iwl-tx.c
+++ b/drivers/net/wireless/iwlegacy/iwl-tx.c
@@ -625,6 +625,8 @@ iwl_legacy_tx_cmd_complete(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
         cmd = txq->cmd[cmd_index];
         meta = &txq->meta[cmd_index];
 
+        txq->time_stamp = jiffies;
+
         pci_unmap_single(priv->pci_dev,
                          dma_unmap_addr(meta, mapping),
                          dma_unmap_len(meta, len),
@@ -645,7 +647,7 @@ iwl_legacy_tx_cmd_complete(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
                 clear_bit(STATUS_HCMD_ACTIVE, &priv->status);
                 IWL_DEBUG_INFO(priv, "Clearing HCMD_ACTIVE for command %s\n",
                                iwl_legacy_get_cmd_string(cmd->hdr.cmd));
-                wake_up_interruptible(&priv->wait_command_queue);
+                wake_up(&priv->wait_command_queue);
         }
 
         /* Mark as unmapped */
diff --git a/drivers/net/wireless/iwlegacy/iwl3945-base.c b/drivers/net/wireless/iwlegacy/iwl3945-base.c
index 795826a014ed..66ee15629a76 100644
--- a/drivers/net/wireless/iwlegacy/iwl3945-base.c
+++ b/drivers/net/wireless/iwlegacy/iwl3945-base.c
@@ -841,7 +841,7 @@ static void iwl3945_rx_card_state_notif(struct iwl_priv *priv,
                 wiphy_rfkill_set_hw_state(priv->hw->wiphy,
                                 test_bit(STATUS_RF_KILL_HW, &priv->status));
         else
-                wake_up_interruptible(&priv->wait_command_queue);
+                wake_up(&priv->wait_command_queue);
 }
 
 /**
@@ -2269,7 +2269,7 @@ static void iwl3945_alive_start(struct iwl_priv *priv)
         iwl3945_reg_txpower_periodic(priv);
 
         IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
-        wake_up_interruptible(&priv->wait_command_queue);
+        wake_up(&priv->wait_command_queue);
 
         return;
 
@@ -2300,7 +2300,7 @@ static void __iwl3945_down(struct iwl_priv *priv)
         iwl_legacy_clear_driver_stations(priv);
 
         /* Unblock any waiting calls */
-        wake_up_interruptible_all(&priv->wait_command_queue);
+        wake_up_all(&priv->wait_command_queue);
 
         /* Wipe out the EXIT_PENDING status bit if we are not actually
          * exiting the module */
@@ -2853,7 +2853,7 @@ static int iwl3945_mac_start(struct ieee80211_hw *hw)
 
         /* Wait for START_ALIVE from ucode. Otherwise callbacks from
          * mac80211 will not be run successfully. */
-        ret = wait_event_interruptible_timeout(priv->wait_command_queue,
+        ret = wait_event_timeout(priv->wait_command_queue,
                         test_bit(STATUS_READY, &priv->status),
                         UCODE_READY_TIMEOUT);
         if (!ret) {
diff --git a/drivers/net/wireless/iwlegacy/iwl4965-base.c b/drivers/net/wireless/iwlegacy/iwl4965-base.c
index 14334668034e..aa0c2539761e 100644
--- a/drivers/net/wireless/iwlegacy/iwl4965-base.c
+++ b/drivers/net/wireless/iwlegacy/iwl4965-base.c
@@ -576,7 +576,7 @@ static void iwl4965_rx_card_state_notif(struct iwl_priv *priv,
                 wiphy_rfkill_set_hw_state(priv->hw->wiphy,
                         test_bit(STATUS_RF_KILL_HW, &priv->status));
         else
-                wake_up_interruptible(&priv->wait_command_queue);
+                wake_up(&priv->wait_command_queue);
 }
 
 /**
@@ -926,7 +926,7 @@ static void iwl4965_irq_tasklet(struct iwl_priv *priv)
                 handled |= CSR_INT_BIT_FH_TX;
                 /* Wake up uCode load routine, now that load is complete */
                 priv->ucode_write_complete = 1;
-                wake_up_interruptible(&priv->wait_command_queue);
+                wake_up(&priv->wait_command_queue);
         }
 
         if (inta & ~handled) {
@@ -1795,7 +1795,7 @@ static void iwl4965_alive_start(struct iwl_priv *priv)
         iwl4965_rf_kill_ct_config(priv);
 
         IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
-        wake_up_interruptible(&priv->wait_command_queue);
+        wake_up(&priv->wait_command_queue);
 
         iwl_legacy_power_update_mode(priv, true);
         IWL_DEBUG_INFO(priv, "Updated power mode\n");
@@ -1828,7 +1828,7 @@ static void __iwl4965_down(struct iwl_priv *priv)
         iwl_legacy_clear_driver_stations(priv);
 
         /* Unblock any waiting calls */
-        wake_up_interruptible_all(&priv->wait_command_queue);
+        wake_up_all(&priv->wait_command_queue);
 
         /* Wipe out the EXIT_PENDING status bit if we are not actually
          * exiting the module */
@@ -2266,7 +2266,7 @@ int iwl4965_mac_start(struct ieee80211_hw *hw)
 
         /* Wait for START_ALIVE from Run Time ucode. Otherwise callbacks from
          * mac80211 will not be run successfully. */
-        ret = wait_event_interruptible_timeout(priv->wait_command_queue,
+        ret = wait_event_timeout(priv->wait_command_queue,
                         test_bit(STATUS_READY, &priv->status),
                         UCODE_READY_TIMEOUT);
         if (!ret) {
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-ucode.c b/drivers/net/wireless/iwlwifi/iwl-agn-ucode.c
index a895a099d086..56211006a182 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn-ucode.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-ucode.c
@@ -167,7 +167,7 @@ static int iwlagn_set_temperature_offset_calib(struct iwl_priv *priv)
 
         memset(&cmd, 0, sizeof(cmd));
         iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD);
-        memcpy(&cmd.radio_sensor_offset, offset_calib, sizeof(offset_calib));
+        memcpy(&cmd.radio_sensor_offset, offset_calib, sizeof(*offset_calib));
         if (!(cmd.radio_sensor_offset))
                 cmd.radio_sensor_offset = DEFAULT_RADIO_SENSOR_OFFSET;
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.c b/drivers/net/wireless/iwlwifi/iwl-agn.c
index b0ae4de7f083..f9c3cd95d614 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn.c
@@ -2140,7 +2140,12 @@ static int iwl_mac_setup_register(struct iwl_priv *priv,
                     IEEE80211_HW_SPECTRUM_MGMT |
                     IEEE80211_HW_REPORTS_TX_ACK_STATUS;
 
+        /*
+         * Including the following line will crash some AP's.  This
+         * workaround removes the stimulus which causes the crash until
+         * the AP software can be fixed.
         hw->max_tx_aggregation_subframes = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
+         */
 
         hw->flags |= IEEE80211_HW_SUPPORTS_PS |
                      IEEE80211_HW_SUPPORTS_DYNAMIC_PS;
diff --git a/drivers/net/wireless/iwlwifi/iwl-pci.c b/drivers/net/wireless/iwlwifi/iwl-pci.c
index 69d4ec467dca..2fdbffa079c1 100644
--- a/drivers/net/wireless/iwlwifi/iwl-pci.c
+++ b/drivers/net/wireless/iwlwifi/iwl-pci.c
@@ -478,27 +478,22 @@ out_no_pci:
         return err;
 }
 
-static void iwl_pci_down(struct iwl_bus *bus)
-{
-        struct iwl_pci_bus *pci_bus = (struct iwl_pci_bus *) bus->bus_specific;
-
-        pci_disable_msi(pci_bus->pci_dev);
-        pci_iounmap(pci_bus->pci_dev, pci_bus->hw_base);
-        pci_release_regions(pci_bus->pci_dev);
-        pci_disable_device(pci_bus->pci_dev);
-        pci_set_drvdata(pci_bus->pci_dev, NULL);
-
-        kfree(bus);
-}
-
 static void __devexit iwl_pci_remove(struct pci_dev *pdev)
 {
         struct iwl_priv *priv = pci_get_drvdata(pdev);
-        void *bus_specific = priv->bus->bus_specific;
+        struct iwl_bus *bus = priv->bus;
+        struct iwl_pci_bus *pci_bus = IWL_BUS_GET_PCI_BUS(bus);
+        struct pci_dev *pci_dev = IWL_BUS_GET_PCI_DEV(bus);
 
         iwl_remove(priv);
 
-        iwl_pci_down(bus_specific);
+        pci_disable_msi(pci_dev);
+        pci_iounmap(pci_dev, pci_bus->hw_base);
+        pci_release_regions(pci_dev);
+        pci_disable_device(pci_dev);
+        pci_set_drvdata(pci_dev, NULL);
+
+        kfree(bus);
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/net/wireless/iwlwifi/iwl-scan.c b/drivers/net/wireless/iwlwifi/iwl-scan.c
index dd6937e97055..77e528f5db88 100644
--- a/drivers/net/wireless/iwlwifi/iwl-scan.c
+++ b/drivers/net/wireless/iwlwifi/iwl-scan.c
@@ -405,31 +405,33 @@ int iwl_mac_hw_scan(struct ieee80211_hw *hw,
 
         mutex_lock(&priv->mutex);
 
-        if (test_bit(STATUS_SCANNING, &priv->status) &&
-            priv->scan_type != IWL_SCAN_NORMAL) {
-                IWL_DEBUG_SCAN(priv, "Scan already in progress.\n");
-                ret = -EAGAIN;
-                goto out_unlock;
-        }
-
-        /* mac80211 will only ask for one band at a time */
-        priv->scan_request = req;
-        priv->scan_vif = vif;
-
         /*
          * If an internal scan is in progress, just set
          * up the scan_request as per above.
          */
         if (priv->scan_type != IWL_SCAN_NORMAL) {
-                IWL_DEBUG_SCAN(priv, "SCAN request during internal scan\n");
+                IWL_DEBUG_SCAN(priv,
+                               "SCAN request during internal scan - defer\n");
+                priv->scan_request = req;
+                priv->scan_vif = vif;
                 ret = 0;
-        } else
+        } else {
+                priv->scan_request = req;
+                priv->scan_vif = vif;
+                /*
+                 * mac80211 will only ask for one band at a time
+                 * so using channels[0] here is ok
+                 */
                 ret = iwl_scan_initiate(priv, vif, IWL_SCAN_NORMAL,
                                         req->channels[0]->band);
+                if (ret) {
+                        priv->scan_request = NULL;
+                        priv->scan_vif = NULL;
+                }
+        }
 
         IWL_DEBUG_MAC80211(priv, "leave\n");
 
-out_unlock:
         mutex_unlock(&priv->mutex);
 
         return ret;
diff --git a/drivers/net/wireless/iwlwifi/iwl-trans-tx-pcie.c b/drivers/net/wireless/iwlwifi/iwl-trans-tx-pcie.c
index a6b2b1db0b1d..222d410c586e 100644
--- a/drivers/net/wireless/iwlwifi/iwl-trans-tx-pcie.c
+++ b/drivers/net/wireless/iwlwifi/iwl-trans-tx-pcie.c
@@ -771,6 +771,8 @@ void iwl_tx_cmd_complete(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
         cmd = txq->cmd[cmd_index];
         meta = &txq->meta[cmd_index];
 
+        txq->time_stamp = jiffies;
+
         iwlagn_unmap_tfd(priv, meta, &txq->tfds[index], DMA_BIDIRECTIONAL);
 
         /* Input error checking is done when commands are added to queue. */
diff --git a/drivers/net/wireless/rt2x00/rt2800lib.c b/drivers/net/wireless/rt2x00/rt2800lib.c
index ef67f6786a84..0019dfd8fb01 100644
--- a/drivers/net/wireless/rt2x00/rt2800lib.c
+++ b/drivers/net/wireless/rt2x00/rt2800lib.c
@@ -3697,14 +3697,15 @@ static void rt2800_efuse_read(struct rt2x00_dev *rt2x00dev, unsigned int i)
         rt2800_regbusy_read(rt2x00dev, EFUSE_CTRL, EFUSE_CTRL_KICK, &reg);
 
         /* Apparently the data is read from end to start */
-        rt2800_register_read_lock(rt2x00dev, EFUSE_DATA3,
-                                        (u32 *)&rt2x00dev->eeprom[i]);
-        rt2800_register_read_lock(rt2x00dev, EFUSE_DATA2,
-                                        (u32 *)&rt2x00dev->eeprom[i + 2]);
-        rt2800_register_read_lock(rt2x00dev, EFUSE_DATA1,
-                                        (u32 *)&rt2x00dev->eeprom[i + 4]);
-        rt2800_register_read_lock(rt2x00dev, EFUSE_DATA0,
-                                        (u32 *)&rt2x00dev->eeprom[i + 6]);
+        rt2800_register_read_lock(rt2x00dev, EFUSE_DATA3, &reg);
+        /* The returned value is in CPU order, but eeprom is le */
+        rt2x00dev->eeprom[i] = cpu_to_le32(reg);
+        rt2800_register_read_lock(rt2x00dev, EFUSE_DATA2, &reg);
+        *(u32 *)&rt2x00dev->eeprom[i + 2] = cpu_to_le32(reg);
+        rt2800_register_read_lock(rt2x00dev, EFUSE_DATA1, &reg);
+        *(u32 *)&rt2x00dev->eeprom[i + 4] = cpu_to_le32(reg);
+        rt2800_register_read_lock(rt2x00dev, EFUSE_DATA0, &reg);
+        *(u32 *)&rt2x00dev->eeprom[i + 6] = cpu_to_le32(reg);
 
         mutex_unlock(&rt2x00dev->csr_mutex);
 }
@@ -3870,19 +3871,23 @@ int rt2800_init_eeprom(struct rt2x00_dev *rt2x00dev)
                 return -ENODEV;
         }
 
-        if (!rt2x00_rf(rt2x00dev, RF2820) &&
-            !rt2x00_rf(rt2x00dev, RF2850) &&
-            !rt2x00_rf(rt2x00dev, RF2720) &&
-            !rt2x00_rf(rt2x00dev, RF2750) &&
-            !rt2x00_rf(rt2x00dev, RF3020) &&
-            !rt2x00_rf(rt2x00dev, RF2020) &&
-            !rt2x00_rf(rt2x00dev, RF3021) &&
-            !rt2x00_rf(rt2x00dev, RF3022) &&
-            !rt2x00_rf(rt2x00dev, RF3052) &&
-            !rt2x00_rf(rt2x00dev, RF3320) &&
-            !rt2x00_rf(rt2x00dev, RF5370) &&
-            !rt2x00_rf(rt2x00dev, RF5390)) {
-                ERROR(rt2x00dev, "Invalid RF chipset detected.\n");
+        switch (rt2x00dev->chip.rf) {
+        case RF2820:
+        case RF2850:
+        case RF2720:
+        case RF2750:
+        case RF3020:
+        case RF2020:
+        case RF3021:
+        case RF3022:
+        case RF3052:
+        case RF3320:
+        case RF5370:
+        case RF5390:
+                break;
+        default:
+                ERROR(rt2x00dev, "Invalid RF chipset 0x%x detected.\n",
+                      rt2x00dev->chip.rf);
                 return -ENODEV;
         }
 
diff --git a/drivers/net/wireless/rt2x00/rt2800usb.c b/drivers/net/wireless/rt2x00/rt2800usb.c
index 507559361d87..dbf501ca317f 100644
--- a/drivers/net/wireless/rt2x00/rt2800usb.c
+++ b/drivers/net/wireless/rt2x00/rt2800usb.c
@@ -464,6 +464,15 @@ static bool rt2800usb_txdone_entry_check(struct queue_entry *entry, u32 reg)
         int wcid, ack, pid;
         int tx_wcid, tx_ack, tx_pid;
 
+        if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) ||
+            !test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags)) {
+                WARNING(entry->queue->rt2x00dev,
+                        "Data pending for entry %u in queue %u\n",
+                        entry->entry_idx, entry->queue->qid);
+                cond_resched();
+                return false;
+        }
+
         wcid    = rt2x00_get_field32(reg, TX_STA_FIFO_WCID);
         ack     = rt2x00_get_field32(reg, TX_STA_FIFO_TX_ACK_REQUIRED);
         pid     = rt2x00_get_field32(reg, TX_STA_FIFO_PID_TYPE);
@@ -529,12 +538,11 @@ static void rt2800usb_txdone(struct rt2x00_dev *rt2x00dev)
                         entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE);
                         if (rt2800usb_txdone_entry_check(entry, reg))
                                 break;
+                        entry = NULL;
                 }
 
-                if (!entry || rt2x00queue_empty(queue))
-                        break;
-
-                rt2800_txdone_entry(entry, reg);
+                if (entry)
+                        rt2800_txdone_entry(entry, reg);
         }
 }
 
@@ -558,8 +566,10 @@ static void rt2800usb_work_txdone(struct work_struct *work)
                 while (!rt2x00queue_empty(queue)) {
                         entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE);
 
-                        if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
+                        if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) ||
+                            !test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags))
                                 break;
+
                         if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags))
                                 rt2x00lib_txdone_noinfo(entry, TXDONE_FAILURE);
                         else if (rt2x00queue_status_timeout(entry))
@@ -921,6 +931,8 @@ static struct usb_device_id rt2800usb_device_table[] = {
         { USB_DEVICE(0x07d1, 0x3c16) },
         /* Draytek */
         { USB_DEVICE(0x07fa, 0x7712) },
+        /* DVICO */
+        { USB_DEVICE(0x0fe9, 0xb307) },
         /* Edimax */
         { USB_DEVICE(0x7392, 0x7711) },
         { USB_DEVICE(0x7392, 0x7717) },
diff --git a/drivers/net/wireless/rt2x00/rt2x00usb.c b/drivers/net/wireless/rt2x00/rt2x00usb.c
index b6b4542c2460..1e31050dafc9 100644
--- a/drivers/net/wireless/rt2x00/rt2x00usb.c
+++ b/drivers/net/wireless/rt2x00/rt2x00usb.c
@@ -262,23 +262,20 @@ static void rt2x00usb_interrupt_txdone(struct urb *urb)
         struct queue_entry *entry = (struct queue_entry *)urb->context;
         struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
 
-        if (!test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
+        if (!test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
                 return;
-
-        if (rt2x00dev->ops->lib->tx_dma_done)
-                rt2x00dev->ops->lib->tx_dma_done(entry);
-
-        /*
-         * Report the frame as DMA done
-         */
-        rt2x00lib_dmadone(entry);
-
         /*
          * Check if the frame was correctly uploaded
          */
         if (urb->status)
                 set_bit(ENTRY_DATA_IO_FAILED, &entry->flags);
+        /*
+         * Report the frame as DMA done
+         */
+        rt2x00lib_dmadone(entry);
 
+        if (rt2x00dev->ops->lib->tx_dma_done)
+                rt2x00dev->ops->lib->tx_dma_done(entry);
         /*
          * Schedule the delayed work for reading the TX status
          * from the device.
@@ -874,18 +871,8 @@ int rt2x00usb_suspend(struct usb_interface *usb_intf, pm_message_t state)
 {
         struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
         struct rt2x00_dev *rt2x00dev = hw->priv;
-        int retval;
-
-        retval = rt2x00lib_suspend(rt2x00dev, state);
-        if (retval)
-                return retval;
 
-        /*
-         * Decrease usbdev refcount.
-         */
-        usb_put_dev(interface_to_usbdev(usb_intf));
-
-        return 0;
+        return rt2x00lib_suspend(rt2x00dev, state);
 }
 EXPORT_SYMBOL_GPL(rt2x00usb_suspend);
 
@@ -894,8 +881,6 @@ int rt2x00usb_resume(struct usb_interface *usb_intf)
         struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
         struct rt2x00_dev *rt2x00dev = hw->priv;
 
-        usb_get_dev(interface_to_usbdev(usb_intf));
-
         return rt2x00lib_resume(rt2x00dev);
 }
 EXPORT_SYMBOL_GPL(rt2x00usb_resume);
diff --git a/drivers/net/wireless/rt2x00/rt73usb.c b/drivers/net/wireless/rt2x00/rt73usb.c
index 6a93939f44e8..0baeb894f093 100644
--- a/drivers/net/wireless/rt2x00/rt73usb.c
+++ b/drivers/net/wireless/rt2x00/rt73usb.c
@@ -2420,6 +2420,7 @@ static struct usb_device_id rt73usb_device_table[] = {
         /* Buffalo */
         { USB_DEVICE(0x0411, 0x00d8) },
         { USB_DEVICE(0x0411, 0x00d9) },
+        { USB_DEVICE(0x0411, 0x00e6) },
         { USB_DEVICE(0x0411, 0x00f4) },
         { USB_DEVICE(0x0411, 0x0116) },
         { USB_DEVICE(0x0411, 0x0119) },
diff --git a/drivers/net/wireless/rtlwifi/core.c b/drivers/net/wireless/rtlwifi/core.c
index 1bdc1aa305c0..04c4e9eb6ee6 100644
--- a/drivers/net/wireless/rtlwifi/core.c
+++ b/drivers/net/wireless/rtlwifi/core.c
@@ -610,6 +610,11 @@ static void rtl_op_bss_info_changed(struct ieee80211_hw *hw,
 
                         mac->link_state = MAC80211_NOLINK;
                         memset(mac->bssid, 0, 6);
+
+                        /* reset sec info */
+                        rtl_cam_reset_sec_info(hw);
+
+                        rtl_cam_reset_all_entry(hw);
                         mac->vendor = PEER_UNKNOWN;
 
                         RT_TRACE(rtlpriv, COMP_MAC80211, DBG_DMESG,
@@ -1063,6 +1068,9 @@ static int rtl_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
                  *or clear all entry here.
                  */
                 rtl_cam_delete_one_entry(hw, mac_addr, key_idx);
+
+                rtl_cam_reset_sec_info(hw);
+
                 break;
         default:
                 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
diff --git a/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c b/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c
index 942f7a3969a7..ef63c0df006a 100644
--- a/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c
+++ b/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c
@@ -281,6 +281,8 @@ static struct usb_device_id rtl8192c_usb_ids[] = {
         {RTL_USB_DEVICE(USB_VENDER_ID_REALTEK, 0x817d, rtl92cu_hal_cfg)},
         /* 8188CE-VAU USB minCard (b/g mode only) */
         {RTL_USB_DEVICE(USB_VENDER_ID_REALTEK, 0x817e, rtl92cu_hal_cfg)},
+        /* 8188RU in Alfa AWUS036NHR */
+        {RTL_USB_DEVICE(USB_VENDER_ID_REALTEK, 0x817f, rtl92cu_hal_cfg)},
         /* 8188 Combo for BC4 */
         {RTL_USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8754, rtl92cu_hal_cfg)},
 
@@ -303,20 +305,23 @@ static struct usb_device_id rtl8192c_usb_ids[] = {
         {RTL_USB_DEVICE(0x0eb0, 0x9071, rtl92cu_hal_cfg)}, /*NO Brand - Etop*/
         /* HP - Lite-On ,8188CUS Slim Combo */
         {RTL_USB_DEVICE(0x103c, 0x1629, rtl92cu_hal_cfg)},
+        {RTL_USB_DEVICE(0x13d3, 0x3357, rtl92cu_hal_cfg)}, /* AzureWave */
         {RTL_USB_DEVICE(0x2001, 0x3308, rtl92cu_hal_cfg)}, /*D-Link - Alpha*/
         {RTL_USB_DEVICE(0x2019, 0xab2a, rtl92cu_hal_cfg)}, /*Planex - Abocom*/
         {RTL_USB_DEVICE(0x2019, 0xed17, rtl92cu_hal_cfg)}, /*PCI - Edimax*/
         {RTL_USB_DEVICE(0x20f4, 0x648b, rtl92cu_hal_cfg)}, /*TRENDnet - Cameo*/
         {RTL_USB_DEVICE(0x7392, 0x7811, rtl92cu_hal_cfg)}, /*Edimax - Edimax*/
-        {RTL_USB_DEVICE(0x3358, 0x13d3, rtl92cu_hal_cfg)}, /*Azwave 8188CE-VAU*/
+        {RTL_USB_DEVICE(0x13d3, 0x3358, rtl92cu_hal_cfg)}, /*Azwave 8188CE-VAU*/
         /* Russian customer -Azwave (8188CE-VAU  b/g mode only) */
-        {RTL_USB_DEVICE(0x3359, 0x13d3, rtl92cu_hal_cfg)},
+        {RTL_USB_DEVICE(0x13d3, 0x3359, rtl92cu_hal_cfg)},
+        {RTL_USB_DEVICE(0x4855, 0x0090, rtl92cu_hal_cfg)}, /* Feixun */
+        {RTL_USB_DEVICE(0x4855, 0x0091, rtl92cu_hal_cfg)}, /* NetweeN-Feixun */
+        {RTL_USB_DEVICE(0x9846, 0x9041, rtl92cu_hal_cfg)}, /* Netgear Cameo */
 
         /****** 8192CU ********/
         {RTL_USB_DEVICE(0x0586, 0x341f, rtl92cu_hal_cfg)}, /*Zyxel -Abocom*/
         {RTL_USB_DEVICE(0x07aa, 0x0056, rtl92cu_hal_cfg)}, /*ATKK-Gemtek*/
         {RTL_USB_DEVICE(0x07b8, 0x8178, rtl92cu_hal_cfg)}, /*Funai -Abocom*/
-        {RTL_USB_DEVICE(0x07b8, 0x8178, rtl92cu_hal_cfg)}, /*Abocom -Abocom*/
         {RTL_USB_DEVICE(0x2001, 0x3307, rtl92cu_hal_cfg)}, /*D-Link-Cameo*/
         {RTL_USB_DEVICE(0x2001, 0x3309, rtl92cu_hal_cfg)}, /*D-Link-Alpha*/
         {RTL_USB_DEVICE(0x2001, 0x330a, rtl92cu_hal_cfg)}, /*D-Link-Alpha*/
diff --git a/drivers/net/wireless/rtlwifi/rtl8192cu/trx.c b/drivers/net/wireless/rtlwifi/rtl8192cu/trx.c
index 906e7aa55bc3..3e52a5496224 100644
--- a/drivers/net/wireless/rtlwifi/rtl8192cu/trx.c
+++ b/drivers/net/wireless/rtlwifi/rtl8192cu/trx.c
@@ -549,15 +549,16 @@ void rtl92cu_tx_fill_desc(struct ieee80211_hw *hw,
                                (tcb_desc->rts_use_shortpreamble ? 1 : 0)
                                : (tcb_desc->rts_use_shortgi ? 1 : 0)));
         if (mac->bw_40) {
-                if (tcb_desc->packet_bw) {
+                if (rate_flag & IEEE80211_TX_RC_DUP_DATA) {
                         SET_TX_DESC_DATA_BW(txdesc, 1);
                         SET_TX_DESC_DATA_SC(txdesc, 3);
+                } else if(rate_flag & IEEE80211_TX_RC_40_MHZ_WIDTH){
+                        SET_TX_DESC_DATA_BW(txdesc, 1);
+                        SET_TX_DESC_DATA_SC(txdesc, mac->cur_40_prime_sc);
                 } else {
                         SET_TX_DESC_DATA_BW(txdesc, 0);
-                                if (rate_flag & IEEE80211_TX_RC_DUP_DATA)
-                                        SET_TX_DESC_DATA_SC(txdesc,
-                                                          mac->cur_40_prime_sc);
-                        }
+                        SET_TX_DESC_DATA_SC(txdesc, 0);
+                }
         } else {
                 SET_TX_DESC_DATA_BW(txdesc, 0);
                 SET_TX_DESC_DATA_SC(txdesc, 0);
diff --git a/drivers/net/wireless/rtlwifi/usb.c b/drivers/net/wireless/rtlwifi/usb.c
index 8b1cef0ffde6..4bf3cf457ef0 100644
--- a/drivers/net/wireless/rtlwifi/usb.c
+++ b/drivers/net/wireless/rtlwifi/usb.c
@@ -863,6 +863,7 @@ static void _rtl_usb_tx_preprocess(struct ieee80211_hw *hw, struct sk_buff *skb,
         u8 tid = 0;
         u16 seq_number = 0;
 
+        memset(&tcb_desc, 0, sizeof(struct rtl_tcb_desc));
         if (ieee80211_is_auth(fc)) {
                 RT_TRACE(rtlpriv, COMP_SEND, DBG_DMESG, ("MAC80211_LINKING\n"));
                 rtl_ips_nic_on(hw);
diff --git a/drivers/net/wireless/wl1251/acx.c b/drivers/net/wireless/wl1251/acx.c
index ef8370edace7..ad87a1ac6462 100644
--- a/drivers/net/wireless/wl1251/acx.c
+++ b/drivers/net/wireless/wl1251/acx.c
@@ -140,8 +140,6 @@ int wl1251_acx_sleep_auth(struct wl1251 *wl, u8 sleep_auth)
         auth->sleep_auth = sleep_auth;
 
         ret = wl1251_cmd_configure(wl, ACX_SLEEP_AUTH, auth, sizeof(*auth));
-        if (ret < 0)
-                return ret;
 
 out:
         kfree(auth);
@@ -681,10 +679,8 @@ int wl1251_acx_cca_threshold(struct wl1251 *wl)
 
         ret = wl1251_cmd_configure(wl, ACX_CCA_THRESHOLD,
                                    detection, sizeof(*detection));
-        if (ret < 0) {
+        if (ret < 0)
                 wl1251_warning("failed to set cca threshold: %d", ret);
-                return ret;
-        }
 
 out:
         kfree(detection);
diff --git a/drivers/net/wireless/wl1251/cmd.c b/drivers/net/wireless/wl1251/cmd.c
index 81f164bc4888..d14d69d733a0 100644
--- a/drivers/net/wireless/wl1251/cmd.c
+++ b/drivers/net/wireless/wl1251/cmd.c
@@ -241,7 +241,7 @@ int wl1251_cmd_data_path(struct wl1251 *wl, u8 channel, bool enable)
         if (ret < 0) {
                 wl1251_error("tx %s cmd for channel %d failed",
                              enable ? "start" : "stop", channel);
-                return ret;
+                goto out;
         }
 
         wl1251_debug(DEBUG_BOOT, "tx %s cmd channel %d",
diff --git a/drivers/net/wireless/wl12xx/acx.c b/drivers/net/wireless/wl12xx/acx.c
index 7e33f1f4f3d4..34f6ab53e519 100644
--- a/drivers/net/wireless/wl12xx/acx.c
+++ b/drivers/net/wireless/wl12xx/acx.c
@@ -77,8 +77,6 @@ int wl1271_acx_sleep_auth(struct wl1271 *wl, u8 sleep_auth)
         auth->sleep_auth = sleep_auth;
 
         ret = wl1271_cmd_configure(wl, ACX_SLEEP_AUTH, auth, sizeof(*auth));
-        if (ret < 0)
-                return ret;
 
 out:
         kfree(auth);
@@ -624,10 +622,8 @@ int wl1271_acx_cca_threshold(struct wl1271 *wl)
 
         ret = wl1271_cmd_configure(wl, ACX_CCA_THRESHOLD,
                                    detection, sizeof(*detection));
-        if (ret < 0) {
+        if (ret < 0)
                 wl1271_warning("failed to set cca threshold: %d", ret);
-                return ret;
-        }
 
 out:
         kfree(detection);
diff --git a/drivers/net/wireless/wl12xx/main.c b/drivers/net/wireless/wl12xx/main.c
index e58c22d21e39..b70ae40ad660 100644
--- a/drivers/net/wireless/wl12xx/main.c
+++ b/drivers/net/wireless/wl12xx/main.c
@@ -4283,6 +4283,7 @@ int wl1271_init_ieee80211(struct wl1271 *wl)
         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
                 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
         wl->hw->wiphy->max_scan_ssids = 1;
+        wl->hw->wiphy->max_sched_scan_ssids = 1;
         /*
          * Maximum length of elements in scanning probe request templates
          * should be the maximum length possible for a template, without
diff --git a/drivers/net/wireless/wl12xx/sdio.c b/drivers/net/wireless/wl12xx/sdio.c
index 5cf18c2c23f0..fb1fd5af75ea 100644
--- a/drivers/net/wireless/wl12xx/sdio.c
+++ b/drivers/net/wireless/wl12xx/sdio.c
@@ -164,7 +164,7 @@ static int wl1271_sdio_power_on(struct wl1271 *wl)
         /* If enabled, tell runtime PM not to power off the card */
         if (pm_runtime_enabled(&func->dev)) {
                 ret = pm_runtime_get_sync(&func->dev);
-                if (ret)
+                if (ret < 0)
                         goto out;
         } else {
                 /* Runtime PM is disabled: power up the card manually */
diff --git a/drivers/net/wireless/wl12xx/testmode.c b/drivers/net/wireless/wl12xx/testmode.c
index 5d5e1ef87206..4ae8effaee22 100644
--- a/drivers/net/wireless/wl12xx/testmode.c
+++ b/drivers/net/wireless/wl12xx/testmode.c
@@ -36,7 +36,6 @@ enum wl1271_tm_commands {
         WL1271_TM_CMD_TEST,
         WL1271_TM_CMD_INTERROGATE,
         WL1271_TM_CMD_CONFIGURE,
-        WL1271_TM_CMD_NVS_PUSH,
         WL1271_TM_CMD_SET_PLT_MODE,
         WL1271_TM_CMD_RECOVER,
 
@@ -139,12 +138,15 @@ static int wl1271_tm_cmd_interrogate(struct wl1271 *wl, struct nlattr *tb[])
 
         if (ret < 0) {
                 wl1271_warning("testmode cmd interrogate failed: %d", ret);
+                kfree(cmd);
                 return ret;
         }
 
         skb = cfg80211_testmode_alloc_reply_skb(wl->hw->wiphy, sizeof(*cmd));
-        if (!skb)
+        if (!skb) {
+                kfree(cmd);
                 return -ENOMEM;
+        }
 
         NLA_PUT(skb, WL1271_TM_ATTR_DATA, sizeof(*cmd), cmd);
 
@@ -187,48 +189,6 @@ static int wl1271_tm_cmd_configure(struct wl1271 *wl, struct nlattr *tb[])
         return 0;
 }
 
-static int wl1271_tm_cmd_nvs_push(struct wl1271 *wl, struct nlattr *tb[])
-{
-        int ret = 0;
-        size_t len;
-        void *buf;
-
-        wl1271_debug(DEBUG_TESTMODE, "testmode cmd nvs push");
-
-        if (!tb[WL1271_TM_ATTR_DATA])
-                return -EINVAL;
-
-        buf = nla_data(tb[WL1271_TM_ATTR_DATA]);
-        len = nla_len(tb[WL1271_TM_ATTR_DATA]);
-
-        mutex_lock(&wl->mutex);
-
-        kfree(wl->nvs);
-
-        if ((wl->chip.id == CHIP_ID_1283_PG20) &&
-            (len != sizeof(struct wl128x_nvs_file)))
-                return -EINVAL;
-        else if (len != sizeof(struct wl1271_nvs_file))
-                return -EINVAL;
-
-        wl->nvs = kzalloc(len, GFP_KERNEL);
-        if (!wl->nvs) {
-                wl1271_error("could not allocate memory for the nvs file");
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        memcpy(wl->nvs, buf, len);
-        wl->nvs_len = len;
-
-        wl1271_debug(DEBUG_TESTMODE, "testmode pushed nvs");
-
-out:
-        mutex_unlock(&wl->mutex);
-
-        return ret;
-}
-
 static int wl1271_tm_cmd_set_plt_mode(struct wl1271 *wl, struct nlattr *tb[])
 {
         u32 val;
@@ -285,8 +245,6 @@ int wl1271_tm_cmd(struct ieee80211_hw *hw, void *data, int len)
                 return wl1271_tm_cmd_interrogate(wl, tb);
         case WL1271_TM_CMD_CONFIGURE:
                 return wl1271_tm_cmd_configure(wl, tb);
-        case WL1271_TM_CMD_NVS_PUSH:
-                return wl1271_tm_cmd_nvs_push(wl, tb);
         case WL1271_TM_CMD_SET_PLT_MODE:
                 return wl1271_tm_cmd_set_plt_mode(wl, tb);
         case WL1271_TM_CMD_RECOVER:
diff --git a/drivers/net/xen-netback/interface.c b/drivers/net/xen-netback/interface.c
index 0ca86f9ec4ed..182562952c79 100644
--- a/drivers/net/xen-netback/interface.c
+++ b/drivers/net/xen-netback/interface.c
@@ -327,12 +327,12 @@ int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
         xenvif_get(vif);
 
         rtnl_lock();
-        if (netif_running(vif->dev))
-                xenvif_up(vif);
         if (!vif->can_sg && vif->dev->mtu > ETH_DATA_LEN)
                 dev_set_mtu(vif->dev, ETH_DATA_LEN);
         netdev_update_features(vif->dev);
         netif_carrier_on(vif->dev);
+        if (netif_running(vif->dev))
+                xenvif_up(vif);
         rtnl_unlock();
 
         return 0;
diff --git a/drivers/pci/hotplug/pcihp_slot.c b/drivers/pci/hotplug/pcihp_slot.c
index 749fdf070319..3ffd9c1acc0a 100644
--- a/drivers/pci/hotplug/pcihp_slot.c
+++ b/drivers/pci/hotplug/pcihp_slot.c
@@ -158,47 +158,6 @@ static void program_hpp_type2(struct pci_dev *dev, struct hpp_type2 *hpp)
          */
 }
 
-/* Program PCIE MaxPayload setting on device: ensure parent maxpayload <= device */
-static int pci_set_payload(struct pci_dev *dev)
-{
-       int pos, ppos;
-       u16 pctl, psz;
-       u16 dctl, dsz, dcap, dmax;
-       struct pci_dev *parent;
-
-       parent = dev->bus->self;
-       pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
-       if (!pos)
-               return 0;
-
-       /* Read Device MaxPayload capability and setting */
-       pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &dctl);
-       pci_read_config_word(dev, pos + PCI_EXP_DEVCAP, &dcap);
-       dsz = (dctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5;
-       dmax = (dcap & PCI_EXP_DEVCAP_PAYLOAD);
-
-       /* Read Parent MaxPayload setting */
-       ppos = pci_find_capability(parent, PCI_CAP_ID_EXP);
-       if (!ppos)
-               return 0;
-       pci_read_config_word(parent, ppos + PCI_EXP_DEVCTL, &pctl);
-       psz = (pctl &  PCI_EXP_DEVCTL_PAYLOAD) >> 5;
-
-       /* If parent payload > device max payload -> error
-        * If parent payload > device payload -> set speed
-        * If parent payload <= device payload -> do nothing
-        */
-       if (psz > dmax)
-               return -1;
-       else if (psz > dsz) {
-               dev_info(&dev->dev, "Setting MaxPayload to %d\n", 128 << psz);
-               pci_write_config_word(dev, pos + PCI_EXP_DEVCTL,
-                                     (dctl & ~PCI_EXP_DEVCTL_PAYLOAD) +
-                                     (psz << 5));
-       }
-       return 0;
-}
-
 void pci_configure_slot(struct pci_dev *dev)
 {
         struct pci_dev *cdev;
@@ -210,9 +169,9 @@ void pci_configure_slot(struct pci_dev *dev)
                         (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI)))
                 return;
 
-       ret = pci_set_payload(dev);
-       if (ret)
-               dev_warn(&dev->dev, "could not set device max payload\n");
+        if (dev->bus && dev->bus->self)
+                pcie_bus_configure_settings(dev->bus,
+                                            dev->bus->self->pcie_mpss);
 
         memset(&hpp, 0, sizeof(hpp));
         ret = pci_get_hp_params(dev, &hpp);
diff --git a/drivers/pci/of.c b/drivers/pci/of.c
index c94d37ec55c8..f0929934bb7a 100644
--- a/drivers/pci/of.c
+++ b/drivers/pci/of.c
@@ -55,7 +55,7 @@ struct device_node * __weak pcibios_get_phb_of_node(struct pci_bus *bus)
          */
         if (bus->bridge->of_node)
                 return of_node_get(bus->bridge->of_node);
-        if (bus->bridge->parent->of_node)
+        if (bus->bridge->parent && bus->bridge->parent->of_node)
                 return of_node_get(bus->bridge->parent->of_node);
         return NULL;
 }
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 08a95b369d85..e9651f0a8817 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -77,6 +77,8 @@ unsigned long pci_cardbus_mem_size = DEFAULT_CARDBUS_MEM_SIZE;
 unsigned long pci_hotplug_io_size  = DEFAULT_HOTPLUG_IO_SIZE;
 unsigned long pci_hotplug_mem_size = DEFAULT_HOTPLUG_MEM_SIZE;
 
+enum pcie_bus_config_types pcie_bus_config = PCIE_BUS_TUNE_OFF;
+
 /*
  * The default CLS is used if arch didn't set CLS explicitly and not
  * all pci devices agree on the same value.  Arch can override either
@@ -3223,6 +3225,67 @@ out:
 EXPORT_SYMBOL(pcie_set_readrq);
 
 /**
+ * pcie_get_mps - get PCI Express maximum payload size
+ * @dev: PCI device to query
+ *
+ * Returns maximum payload size in bytes
+ *    or appropriate error value.
+ */
+int pcie_get_mps(struct pci_dev *dev)
+{
+        int ret, cap;
+        u16 ctl;
+
+        cap = pci_pcie_cap(dev);
+        if (!cap)
+                return -EINVAL;
+
+        ret = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
+        if (!ret)
+                ret = 128 << ((ctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5);
+
+        return ret;
+}
+
+/**
+ * pcie_set_mps - set PCI Express maximum payload size
+ * @dev: PCI device to query
+ * @mps: maximum payload size in bytes
+ *    valid values are 128, 256, 512, 1024, 2048, 4096
+ *
+ * If possible sets maximum payload size
+ */
+int pcie_set_mps(struct pci_dev *dev, int mps)
+{
+        int cap, err = -EINVAL;
+        u16 ctl, v;
+
+        if (mps < 128 || mps > 4096 || !is_power_of_2(mps))
+                goto out;
+
+        v = ffs(mps) - 8;
+        if (v > dev->pcie_mpss) 
+                goto out;
+        v <<= 5;
+
+        cap = pci_pcie_cap(dev);
+        if (!cap)
+                goto out;
+
+        err = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
+        if (err)
+                goto out;
+
+        if ((ctl & PCI_EXP_DEVCTL_PAYLOAD) != v) {
+                ctl &= ~PCI_EXP_DEVCTL_PAYLOAD;
+                ctl |= v;
+                err = pci_write_config_word(dev, cap + PCI_EXP_DEVCTL, ctl);
+        }
+out:
+        return err;
+}
+
+/**
  * pci_select_bars - Make BAR mask from the type of resource
  * @dev: the PCI device for which BAR mask is made
  * @flags: resource type mask to be selected
@@ -3505,6 +3568,14 @@ static int __init pci_setup(char *str)
                                 pci_hotplug_io_size = memparse(str + 9, &str);
                         } else if (!strncmp(str, "hpmemsize=", 10)) {
                                 pci_hotplug_mem_size = memparse(str + 10, &str);
+                        } else if (!strncmp(str, "pcie_bus_tune_off", 17)) {
+                                pcie_bus_config = PCIE_BUS_TUNE_OFF;
+                        } else if (!strncmp(str, "pcie_bus_safe", 13)) {
+                                pcie_bus_config = PCIE_BUS_SAFE;
+                        } else if (!strncmp(str, "pcie_bus_perf", 13)) {
+                                pcie_bus_config = PCIE_BUS_PERFORMANCE;
+                        } else if (!strncmp(str, "pcie_bus_peer2peer", 18)) {
+                                pcie_bus_config = PCIE_BUS_PEER2PEER;
                         } else {
                                 printk(KERN_ERR "PCI: Unknown option `%s'\n",
                                                 str);
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index c8cee764b0de..b74084e9ca12 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -283,6 +283,8 @@ static inline int pci_iov_bus_range(struct pci_bus *bus)
 
 #endif /* CONFIG_PCI_IOV */
 
+extern unsigned long pci_cardbus_resource_alignment(struct resource *);
+
 static inline resource_size_t pci_resource_alignment(struct pci_dev *dev,
                                          struct resource *res)
 {
@@ -292,6 +294,8 @@ static inline resource_size_t pci_resource_alignment(struct pci_dev *dev,
         if (resno >= PCI_IOV_RESOURCES && resno <= PCI_IOV_RESOURCE_END)
                 return pci_sriov_resource_alignment(dev, resno);
 #endif
+        if (dev->class >> 8  == PCI_CLASS_BRIDGE_CARDBUS)
+                return pci_cardbus_resource_alignment(res);
         return resource_alignment(res);
 }
 
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 795c9026d55f..6ab6bd3df4b2 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -856,6 +856,8 @@ void set_pcie_port_type(struct pci_dev *pdev)
         pdev->pcie_cap = pos;
         pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
         pdev->pcie_type = (reg16 & PCI_EXP_FLAGS_TYPE) >> 4;
+        pci_read_config_word(pdev, pos + PCI_EXP_DEVCAP, &reg16);
+        pdev->pcie_mpss = reg16 & PCI_EXP_DEVCAP_PAYLOAD;
 }
 
 void set_pcie_hotplug_bridge(struct pci_dev *pdev)
@@ -1326,6 +1328,163 @@ int pci_scan_slot(struct pci_bus *bus, int devfn)
         return nr;
 }
 
+static int pcie_find_smpss(struct pci_dev *dev, void *data)
+{
+        u8 *smpss = data;
+
+        if (!pci_is_pcie(dev))
+                return 0;
+
+        /* For PCIE hotplug enabled slots not connected directly to a
+         * PCI-E root port, there can be problems when hotplugging
+         * devices.  This is due to the possibility of hotplugging a
+         * device into the fabric with a smaller MPS that the devices
+         * currently running have configured.  Modifying the MPS on the
+         * running devices could cause a fatal bus error due to an
+         * incoming frame being larger than the newly configured MPS.
+         * To work around this, the MPS for the entire fabric must be
+         * set to the minimum size.  Any devices hotplugged into this
+         * fabric will have the minimum MPS set.  If the PCI hotplug
+         * slot is directly connected to the root port and there are not
+         * other devices on the fabric (which seems to be the most
+         * common case), then this is not an issue and MPS discovery
+         * will occur as normal.
+         */
+        if (dev->is_hotplug_bridge && (!list_is_singular(&dev->bus->devices) ||
+             (dev->bus->self &&
+              dev->bus->self->pcie_type != PCI_EXP_TYPE_ROOT_PORT)))
+                *smpss = 0;
+
+        if (*smpss > dev->pcie_mpss)
+                *smpss = dev->pcie_mpss;
+
+        return 0;
+}
+
+static void pcie_write_mps(struct pci_dev *dev, int mps)
+{
+        int rc, dev_mpss;
+
+        dev_mpss = 128 << dev->pcie_mpss;
+
+        if (pcie_bus_config == PCIE_BUS_PERFORMANCE) {
+                if (dev->bus->self) {
+                        dev_dbg(&dev->bus->dev, "Bus MPSS %d\n",
+                                128 << dev->bus->self->pcie_mpss);
+
+                        /* For "MPS Force Max", the assumption is made that
+                         * downstream communication will never be larger than
+                         * the MRRS.  So, the MPS only needs to be configured
+                         * for the upstream communication.  This being the case,
+                         * walk from the top down and set the MPS of the child
+                         * to that of the parent bus.
+                         */
+                        mps = 128 << dev->bus->self->pcie_mpss;
+                        if (mps > dev_mpss)
+                                dev_warn(&dev->dev, "MPS configured higher than"
+                                         " maximum supported by the device.  If"
+                                         " a bus issue occurs, try running with"
+                                         " pci=pcie_bus_safe.\n");
+                }
+
+                dev->pcie_mpss = ffs(mps) - 8;
+        }
+
+        rc = pcie_set_mps(dev, mps);
+        if (rc)
+                dev_err(&dev->dev, "Failed attempting to set the MPS\n");
+}
+
+static void pcie_write_mrrs(struct pci_dev *dev, int mps)
+{
+        int rc, mrrs, dev_mpss;
+
+        /* In the "safe" case, do not configure the MRRS.  There appear to be
+         * issues with setting MRRS to 0 on a number of devices.
+         */
+
+        if (pcie_bus_config != PCIE_BUS_PERFORMANCE)
+                return;
+
+        dev_mpss = 128 << dev->pcie_mpss;
+
+        /* For Max performance, the MRRS must be set to the largest supported
+         * value.  However, it cannot be configured larger than the MPS the
+         * device or the bus can support.  This assumes that the largest MRRS
+         * available on the device cannot be smaller than the device MPSS.
+         */
+        mrrs = min(mps, dev_mpss);
+
+        /* MRRS is a R/W register.  Invalid values can be written, but a
+         * subsequent read will verify if the value is acceptable or not.
+         * If the MRRS value provided is not acceptable (e.g., too large),
+         * shrink the value until it is acceptable to the HW.
+         */
+        while (mrrs != pcie_get_readrq(dev) && mrrs >= 128) {
+                dev_warn(&dev->dev, "Attempting to modify the PCI-E MRRS value"
+                         " to %d.  If any issues are encountered, please try "
+                         "running with pci=pcie_bus_safe\n", mrrs);
+                rc = pcie_set_readrq(dev, mrrs);
+                if (rc)
+                        dev_err(&dev->dev,
+                                "Failed attempting to set the MRRS\n");
+
+                mrrs /= 2;
+        }
+}
+
+static int pcie_bus_configure_set(struct pci_dev *dev, void *data)
+{
+        int mps = 128 << *(u8 *)data;
+
+        if (!pci_is_pcie(dev))
+                return 0;
+
+        dev_dbg(&dev->dev, "Dev MPS %d MPSS %d MRRS %d\n",
+                 pcie_get_mps(dev), 128<<dev->pcie_mpss, pcie_get_readrq(dev));
+
+        pcie_write_mps(dev, mps);
+        pcie_write_mrrs(dev, mps);
+
+        dev_dbg(&dev->dev, "Dev MPS %d MPSS %d MRRS %d\n",
+                 pcie_get_mps(dev), 128<<dev->pcie_mpss, pcie_get_readrq(dev));
+
+        return 0;
+}
+
+/* pcie_bus_configure_mps requires that pci_walk_bus work in a top-down,
+ * parents then children fashion.  If this changes, then this code will not
+ * work as designed.
+ */
+void pcie_bus_configure_settings(struct pci_bus *bus, u8 mpss)
+{
+        u8 smpss;
+
+        if (!pci_is_pcie(bus->self))
+                return;
+
+        if (pcie_bus_config == PCIE_BUS_TUNE_OFF)
+                return;
+
+        /* FIXME - Peer to peer DMA is possible, though the endpoint would need
+         * to be aware to the MPS of the destination.  To work around this,
+         * simply force the MPS of the entire system to the smallest possible.
+         */
+        if (pcie_bus_config == PCIE_BUS_PEER2PEER)
+                smpss = 0;
+
+        if (pcie_bus_config == PCIE_BUS_SAFE) {
+                smpss = mpss;
+
+                pcie_find_smpss(bus->self, &smpss);
+                pci_walk_bus(bus, pcie_find_smpss, &smpss);
+        }
+
+        pcie_bus_configure_set(bus->self, &smpss);
+        pci_walk_bus(bus, pcie_bus_configure_set, &smpss);
+}
+EXPORT_SYMBOL_GPL(pcie_bus_configure_settings);
+
 unsigned int __devinit pci_scan_child_bus(struct pci_bus *bus)
 {
         unsigned int devfn, pass, max = bus->secondary;
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index 8a1d3c7863a8..784da9d36029 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -34,6 +34,7 @@ struct resource_list_x {
         resource_size_t start;
         resource_size_t end;
         resource_size_t add_size;
+        resource_size_t min_align;
         unsigned long flags;
 };
 
@@ -65,7 +66,7 @@ void pci_realloc(void)
  */
 static void add_to_list(struct resource_list_x *head,
                  struct pci_dev *dev, struct resource *res,
-                 resource_size_t add_size)
+                 resource_size_t add_size, resource_size_t min_align)
 {
         struct resource_list_x *list = head;
         struct resource_list_x *ln = list->next;
@@ -84,13 +85,16 @@ static void add_to_list(struct resource_list_x *head,
         tmp->end = res->end;
         tmp->flags = res->flags;
         tmp->add_size = add_size;
+        tmp->min_align = min_align;
         list->next = tmp;
 }
 
 static void add_to_failed_list(struct resource_list_x *head,
                                 struct pci_dev *dev, struct resource *res)
 {
-        add_to_list(head, dev, res, 0);
+        add_to_list(head, dev, res,
+                        0 /* dont care */,
+                        0 /* dont care */);
 }
 
 static void __dev_sort_resources(struct pci_dev *dev,
@@ -121,18 +125,18 @@ static inline void reset_resource(struct resource *res)
 }
 
 /**
- * adjust_resources_sorted() - satisfy any additional resource requests
+ * reassign_resources_sorted() - satisfy any additional resource requests
  *
- * @add_head : head of the list tracking requests requiring additional
+ * @realloc_head : head of the list tracking requests requiring additional
  *             resources
  * @head     : head of the list tracking requests with allocated
  *             resources
  *
- * Walk through each element of the add_head and try to procure
+ * Walk through each element of the realloc_head and try to procure
  * additional resources for the element, provided the element
  * is in the head list.
  */
-static void adjust_resources_sorted(struct resource_list_x *add_head,
+static void reassign_resources_sorted(struct resource_list_x *realloc_head,
                 struct resource_list *head)
 {
         struct resource *res;
@@ -141,8 +145,8 @@ static void adjust_resources_sorted(struct resource_list_x *add_head,
         resource_size_t add_size;
         int idx;
 
-        prev = add_head;
-        for (list = add_head->next; list;) {
+        prev = realloc_head;
+        for (list = realloc_head->next; list;) {
                 res = list->res;
                 /* skip resource that has been reset */
                 if (!res->flags)
@@ -159,13 +163,17 @@ static void adjust_resources_sorted(struct resource_list_x *add_head,
 
                 idx = res - &list->dev->resource[0];
                 add_size=list->add_size;
-                if (!resource_size(res) && add_size) {
-                         res->end = res->start + add_size - 1;
-                         if(pci_assign_resource(list->dev, idx))
+                if (!resource_size(res)) {
+                        res->start = list->start;
+                        res->end = res->start + add_size - 1;
+                        if(pci_assign_resource(list->dev, idx))
                                 reset_resource(res);
-                } else if (add_size) {
-                        adjust_resource(res, res->start,
-                                resource_size(res) + add_size);
+                } else {
+                        resource_size_t align = list->min_align;
+                        res->flags |= list->flags & (IORESOURCE_STARTALIGN|IORESOURCE_SIZEALIGN);
+                        if (pci_reassign_resource(list->dev, idx, add_size, align))
+                                dev_printk(KERN_DEBUG, &list->dev->dev, "failed to add optional resources res=%pR\n",
+                                                        res);
                 }
 out:
                 tmp = list;
@@ -210,16 +218,16 @@ static void assign_requested_resources_sorted(struct resource_list *head,
 }
 
 static void __assign_resources_sorted(struct resource_list *head,
-                                 struct resource_list_x *add_head,
+                                 struct resource_list_x *realloc_head,
                                  struct resource_list_x *fail_head)
 {
         /* Satisfy the must-have resource requests */
         assign_requested_resources_sorted(head, fail_head);
 
-        /* Try to satisfy any additional nice-to-have resource
+        /* Try to satisfy any additional optional resource
                 requests */
-        if (add_head)
-                adjust_resources_sorted(add_head, head);
+        if (realloc_head)
+                reassign_resources_sorted(realloc_head, head);
         free_list(resource_list, head);
 }
 
@@ -235,7 +243,7 @@ static void pdev_assign_resources_sorted(struct pci_dev *dev,
 }
 
 static void pbus_assign_resources_sorted(const struct pci_bus *bus,
-                                         struct resource_list_x *add_head,
+                                         struct resource_list_x *realloc_head,
                                          struct resource_list_x *fail_head)
 {
         struct pci_dev *dev;
@@ -245,7 +253,7 @@ static void pbus_assign_resources_sorted(const struct pci_bus *bus,
         list_for_each_entry(dev, &bus->devices, bus_list)
                 __dev_sort_resources(dev, &head);
 
-        __assign_resources_sorted(&head, add_head, fail_head);
+        __assign_resources_sorted(&head, realloc_head, fail_head);
 }
 
 void pci_setup_cardbus(struct pci_bus *bus)
@@ -540,13 +548,27 @@ static resource_size_t calculate_memsize(resource_size_t size,
         return size;
 }
 
+static resource_size_t get_res_add_size(struct resource_list_x *realloc_head,
+                                        struct resource *res)
+{
+        struct resource_list_x *list;
+
+        /* check if it is in realloc_head list */
+        for (list = realloc_head->next; list && list->res != res;
+                        list = list->next);
+        if (list)
+                return list->add_size;
+
+        return 0;
+}
+
 /**
  * pbus_size_io() - size the io window of a given bus
  *
  * @bus : the bus
  * @min_size : the minimum io window that must to be allocated
  * @add_size : additional optional io window
- * @add_head : track the additional io window on this list
+ * @realloc_head : track the additional io window on this list
  *
  * Sizing the IO windows of the PCI-PCI bridge is trivial,
  * since these windows have 4K granularity and the IO ranges
@@ -554,11 +576,12 @@ static resource_size_t calculate_memsize(resource_size_t size,
  * We must be careful with the ISA aliasing though.
  */
 static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
-                resource_size_t add_size, struct resource_list_x *add_head)
+                resource_size_t add_size, struct resource_list_x *realloc_head)
 {
         struct pci_dev *dev;
         struct resource *b_res = find_free_bus_resource(bus, IORESOURCE_IO);
         unsigned long size = 0, size0 = 0, size1 = 0;
+        resource_size_t children_add_size = 0;
 
         if (!b_res)
                 return;
@@ -579,11 +602,16 @@ static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
                                 size += r_size;
                         else
                                 size1 += r_size;
+
+                        if (realloc_head)
+                                children_add_size += get_res_add_size(realloc_head, r);
                 }
         }
         size0 = calculate_iosize(size, min_size, size1,
                         resource_size(b_res), 4096);
-        size1 = (!add_head || (add_head && !add_size)) ? size0 :
+        if (children_add_size > add_size)
+                add_size = children_add_size;
+        size1 = (!realloc_head || (realloc_head && !add_size)) ? size0 :
                 calculate_iosize(size, min_size+add_size, size1,
                         resource_size(b_res), 4096);
         if (!size0 && !size1) {
@@ -598,8 +626,8 @@ static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
         b_res->start = 4096;
         b_res->end = b_res->start + size0 - 1;
         b_res->flags |= IORESOURCE_STARTALIGN;
-        if (size1 > size0 && add_head)
-                add_to_list(add_head, bus->self, b_res, size1-size0);
+        if (size1 > size0 && realloc_head)
+                add_to_list(realloc_head, bus->self, b_res, size1-size0, 4096);
 }
 
 /**
@@ -608,7 +636,7 @@ static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
  * @bus : the bus
  * @min_size : the minimum memory window that must to be allocated
  * @add_size : additional optional memory window
- * @add_head : track the additional memory window on this list
+ * @realloc_head : track the additional memory window on this list
  *
  * Calculate the size of the bus and minimal alignment which
  * guarantees that all child resources fit in this size.
@@ -616,7 +644,7 @@ static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
 static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
                          unsigned long type, resource_size_t min_size,
                         resource_size_t add_size,
-                        struct resource_list_x *add_head)
+                        struct resource_list_x *realloc_head)
 {
         struct pci_dev *dev;
         resource_size_t min_align, align, size, size0, size1;
@@ -624,6 +652,7 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
         int order, max_order;
         struct resource *b_res = find_free_bus_resource(bus, type);
         unsigned int mem64_mask = 0;
+        resource_size_t children_add_size = 0;
 
         if (!b_res)
                 return 0;
@@ -645,6 +674,16 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
                         if (r->parent || (r->flags & mask) != type)
                                 continue;
                         r_size = resource_size(r);
+#ifdef CONFIG_PCI_IOV
+                        /* put SRIOV requested res to the optional list */
+                        if (realloc_head && i >= PCI_IOV_RESOURCES &&
+                                        i <= PCI_IOV_RESOURCE_END) {
+                                r->end = r->start - 1;
+                                add_to_list(realloc_head, dev, r, r_size, 0/* dont' care */);
+                                children_add_size += r_size;
+                                continue;
+                        }
+#endif
                         /* For bridges size != alignment */
                         align = pci_resource_alignment(dev, r);
                         order = __ffs(align) - 20;
@@ -665,6 +704,9 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
                         if (order > max_order)
                                 max_order = order;
                         mem64_mask &= r->flags & IORESOURCE_MEM_64;
+
+                        if (realloc_head)
+                                children_add_size += get_res_add_size(realloc_head, r);
                 }
         }
         align = 0;
@@ -681,7 +723,9 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
                 align += aligns[order];
         }
         size0 = calculate_memsize(size, min_size, 0, resource_size(b_res), min_align);
-        size1 = (!add_head || (add_head && !add_size)) ? size0 :
+        if (children_add_size > add_size)
+                add_size = children_add_size;
+        size1 = (!realloc_head || (realloc_head && !add_size)) ? size0 :
                 calculate_memsize(size, min_size+add_size, 0,
                                 resource_size(b_res), min_align);
         if (!size0 && !size1) {
@@ -695,12 +739,22 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
         b_res->start = min_align;
         b_res->end = size0 + min_align - 1;
         b_res->flags |= IORESOURCE_STARTALIGN | mem64_mask;
-        if (size1 > size0 && add_head)
-                add_to_list(add_head, bus->self, b_res, size1-size0);
+        if (size1 > size0 && realloc_head)
+                add_to_list(realloc_head, bus->self, b_res, size1-size0, min_align);
         return 1;
 }
 
-static void pci_bus_size_cardbus(struct pci_bus *bus)
+unsigned long pci_cardbus_resource_alignment(struct resource *res)
+{
+        if (res->flags & IORESOURCE_IO)
+                return pci_cardbus_io_size;
+        if (res->flags & IORESOURCE_MEM)
+                return pci_cardbus_mem_size;
+        return 0;
+}
+
+static void pci_bus_size_cardbus(struct pci_bus *bus,
+                        struct resource_list_x *realloc_head)
 {
         struct pci_dev *bridge = bus->self;
         struct resource *b_res = &bridge->resource[PCI_BRIDGE_RESOURCES];
@@ -711,12 +765,14 @@ static void pci_bus_size_cardbus(struct pci_bus *bus)
          * a fixed amount of bus space for CardBus bridges.
          */
         b_res[0].start = 0;
-        b_res[0].end = pci_cardbus_io_size - 1;
         b_res[0].flags |= IORESOURCE_IO | IORESOURCE_SIZEALIGN;
+        if (realloc_head)
+                add_to_list(realloc_head, bridge, b_res, pci_cardbus_io_size, 0 /* dont care */);
 
         b_res[1].start = 0;
-        b_res[1].end = pci_cardbus_io_size - 1;
         b_res[1].flags |= IORESOURCE_IO | IORESOURCE_SIZEALIGN;
+        if (realloc_head)
+                add_to_list(realloc_head, bridge, b_res+1, pci_cardbus_io_size, 0 /* dont care */);
 
         /*
          * Check whether prefetchable memory is supported
@@ -736,21 +792,31 @@ static void pci_bus_size_cardbus(struct pci_bus *bus)
          */
         if (ctrl & PCI_CB_BRIDGE_CTL_PREFETCH_MEM0) {
                 b_res[2].start = 0;
-                b_res[2].end = pci_cardbus_mem_size - 1;
                 b_res[2].flags |= IORESOURCE_MEM | IORESOURCE_PREFETCH | IORESOURCE_SIZEALIGN;
+                if (realloc_head)
+                        add_to_list(realloc_head, bridge, b_res+2, pci_cardbus_mem_size, 0 /* dont care */);
 
                 b_res[3].start = 0;
-                b_res[3].end = pci_cardbus_mem_size - 1;
                 b_res[3].flags |= IORESOURCE_MEM | IORESOURCE_SIZEALIGN;
+                if (realloc_head)
+                        add_to_list(realloc_head, bridge, b_res+3, pci_cardbus_mem_size, 0 /* dont care */);
         } else {
                 b_res[3].start = 0;
-                b_res[3].end = pci_cardbus_mem_size * 2 - 1;
                 b_res[3].flags |= IORESOURCE_MEM | IORESOURCE_SIZEALIGN;
+                if (realloc_head)
+                        add_to_list(realloc_head, bridge, b_res+3, pci_cardbus_mem_size * 2, 0 /* dont care */);
         }
+
+        /* set the size of the resource to zero, so that the resource does not
+         * get assigned during required-resource allocation cycle but gets assigned
+         * during the optional-resource allocation cycle.
+         */
+        b_res[0].start = b_res[1].start = b_res[2].start = b_res[3].start = 1;
+        b_res[0].end = b_res[1].end = b_res[2].end = b_res[3].end = 0;
 }
 
 void __ref __pci_bus_size_bridges(struct pci_bus *bus,
-                        struct resource_list_x *add_head)
+                        struct resource_list_x *realloc_head)
 {
         struct pci_dev *dev;
         unsigned long mask, prefmask;
@@ -763,12 +829,12 @@ void __ref __pci_bus_size_bridges(struct pci_bus *bus,
 
                 switch (dev->class >> 8) {
                 case PCI_CLASS_BRIDGE_CARDBUS:
-                        pci_bus_size_cardbus(b);
+                        pci_bus_size_cardbus(b, realloc_head);
                         break;
 
                 case PCI_CLASS_BRIDGE_PCI:
                 default:
-                        __pci_bus_size_bridges(b, add_head);
+                        __pci_bus_size_bridges(b, realloc_head);
                         break;
                 }
         }
@@ -792,7 +858,7 @@ void __ref __pci_bus_size_bridges(struct pci_bus *bus,
                  * Follow thru
                  */
         default:
-                pbus_size_io(bus, 0, additional_io_size, add_head);
+                pbus_size_io(bus, 0, additional_io_size, realloc_head);
                 /* If the bridge supports prefetchable range, size it
                    separately. If it doesn't, or its prefetchable window
                    has already been allocated by arch code, try
@@ -800,11 +866,11 @@ void __ref __pci_bus_size_bridges(struct pci_bus *bus,
                    resources. */
                 mask = IORESOURCE_MEM;
                 prefmask = IORESOURCE_MEM | IORESOURCE_PREFETCH;
-                if (pbus_size_mem(bus, prefmask, prefmask, 0, additional_mem_size, add_head))
+                if (pbus_size_mem(bus, prefmask, prefmask, 0, additional_mem_size, realloc_head))
                         mask = prefmask; /* Success, size non-prefetch only. */
                 else
                         additional_mem_size += additional_mem_size;
-                pbus_size_mem(bus, mask, IORESOURCE_MEM, 0, additional_mem_size, add_head);
+                pbus_size_mem(bus, mask, IORESOURCE_MEM, 0, additional_mem_size, realloc_head);
                 break;
         }
 }
@@ -816,20 +882,20 @@ void __ref pci_bus_size_bridges(struct pci_bus *bus)
 EXPORT_SYMBOL(pci_bus_size_bridges);
 
 static void __ref __pci_bus_assign_resources(const struct pci_bus *bus,
-                                         struct resource_list_x *add_head,
+                                         struct resource_list_x *realloc_head,
                                          struct resource_list_x *fail_head)
 {
         struct pci_bus *b;
         struct pci_dev *dev;
 
-        pbus_assign_resources_sorted(bus, add_head, fail_head);
+        pbus_assign_resources_sorted(bus, realloc_head, fail_head);
 
         list_for_each_entry(dev, &bus->devices, bus_list) {
                 b = dev->subordinate;
                 if (!b)
                         continue;
 
-                __pci_bus_assign_resources(b, add_head, fail_head);
+                __pci_bus_assign_resources(b, realloc_head, fail_head);
 
                 switch (dev->class >> 8) {
                 case PCI_CLASS_BRIDGE_PCI:
@@ -1039,7 +1105,7 @@ void __init
 pci_assign_unassigned_resources(void)
 {
         struct pci_bus *bus;
-        struct resource_list_x add_list; /* list of resources that
+        struct resource_list_x realloc_list; /* list of resources that
                                         want additional resources */
         int tried_times = 0;
         enum release_type rel_type = leaf_only;
@@ -1052,7 +1118,7 @@ pci_assign_unassigned_resources(void)
 
 
         head.next = NULL;
-        add_list.next = NULL;
+        realloc_list.next = NULL;
 
         pci_try_num = max_depth + 1;
         printk(KERN_DEBUG "PCI: max bus depth: %d pci_try_num: %d\n",
@@ -1062,12 +1128,12 @@ again:
         /* Depth first, calculate sizes and alignments of all
            subordinate buses. */
         list_for_each_entry(bus, &pci_root_buses, node)
-                __pci_bus_size_bridges(bus, &add_list);
+                __pci_bus_size_bridges(bus, &realloc_list);
 
         /* Depth last, allocate resources and update the hardware. */
         list_for_each_entry(bus, &pci_root_buses, node)
-                __pci_bus_assign_resources(bus, &add_list, &head);
-        BUG_ON(add_list.next);
+                __pci_bus_assign_resources(bus, &realloc_list, &head);
+        BUG_ON(realloc_list.next);
         tried_times++;
 
         /* any device complain? */
diff --git a/drivers/pci/setup-res.c b/drivers/pci/setup-res.c
index 319f359906e8..51a9095c7da4 100644
--- a/drivers/pci/setup-res.c
+++ b/drivers/pci/setup-res.c
@@ -128,16 +128,16 @@ void pci_disable_bridge_window(struct pci_dev *dev)
 }
 #endif  /* CONFIG_PCI_QUIRKS */
 
+
+
 static int __pci_assign_resource(struct pci_bus *bus, struct pci_dev *dev,
-                                 int resno)
+                int resno, resource_size_t size, resource_size_t align)
 {
         struct resource *res = dev->resource + resno;
-        resource_size_t size, min, align;
+        resource_size_t min;
         int ret;
 
-        size = resource_size(res);
         min = (res->flags & IORESOURCE_IO) ? PCIBIOS_MIN_IO : PCIBIOS_MIN_MEM;
-        align = pci_resource_alignment(dev, res);
 
         /* First, try exact prefetching match.. */
         ret = pci_bus_alloc_resource(bus, res, size, align, min,
@@ -154,56 +154,101 @@ static int __pci_assign_resource(struct pci_bus *bus, struct pci_dev *dev,
                 ret = pci_bus_alloc_resource(bus, res, size, align, min, 0,
                                              pcibios_align_resource, dev);
         }
+        return ret;
+}
 
-        if (ret < 0 && dev->fw_addr[resno]) {
-                struct resource *root, *conflict;
-                resource_size_t start, end;
+static int pci_revert_fw_address(struct resource *res, struct pci_dev *dev, 
+                int resno, resource_size_t size)
+{
+        struct resource *root, *conflict;
+        resource_size_t start, end;
+        int ret = 0;
 
-                /*
-                 * If we failed to assign anything, let's try the address
-                 * where firmware left it.  That at least has a chance of
-                 * working, which is better than just leaving it disabled.
-                 */
+        if (res->flags & IORESOURCE_IO)
+                root = &ioport_resource;
+        else
+                root = &iomem_resource;
+
+        start = res->start;
+        end = res->end;
+        res->start = dev->fw_addr[resno];
+        res->end = res->start + size - 1;
+        dev_info(&dev->dev, "BAR %d: trying firmware assignment %pR\n",
+                 resno, res);
+        conflict = request_resource_conflict(root, res);
+        if (conflict) {
+                dev_info(&dev->dev,
+                         "BAR %d: %pR conflicts with %s %pR\n", resno,
+                         res, conflict->name, conflict);
+                res->start = start;
+                res->end = end;
+                ret = 1;
+        }
+        return ret;
+}
+
+static int _pci_assign_resource(struct pci_dev *dev, int resno, int size, resource_size_t min_align)
+{
+        struct resource *res = dev->resource + resno;
+        struct pci_bus *bus;
+        int ret;
+        char *type;
 
-                if (res->flags & IORESOURCE_IO)
-                        root = &ioport_resource;
+        bus = dev->bus;
+        while ((ret = __pci_assign_resource(bus, dev, resno, size, min_align))) {
+                if (!bus->parent || !bus->self->transparent)
+                        break;
+                bus = bus->parent;
+        }
+
+        if (ret) {
+                if (res->flags & IORESOURCE_MEM)
+                        if (res->flags & IORESOURCE_PREFETCH)
+                                type = "mem pref";
+                        else
+                                type = "mem";
+                else if (res->flags & IORESOURCE_IO)
+                        type = "io";
                 else
-                        root = &iomem_resource;
-
-                start = res->start;
-                end = res->end;
-                res->start = dev->fw_addr[resno];
-                res->end = res->start + size - 1;
-                dev_info(&dev->dev, "BAR %d: trying firmware assignment %pR\n",
-                         resno, res);
-                conflict = request_resource_conflict(root, res);
-                if (conflict) {
-                        dev_info(&dev->dev,
-                                 "BAR %d: %pR conflicts with %s %pR\n", resno,
-                                 res, conflict->name, conflict);
-                        res->start = start;
-                        res->end = end;
-                } else
-                        ret = 0;
+                        type = "unknown";
+                dev_info(&dev->dev,
+                         "BAR %d: can't assign %s (size %#llx)\n",
+                         resno, type, (unsigned long long) resource_size(res));
         }
 
+        return ret;
+}
+
+int pci_reassign_resource(struct pci_dev *dev, int resno, resource_size_t addsize,
+                        resource_size_t min_align)
+{
+        struct resource *res = dev->resource + resno;
+        resource_size_t new_size;
+        int ret;
+
+        if (!res->parent) {
+                dev_info(&dev->dev, "BAR %d: can't reassign an unassigned resouce %pR "
+                         "\n", resno, res);
+                return -EINVAL;
+        }
+
+        new_size = resource_size(res) + addsize + min_align;
+        ret = _pci_assign_resource(dev, resno, new_size, min_align);
         if (!ret) {
                 res->flags &= ~IORESOURCE_STARTALIGN;
                 dev_info(&dev->dev, "BAR %d: assigned %pR\n", resno, res);
                 if (resno < PCI_BRIDGE_RESOURCES)
                         pci_update_resource(dev, resno);
         }
-
         return ret;
 }
 
 int pci_assign_resource(struct pci_dev *dev, int resno)
 {
         struct resource *res = dev->resource + resno;
-        resource_size_t align;
+        resource_size_t align, size;
         struct pci_bus *bus;
         int ret;
-        char *type;
 
         align = pci_resource_alignment(dev, res);
         if (!align) {
@@ -213,34 +258,27 @@ int pci_assign_resource(struct pci_dev *dev, int resno)
         }
 
         bus = dev->bus;
-        while ((ret = __pci_assign_resource(bus, dev, resno))) {
-                if (bus->parent && bus->self->transparent)
-                        bus = bus->parent;
-                else
-                        bus = NULL;
-                if (bus)
-                        continue;
-                break;
-        }
+        size = resource_size(res);
+        ret = _pci_assign_resource(dev, resno, size, align);
 
-        if (ret) {
-                if (res->flags & IORESOURCE_MEM)
-                        if (res->flags & IORESOURCE_PREFETCH)
-                                type = "mem pref";
-                        else
-                                type = "mem";
-                else if (res->flags & IORESOURCE_IO)
-                        type = "io";
-                else
-                        type = "unknown";
-                dev_info(&dev->dev,
-                         "BAR %d: can't assign %s (size %#llx)\n",
-                         resno, type, (unsigned long long) resource_size(res));
-        }
+        /*
+         * If we failed to assign anything, let's try the address
+         * where firmware left it.  That at least has a chance of
+         * working, which is better than just leaving it disabled.
+         */
+        if (ret < 0 && dev->fw_addr[resno])
+                ret = pci_revert_fw_address(res, dev, resno, size);
 
+        if (!ret) {
+                res->flags &= ~IORESOURCE_STARTALIGN;
+                dev_info(&dev->dev, "BAR %d: assigned %pR\n", resno, res);
+                if (resno < PCI_BRIDGE_RESOURCES)
+                        pci_update_resource(dev, resno);
+        }
         return ret;
 }
 
+
 /* Sort resources by alignment */
 void pdev_sort_resources(struct pci_dev *dev, struct resource_list *head)
 {
diff --git a/drivers/pcmcia/pxa2xx_vpac270.c b/drivers/pcmcia/pxa2xx_vpac270.c
index e956f659089a..66ab92cf3105 100644
--- a/drivers/pcmcia/pxa2xx_vpac270.c
+++ b/drivers/pcmcia/pxa2xx_vpac270.c
@@ -17,7 +17,7 @@
 
 #include <asm/mach-types.h>
 
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include <mach/vpac270.h>
 
 #include "soc_common.h"
diff --git a/drivers/power/max8997_charger.c b/drivers/power/max8997_charger.c
index 7106b49b26e4..ffc5033ea9c9 100644
--- a/drivers/power/max8997_charger.c
+++ b/drivers/power/max8997_charger.c
@@ -20,6 +20,7 @@
  */
 
 #include <linux/err.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/platform_device.h>
 #include <linux/power_supply.h>
diff --git a/drivers/power/max8998_charger.c b/drivers/power/max8998_charger.c
index cc21fa2120be..ef8efadb58cb 100644
--- a/drivers/power/max8998_charger.c
+++ b/drivers/power/max8998_charger.c
@@ -20,6 +20,7 @@
  */
 
 #include <linux/err.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/platform_device.h>
 #include <linux/power_supply.h>
diff --git a/drivers/power/s3c_adc_battery.c b/drivers/power/s3c_adc_battery.c
index a675e31b4f13..d32d0d70f9ba 100644
--- a/drivers/power/s3c_adc_battery.c
+++ b/drivers/power/s3c_adc_battery.c
@@ -20,6 +20,7 @@
 #include <linux/s3c_adc_battery.h>
 #include <linux/errno.h>
 #include <linux/init.h>
+#include <linux/module.h>
 
 #include <plat/adc.h>
 
diff --git a/drivers/rapidio/rio-scan.c b/drivers/rapidio/rio-scan.c
index ee893581d4b7..ebe77dd87daf 100644
--- a/drivers/rapidio/rio-scan.c
+++ b/drivers/rapidio/rio-scan.c
@@ -505,8 +505,7 @@ static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
         rdev->dev.dma_mask = &rdev->dma_mask;
         rdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
 
-        if ((rdev->pef & RIO_PEF_INB_DOORBELL) &&
-            (rdev->dst_ops & RIO_DST_OPS_DOORBELL))
+        if (rdev->dst_ops & RIO_DST_OPS_DOORBELL)
                 rio_init_dbell_res(&rdev->riores[RIO_DOORBELL_RESOURCE],
                                    0, 0xffff);
 
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 3195dbd3ec34..44e91e598f8d 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -639,7 +639,7 @@ EXPORT_SYMBOL_GPL(rtc_irq_unregister);
 static int rtc_update_hrtimer(struct rtc_device *rtc, int enabled)
 {
         /*
-         * We unconditionally cancel the timer here, because otherwise
+         * We always cancel the timer here first, because otherwise
          * we could run into BUG_ON(timer->state != HRTIMER_STATE_CALLBACK);
          * when we manage to start the timer before the callback
          * returns HRTIMER_RESTART.
@@ -708,7 +708,7 @@ int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
         int err = 0;
         unsigned long flags;
 
-        if (freq <= 0 || freq > 5000)
+        if (freq <= 0 || freq > RTC_MAX_FREQ)
                 return -EINVAL;
 retry:
         spin_lock_irqsave(&rtc->irq_task_lock, flags);
diff --git a/drivers/rtc/rtc-ep93xx.c b/drivers/rtc/rtc-ep93xx.c
index 335551d333b2..14a42a1edc66 100644
--- a/drivers/rtc/rtc-ep93xx.c
+++ b/drivers/rtc/rtc-ep93xx.c
@@ -36,6 +36,7 @@
  */
 struct ep93xx_rtc {
         void __iomem    *mmio_base;
+        struct rtc_device *rtc;
 };
 
 static int ep93xx_rtc_get_swcomp(struct device *dev, unsigned short *preload,
@@ -130,7 +131,6 @@ static int __init ep93xx_rtc_probe(struct platform_device *pdev)
 {
         struct ep93xx_rtc *ep93xx_rtc;
         struct resource *res;
-        struct rtc_device *rtc;
         int err;
 
         ep93xx_rtc = devm_kzalloc(&pdev->dev, sizeof(*ep93xx_rtc), GFP_KERNEL);
@@ -151,12 +151,12 @@ static int __init ep93xx_rtc_probe(struct platform_device *pdev)
                 return -ENXIO;
 
         pdev->dev.platform_data = ep93xx_rtc;
-        platform_set_drvdata(pdev, rtc);
+        platform_set_drvdata(pdev, ep93xx_rtc);
 
-        rtc = rtc_device_register(pdev->name,
+        ep93xx_rtc->rtc = rtc_device_register(pdev->name,
                                 &pdev->dev, &ep93xx_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                err = PTR_ERR(rtc);
+        if (IS_ERR(ep93xx_rtc->rtc)) {
+                err = PTR_ERR(ep93xx_rtc->rtc);
                 goto exit;
         }
 
@@ -167,7 +167,7 @@ static int __init ep93xx_rtc_probe(struct platform_device *pdev)
         return 0;
 
 fail:
-        rtc_device_unregister(rtc);
+        rtc_device_unregister(ep93xx_rtc->rtc);
 exit:
         platform_set_drvdata(pdev, NULL);
         pdev->dev.platform_data = NULL;
@@ -176,11 +176,11 @@ exit:
 
 static int __exit ep93xx_rtc_remove(struct platform_device *pdev)
 {
-        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct ep93xx_rtc *ep93xx_rtc = platform_get_drvdata(pdev);
 
         sysfs_remove_group(&pdev->dev.kobj, &ep93xx_rtc_sysfs_files);
         platform_set_drvdata(pdev, NULL);
-        rtc_device_unregister(rtc);
+        rtc_device_unregister(ep93xx_rtc->rtc);
         pdev->dev.platform_data = NULL;
 
         return 0;
diff --git a/drivers/rtc/rtc-imxdi.c b/drivers/rtc/rtc-imxdi.c
index 2dd3c0163272..d93a9608b1f0 100644
--- a/drivers/rtc/rtc-imxdi.c
+++ b/drivers/rtc/rtc-imxdi.c
@@ -35,6 +35,7 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/rtc.h>
+#include <linux/sched.h>
 #include <linux/workqueue.h>
 
 /* DryIce Register Definitions */
diff --git a/drivers/rtc/rtc-lib.c b/drivers/rtc/rtc-lib.c
index 075f1708deae..c4cf05731118 100644
--- a/drivers/rtc/rtc-lib.c
+++ b/drivers/rtc/rtc-lib.c
@@ -85,6 +85,8 @@ void rtc_time_to_tm(unsigned long time, struct rtc_time *tm)
         time -= tm->tm_hour * 3600;
         tm->tm_min = time / 60;
         tm->tm_sec = time - tm->tm_min * 60;
+
+        tm->tm_isdst = 0;
 }
 EXPORT_SYMBOL(rtc_time_to_tm);
 
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index 9329dbb9ebab..7639ab906f02 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -51,6 +51,27 @@ static enum s3c_cpu_type s3c_rtc_cpu_type;
 
 static DEFINE_SPINLOCK(s3c_rtc_pie_lock);
 
+static void s3c_rtc_alarm_clk_enable(bool enable)
+{
+        static DEFINE_SPINLOCK(s3c_rtc_alarm_clk_lock);
+        static bool alarm_clk_enabled;
+        unsigned long irq_flags;
+
+        spin_lock_irqsave(&s3c_rtc_alarm_clk_lock, irq_flags);
+        if (enable) {
+                if (!alarm_clk_enabled) {
+                        clk_enable(rtc_clk);
+                        alarm_clk_enabled = true;
+                }
+        } else {
+                if (alarm_clk_enabled) {
+                        clk_disable(rtc_clk);
+                        alarm_clk_enabled = false;
+                }
+        }
+        spin_unlock_irqrestore(&s3c_rtc_alarm_clk_lock, irq_flags);
+}
+
 /* IRQ Handlers */
 
 static irqreturn_t s3c_rtc_alarmirq(int irq, void *id)
@@ -64,6 +85,9 @@ static irqreturn_t s3c_rtc_alarmirq(int irq, void *id)
                 writeb(S3C2410_INTP_ALM, s3c_rtc_base + S3C2410_INTP);
 
         clk_disable(rtc_clk);
+
+        s3c_rtc_alarm_clk_enable(false);
+
         return IRQ_HANDLED;
 }
 
@@ -97,6 +121,8 @@ static int s3c_rtc_setaie(struct device *dev, unsigned int enabled)
         writeb(tmp, s3c_rtc_base + S3C2410_RTCALM);
         clk_disable(rtc_clk);
 
+        s3c_rtc_alarm_clk_enable(enabled);
+
         return 0;
 }
 
@@ -152,10 +178,6 @@ static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
                 goto retry_get_time;
         }
 
-        pr_debug("read time %04d.%02d.%02d %02d:%02d:%02d\n",
-                 1900 + rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
-                 rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec);
-
         rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
         rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
         rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
@@ -164,6 +186,11 @@ static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
         rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
 
         rtc_tm->tm_year += 100;
+
+        pr_debug("read time %04d.%02d.%02d %02d:%02d:%02d\n",
+                 1900 + rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
+                 rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec);
+
         rtc_tm->tm_mon -= 1;
 
         clk_disable(rtc_clk);
@@ -269,10 +296,9 @@ static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
         clk_enable(rtc_clk);
         pr_debug("s3c_rtc_setalarm: %d, %04d.%02d.%02d %02d:%02d:%02d\n",
                  alrm->enabled,
-                 1900 + tm->tm_year, tm->tm_mon, tm->tm_mday,
+                 1900 + tm->tm_year, tm->tm_mon + 1, tm->tm_mday,
                  tm->tm_hour, tm->tm_min, tm->tm_sec);
 
-
         alrm_en = readb(base + S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN;
         writeb(0x00, base + S3C2410_RTCALM);
 
@@ -319,49 +345,7 @@ static int s3c_rtc_proc(struct device *dev, struct seq_file *seq)
         return 0;
 }
 
-static int s3c_rtc_open(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct rtc_device *rtc_dev = platform_get_drvdata(pdev);
-        int ret;
-
-        ret = request_irq(s3c_rtc_alarmno, s3c_rtc_alarmirq,
-                          IRQF_DISABLED,  "s3c2410-rtc alarm", rtc_dev);
-
-        if (ret) {
-                dev_err(dev, "IRQ%d error %d\n", s3c_rtc_alarmno, ret);
-                return ret;
-        }
-
-        ret = request_irq(s3c_rtc_tickno, s3c_rtc_tickirq,
-                          IRQF_DISABLED,  "s3c2410-rtc tick", rtc_dev);
-
-        if (ret) {
-                dev_err(dev, "IRQ%d error %d\n", s3c_rtc_tickno, ret);
-                goto tick_err;
-        }
-
-        return ret;
-
- tick_err:
-        free_irq(s3c_rtc_alarmno, rtc_dev);
-        return ret;
-}
-
-static void s3c_rtc_release(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct rtc_device *rtc_dev = platform_get_drvdata(pdev);
-
-        /* do not clear AIE here, it may be needed for wake */
-
-        free_irq(s3c_rtc_alarmno, rtc_dev);
-        free_irq(s3c_rtc_tickno, rtc_dev);
-}
-
 static const struct rtc_class_ops s3c_rtcops = {
-        .open           = s3c_rtc_open,
-        .release        = s3c_rtc_release,
         .read_time      = s3c_rtc_gettime,
         .set_time       = s3c_rtc_settime,
         .read_alarm     = s3c_rtc_getalarm,
@@ -425,6 +409,9 @@ static int __devexit s3c_rtc_remove(struct platform_device *dev)
 {
         struct rtc_device *rtc = platform_get_drvdata(dev);
 
+        free_irq(s3c_rtc_alarmno, rtc);
+        free_irq(s3c_rtc_tickno, rtc);
+
         platform_set_drvdata(dev, NULL);
         rtc_device_unregister(rtc);
 
@@ -548,10 +535,32 @@ static int __devinit s3c_rtc_probe(struct platform_device *pdev)
 
         s3c_rtc_setfreq(&pdev->dev, 1);
 
+        ret = request_irq(s3c_rtc_alarmno, s3c_rtc_alarmirq,
+                          IRQF_DISABLED,  "s3c2410-rtc alarm", rtc);
+        if (ret) {
+                dev_err(&pdev->dev, "IRQ%d error %d\n", s3c_rtc_alarmno, ret);
+                goto err_alarm_irq;
+        }
+
+        ret = request_irq(s3c_rtc_tickno, s3c_rtc_tickirq,
+                          IRQF_DISABLED,  "s3c2410-rtc tick", rtc);
+        if (ret) {
+                dev_err(&pdev->dev, "IRQ%d error %d\n", s3c_rtc_tickno, ret);
+                free_irq(s3c_rtc_alarmno, rtc);
+                goto err_tick_irq;
+        }
+
         clk_disable(rtc_clk);
 
         return 0;
 
+ err_tick_irq:
+        free_irq(s3c_rtc_alarmno, rtc);
+
+ err_alarm_irq:
+        platform_set_drvdata(pdev, NULL);
+        rtc_device_unregister(rtc);
+
  err_nortc:
         s3c_rtc_enable(pdev, 0);
         clk_disable(rtc_clk);
diff --git a/drivers/rtc/rtc-twl.c b/drivers/rtc/rtc-twl.c
index 9a81f778d6b2..20687d55e7a7 100644
--- a/drivers/rtc/rtc-twl.c
+++ b/drivers/rtc/rtc-twl.c
@@ -362,14 +362,6 @@ static irqreturn_t twl_rtc_interrupt(int irq, void *rtc)
         int res;
         u8 rd_reg;
 
-#ifdef CONFIG_LOCKDEP
-        /* WORKAROUND for lockdep forcing IRQF_DISABLED on us, which
-         * we don't want and can't tolerate.  Although it might be
-         * friendlier not to borrow this thread context...
-         */
-        local_irq_enable();
-#endif
-
         res = twl_rtc_read_u8(&rd_reg, REG_RTC_STATUS_REG);
         if (res)
                 goto out;
@@ -428,24 +420,12 @@ static struct rtc_class_ops twl_rtc_ops = {
 static int __devinit twl_rtc_probe(struct platform_device *pdev)
 {
         struct rtc_device *rtc;
-        int ret = 0;
+        int ret = -EINVAL;
         int irq = platform_get_irq(pdev, 0);
         u8 rd_reg;
 
         if (irq <= 0)
-                return -EINVAL;
-
-        rtc = rtc_device_register(pdev->name,
-                                  &pdev->dev, &twl_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                ret = PTR_ERR(rtc);
-                dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
-                        PTR_ERR(rtc));
-                goto out0;
-
-        }
-
-        platform_set_drvdata(pdev, rtc);
+                goto out1;
 
         ret = twl_rtc_read_u8(&rd_reg, REG_RTC_STATUS_REG);
         if (ret < 0)
@@ -462,14 +442,6 @@ static int __devinit twl_rtc_probe(struct platform_device *pdev)
         if (ret < 0)
                 goto out1;
 
-        ret = request_irq(irq, twl_rtc_interrupt,
-                                IRQF_TRIGGER_RISING,
-                                dev_name(&rtc->dev), rtc);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "IRQ is not free.\n");
-                goto out1;
-        }
-
         if (twl_class_is_6030()) {
                 twl6030_interrupt_unmask(TWL6030_RTC_INT_MASK,
                         REG_INT_MSK_LINE_A);
@@ -480,28 +452,44 @@ static int __devinit twl_rtc_probe(struct platform_device *pdev)
         /* Check RTC module status, Enable if it is off */
         ret = twl_rtc_read_u8(&rd_reg, REG_RTC_CTRL_REG);
         if (ret < 0)
-                goto out2;
+                goto out1;
 
         if (!(rd_reg & BIT_RTC_CTRL_REG_STOP_RTC_M)) {
                 dev_info(&pdev->dev, "Enabling TWL-RTC.\n");
                 rd_reg = BIT_RTC_CTRL_REG_STOP_RTC_M;
                 ret = twl_rtc_write_u8(rd_reg, REG_RTC_CTRL_REG);
                 if (ret < 0)
-                        goto out2;
+                        goto out1;
         }
 
         /* init cached IRQ enable bits */
         ret = twl_rtc_read_u8(&rtc_irq_bits, REG_RTC_INTERRUPTS_REG);
         if (ret < 0)
+                goto out1;
+
+        rtc = rtc_device_register(pdev->name,
+                                  &pdev->dev, &twl_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                ret = PTR_ERR(rtc);
+                dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
+                        PTR_ERR(rtc));
+                goto out1;
+        }
+
+        ret = request_threaded_irq(irq, NULL, twl_rtc_interrupt,
+                                   IRQF_TRIGGER_RISING,
+                                   dev_name(&rtc->dev), rtc);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "IRQ is not free.\n");
                 goto out2;
+        }
 
-        return ret;
+        platform_set_drvdata(pdev, rtc);
+        return 0;
 
 out2:
-        free_irq(irq, rtc);
-out1:
         rtc_device_unregister(rtc);
-out0:
+out1:
         return ret;
 }
 
diff --git a/drivers/s390/block/dasd_ioctl.c b/drivers/s390/block/dasd_ioctl.c
index eb4e034378cd..f1a2016829fc 100644
--- a/drivers/s390/block/dasd_ioctl.c
+++ b/drivers/s390/block/dasd_ioctl.c
@@ -249,6 +249,7 @@ static int dasd_ioctl_reset_profile(struct dasd_block *block)
 static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp)
 {
         struct dasd_profile_info_t *data;
+        int rc = 0;
 
         data = kmalloc(sizeof(*data), GFP_KERNEL);
         if (!data)
@@ -279,11 +280,14 @@ static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp)
                 spin_unlock_bh(&block->profile.lock);
         } else {
                 spin_unlock_bh(&block->profile.lock);
-                return -EIO;
+                rc = -EIO;
+                goto out;
         }
         if (copy_to_user(argp, data, sizeof(*data)))
-                return -EFAULT;
-        return 0;
+                rc = -EFAULT;
+out:
+        kfree(data);
+        return rc;
 }
 #else
 static int dasd_ioctl_reset_profile(struct dasd_block *block)
diff --git a/drivers/s390/char/sclp_cmd.c b/drivers/s390/char/sclp_cmd.c
index be55fb2b1b1c..837e010299a8 100644
--- a/drivers/s390/char/sclp_cmd.c
+++ b/drivers/s390/char/sclp_cmd.c
@@ -383,8 +383,10 @@ static int sclp_attach_storage(u8 id)
         switch (sccb->header.response_code) {
         case 0x0020:
                 set_bit(id, sclp_storage_ids);
-                for (i = 0; i < sccb->assigned; i++)
-                        sclp_unassign_storage(sccb->entries[i] >> 16);
+                for (i = 0; i < sccb->assigned; i++) {
+                        if (sccb->entries[i])
+                                sclp_unassign_storage(sccb->entries[i] >> 16);
+                }
                 break;
         default:
                 rc = -EIO;
diff --git a/drivers/s390/cio/cio.c b/drivers/s390/cio/cio.c
index cbde448f9947..eb3140ee821e 100644
--- a/drivers/s390/cio/cio.c
+++ b/drivers/s390/cio/cio.c
@@ -654,8 +654,8 @@ static struct io_subchannel_private console_priv;
 static int console_subchannel_in_use;
 
 /*
- * Use tpi to get a pending interrupt, call the interrupt handler and
- * return a pointer to the subchannel structure.
+ * Use cio_tpi to get a pending interrupt and call the interrupt handler.
+ * Return non-zero if an interrupt was processed, zero otherwise.
  */
 static int cio_tpi(void)
 {
@@ -667,6 +667,10 @@ static int cio_tpi(void)
         tpi_info = (struct tpi_info *)&S390_lowcore.subchannel_id;
         if (tpi(NULL) != 1)
                 return 0;
+        if (tpi_info->adapter_IO) {
+                do_adapter_IO(tpi_info->isc);
+                return 1;
+        }
         irb = (struct irb *)&S390_lowcore.irb;
         /* Store interrupt response block to lowcore. */
         if (tsch(tpi_info->schid, irb) != 0)
diff --git a/drivers/scsi/3w-9xxx.c b/drivers/scsi/3w-9xxx.c
index b7bd5b0cc7aa..3868ab2397c6 100644
--- a/drivers/scsi/3w-9xxx.c
+++ b/drivers/scsi/3w-9xxx.c
@@ -1800,10 +1800,12 @@ static int twa_scsi_queue_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_
         switch (retval) {
         case SCSI_MLQUEUE_HOST_BUSY:
                 twa_free_request_id(tw_dev, request_id);
+                twa_unmap_scsi_data(tw_dev, request_id);
                 break;
         case 1:
                 tw_dev->state[request_id] = TW_S_COMPLETED;
                 twa_free_request_id(tw_dev, request_id);
+                twa_unmap_scsi_data(tw_dev, request_id);
                 SCpnt->result = (DID_ERROR << 16);
                 done(SCpnt);
                 retval = 0;
diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index 8d9dae89f065..3878b7395081 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -837,6 +837,7 @@ config SCSI_ISCI
         # (temporary): known alpha quality driver
         depends on EXPERIMENTAL
         select SCSI_SAS_LIBSAS
+        select SCSI_SAS_HOST_SMP
         ---help---
           This driver supports the 6Gb/s SAS capabilities of the storage
           control unit found in the Intel(R) C600 series chipset.
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index 3c08f5352b2d..6153a66a8a31 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -88,7 +88,7 @@ obj-$(CONFIG_SCSI_QLOGIC_FAS)	+= qlogicfas408.o	qlogicfas.o
 obj-$(CONFIG_PCMCIA_QLOGIC)     += qlogicfas408.o
 obj-$(CONFIG_SCSI_QLOGIC_1280)  += qla1280.o 
 obj-$(CONFIG_SCSI_QLA_FC)       += qla2xxx/
-obj-$(CONFIG_SCSI_QLA_ISCSI)    += qla4xxx/
+obj-$(CONFIG_SCSI_QLA_ISCSI)    += libiscsi.o qla4xxx/
 obj-$(CONFIG_SCSI_LPFC)         += lpfc/
 obj-$(CONFIG_SCSI_BFA_FC)       += bfa/
 obj-$(CONFIG_SCSI_PAS16)        += pas16.o
diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index e7d0d47b9185..e5f2d7d9002e 100644
--- a/drivers/scsi/aacraid/commsup.c
+++ b/drivers/scsi/aacraid/commsup.c
@@ -1283,6 +1283,8 @@ static int _aac_reset_adapter(struct aac_dev *aac, int forced)
         kfree(aac->queues);
         aac->queues = NULL;
         free_irq(aac->pdev->irq, aac);
+        if (aac->msi)
+                pci_disable_msi(aac->pdev);
         kfree(aac->fsa_dev);
         aac->fsa_dev = NULL;
         quirks = aac_get_driver_ident(index)->quirks;
diff --git a/drivers/scsi/bnx2i/bnx2i_hwi.c b/drivers/scsi/bnx2i/bnx2i_hwi.c
index 9ae80cd5953b..dba72a4e6a1c 100644
--- a/drivers/scsi/bnx2i/bnx2i_hwi.c
+++ b/drivers/scsi/bnx2i/bnx2i_hwi.c
@@ -563,7 +563,7 @@ int bnx2i_send_iscsi_nopout(struct bnx2i_conn *bnx2i_conn,
         nopout_wqe->itt = ((u16)task->itt |
                            (ISCSI_TASK_TYPE_MPATH <<
                             ISCSI_TMF_REQUEST_TYPE_SHIFT));
-        nopout_wqe->ttt = nopout_hdr->ttt;
+        nopout_wqe->ttt = be32_to_cpu(nopout_hdr->ttt);
         nopout_wqe->flags = 0;
         if (!unsol)
                 nopout_wqe->flags = ISCSI_NOP_OUT_REQUEST_LOCAL_COMPLETION;
diff --git a/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c b/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c
index bd22041e2789..f58644850333 100644
--- a/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c
+++ b/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c
@@ -913,7 +913,7 @@ static void l2t_put(struct cxgbi_sock *csk)
         struct t3cdev *t3dev = (struct t3cdev *)csk->cdev->lldev;
 
         if (csk->l2t) {
-                l2t_release(L2DATA(t3dev), csk->l2t);
+                l2t_release(t3dev, csk->l2t);
                 csk->l2t = NULL;
                 cxgbi_sock_put(csk);
         }
diff --git a/drivers/scsi/fcoe/fcoe.c b/drivers/scsi/fcoe/fcoe.c
index ba710e350ac5..5d0e9a24ae94 100644
--- a/drivers/scsi/fcoe/fcoe.c
+++ b/drivers/scsi/fcoe/fcoe.c
@@ -432,6 +432,8 @@ void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
         u8 flogi_maddr[ETH_ALEN];
         const struct net_device_ops *ops;
 
+        rtnl_lock();
+
         /*
          * Don't listen for Ethernet packets anymore.
          * synchronize_net() ensures that the packet handlers are not running
@@ -461,6 +463,8 @@ void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
                                         " specific feature for LLD.\n");
         }
 
+        rtnl_unlock();
+
         /* Release the self-reference taken during fcoe_interface_create() */
         fcoe_interface_put(fcoe);
 }
@@ -1951,11 +1955,8 @@ static void fcoe_destroy_work(struct work_struct *work)
         fcoe_if_destroy(port->lport);
 
         /* Do not tear down the fcoe interface for NPIV port */
-        if (!npiv) {
-                rtnl_lock();
+        if (!npiv)
                 fcoe_interface_cleanup(fcoe);
-                rtnl_unlock();
-        }
 
         mutex_unlock(&fcoe_config_mutex);
 }
@@ -2009,8 +2010,9 @@ static int fcoe_create(struct net_device *netdev, enum fip_state fip_mode)
                 printk(KERN_ERR "fcoe: Failed to create interface (%s)\n",
                        netdev->name);
                 rc = -EIO;
+                rtnl_unlock();
                 fcoe_interface_cleanup(fcoe);
-                goto out_nodev;
+                goto out_nortnl;
         }
 
         /* Make this the "master" N_Port */
@@ -2027,6 +2029,7 @@ static int fcoe_create(struct net_device *netdev, enum fip_state fip_mode)
 
 out_nodev:
         rtnl_unlock();
+out_nortnl:
         mutex_unlock(&fcoe_config_mutex);
         return rc;
 }
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index ec61bdb833ac..b200b736b000 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -676,6 +676,16 @@ static void hpsa_scsi_replace_entry(struct ctlr_info *h, int hostno,
         BUG_ON(entry < 0 || entry >= HPSA_MAX_SCSI_DEVS_PER_HBA);
         removed[*nremoved] = h->dev[entry];
         (*nremoved)++;
+
+        /*
+         * New physical devices won't have target/lun assigned yet
+         * so we need to preserve the values in the slot we are replacing.
+         */
+        if (new_entry->target == -1) {
+                new_entry->target = h->dev[entry]->target;
+                new_entry->lun = h->dev[entry]->lun;
+        }
+
         h->dev[entry] = new_entry;
         added[*nadded] = new_entry;
         (*nadded)++;
@@ -1548,10 +1558,17 @@ static inline void hpsa_set_bus_target_lun(struct hpsa_scsi_dev_t *device,
 }
 
 static int hpsa_update_device_info(struct ctlr_info *h,
-        unsigned char scsi3addr[], struct hpsa_scsi_dev_t *this_device)
+        unsigned char scsi3addr[], struct hpsa_scsi_dev_t *this_device,
+        unsigned char *is_OBDR_device)
 {
-#define OBDR_TAPE_INQ_SIZE 49
+
+#define OBDR_SIG_OFFSET 43
+#define OBDR_TAPE_SIG "$DR-10"
+#define OBDR_SIG_LEN (sizeof(OBDR_TAPE_SIG) - 1)
+#define OBDR_TAPE_INQ_SIZE (OBDR_SIG_OFFSET + OBDR_SIG_LEN)
+
         unsigned char *inq_buff;
+        unsigned char *obdr_sig;
 
         inq_buff = kzalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
         if (!inq_buff)
@@ -1583,6 +1600,16 @@ static int hpsa_update_device_info(struct ctlr_info *h,
         else
                 this_device->raid_level = RAID_UNKNOWN;
 
+        if (is_OBDR_device) {
+                /* See if this is a One-Button-Disaster-Recovery device
+                 * by looking for "$DR-10" at offset 43 in inquiry data.
+                 */
+                obdr_sig = &inq_buff[OBDR_SIG_OFFSET];
+                *is_OBDR_device = (this_device->devtype == TYPE_ROM &&
+                                        strncmp(obdr_sig, OBDR_TAPE_SIG,
+                                                OBDR_SIG_LEN) == 0);
+        }
+
         kfree(inq_buff);
         return 0;
 
@@ -1716,7 +1743,7 @@ static int add_msa2xxx_enclosure_device(struct ctlr_info *h,
                 return 0;
         }
 
-        if (hpsa_update_device_info(h, scsi3addr, this_device))
+        if (hpsa_update_device_info(h, scsi3addr, this_device, NULL))
                 return 0;
         (*nmsa2xxx_enclosures)++;
         hpsa_set_bus_target_lun(this_device, bus, target, 0);
@@ -1808,7 +1835,6 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
          */
         struct ReportLUNdata *physdev_list = NULL;
         struct ReportLUNdata *logdev_list = NULL;
-        unsigned char *inq_buff = NULL;
         u32 nphysicals = 0;
         u32 nlogicals = 0;
         u32 ndev_allocated = 0;
@@ -1824,11 +1850,9 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
                 GFP_KERNEL);
         physdev_list = kzalloc(reportlunsize, GFP_KERNEL);
         logdev_list = kzalloc(reportlunsize, GFP_KERNEL);
-        inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
         tmpdevice = kzalloc(sizeof(*tmpdevice), GFP_KERNEL);
 
-        if (!currentsd || !physdev_list || !logdev_list ||
-                !inq_buff || !tmpdevice) {
+        if (!currentsd || !physdev_list || !logdev_list || !tmpdevice) {
                 dev_err(&h->pdev->dev, "out of memory\n");
                 goto out;
         }
@@ -1863,7 +1887,7 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
         /* adjust our table of devices */
         nmsa2xxx_enclosures = 0;
         for (i = 0; i < nphysicals + nlogicals + 1; i++) {
-                u8 *lunaddrbytes;
+                u8 *lunaddrbytes, is_OBDR = 0;
 
                 /* Figure out where the LUN ID info is coming from */
                 lunaddrbytes = figure_lunaddrbytes(h, raid_ctlr_position,
@@ -1874,7 +1898,8 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
                         continue;
 
                 /* Get device type, vendor, model, device id */
-                if (hpsa_update_device_info(h, lunaddrbytes, tmpdevice))
+                if (hpsa_update_device_info(h, lunaddrbytes, tmpdevice,
+                                                        &is_OBDR))
                         continue; /* skip it if we can't talk to it. */
                 figure_bus_target_lun(h, lunaddrbytes, &bus, &target, &lun,
                         tmpdevice);
@@ -1898,7 +1923,7 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
                 hpsa_set_bus_target_lun(this_device, bus, target, lun);
 
                 switch (this_device->devtype) {
-                case TYPE_ROM: {
+                case TYPE_ROM:
                         /* We don't *really* support actual CD-ROM devices,
                          * just "One Button Disaster Recovery" tape drive
                          * which temporarily pretends to be a CD-ROM drive.
@@ -1906,15 +1931,8 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
                          * device by checking for "$DR-10" in bytes 43-48 of
                          * the inquiry data.
                          */
-                                char obdr_sig[7];
-#define OBDR_TAPE_SIG "$DR-10"
-                                strncpy(obdr_sig, &inq_buff[43], 6);
-                                obdr_sig[6] = '\0';
-                                if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
-                                        /* Not OBDR device, ignore it. */
-                                        break;
-                        }
-                        ncurrent++;
+                        if (is_OBDR)
+                                ncurrent++;
                         break;
                 case TYPE_DISK:
                         if (i < nphysicals)
@@ -1947,7 +1965,6 @@ out:
         for (i = 0; i < ndev_allocated; i++)
                 kfree(currentsd[i]);
         kfree(currentsd);
-        kfree(inq_buff);
         kfree(physdev_list);
         kfree(logdev_list);
 }
diff --git a/drivers/scsi/isci/host.c b/drivers/scsi/isci/host.c
index 26072f1e9852..6981b773a88d 100644
--- a/drivers/scsi/isci/host.c
+++ b/drivers/scsi/isci/host.c
@@ -531,6 +531,9 @@ static void sci_controller_process_completions(struct isci_host *ihost)
                         break;
 
                 case SCU_COMPLETION_TYPE_EVENT:
+                        sci_controller_event_completion(ihost, ent);
+                        break;
+
                 case SCU_COMPLETION_TYPE_NOTIFY: {
                         event_cycle ^= ((event_get+1) & SCU_MAX_EVENTS) <<
                                        (SMU_COMPLETION_QUEUE_GET_EVENT_CYCLE_BIT_SHIFT - SCU_MAX_EVENTS_SHIFT);
@@ -1091,6 +1094,7 @@ static void isci_host_completion_routine(unsigned long data)
         struct isci_request *request;
         struct isci_request *next_request;
         struct sas_task     *task;
+        u16 active;
 
         INIT_LIST_HEAD(&completed_request_list);
         INIT_LIST_HEAD(&errored_request_list);
@@ -1181,6 +1185,13 @@ static void isci_host_completion_routine(unsigned long data)
                 }
         }
 
+        /* the coalesence timeout doubles at each encoding step, so
+         * update it based on the ilog2 value of the outstanding requests
+         */
+        active = isci_tci_active(ihost);
+        writel(SMU_ICC_GEN_VAL(NUMBER, active) |
+               SMU_ICC_GEN_VAL(TIMER, ISCI_COALESCE_BASE + ilog2(active)),
+               &ihost->smu_registers->interrupt_coalesce_control);
 }
 
 /**
@@ -1471,7 +1482,7 @@ static void sci_controller_ready_state_enter(struct sci_base_state_machine *sm)
         struct isci_host *ihost = container_of(sm, typeof(*ihost), sm);
 
         /* set the default interrupt coalescence number and timeout value. */
-        sci_controller_set_interrupt_coalescence(ihost, 0x10, 250);
+        sci_controller_set_interrupt_coalescence(ihost, 0, 0);
 }
 
 static void sci_controller_ready_state_exit(struct sci_base_state_machine *sm)
diff --git a/drivers/scsi/isci/host.h b/drivers/scsi/isci/host.h
index 062101a39f79..9f33831a2f04 100644
--- a/drivers/scsi/isci/host.h
+++ b/drivers/scsi/isci/host.h
@@ -369,6 +369,9 @@ static inline struct isci_host *dev_to_ihost(struct domain_device *dev)
 #define ISCI_TAG_SEQ(tag) (((tag) >> 12) & (SCI_MAX_SEQ-1))
 #define ISCI_TAG_TCI(tag) ((tag) & (SCI_MAX_IO_REQUESTS-1))
 
+/* interrupt coalescing baseline: 9 == 3 to 5us interrupt delay per command */
+#define ISCI_COALESCE_BASE 9
+
 /* expander attached sata devices require 3 rnc slots */
 static inline int sci_remote_device_node_count(struct isci_remote_device *idev)
 {
diff --git a/drivers/scsi/isci/init.c b/drivers/scsi/isci/init.c
index 61e0d09e2b57..29aa34efb0f5 100644
--- a/drivers/scsi/isci/init.c
+++ b/drivers/scsi/isci/init.c
@@ -59,10 +59,19 @@
 #include <linux/firmware.h>
 #include <linux/efi.h>
 #include <asm/string.h>
+#include <scsi/scsi_host.h>
 #include "isci.h"
 #include "task.h"
 #include "probe_roms.h"
 
+#define MAJ 1
+#define MIN 0
+#define BUILD 0
+#define DRV_VERSION __stringify(MAJ) "." __stringify(MIN) "." \
+        __stringify(BUILD)
+
+MODULE_VERSION(DRV_VERSION);
+
 static struct scsi_transport_template *isci_transport_template;
 
 static DEFINE_PCI_DEVICE_TABLE(isci_id_table) = {
@@ -113,6 +122,22 @@ unsigned char max_concurr_spinup = 1;
 module_param(max_concurr_spinup, byte, 0);
 MODULE_PARM_DESC(max_concurr_spinup, "Max concurrent device spinup");
 
+static ssize_t isci_show_id(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *shost = container_of(dev, typeof(*shost), shost_dev);
+        struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
+        struct isci_host *ihost = container_of(sas_ha, typeof(*ihost), sas_ha);
+
+        return snprintf(buf, PAGE_SIZE, "%d\n", ihost->id);
+}
+
+static DEVICE_ATTR(isci_id, S_IRUGO, isci_show_id, NULL);
+
+struct device_attribute *isci_host_attrs[] = {
+        &dev_attr_isci_id,
+        NULL
+};
+
 static struct scsi_host_template isci_sht = {
 
         .module                         = THIS_MODULE,
@@ -138,6 +163,7 @@ static struct scsi_host_template isci_sht = {
         .slave_alloc                    = sas_slave_alloc,
         .target_destroy                 = sas_target_destroy,
         .ioctl                          = sas_ioctl,
+        .shost_attrs                    = isci_host_attrs,
 };
 
 static struct sas_domain_function_template isci_transport_ops  = {
@@ -232,17 +258,6 @@ static int isci_register_sas_ha(struct isci_host *isci_host)
         return 0;
 }
 
-static ssize_t isci_show_id(struct device *dev, struct device_attribute *attr, char *buf)
-{
-        struct Scsi_Host *shost = container_of(dev, typeof(*shost), shost_dev);
-        struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
-        struct isci_host *ihost = container_of(sas_ha, typeof(*ihost), sas_ha);
-
-        return snprintf(buf, PAGE_SIZE, "%d\n", ihost->id);
-}
-
-static DEVICE_ATTR(isci_id, S_IRUGO, isci_show_id, NULL);
-
 static void isci_unregister(struct isci_host *isci_host)
 {
         struct Scsi_Host *shost;
@@ -251,7 +266,6 @@ static void isci_unregister(struct isci_host *isci_host)
                 return;
 
         shost = isci_host->shost;
-        device_remove_file(&shost->shost_dev, &dev_attr_isci_id);
 
         sas_unregister_ha(&isci_host->sas_ha);
 
@@ -415,14 +429,8 @@ static struct isci_host *isci_host_alloc(struct pci_dev *pdev, int id)
         if (err)
                 goto err_shost_remove;
 
-        err = device_create_file(&shost->shost_dev, &dev_attr_isci_id);
-        if (err)
-                goto err_unregister_ha;
-
         return isci_host;
 
- err_unregister_ha:
-        sas_unregister_ha(&(isci_host->sas_ha));
  err_shost_remove:
         scsi_remove_host(shost);
  err_shost:
@@ -540,7 +548,8 @@ static __init int isci_init(void)
 {
         int err;
 
-        pr_info("%s: Intel(R) C600 SAS Controller Driver\n", DRV_NAME);
+        pr_info("%s: Intel(R) C600 SAS Controller Driver - version %s\n",
+                DRV_NAME, DRV_VERSION);
 
         isci_transport_template = sas_domain_attach_transport(&isci_transport_ops);
         if (!isci_transport_template)
diff --git a/drivers/scsi/isci/phy.c b/drivers/scsi/isci/phy.c
index 79313a7a2356..430fc8ff014a 100644
--- a/drivers/scsi/isci/phy.c
+++ b/drivers/scsi/isci/phy.c
@@ -104,6 +104,7 @@ sci_phy_link_layer_initialization(struct isci_phy *iphy,
         u32 parity_count = 0;
         u32 llctl, link_rate;
         u32 clksm_value = 0;
+        u32 sp_timeouts = 0;
 
         iphy->link_layer_registers = reg;
 
@@ -211,6 +212,18 @@ sci_phy_link_layer_initialization(struct isci_phy *iphy,
         llctl |= SCU_SAS_LLCTL_GEN_VAL(MAX_LINK_RATE, link_rate);
         writel(llctl, &iphy->link_layer_registers->link_layer_control);
 
+        sp_timeouts = readl(&iphy->link_layer_registers->sas_phy_timeouts);
+
+        /* Clear the default 0x36 (54us) RATE_CHANGE timeout value. */
+        sp_timeouts &= ~SCU_SAS_PHYTOV_GEN_VAL(RATE_CHANGE, 0xFF);
+
+        /* Set RATE_CHANGE timeout value to 0x3B (59us).  This ensures SCU can
+         * lock with 3Gb drive when SCU max rate is set to 1.5Gb.
+         */
+        sp_timeouts |= SCU_SAS_PHYTOV_GEN_VAL(RATE_CHANGE, 0x3B);
+
+        writel(sp_timeouts, &iphy->link_layer_registers->sas_phy_timeouts);
+
         if (is_a2(ihost->pdev)) {
                 /* Program the max ARB time for the PHY to 700us so we inter-operate with
                  * the PMC expander which shuts down PHYs if the expander PHY generates too
diff --git a/drivers/scsi/isci/registers.h b/drivers/scsi/isci/registers.h
index 9b266c7428e8..00afc738bbed 100644
--- a/drivers/scsi/isci/registers.h
+++ b/drivers/scsi/isci/registers.h
@@ -1299,6 +1299,18 @@ struct scu_transport_layer_registers {
 #define SCU_AFE_XCVRCR_OFFSET       0x00DC
 #define SCU_AFE_LUTCR_OFFSET        0x00E0
 
+#define SCU_SAS_PHY_TIMER_TIMEOUT_VALUES_ALIGN_DETECTION_SHIFT          (0UL)
+#define SCU_SAS_PHY_TIMER_TIMEOUT_VALUES_ALIGN_DETECTION_MASK           (0x000000FFUL)
+#define SCU_SAS_PHY_TIMER_TIMEOUT_VALUES_HOT_PLUG_SHIFT                 (8UL)
+#define SCU_SAS_PHY_TIMER_TIMEOUT_VALUES_HOT_PLUG_MASK                  (0x0000FF00UL)
+#define SCU_SAS_PHY_TIMER_TIMEOUT_VALUES_COMSAS_DETECTION_SHIFT         (16UL)
+#define SCU_SAS_PHY_TIMER_TIMEOUT_VALUES_COMSAS_DETECTION_MASK          (0x00FF0000UL)
+#define SCU_SAS_PHY_TIMER_TIMEOUT_VALUES_RATE_CHANGE_SHIFT              (24UL)
+#define SCU_SAS_PHY_TIMER_TIMEOUT_VALUES_RATE_CHANGE_MASK               (0xFF000000UL)
+
+#define SCU_SAS_PHYTOV_GEN_VAL(name, value) \
+        SCU_GEN_VALUE(SCU_SAS_PHY_TIMER_TIMEOUT_VALUES_##name, value)
+
 #define SCU_SAS_LINK_LAYER_CONTROL_MAX_LINK_RATE_SHIFT                  (0)
 #define SCU_SAS_LINK_LAYER_CONTROL_MAX_LINK_RATE_MASK                   (0x00000003)
 #define SCU_SAS_LINK_LAYER_CONTROL_MAX_LINK_RATE_GEN1                   (0)
diff --git a/drivers/scsi/isci/request.c b/drivers/scsi/isci/request.c
index a46e07ac789f..b5d3a8c4d329 100644
--- a/drivers/scsi/isci/request.c
+++ b/drivers/scsi/isci/request.c
@@ -732,12 +732,20 @@ sci_io_request_terminate(struct isci_request *ireq)
                 sci_change_state(&ireq->sm, SCI_REQ_ABORTING);
                 return SCI_SUCCESS;
         case SCI_REQ_TASK_WAIT_TC_RESP:
+                /* The task frame was already confirmed to have been
+                 * sent by the SCU HW.  Since the state machine is
+                 * now only waiting for the task response itself,
+                 * abort the request and complete it immediately
+                 * and don't wait for the task response.
+                 */
                 sci_change_state(&ireq->sm, SCI_REQ_ABORTING);
                 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
                 return SCI_SUCCESS;
         case SCI_REQ_ABORTING:
-                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
-                return SCI_SUCCESS;
+                /* If a request has a termination requested twice, return
+                 * a failure indication, since HW confirmation of the first
+                 * abort is still outstanding.
+                 */
         case SCI_REQ_COMPLETED:
         default:
                 dev_warn(&ireq->owning_controller->pdev->dev,
@@ -2399,22 +2407,19 @@ static void isci_task_save_for_upper_layer_completion(
         }
 }
 
-static void isci_request_process_stp_response(struct sas_task *task,
-                                              void *response_buffer)
+static void isci_process_stp_response(struct sas_task *task, struct dev_to_host_fis *fis)
 {
-        struct dev_to_host_fis *d2h_reg_fis = response_buffer;
         struct task_status_struct *ts = &task->task_status;
         struct ata_task_resp *resp = (void *)&ts->buf[0];
 
-        resp->frame_len = le16_to_cpu(*(__le16 *)(response_buffer + 6));
-        memcpy(&resp->ending_fis[0], response_buffer + 16, 24);
+        resp->frame_len = sizeof(*fis);
+        memcpy(resp->ending_fis, fis, sizeof(*fis));
         ts->buf_valid_size = sizeof(*resp);
 
-        /**
-         * If the device fault bit is set in the status register, then
+        /* If the device fault bit is set in the status register, then
          * set the sense data and return.
          */
-        if (d2h_reg_fis->status & ATA_DF)
+        if (fis->status & ATA_DF)
                 ts->stat = SAS_PROTO_RESPONSE;
         else
                 ts->stat = SAM_STAT_GOOD;
@@ -2428,7 +2433,6 @@ static void isci_request_io_request_complete(struct isci_host *ihost,
 {
         struct sas_task *task = isci_request_access_task(request);
         struct ssp_response_iu *resp_iu;
-        void *resp_buf;
         unsigned long task_flags;
         struct isci_remote_device *idev = isci_lookup_device(task->dev);
         enum service_response response       = SAS_TASK_UNDELIVERED;
@@ -2565,9 +2569,7 @@ static void isci_request_io_request_complete(struct isci_host *ihost,
                                 task);
 
                         if (sas_protocol_ata(task->task_proto)) {
-                                resp_buf = &request->stp.rsp;
-                                isci_request_process_stp_response(task,
-                                                                  resp_buf);
+                                isci_process_stp_response(task, &request->stp.rsp);
                         } else if (SAS_PROTOCOL_SSP == task->task_proto) {
 
                                 /* crack the iu response buffer. */
diff --git a/drivers/scsi/isci/unsolicited_frame_control.c b/drivers/scsi/isci/unsolicited_frame_control.c
index e9e1e2abacb9..16f88ab939c8 100644
--- a/drivers/scsi/isci/unsolicited_frame_control.c
+++ b/drivers/scsi/isci/unsolicited_frame_control.c
@@ -72,7 +72,7 @@ int sci_unsolicited_frame_control_construct(struct isci_host *ihost)
          */
         buf_len = SCU_MAX_UNSOLICITED_FRAMES * SCU_UNSOLICITED_FRAME_BUFFER_SIZE;
         header_len = SCU_MAX_UNSOLICITED_FRAMES * sizeof(struct scu_unsolicited_frame_header);
-        size = buf_len + header_len + SCU_MAX_UNSOLICITED_FRAMES * sizeof(dma_addr_t);
+        size = buf_len + header_len + SCU_MAX_UNSOLICITED_FRAMES * sizeof(uf_control->address_table.array[0]);
 
         /*
          * The Unsolicited Frame buffers are set at the start of the UF
diff --git a/drivers/scsi/isci/unsolicited_frame_control.h b/drivers/scsi/isci/unsolicited_frame_control.h
index 31cb9506f52d..75d896686f5a 100644
--- a/drivers/scsi/isci/unsolicited_frame_control.h
+++ b/drivers/scsi/isci/unsolicited_frame_control.h
@@ -214,7 +214,7 @@ struct sci_uf_address_table_array {
          * starting address of the UF address table.
          * 64-bit pointers are required by the hardware.
          */
-        dma_addr_t *array;
+        u64 *array;
 
         /**
          * This field specifies the physical address location for the UF
diff --git a/drivers/scsi/libfc/fc_exch.c b/drivers/scsi/libfc/fc_exch.c
index 01ff082dc34c..d261e982a2fa 100644
--- a/drivers/scsi/libfc/fc_exch.c
+++ b/drivers/scsi/libfc/fc_exch.c
@@ -494,6 +494,9 @@ static int fc_seq_send(struct fc_lport *lport, struct fc_seq *sp,
          */
         error = lport->tt.frame_send(lport, fp);
 
+        if (fh->fh_type == FC_TYPE_BLS)
+                return error;
+
         /*
          * Update the exchange and sequence flags,
          * assuming all frames for the sequence have been sent.
@@ -575,42 +578,35 @@ static void fc_seq_set_resp(struct fc_seq *sp,
 }
 
 /**
- * fc_seq_exch_abort() - Abort an exchange and sequence
- * @req_sp:     The sequence to be aborted
+ * fc_exch_abort_locked() - Abort an exchange
+ * @ep: The exchange to be aborted
  * @timer_msec: The period of time to wait before aborting
  *
- * Generally called because of a timeout or an abort from the upper layer.
+ * Locking notes:  Called with exch lock held
+ *
+ * Return value: 0 on success else error code
  */
-static int fc_seq_exch_abort(const struct fc_seq *req_sp,
-                             unsigned int timer_msec)
+static int fc_exch_abort_locked(struct fc_exch *ep,
+                                unsigned int timer_msec)
 {
         struct fc_seq *sp;
-        struct fc_exch *ep;
         struct fc_frame *fp;
         int error;
 
-        ep = fc_seq_exch(req_sp);
-
-        spin_lock_bh(&ep->ex_lock);
         if (ep->esb_stat & (ESB_ST_COMPLETE | ESB_ST_ABNORMAL) ||
-            ep->state & (FC_EX_DONE | FC_EX_RST_CLEANUP)) {
-                spin_unlock_bh(&ep->ex_lock);
+            ep->state & (FC_EX_DONE | FC_EX_RST_CLEANUP))
                 return -ENXIO;
-        }
 
         /*
          * Send the abort on a new sequence if possible.
          */
         sp = fc_seq_start_next_locked(&ep->seq);
-        if (!sp) {
-                spin_unlock_bh(&ep->ex_lock);
+        if (!sp)
                 return -ENOMEM;
-        }
 
         ep->esb_stat |= ESB_ST_SEQ_INIT | ESB_ST_ABNORMAL;
         if (timer_msec)
                 fc_exch_timer_set_locked(ep, timer_msec);
-        spin_unlock_bh(&ep->ex_lock);
 
         /*
          * If not logged into the fabric, don't send ABTS but leave
@@ -633,6 +629,28 @@ static int fc_seq_exch_abort(const struct fc_seq *req_sp,
 }
 
 /**
+ * fc_seq_exch_abort() - Abort an exchange and sequence
+ * @req_sp:     The sequence to be aborted
+ * @timer_msec: The period of time to wait before aborting
+ *
+ * Generally called because of a timeout or an abort from the upper layer.
+ *
+ * Return value: 0 on success else error code
+ */
+static int fc_seq_exch_abort(const struct fc_seq *req_sp,
+                             unsigned int timer_msec)
+{
+        struct fc_exch *ep;
+        int error;
+
+        ep = fc_seq_exch(req_sp);
+        spin_lock_bh(&ep->ex_lock);
+        error = fc_exch_abort_locked(ep, timer_msec);
+        spin_unlock_bh(&ep->ex_lock);
+        return error;
+}
+
+/**
  * fc_exch_timeout() - Handle exchange timer expiration
  * @work: The work_struct identifying the exchange that timed out
  */
@@ -1715,6 +1733,7 @@ static void fc_exch_reset(struct fc_exch *ep)
         int rc = 1;
 
         spin_lock_bh(&ep->ex_lock);
+        fc_exch_abort_locked(ep, 0);
         ep->state |= FC_EX_RST_CLEANUP;
         if (cancel_delayed_work(&ep->timeout_work))
                 atomic_dec(&ep->ex_refcnt);     /* drop hold for timer */
@@ -1962,6 +1981,7 @@ static struct fc_seq *fc_exch_seq_send(struct fc_lport *lport,
         struct fc_exch *ep;
         struct fc_seq *sp = NULL;
         struct fc_frame_header *fh;
+        struct fc_fcp_pkt *fsp = NULL;
         int rc = 1;
 
         ep = fc_exch_alloc(lport, fp);
@@ -1984,8 +2004,10 @@ static struct fc_seq *fc_exch_seq_send(struct fc_lport *lport,
         fc_exch_setup_hdr(ep, fp, ep->f_ctl);
         sp->cnt++;
 
-        if (ep->xid <= lport->lro_xid && fh->fh_r_ctl == FC_RCTL_DD_UNSOL_CMD)
+        if (ep->xid <= lport->lro_xid && fh->fh_r_ctl == FC_RCTL_DD_UNSOL_CMD) {
+                fsp = fr_fsp(fp);
                 fc_fcp_ddp_setup(fr_fsp(fp), ep->xid);
+        }
 
         if (unlikely(lport->tt.frame_send(lport, fp)))
                 goto err;
@@ -1999,7 +2021,8 @@ static struct fc_seq *fc_exch_seq_send(struct fc_lport *lport,
         spin_unlock_bh(&ep->ex_lock);
         return sp;
 err:
-        fc_fcp_ddp_done(fr_fsp(fp));
+        if (fsp)
+                fc_fcp_ddp_done(fsp);
         rc = fc_exch_done_locked(ep);
         spin_unlock_bh(&ep->ex_lock);
         if (!rc)
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index afb63c843144..4c41ee816f0b 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -2019,6 +2019,11 @@ int fc_eh_abort(struct scsi_cmnd *sc_cmd)
         struct fc_fcp_internal *si;
         int rc = FAILED;
         unsigned long flags;
+        int rval;
+
+        rval = fc_block_scsi_eh(sc_cmd);
+        if (rval)
+                return rval;
 
         lport = shost_priv(sc_cmd->device->host);
         if (lport->state != LPORT_ST_READY)
@@ -2068,9 +2073,9 @@ int fc_eh_device_reset(struct scsi_cmnd *sc_cmd)
         int rc = FAILED;
         int rval;
 
-        rval = fc_remote_port_chkready(rport);
+        rval = fc_block_scsi_eh(sc_cmd);
         if (rval)
-                goto out;
+                return rval;
 
         lport = shost_priv(sc_cmd->device->host);
 
@@ -2116,6 +2121,8 @@ int fc_eh_host_reset(struct scsi_cmnd *sc_cmd)
 
         FC_SCSI_DBG(lport, "Resetting host\n");
 
+        fc_block_scsi_eh(sc_cmd);
+
         lport->tt.lport_reset(lport);
         wait_tmo = jiffies + FC_HOST_RESET_TIMEOUT;
         while (!fc_fcp_lport_queue_ready(lport) && time_before(jiffies,
diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index e55ed9cf23fb..628f347404f9 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -88,6 +88,7 @@
  */
 
 #include <linux/timer.h>
+#include <linux/delay.h>
 #include <linux/slab.h>
 #include <asm/unaligned.h>
 
@@ -1029,8 +1030,16 @@ static void fc_lport_enter_reset(struct fc_lport *lport)
                            FCH_EVT_LIPRESET, 0);
         fc_vports_linkchange(lport);
         fc_lport_reset_locked(lport);
-        if (lport->link_up)
+        if (lport->link_up) {
+                /*
+                 * Wait upto resource allocation time out before
+                 * doing re-login since incomplete FIP exchanged
+                 * from last session may collide with exchanges
+                 * in new session.
+                 */
+                msleep(lport->r_a_tov);
                 fc_lport_enter_flogi(lport);
+        }
 }
 
 /**
diff --git a/drivers/scsi/libsas/sas_expander.c b/drivers/scsi/libsas/sas_expander.c
index f84084bba2f0..c9e3dc024bc3 100644
--- a/drivers/scsi/libsas/sas_expander.c
+++ b/drivers/scsi/libsas/sas_expander.c
@@ -1721,7 +1721,7 @@ static int sas_find_bcast_dev(struct domain_device *dev,
         list_for_each_entry(ch, &ex->children, siblings) {
                 if (ch->dev_type == EDGE_DEV || ch->dev_type == FANOUT_DEV) {
                         res = sas_find_bcast_dev(ch, src_dev);
-                        if (src_dev)
+                        if (*src_dev)
                                 return res;
                 }
         }
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index 7836eb01c7fc..a31e05f3bfd4 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -1786,13 +1786,16 @@ qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
                         fc_vport_set_state(fc_vport, FC_VPORT_LINKDOWN);
         }
 
-        if ((IS_QLA25XX(ha) || IS_QLA81XX(ha)) && ql2xenabledif) {
+        if (IS_T10_PI_CAPABLE(ha) && ql2xenabledif) {
                 if (ha->fw_attributes & BIT_4) {
+                        int prot = 0;
                         vha->flags.difdix_supported = 1;
                         ql_dbg(ql_dbg_user, vha, 0x7082,
                             "Registered for DIF/DIX type 1 and 3 protection.\n");
+                        if (ql2xenabledif == 1)
+                                prot = SHOST_DIX_TYPE0_PROTECTION;
                         scsi_host_set_prot(vha->host,
-                            SHOST_DIF_TYPE1_PROTECTION
+                            prot | SHOST_DIF_TYPE1_PROTECTION
                             | SHOST_DIF_TYPE2_PROTECTION
                             | SHOST_DIF_TYPE3_PROTECTION
                             | SHOST_DIX_TYPE1_PROTECTION
diff --git a/drivers/scsi/qla2xxx/qla_dbg.c b/drivers/scsi/qla2xxx/qla_dbg.c
index 2155071f3100..d79cd8a5f831 100644
--- a/drivers/scsi/qla2xxx/qla_dbg.c
+++ b/drivers/scsi/qla2xxx/qla_dbg.c
@@ -8,24 +8,24 @@
 /*
  * Table for showing the current message id in use for particular level
  * Change this table for addition of log/debug messages.
- * -----------------------------------------------------
- * |             Level            |   Last Value Used  |
- * -----------------------------------------------------
- * | Module Init and Probe        |       0x0116       |
- * | Mailbox commands             |       0x111e       |
- * | Device Discovery             |       0x2083       |
- * | Queue Command and IO tracing |       0x302e       |
- * | DPC Thread                   |       0x401c       |
- * | Async Events                 |       0x5059       |
- * | Timer Routines               |       0x600d       |
- * | User Space Interactions      |       0x709c       |
- * | Task Management              |       0x8043       |
- * | AER/EEH                      |       0x900f       |
- * | Virtual Port                 |       0xa007       |
- * | ISP82XX Specific             |       0xb027       |
- * | MultiQ                       |       0xc00b       |
- * | Misc                         |       0xd00b       |
- * -----------------------------------------------------
+ * ----------------------------------------------------------------------
+ * |             Level            |   Last Value Used  |     Holes      |
+ * ----------------------------------------------------------------------
+ * | Module Init and Probe        |       0x0116       |                |
+ * | Mailbox commands             |       0x1126       |                |
+ * | Device Discovery             |       0x2083       |                |
+ * | Queue Command and IO tracing |       0x302e       |     0x3008     |
+ * | DPC Thread                   |       0x401c       |                |
+ * | Async Events                 |       0x5059       |                |
+ * | Timer Routines               |       0x600d       |                |
+ * | User Space Interactions      |       0x709d       |                |
+ * | Task Management              |       0x8041       |                |
+ * | AER/EEH                      |       0x900f       |                |
+ * | Virtual Port                 |       0xa007       |                |
+ * | ISP82XX Specific             |       0xb04f       |                |
+ * | MultiQ                       |       0xc00b       |                |
+ * | Misc                         |       0xd00b       |                |
+ * ----------------------------------------------------------------------
  */
 
 #include "qla_def.h"
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index cc5a79259d33..a03eaf40f377 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -2529,6 +2529,7 @@ struct qla_hw_data {
 #define DT_ISP8021                      BIT_14
 #define DT_ISP_LAST                     (DT_ISP8021 << 1)
 
+#define DT_T10_PI                       BIT_25
 #define DT_IIDMA                        BIT_26
 #define DT_FWI2                         BIT_27
 #define DT_ZIO_SUPPORTED                BIT_28
@@ -2572,6 +2573,7 @@ struct qla_hw_data {
 #define IS_NOCACHE_VPD_TYPE(ha) (IS_QLA81XX(ha))
 #define IS_ALOGIO_CAPABLE(ha)   (IS_QLA23XX(ha) || IS_FWI2_CAPABLE(ha))
 
+#define IS_T10_PI_CAPABLE(ha)   ((ha)->device_type & DT_T10_PI)
 #define IS_IIDMA_CAPABLE(ha)    ((ha)->device_type & DT_IIDMA)
 #define IS_FWI2_CAPABLE(ha)     ((ha)->device_type & DT_FWI2)
 #define IS_ZIO_SUPPORTED(ha)    ((ha)->device_type & DT_ZIO_SUPPORTED)
diff --git a/drivers/scsi/qla2xxx/qla_fw.h b/drivers/scsi/qla2xxx/qla_fw.h
index 691783abfb69..aa69486dc064 100644
--- a/drivers/scsi/qla2xxx/qla_fw.h
+++ b/drivers/scsi/qla2xxx/qla_fw.h
@@ -537,6 +537,11 @@ struct sts_entry_24xx {
         /*
          * If DIF Error is set in comp_status, these additional fields are
          * defined:
+         *
+         * !!! NOTE: Firmware sends expected/actual DIF data in big endian
+         * format; but all of the "data" field gets swab32-d in the beginning
+         * of qla2x00_status_entry().
+         *
          * &data[10] : uint8_t report_runt_bg[2];       - computed guard
          * &data[12] : uint8_t actual_dif[8];           - DIF Data received
          * &data[20] : uint8_t expected_dif[8];         - DIF Data computed
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index def694271bf7..37da04d3db26 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -3838,15 +3838,12 @@ qla2x00_loop_resync(scsi_qla_host_t *vha)
                 req = vha->req;
         rsp = req->rsp;
 
-        atomic_set(&vha->loop_state, LOOP_UPDATE);
         clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
         if (vha->flags.online) {
                 if (!(rval = qla2x00_fw_ready(vha))) {
                         /* Wait at most MAX_TARGET RSCNs for a stable link. */
                         wait_time = 256;
                         do {
-                                atomic_set(&vha->loop_state, LOOP_UPDATE);
-
                                 /* Issue a marker after FW becomes ready. */
                                 qla2x00_marker(vha, req, rsp, 0, 0,
                                         MK_SYNC_ALL);
diff --git a/drivers/scsi/qla2xxx/qla_inline.h b/drivers/scsi/qla2xxx/qla_inline.h
index d2e904bc21c0..9902834e0b74 100644
--- a/drivers/scsi/qla2xxx/qla_inline.h
+++ b/drivers/scsi/qla2xxx/qla_inline.h
@@ -102,3 +102,32 @@ qla2x00_set_fcport_state(fc_port_t *fcport, int state)
                     fcport->d_id.b.al_pa);
         }
 }
+
+static inline int
+qla2x00_hba_err_chk_enabled(srb_t *sp)
+{
+        /*
+         * Uncomment when corresponding SCSI changes are done.
+         *
+        if (!sp->cmd->prot_chk)
+                return 0;
+         *
+         */
+
+        switch (scsi_get_prot_op(sp->cmd)) {
+        case SCSI_PROT_READ_STRIP:
+        case SCSI_PROT_WRITE_INSERT:
+                if (ql2xenablehba_err_chk >= 1)
+                        return 1;
+                break;
+        case SCSI_PROT_READ_PASS:
+        case SCSI_PROT_WRITE_PASS:
+                if (ql2xenablehba_err_chk >= 2)
+                        return 1;
+                break;
+        case SCSI_PROT_READ_INSERT:
+        case SCSI_PROT_WRITE_STRIP:
+                return 1;
+        }
+        return 0;
+}
diff --git a/drivers/scsi/qla2xxx/qla_iocb.c b/drivers/scsi/qla2xxx/qla_iocb.c
index 49d6906af886..dbec89622a0f 100644
--- a/drivers/scsi/qla2xxx/qla_iocb.c
+++ b/drivers/scsi/qla2xxx/qla_iocb.c
@@ -709,20 +709,28 @@ struct fw_dif_context {
  *
  */
 static inline void
-qla24xx_set_t10dif_tags(struct scsi_cmnd *cmd, struct fw_dif_context *pkt,
+qla24xx_set_t10dif_tags(srb_t *sp, struct fw_dif_context *pkt,
     unsigned int protcnt)
 {
-        struct sd_dif_tuple *spt;
+        struct scsi_cmnd *cmd = sp->cmd;
         scsi_qla_host_t *vha = shost_priv(cmd->device->host);
-        unsigned char op = scsi_get_prot_op(cmd);
 
         switch (scsi_get_prot_type(cmd)) {
-        /* For TYPE 0 protection: no checking */
         case SCSI_PROT_DIF_TYPE0:
-                pkt->ref_tag_mask[0] = 0x00;
-                pkt->ref_tag_mask[1] = 0x00;
-                pkt->ref_tag_mask[2] = 0x00;
-                pkt->ref_tag_mask[3] = 0x00;
+                /*
+                 * No check for ql2xenablehba_err_chk, as it would be an
+                 * I/O error if hba tag generation is not done.
+                 */
+                pkt->ref_tag = cpu_to_le32((uint32_t)
+                    (0xffffffff & scsi_get_lba(cmd)));
+
+                if (!qla2x00_hba_err_chk_enabled(sp))
+                        break;
+
+                pkt->ref_tag_mask[0] = 0xff;
+                pkt->ref_tag_mask[1] = 0xff;
+                pkt->ref_tag_mask[2] = 0xff;
+                pkt->ref_tag_mask[3] = 0xff;
                 break;
 
         /*
@@ -730,20 +738,16 @@ qla24xx_set_t10dif_tags(struct scsi_cmnd *cmd, struct fw_dif_context *pkt,
          * match LBA in CDB + N
          */
         case SCSI_PROT_DIF_TYPE2:
-                if (!ql2xenablehba_err_chk)
-                        break;
-
-                if (scsi_prot_sg_count(cmd)) {
-                        spt = page_address(sg_page(scsi_prot_sglist(cmd))) +
-                            scsi_prot_sglist(cmd)[0].offset;
-                        pkt->app_tag = swab32(spt->app_tag);
-                        pkt->app_tag_mask[0] =  0xff;
-                        pkt->app_tag_mask[1] =  0xff;
-                }
+                pkt->app_tag = __constant_cpu_to_le16(0);
+                pkt->app_tag_mask[0] = 0x0;
+                pkt->app_tag_mask[1] = 0x0;
 
                 pkt->ref_tag = cpu_to_le32((uint32_t)
                     (0xffffffff & scsi_get_lba(cmd)));
 
+                if (!qla2x00_hba_err_chk_enabled(sp))
+                        break;
+
                 /* enable ALL bytes of the ref tag */
                 pkt->ref_tag_mask[0] = 0xff;
                 pkt->ref_tag_mask[1] = 0xff;
@@ -763,26 +767,15 @@ qla24xx_set_t10dif_tags(struct scsi_cmnd *cmd, struct fw_dif_context *pkt,
          * 16 bit app tag.
          */
         case SCSI_PROT_DIF_TYPE1:
-                if (!ql2xenablehba_err_chk)
+                pkt->ref_tag = cpu_to_le32((uint32_t)
+                    (0xffffffff & scsi_get_lba(cmd)));
+                pkt->app_tag = __constant_cpu_to_le16(0);
+                pkt->app_tag_mask[0] = 0x0;
+                pkt->app_tag_mask[1] = 0x0;
+
+                if (!qla2x00_hba_err_chk_enabled(sp))
                         break;
 
-                if (protcnt && (op == SCSI_PROT_WRITE_STRIP ||
-                    op == SCSI_PROT_WRITE_PASS)) {
-                        spt = page_address(sg_page(scsi_prot_sglist(cmd))) +
-                            scsi_prot_sglist(cmd)[0].offset;
-                        ql_dbg(ql_dbg_io, vha, 0x3008,
-                            "LBA from user %p, lba = 0x%x for cmd=%p.\n",
-                            spt, (int)spt->ref_tag, cmd);
-                        pkt->ref_tag = swab32(spt->ref_tag);
-                        pkt->app_tag_mask[0] = 0x0;
-                        pkt->app_tag_mask[1] = 0x0;
-                } else {
-                        pkt->ref_tag = cpu_to_le32((uint32_t)
-                            (0xffffffff & scsi_get_lba(cmd)));
-                        pkt->app_tag = __constant_cpu_to_le16(0);
-                        pkt->app_tag_mask[0] = 0x0;
-                        pkt->app_tag_mask[1] = 0x0;
-                }
                 /* enable ALL bytes of the ref tag */
                 pkt->ref_tag_mask[0] = 0xff;
                 pkt->ref_tag_mask[1] = 0xff;
@@ -798,8 +791,162 @@ qla24xx_set_t10dif_tags(struct scsi_cmnd *cmd, struct fw_dif_context *pkt,
             scsi_get_prot_type(cmd), cmd);
 }
 
+struct qla2_sgx {
+        dma_addr_t              dma_addr;       /* OUT */
+        uint32_t                dma_len;        /* OUT */
+
+        uint32_t                tot_bytes;      /* IN */
+        struct scatterlist      *cur_sg;        /* IN */
+
+        /* for book keeping, bzero on initial invocation */
+        uint32_t                bytes_consumed;
+        uint32_t                num_bytes;
+        uint32_t                tot_partial;
+
+        /* for debugging */
+        uint32_t                num_sg;
+        srb_t                   *sp;
+};
 
 static int
+qla24xx_get_one_block_sg(uint32_t blk_sz, struct qla2_sgx *sgx,
+        uint32_t *partial)
+{
+        struct scatterlist *sg;
+        uint32_t cumulative_partial, sg_len;
+        dma_addr_t sg_dma_addr;
+
+        if (sgx->num_bytes == sgx->tot_bytes)
+                return 0;
+
+        sg = sgx->cur_sg;
+        cumulative_partial = sgx->tot_partial;
+
+        sg_dma_addr = sg_dma_address(sg);
+        sg_len = sg_dma_len(sg);
+
+        sgx->dma_addr = sg_dma_addr + sgx->bytes_consumed;
+
+        if ((cumulative_partial + (sg_len - sgx->bytes_consumed)) >= blk_sz) {
+                sgx->dma_len = (blk_sz - cumulative_partial);
+                sgx->tot_partial = 0;
+                sgx->num_bytes += blk_sz;
+                *partial = 0;
+        } else {
+                sgx->dma_len = sg_len - sgx->bytes_consumed;
+                sgx->tot_partial += sgx->dma_len;
+                *partial = 1;
+        }
+
+        sgx->bytes_consumed += sgx->dma_len;
+
+        if (sg_len == sgx->bytes_consumed) {
+                sg = sg_next(sg);
+                sgx->num_sg++;
+                sgx->cur_sg = sg;
+                sgx->bytes_consumed = 0;
+        }
+
+        return 1;
+}
+
+static int
+qla24xx_walk_and_build_sglist_no_difb(struct qla_hw_data *ha, srb_t *sp,
+        uint32_t *dsd, uint16_t tot_dsds)
+{
+        void *next_dsd;
+        uint8_t avail_dsds = 0;
+        uint32_t dsd_list_len;
+        struct dsd_dma *dsd_ptr;
+        struct scatterlist *sg_prot;
+        uint32_t *cur_dsd = dsd;
+        uint16_t        used_dsds = tot_dsds;
+
+        uint32_t        prot_int;
+        uint32_t        partial;
+        struct qla2_sgx sgx;
+        dma_addr_t      sle_dma;
+        uint32_t        sle_dma_len, tot_prot_dma_len = 0;
+        struct scsi_cmnd *cmd = sp->cmd;
+
+        prot_int = cmd->device->sector_size;
+
+        memset(&sgx, 0, sizeof(struct qla2_sgx));
+        sgx.tot_bytes = scsi_bufflen(sp->cmd);
+        sgx.cur_sg = scsi_sglist(sp->cmd);
+        sgx.sp = sp;
+
+        sg_prot = scsi_prot_sglist(sp->cmd);
+
+        while (qla24xx_get_one_block_sg(prot_int, &sgx, &partial)) {
+
+                sle_dma = sgx.dma_addr;
+                sle_dma_len = sgx.dma_len;
+alloc_and_fill:
+                /* Allocate additional continuation packets? */
+                if (avail_dsds == 0) {
+                        avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ?
+                                        QLA_DSDS_PER_IOCB : used_dsds;
+                        dsd_list_len = (avail_dsds + 1) * 12;
+                        used_dsds -= avail_dsds;
+
+                        /* allocate tracking DS */
+                        dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC);
+                        if (!dsd_ptr)
+                                return 1;
+
+                        /* allocate new list */
+                        dsd_ptr->dsd_addr = next_dsd =
+                            dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC,
+                                &dsd_ptr->dsd_list_dma);
+
+                        if (!next_dsd) {
+                                /*
+                                 * Need to cleanup only this dsd_ptr, rest
+                                 * will be done by sp_free_dma()
+                                 */
+                                kfree(dsd_ptr);
+                                return 1;
+                        }
+
+                        list_add_tail(&dsd_ptr->list,
+                            &((struct crc_context *)sp->ctx)->dsd_list);
+
+                        sp->flags |= SRB_CRC_CTX_DSD_VALID;
+
+                        /* add new list to cmd iocb or last list */
+                        *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma));
+                        *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma));
+                        *cur_dsd++ = dsd_list_len;
+                        cur_dsd = (uint32_t *)next_dsd;
+                }
+                *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
+                *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
+                *cur_dsd++ = cpu_to_le32(sle_dma_len);
+                avail_dsds--;
+
+                if (partial == 0) {
+                        /* Got a full protection interval */
+                        sle_dma = sg_dma_address(sg_prot) + tot_prot_dma_len;
+                        sle_dma_len = 8;
+
+                        tot_prot_dma_len += sle_dma_len;
+                        if (tot_prot_dma_len == sg_dma_len(sg_prot)) {
+                                tot_prot_dma_len = 0;
+                                sg_prot = sg_next(sg_prot);
+                        }
+
+                        partial = 1; /* So as to not re-enter this block */
+                        goto alloc_and_fill;
+                }
+        }
+        /* Null termination */
+        *cur_dsd++ = 0;
+        *cur_dsd++ = 0;
+        *cur_dsd++ = 0;
+        return 0;
+}
+static int
 qla24xx_walk_and_build_sglist(struct qla_hw_data *ha, srb_t *sp, uint32_t *dsd,
         uint16_t tot_dsds)
 {
@@ -981,7 +1128,7 @@ qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
         struct scsi_cmnd        *cmd;
         struct scatterlist      *cur_seg;
         int                     sgc;
-        uint32_t                total_bytes;
+        uint32_t                total_bytes = 0;
         uint32_t                data_bytes;
         uint32_t                dif_bytes;
         uint8_t                 bundling = 1;
@@ -1023,8 +1170,10 @@ qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
                     __constant_cpu_to_le16(CF_READ_DATA);
         }
 
-        tot_prot_dsds = scsi_prot_sg_count(cmd);
-        if (!tot_prot_dsds)
+        if ((scsi_get_prot_op(sp->cmd) == SCSI_PROT_READ_INSERT) ||
+            (scsi_get_prot_op(sp->cmd) == SCSI_PROT_WRITE_STRIP) ||
+            (scsi_get_prot_op(sp->cmd) == SCSI_PROT_READ_STRIP) ||
+            (scsi_get_prot_op(sp->cmd) == SCSI_PROT_WRITE_INSERT))
                 bundling = 0;
 
         /* Allocate CRC context from global pool */
@@ -1047,7 +1196,7 @@ qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
 
         INIT_LIST_HEAD(&crc_ctx_pkt->dsd_list);
 
-        qla24xx_set_t10dif_tags(cmd, (struct fw_dif_context *)
+        qla24xx_set_t10dif_tags(sp, (struct fw_dif_context *)
             &crc_ctx_pkt->ref_tag, tot_prot_dsds);
 
         cmd_pkt->crc_context_address[0] = cpu_to_le32(LSD(crc_ctx_dma));
@@ -1076,7 +1225,6 @@ qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
                 fcp_cmnd->additional_cdb_len |= 2;
 
         int_to_scsilun(sp->cmd->device->lun, &fcp_cmnd->lun);
-        host_to_fcp_swap((uint8_t *)&fcp_cmnd->lun, sizeof(fcp_cmnd->lun));
         memcpy(fcp_cmnd->cdb, cmd->cmnd, cmd->cmd_len);
         cmd_pkt->fcp_cmnd_dseg_len = cpu_to_le16(fcp_cmnd_len);
         cmd_pkt->fcp_cmnd_dseg_address[0] = cpu_to_le32(
@@ -1107,15 +1255,28 @@ qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
         cmd_pkt->fcp_rsp_dseg_len = 0; /* Let response come in status iocb */
 
         /* Compute dif len and adjust data len to incude protection */
-        total_bytes = data_bytes;
         dif_bytes = 0;
         blk_size = cmd->device->sector_size;
-        if (scsi_get_prot_op(cmd) != SCSI_PROT_NORMAL) {
-                dif_bytes = (data_bytes / blk_size) * 8;
-                total_bytes += dif_bytes;
+        dif_bytes = (data_bytes / blk_size) * 8;
+
+        switch (scsi_get_prot_op(sp->cmd)) {
+        case SCSI_PROT_READ_INSERT:
+        case SCSI_PROT_WRITE_STRIP:
+            total_bytes = data_bytes;
+            data_bytes += dif_bytes;
+            break;
+
+        case SCSI_PROT_READ_STRIP:
+        case SCSI_PROT_WRITE_INSERT:
+        case SCSI_PROT_READ_PASS:
+        case SCSI_PROT_WRITE_PASS:
+            total_bytes = data_bytes + dif_bytes;
+            break;
+        default:
+            BUG();
         }
 
-        if (!ql2xenablehba_err_chk)
+        if (!qla2x00_hba_err_chk_enabled(sp))
                 fw_prot_opts |= 0x10; /* Disable Guard tag checking */
 
         if (!bundling) {
@@ -1151,7 +1312,12 @@ qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
 
         cmd_pkt->control_flags |=
             __constant_cpu_to_le16(CF_DATA_SEG_DESCR_ENABLE);
-        if (qla24xx_walk_and_build_sglist(ha, sp, cur_dsd,
+
+        if (!bundling && tot_prot_dsds) {
+                if (qla24xx_walk_and_build_sglist_no_difb(ha, sp,
+                    cur_dsd, tot_dsds))
+                        goto crc_queuing_error;
+        } else if (qla24xx_walk_and_build_sglist(ha, sp, cur_dsd,
             (tot_dsds - tot_prot_dsds)))
                 goto crc_queuing_error;
 
@@ -1414,6 +1580,22 @@ qla24xx_dif_start_scsi(srb_t *sp)
                         goto queuing_error;
                 else
                         sp->flags |= SRB_DMA_VALID;
+
+                if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) ||
+                    (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) {
+                        struct qla2_sgx sgx;
+                        uint32_t        partial;
+
+                        memset(&sgx, 0, sizeof(struct qla2_sgx));
+                        sgx.tot_bytes = scsi_bufflen(cmd);
+                        sgx.cur_sg = scsi_sglist(cmd);
+                        sgx.sp = sp;
+
+                        nseg = 0;
+                        while (qla24xx_get_one_block_sg(
+                            cmd->device->sector_size, &sgx, &partial))
+                                nseg++;
+                }
         } else
                 nseg = 0;
 
@@ -1428,6 +1610,11 @@ qla24xx_dif_start_scsi(srb_t *sp)
                         goto queuing_error;
                 else
                         sp->flags |= SRB_CRC_PROT_DMA_VALID;
+
+                if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) ||
+                    (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) {
+                        nseg = scsi_bufflen(cmd) / cmd->device->sector_size;
+                }
         } else {
                 nseg = 0;
         }
@@ -1454,6 +1641,7 @@ qla24xx_dif_start_scsi(srb_t *sp)
         /* Build header part of command packet (excluding the OPCODE). */
         req->current_outstanding_cmd = handle;
         req->outstanding_cmds[handle] = sp;
+        sp->handle = handle;
         sp->cmd->host_scribble = (unsigned char *)(unsigned long)handle;
         req->cnt -= req_cnt;
 
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index b16b7725dee0..8a7591f035e6 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -719,7 +719,6 @@ skip_rio:
                         vha->flags.rscn_queue_overflow = 1;
                 }
 
-                atomic_set(&vha->loop_state, LOOP_UPDATE);
                 atomic_set(&vha->loop_down_timer, 0);
                 vha->flags.management_server_logged_in = 0;
 
@@ -1435,25 +1434,27 @@ struct scsi_dif_tuple {
  * ASC/ASCQ fields in the sense buffer with ILLEGAL_REQUEST
  * to indicate to the kernel that the HBA detected error.
  */
-static inline void
+static inline int
 qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
 {
         struct scsi_qla_host *vha = sp->fcport->vha;
         struct scsi_cmnd *cmd = sp->cmd;
-        struct scsi_dif_tuple   *ep =
-                        (struct scsi_dif_tuple *)&sts24->data[20];
-        struct scsi_dif_tuple   *ap =
-                        (struct scsi_dif_tuple *)&sts24->data[12];
+        uint8_t         *ap = &sts24->data[12];
+        uint8_t         *ep = &sts24->data[20];
         uint32_t        e_ref_tag, a_ref_tag;
         uint16_t        e_app_tag, a_app_tag;
         uint16_t        e_guard, a_guard;
 
-        e_ref_tag = be32_to_cpu(ep->ref_tag);
-        a_ref_tag = be32_to_cpu(ap->ref_tag);
-        e_app_tag = be16_to_cpu(ep->app_tag);
-        a_app_tag = be16_to_cpu(ap->app_tag);
-        e_guard = be16_to_cpu(ep->guard);
-        a_guard = be16_to_cpu(ap->guard);
+        /*
+         * swab32 of the "data" field in the beginning of qla2x00_status_entry()
+         * would make guard field appear at offset 2
+         */
+        a_guard   = le16_to_cpu(*(uint16_t *)(ap + 2));
+        a_app_tag = le16_to_cpu(*(uint16_t *)(ap + 0));
+        a_ref_tag = le32_to_cpu(*(uint32_t *)(ap + 4));
+        e_guard   = le16_to_cpu(*(uint16_t *)(ep + 2));
+        e_app_tag = le16_to_cpu(*(uint16_t *)(ep + 0));
+        e_ref_tag = le32_to_cpu(*(uint32_t *)(ep + 4));
 
         ql_dbg(ql_dbg_io, vha, 0x3023,
             "iocb(s) %p Returned STATUS.\n", sts24);
@@ -1465,6 +1466,63 @@ qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
             cmd->cmnd[0], (u64)scsi_get_lba(cmd), a_ref_tag, e_ref_tag,
             a_app_tag, e_app_tag, a_guard, e_guard);
 
+        /*
+         * Ignore sector if:
+         * For type     3: ref & app tag is all 'f's
+         * For type 0,1,2: app tag is all 'f's
+         */
+        if ((a_app_tag == 0xffff) &&
+            ((scsi_get_prot_type(cmd) != SCSI_PROT_DIF_TYPE3) ||
+             (a_ref_tag == 0xffffffff))) {
+                uint32_t blocks_done, resid;
+                sector_t lba_s = scsi_get_lba(cmd);
+
+                /* 2TB boundary case covered automatically with this */
+                blocks_done = e_ref_tag - (uint32_t)lba_s + 1;
+
+                resid = scsi_bufflen(cmd) - (blocks_done *
+                    cmd->device->sector_size);
+
+                scsi_set_resid(cmd, resid);
+                cmd->result = DID_OK << 16;
+
+                /* Update protection tag */
+                if (scsi_prot_sg_count(cmd)) {
+                        uint32_t i, j = 0, k = 0, num_ent;
+                        struct scatterlist *sg;
+                        struct sd_dif_tuple *spt;
+
+                        /* Patch the corresponding protection tags */
+                        scsi_for_each_prot_sg(cmd, sg,
+                            scsi_prot_sg_count(cmd), i) {
+                                num_ent = sg_dma_len(sg) / 8;
+                                if (k + num_ent < blocks_done) {
+                                        k += num_ent;
+                                        continue;
+                                }
+                                j = blocks_done - k - 1;
+                                k = blocks_done;
+                                break;
+                        }
+
+                        if (k != blocks_done) {
+                                qla_printk(KERN_WARNING, sp->fcport->vha->hw,
+                                    "unexpected tag values tag:lba=%x:%llx)\n",
+                                    e_ref_tag, (unsigned long long)lba_s);
+                                return 1;
+                        }
+
+                        spt = page_address(sg_page(sg)) + sg->offset;
+                        spt += j;
+
+                        spt->app_tag = 0xffff;
+                        if (scsi_get_prot_type(cmd) == SCSI_PROT_DIF_TYPE3)
+                                spt->ref_tag = 0xffffffff;
+                }
+
+                return 0;
+        }
+
         /* check guard */
         if (e_guard != a_guard) {
                 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
@@ -1472,28 +1530,30 @@ qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
                 set_driver_byte(cmd, DRIVER_SENSE);
                 set_host_byte(cmd, DID_ABORT);
                 cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
-                return;
+                return 1;
         }
 
-        /* check appl tag */
-        if (e_app_tag != a_app_tag) {
+        /* check ref tag */
+        if (e_ref_tag != a_ref_tag) {
                 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
-                    0x10, 0x2);
+                    0x10, 0x3);
                 set_driver_byte(cmd, DRIVER_SENSE);
                 set_host_byte(cmd, DID_ABORT);
                 cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
-                return;
+                return 1;
         }
 
-        /* check ref tag */
-        if (e_ref_tag != a_ref_tag) {
+        /* check appl tag */
+        if (e_app_tag != a_app_tag) {
                 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
-                    0x10, 0x3);
+                    0x10, 0x2);
                 set_driver_byte(cmd, DRIVER_SENSE);
                 set_host_byte(cmd, DID_ABORT);
                 cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
-                return;
+                return 1;
         }
+
+        return 1;
 }
 
 /**
@@ -1767,7 +1827,7 @@ check_scsi_status:
                 break;
 
         case CS_DIF_ERROR:
-                qla2x00_handle_dif_error(sp, sts24);
+                logit = qla2x00_handle_dif_error(sp, sts24);
                 break;
         default:
                 cp->result = DID_ERROR << 16;
@@ -2468,11 +2528,10 @@ qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
                 goto skip_msi;
         }
 
-        if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX ||
-                !QLA_MSIX_FW_MODE_1(ha->fw_attributes))) {
+        if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX)) {
                 ql_log(ql_log_warn, vha, 0x0035,
                     "MSI-X; Unsupported ISP2432 (0x%X, 0x%X).\n",
-                    ha->pdev->revision, ha->fw_attributes);
+                    ha->pdev->revision, QLA_MSIX_CHIP_REV_24XX);
                 goto skip_msix;
         }
 
diff --git a/drivers/scsi/qla2xxx/qla_mid.c b/drivers/scsi/qla2xxx/qla_mid.c
index c706ed370000..f488cc69fc79 100644
--- a/drivers/scsi/qla2xxx/qla_mid.c
+++ b/drivers/scsi/qla2xxx/qla_mid.c
@@ -472,7 +472,7 @@ qla24xx_create_vhost(struct fc_vport *fc_vport)
         host->can_queue = base_vha->req->length + 128;
         host->this_id = 255;
         host->cmd_per_lun = 3;
-        if ((IS_QLA25XX(ha) || IS_QLA81XX(ha)) && ql2xenabledif)
+        if (IS_T10_PI_CAPABLE(ha) && ql2xenabledif)
                 host->max_cmd_len = 32;
         else
                 host->max_cmd_len = MAX_CMDSZ;
diff --git a/drivers/scsi/qla2xxx/qla_nx.c b/drivers/scsi/qla2xxx/qla_nx.c
index 5cbf33a50b14..049807cda419 100644
--- a/drivers/scsi/qla2xxx/qla_nx.c
+++ b/drivers/scsi/qla2xxx/qla_nx.c
@@ -2208,6 +2208,7 @@ qla82xx_msix_rsp_q(int irq, void *dev_id)
         struct qla_hw_data *ha;
         struct rsp_que *rsp;
         struct device_reg_82xx __iomem *reg;
+        unsigned long flags;
 
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
@@ -2218,11 +2219,11 @@ qla82xx_msix_rsp_q(int irq, void *dev_id)
 
         ha = rsp->hw;
         reg = &ha->iobase->isp82;
-        spin_lock_irq(&ha->hardware_lock);
+        spin_lock_irqsave(&ha->hardware_lock, flags);
         vha = pci_get_drvdata(ha->pdev);
         qla24xx_process_response_queue(vha, rsp);
         WRT_REG_DWORD(&reg->host_int, 0);
-        spin_unlock_irq(&ha->hardware_lock);
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
         return IRQ_HANDLED;
 }
 
@@ -2838,6 +2839,16 @@ sufficient_dsds:
                 int_to_scsilun(sp->cmd->device->lun, &cmd_pkt->lun);
                 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
 
+                /* build FCP_CMND IU */
+                memset(ctx->fcp_cmnd, 0, sizeof(struct fcp_cmnd));
+                int_to_scsilun(sp->cmd->device->lun, &ctx->fcp_cmnd->lun);
+                ctx->fcp_cmnd->additional_cdb_len = additional_cdb_len;
+
+                if (cmd->sc_data_direction == DMA_TO_DEVICE)
+                        ctx->fcp_cmnd->additional_cdb_len |= 1;
+                else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
+                        ctx->fcp_cmnd->additional_cdb_len |= 2;
+
                 /*
                  * Update tagged queuing modifier -- default is TSK_SIMPLE (0).
                  */
@@ -2854,16 +2865,6 @@ sufficient_dsds:
                         }
                 }
 
-                /* build FCP_CMND IU */
-                memset(ctx->fcp_cmnd, 0, sizeof(struct fcp_cmnd));
-                int_to_scsilun(sp->cmd->device->lun, &ctx->fcp_cmnd->lun);
-                ctx->fcp_cmnd->additional_cdb_len = additional_cdb_len;
-
-                if (cmd->sc_data_direction == DMA_TO_DEVICE)
-                        ctx->fcp_cmnd->additional_cdb_len |= 1;
-                else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
-                        ctx->fcp_cmnd->additional_cdb_len |= 2;
-
                 memcpy(ctx->fcp_cmnd->cdb, cmd->cmnd, cmd->cmd_len);
 
                 fcp_dl = (uint32_t *)(ctx->fcp_cmnd->cdb + 16 +
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index e02df276804e..4cace3f20c04 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -106,17 +106,21 @@ MODULE_PARM_DESC(ql2xmaxqdepth,
                 "Maximum queue depth to report for target devices.");
 
 /* Do not change the value of this after module load */
-int ql2xenabledif = 1;
+int ql2xenabledif = 0;
 module_param(ql2xenabledif, int, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(ql2xenabledif,
                 " Enable T10-CRC-DIF "
-                " Default is 0 - No DIF Support. 1 - Enable it");
+                " Default is 0 - No DIF Support. 1 - Enable it"
+                ", 2 - Enable DIF for all types, except Type 0.");
 
-int ql2xenablehba_err_chk;
+int ql2xenablehba_err_chk = 2;
 module_param(ql2xenablehba_err_chk, int, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(ql2xenablehba_err_chk,
-                " Enable T10-CRC-DIF Error isolation by HBA"
-                " Default is 0 - Error isolation disabled, 1 - Enable it");
+                " Enable T10-CRC-DIF Error isolation by HBA:\n"
+                " Default is 1.\n"
+                "  0 -- Error isolation disabled\n"
+                "  1 -- Error isolation enabled only for DIX Type 0\n"
+                "  2 -- Error isolation enabled for all Types\n");
 
 int ql2xiidmaenable=1;
 module_param(ql2xiidmaenable, int, S_IRUGO);
@@ -909,7 +913,14 @@ qla2xxx_eh_abort(struct scsi_cmnd *cmd)
                     "Abort command mbx success.\n");
                 wait = 1;
         }
+
+        spin_lock_irqsave(&ha->hardware_lock, flags);
         qla2x00_sp_compl(ha, sp);
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
+
+        /* Did the command return during mailbox execution? */
+        if (ret == FAILED && !CMD_SP(cmd))
+                ret = SUCCESS;
 
         /* Wait for the command to be returned. */
         if (wait) {
@@ -2251,7 +2262,7 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         host->this_id = 255;
         host->cmd_per_lun = 3;
         host->unique_id = host->host_no;
-        if ((IS_QLA25XX(ha) || IS_QLA81XX(ha)) && ql2xenabledif)
+        if (IS_T10_PI_CAPABLE(ha) && ql2xenabledif)
                 host->max_cmd_len = 32;
         else
                 host->max_cmd_len = MAX_CMDSZ;
@@ -2378,13 +2389,16 @@ skip_dpc:
             "Detected hba at address=%p.\n",
             ha);
 
-        if ((IS_QLA25XX(ha) || IS_QLA81XX(ha)) && ql2xenabledif) {
+        if (IS_T10_PI_CAPABLE(ha) && ql2xenabledif) {
                 if (ha->fw_attributes & BIT_4) {
+                        int prot = 0;
                         base_vha->flags.difdix_supported = 1;
                         ql_dbg(ql_dbg_init, base_vha, 0x00f1,
                             "Registering for DIF/DIX type 1 and 3 protection.\n");
+                        if (ql2xenabledif == 1)
+                                prot = SHOST_DIX_TYPE0_PROTECTION;
                         scsi_host_set_prot(host,
-                            SHOST_DIF_TYPE1_PROTECTION
+                            prot | SHOST_DIF_TYPE1_PROTECTION
                             | SHOST_DIF_TYPE2_PROTECTION
                             | SHOST_DIF_TYPE3_PROTECTION
                             | SHOST_DIX_TYPE1_PROTECTION
diff --git a/drivers/scsi/qla2xxx/qla_version.h b/drivers/scsi/qla2xxx/qla_version.h
index 062c97bf62f5..13b6357c1fa2 100644
--- a/drivers/scsi/qla2xxx/qla_version.h
+++ b/drivers/scsi/qla2xxx/qla_version.h
@@ -7,7 +7,7 @@
 /*
  * Driver version
  */
-#define QLA2XXX_VERSION      "8.03.07.03-k"
+#define QLA2XXX_VERSION      "8.03.07.07-k"
 
 #define QLA_DRIVER_MAJOR_VER    8
 #define QLA_DRIVER_MINOR_VER    3
diff --git a/drivers/scsi/qla4xxx/Kconfig b/drivers/scsi/qla4xxx/Kconfig
index 2c33ce6eac1e..0f5599e0abf6 100644
--- a/drivers/scsi/qla4xxx/Kconfig
+++ b/drivers/scsi/qla4xxx/Kconfig
@@ -1,6 +1,6 @@
 config SCSI_QLA_ISCSI
         tristate "QLogic ISP4XXX and ISP82XX host adapter family support"
-        depends on PCI && SCSI
+        depends on PCI && SCSI && NET
         select SCSI_ISCSI_ATTRS
         ---help---
         This driver supports the QLogic 40xx (ISP4XXX) and 8022 (ISP82XX)
diff --git a/drivers/sh/intc/chip.c b/drivers/sh/intc/chip.c
index f33e2dd97934..33b2ed451e09 100644
--- a/drivers/sh/intc/chip.c
+++ b/drivers/sh/intc/chip.c
@@ -186,6 +186,9 @@ static unsigned char intc_irq_sense_table[IRQ_TYPE_SENSE_MASK + 1] = {
     !defined(CONFIG_CPU_SUBTYPE_SH7709)
         [IRQ_TYPE_LEVEL_HIGH] = VALID(3),
 #endif
+#if defined(CONFIG_ARCH_SH7372)
+        [IRQ_TYPE_EDGE_BOTH] = VALID(4),
+#endif
 };
 
 static int intc_set_type(struct irq_data *data, unsigned int type)
diff --git a/drivers/spi/spi-atmel.c b/drivers/spi/spi-atmel.c
index 82dee9a6c0de..d3bff424286f 100644
--- a/drivers/spi/spi-atmel.c
+++ b/drivers/spi/spi-atmel.c
@@ -22,7 +22,7 @@
 
 #include <asm/io.h>
 #include <mach/board.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include <mach/cpu.h>
 
 /* SPI register offsets */
diff --git a/drivers/spi/spi-fsl-spi.c b/drivers/spi/spi-fsl-spi.c
index d2407558773f..24cacff57786 100644
--- a/drivers/spi/spi-fsl-spi.c
+++ b/drivers/spi/spi-fsl-spi.c
@@ -825,6 +825,9 @@ static void fsl_spi_cpm_free(struct mpc8xxx_spi *mspi)
 {
         struct device *dev = mspi->dev;
 
+        if (!(mspi->flags & SPI_CPM_MODE))
+                return;
+
         dma_unmap_single(dev, mspi->dma_dummy_rx, SPI_MRBLR, DMA_FROM_DEVICE);
         dma_unmap_single(dev, mspi->dma_dummy_tx, PAGE_SIZE, DMA_TO_DEVICE);
         cpm_muram_free(cpm_muram_offset(mspi->tx_bd));
diff --git a/drivers/spi/spi-imx.c b/drivers/spi/spi-imx.c
index 8ac6542aedcd..fa594d604aca 100644
--- a/drivers/spi/spi-imx.c
+++ b/drivers/spi/spi-imx.c
@@ -786,9 +786,11 @@ static int __devinit spi_imx_probe(struct platform_device *pdev)
                 int cs_gpio = of_get_named_gpio(np, "cs-gpios", i);
                 if (cs_gpio < 0)
                         cs_gpio = mxc_platform_info->chipselect[i];
+
+                spi_imx->chipselect[i] = cs_gpio;
                 if (cs_gpio < 0)
                         continue;
-                spi_imx->chipselect[i] = cs_gpio;
+
                 ret = gpio_request(spi_imx->chipselect[i], DRIVER_NAME);
                 if (ret) {
                         while (i > 0) {
diff --git a/drivers/spi/spi-topcliff-pch.c b/drivers/spi/spi-topcliff-pch.c
index 1d23f3831866..6a80749391db 100644
--- a/drivers/spi/spi-topcliff-pch.c
+++ b/drivers/spi/spi-topcliff-pch.c
@@ -50,6 +50,8 @@
 #define PCH_RX_THOLD            7
 #define PCH_RX_THOLD_MAX        15
 
+#define PCH_TX_THOLD            2
+
 #define PCH_MAX_BAUDRATE        5000000
 #define PCH_MAX_FIFO_DEPTH      16
 
@@ -58,6 +60,7 @@
 #define PCH_SLEEP_TIME          10
 
 #define SSN_LOW                 0x02U
+#define SSN_HIGH                0x03U
 #define SSN_NO_CONTROL          0x00U
 #define PCH_MAX_CS              0xFF
 #define PCI_DEVICE_ID_GE_SPI    0x8816
@@ -316,16 +319,19 @@ static void pch_spi_handler_sub(struct pch_spi_data *data, u32 reg_spsr_val,
 
         /* if transfer complete interrupt */
         if (reg_spsr_val & SPSR_FI_BIT) {
-                if (tx_index < bpw_len)
+                if ((tx_index == bpw_len) && (rx_index == tx_index)) {
+                        /* disable interrupts */
+                        pch_spi_setclr_reg(data->master, PCH_SPCR, 0, PCH_ALL);
+
+                        /* transfer is completed;
+                           inform pch_spi_process_messages */
+                        data->transfer_complete = true;
+                        data->transfer_active = false;
+                        wake_up(&data->wait);
+                } else {
                         dev_err(&data->master->dev,
                                 "%s : Transfer is not completed", __func__);
-                /* disable interrupts */
-                pch_spi_setclr_reg(data->master, PCH_SPCR, 0, PCH_ALL);
-
-                /* transfer is completed;inform pch_spi_process_messages */
-                data->transfer_complete = true;
-                data->transfer_active = false;
-                wake_up(&data->wait);
+                }
         }
 }
 
@@ -348,16 +354,26 @@ static irqreturn_t pch_spi_handler(int irq, void *dev_id)
                         "%s returning due to suspend\n", __func__);
                 return IRQ_NONE;
         }
-        if (data->use_dma)
-                return IRQ_NONE;
 
         io_remap_addr = data->io_remap_addr;
         spsr = io_remap_addr + PCH_SPSR;
 
         reg_spsr_val = ioread32(spsr);
 
-        if (reg_spsr_val & SPSR_ORF_BIT)
-                dev_err(&board_dat->pdev->dev, "%s Over run error", __func__);
+        if (reg_spsr_val & SPSR_ORF_BIT) {
+                dev_err(&board_dat->pdev->dev, "%s Over run error\n", __func__);
+                if (data->current_msg->complete != 0) {
+                        data->transfer_complete = true;
+                        data->current_msg->status = -EIO;
+                        data->current_msg->complete(data->current_msg->context);
+                        data->bcurrent_msg_processing = false;
+                        data->current_msg = NULL;
+                        data->cur_trans = NULL;
+                }
+        }
+
+        if (data->use_dma)
+                return IRQ_NONE;
 
         /* Check if the interrupt is for SPI device */
         if (reg_spsr_val & (SPSR_FI_BIT | SPSR_RFI_BIT)) {
@@ -756,10 +772,6 @@ static void pch_spi_set_ir(struct pch_spi_data *data)
 
         wait_event_interruptible(data->wait, data->transfer_complete);
 
-        pch_spi_writereg(data->master, PCH_SSNXCR, SSN_NO_CONTROL);
-        dev_dbg(&data->master->dev,
-                "%s:no more control over SSN-writing 0 to SSNXCR.", __func__);
-
         /* clear all interrupts */
         pch_spi_writereg(data->master, PCH_SPSR,
                          pch_spi_readreg(data->master, PCH_SPSR));
@@ -815,10 +827,11 @@ static void pch_spi_copy_rx_data_for_dma(struct pch_spi_data *data, int bpw)
         }
 }
 
-static void pch_spi_start_transfer(struct pch_spi_data *data)
+static int pch_spi_start_transfer(struct pch_spi_data *data)
 {
         struct pch_spi_dma_ctrl *dma;
         unsigned long flags;
+        int rtn;
 
         dma = &data->dma;
 
@@ -833,19 +846,23 @@ static void pch_spi_start_transfer(struct pch_spi_data *data)
                                  initiating the transfer. */
         dev_dbg(&data->master->dev,
                 "%s:waiting for transfer to get over\n", __func__);
-        wait_event_interruptible(data->wait, data->transfer_complete);
+        rtn = wait_event_interruptible_timeout(data->wait,
+                                               data->transfer_complete,
+                                               msecs_to_jiffies(2 * HZ));
 
         dma_sync_sg_for_cpu(&data->master->dev, dma->sg_rx_p, dma->nent,
                             DMA_FROM_DEVICE);
+
+        dma_sync_sg_for_cpu(&data->master->dev, dma->sg_tx_p, dma->nent,
+                            DMA_FROM_DEVICE);
+        memset(data->dma.tx_buf_virt, 0, PAGE_SIZE);
+
         async_tx_ack(dma->desc_rx);
         async_tx_ack(dma->desc_tx);
         kfree(dma->sg_tx_p);
         kfree(dma->sg_rx_p);
 
         spin_lock_irqsave(&data->lock, flags);
-        pch_spi_writereg(data->master, PCH_SSNXCR, SSN_NO_CONTROL);
-        dev_dbg(&data->master->dev,
-                "%s:no more control over SSN-writing 0 to SSNXCR.", __func__);
 
         /* clear fifo threshold, disable interrupts, disable SPI transfer */
         pch_spi_setclr_reg(data->master, PCH_SPCR, 0,
@@ -858,6 +875,8 @@ static void pch_spi_start_transfer(struct pch_spi_data *data)
         pch_spi_clear_fifo(data->master);
 
         spin_unlock_irqrestore(&data->lock, flags);
+
+        return rtn;
 }
 
 static void pch_dma_rx_complete(void *arg)
@@ -1023,8 +1042,7 @@ static void pch_spi_handle_dma(struct pch_spi_data *data, int *bpw)
         /* set receive fifo threshold and transmit fifo threshold */
         pch_spi_setclr_reg(data->master, PCH_SPCR,
                            ((size - 1) << SPCR_RFIC_FIELD) |
-                           ((PCH_MAX_FIFO_DEPTH - PCH_DMA_TRANS_SIZE) <<
-                            SPCR_TFIC_FIELD),
+                           (PCH_TX_THOLD << SPCR_TFIC_FIELD),
                            MASK_RFIC_SPCR_BITS | MASK_TFIC_SPCR_BITS);
 
         spin_unlock_irqrestore(&data->lock, flags);
@@ -1035,13 +1053,20 @@ static void pch_spi_handle_dma(struct pch_spi_data *data, int *bpw)
         /* offset, length setting */
         sg = dma->sg_rx_p;
         for (i = 0; i < num; i++, sg++) {
-                if (i == 0) {
-                        sg->offset = 0;
+                if (i == (num - 2)) {
+                        sg->offset = size * i;
+                        sg->offset = sg->offset * (*bpw / 8);
                         sg_set_page(sg, virt_to_page(dma->rx_buf_virt), rem,
                                     sg->offset);
                         sg_dma_len(sg) = rem;
+                } else if (i == (num - 1)) {
+                        sg->offset = size * (i - 1) + rem;
+                        sg->offset = sg->offset * (*bpw / 8);
+                        sg_set_page(sg, virt_to_page(dma->rx_buf_virt), size,
+                                    sg->offset);
+                        sg_dma_len(sg) = size;
                 } else {
-                        sg->offset = rem + size * (i - 1);
+                        sg->offset = size * i;
                         sg->offset = sg->offset * (*bpw / 8);
                         sg_set_page(sg, virt_to_page(dma->rx_buf_virt), size,
                                     sg->offset);
@@ -1065,6 +1090,16 @@ static void pch_spi_handle_dma(struct pch_spi_data *data, int *bpw)
         dma->desc_rx = desc_rx;
 
         /* TX */
+        if (data->bpw_len > PCH_DMA_TRANS_SIZE) {
+                num = data->bpw_len / PCH_DMA_TRANS_SIZE;
+                size = PCH_DMA_TRANS_SIZE;
+                rem = 16;
+        } else {
+                num = 1;
+                size = data->bpw_len;
+                rem = data->bpw_len;
+        }
+
         dma->sg_tx_p = kzalloc(sizeof(struct scatterlist)*num, GFP_ATOMIC);
         sg_init_table(dma->sg_tx_p, num); /* Initialize SG table */
         /* offset, length setting */
@@ -1162,6 +1197,7 @@ static void pch_spi_process_messages(struct work_struct *pwork)
         if (data->use_dma)
                 pch_spi_request_dma(data,
                                     data->current_msg->spi->bits_per_word);
+        pch_spi_writereg(data->master, PCH_SSNXCR, SSN_NO_CONTROL);
         do {
                 /* If we are already processing a message get the next
                 transfer structure from the message otherwise retrieve
@@ -1184,7 +1220,8 @@ static void pch_spi_process_messages(struct work_struct *pwork)
 
                 if (data->use_dma) {
                         pch_spi_handle_dma(data, &bpw);
-                        pch_spi_start_transfer(data);
+                        if (!pch_spi_start_transfer(data))
+                                goto out;
                         pch_spi_copy_rx_data_for_dma(data, bpw);
                 } else {
                         pch_spi_set_tx(data, &bpw);
@@ -1222,6 +1259,8 @@ static void pch_spi_process_messages(struct work_struct *pwork)
 
         } while (data->cur_trans != NULL);
 
+out:
+        pch_spi_writereg(data->master, PCH_SSNXCR, SSN_HIGH);
         if (data->use_dma)
                 pch_spi_release_dma(data);
 }
diff --git a/drivers/staging/ath6kl/miscdrv/ar3kps/ar3kpsparser.c b/drivers/staging/ath6kl/miscdrv/ar3kps/ar3kpsparser.c
index c01c0cb0af4e..b99a11a9dd69 100644
--- a/drivers/staging/ath6kl/miscdrv/ar3kps/ar3kpsparser.c
+++ b/drivers/staging/ath6kl/miscdrv/ar3kps/ar3kpsparser.c
@@ -812,7 +812,7 @@ int AthCreateCommandList(struct ps_cmd_packet **HciPacketList, u32 *numPackets)
     for(count = 0; count < Patch_Count; count++) {
 
         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Freeing Patch Buffer %d \r\n",count));
-        kfree(RamPatch[Patch_Count].Data);
+        kfree(RamPatch[count].Data);
     }
 
     for(count = 0; count < Tag_Count; count++) {
diff --git a/drivers/staging/brcm80211/brcmsmac/otp.c b/drivers/staging/brcm80211/brcmsmac/otp.c
index 34253cf37812..4a70180eba5d 100644
--- a/drivers/staging/brcm80211/brcmsmac/otp.c
+++ b/drivers/staging/brcm80211/brcmsmac/otp.c
@@ -16,6 +16,7 @@
 
 #include <linux/io.h>
 #include <linux/errno.h>
+#include <linux/string.h>
 
 #include <brcm_hw_ids.h>
 #include <chipcommon.h>
diff --git a/drivers/staging/brcm80211/brcmsmac/types.h b/drivers/staging/brcm80211/brcmsmac/types.h
index bbf21897ae0e..823b5e4672e2 100644
--- a/drivers/staging/brcm80211/brcmsmac/types.h
+++ b/drivers/staging/brcm80211/brcmsmac/types.h
@@ -18,6 +18,7 @@
 #define _BRCM_TYPES_H_
 
 #include <linux/types.h>
+#include <linux/io.h>
 
 /* Bus types */
 #define SI_BUS                  0       /* SOC Interconnect */
diff --git a/drivers/staging/comedi/drivers/ni_labpc.c b/drivers/staging/comedi/drivers/ni_labpc.c
index 6859af0778cf..7611def97d06 100644
--- a/drivers/staging/comedi/drivers/ni_labpc.c
+++ b/drivers/staging/comedi/drivers/ni_labpc.c
@@ -241,8 +241,10 @@ static int labpc_eeprom_write_insn(struct comedi_device *dev,
                                    struct comedi_insn *insn,
                                    unsigned int *data);
 static void labpc_adc_timing(struct comedi_device *dev, struct comedi_cmd *cmd);
-#ifdef CONFIG_COMEDI_PCI
+#ifdef CONFIG_ISA_DMA_API
 static unsigned int labpc_suggest_transfer_size(struct comedi_cmd cmd);
+#endif
+#ifdef CONFIG_COMEDI_PCI
 static int labpc_find_device(struct comedi_device *dev, int bus, int slot);
 #endif
 static int labpc_dio_mem_callback(int dir, int port, int data,
diff --git a/drivers/staging/dt3155v4l/dt3155v4l.c b/drivers/staging/dt3155v4l/dt3155v4l.c
index fe02d22274b4..05aa41cf875b 100644
--- a/drivers/staging/dt3155v4l/dt3155v4l.c
+++ b/drivers/staging/dt3155v4l/dt3155v4l.c
@@ -22,6 +22,7 @@
 #include <linux/stringify.h>
 #include <linux/delay.h>
 #include <linux/kthread.h>
+#include <linux/slab.h>
 #include <media/v4l2-dev.h>
 #include <media/v4l2-ioctl.h>
 #include <media/videobuf2-dma-contig.h>
diff --git a/drivers/staging/ft1000/ft1000-pcmcia/ft1000_proc.c b/drivers/staging/ft1000/ft1000-pcmcia/ft1000_proc.c
index 627a98b4ec30..9e728b3415e3 100644
--- a/drivers/staging/ft1000/ft1000-pcmcia/ft1000_proc.c
+++ b/drivers/staging/ft1000/ft1000-pcmcia/ft1000_proc.c
@@ -22,6 +22,7 @@
 #include <linux/string.h>
 #include <linux/vmalloc.h>
 #include <linux/netdevice.h>
+#include <asm/io.h>
 #include <asm/uaccess.h>
 #include "ft1000.h"
 
diff --git a/drivers/staging/gma500/gem_glue.c b/drivers/staging/gma500/gem_glue.c
index 779ac1a12d24..daac12120653 100644
--- a/drivers/staging/gma500/gem_glue.c
+++ b/drivers/staging/gma500/gem_glue.c
@@ -20,26 +20,6 @@
 #include <drm/drmP.h>
 #include <drm/drm.h>
 
-/**
- * Initialize an already allocated GEM object of the specified size with
- * no GEM provided backing store. Instead the caller is responsible for
- * backing the object and handling it.
- */
-int drm_gem_private_object_init(struct drm_device *dev,
-                        struct drm_gem_object *obj, size_t size)
-{
-        BUG_ON((size & (PAGE_SIZE - 1)) != 0);
-
-        obj->dev = dev;
-        obj->filp = NULL;
-
-        kref_init(&obj->refcount);
-        atomic_set(&obj->handle_count, 0);
-        obj->size = size;
-
-        return 0;
-}
-
 void drm_gem_object_release_wrap(struct drm_gem_object *obj)
 {
         /* Remove the list map if one is present */
@@ -51,8 +31,7 @@ void drm_gem_object_release_wrap(struct drm_gem_object *obj)
                 kfree(list->map);
                 list->map = NULL;
         }
-        if (obj->filp)
-                drm_gem_object_release(obj);
+        drm_gem_object_release(obj);
 }
 
 /**
diff --git a/drivers/staging/gma500/gem_glue.h b/drivers/staging/gma500/gem_glue.h
index a0f2bc4e4ae7..ce5ce30f74db 100644
--- a/drivers/staging/gma500/gem_glue.h
+++ b/drivers/staging/gma500/gem_glue.h
@@ -1,4 +1,2 @@
 extern void drm_gem_object_release_wrap(struct drm_gem_object *obj);
-extern int drm_gem_private_object_init(struct drm_device *dev,
-                        struct drm_gem_object *obj, size_t size);
 extern int gem_create_mmap_offset(struct drm_gem_object *obj);
diff --git a/drivers/staging/gma500/mdfld_dsi_dbi.c b/drivers/staging/gma500/mdfld_dsi_dbi.c
index 02e17c9c8637..fd211f3467c4 100644
--- a/drivers/staging/gma500/mdfld_dsi_dbi.c
+++ b/drivers/staging/gma500/mdfld_dsi_dbi.c
@@ -711,10 +711,11 @@ struct mdfld_dsi_encoder *mdfld_dsi_dbi_init(struct drm_device *dev,
         /* Create drm encoder object */
         connector = &dsi_connector->base.base;
         encoder = &dbi_output->base.base;
+        /* Review this if we ever get MIPI-HDMI bridges or similar */
         drm_encoder_init(dev,
                         encoder,
                         p_funcs->encoder_funcs,
-                        DRM_MODE_ENCODER_MIPI);
+                        DRM_MODE_ENCODER_LVDS);
         drm_encoder_helper_add(encoder, p_funcs->encoder_helper_funcs);
 
         /* Attach to given connector */
diff --git a/drivers/staging/gma500/mdfld_dsi_dbi.h b/drivers/staging/gma500/mdfld_dsi_dbi.h
index dc6242c51d0b..f0fa986fd934 100644
--- a/drivers/staging/gma500/mdfld_dsi_dbi.h
+++ b/drivers/staging/gma500/mdfld_dsi_dbi.h
@@ -42,9 +42,6 @@
 #include "mdfld_dsi_output.h"
 #include "mdfld_output.h"
 
-#define DRM_MODE_ENCODER_MIPI  5
-
-
 /*
  * DBI encoder which inherits from mdfld_dsi_encoder
  */
diff --git a/drivers/staging/gma500/mdfld_dsi_dpi.c b/drivers/staging/gma500/mdfld_dsi_dpi.c
index 6e03a91e947e..e685f1217baa 100644
--- a/drivers/staging/gma500/mdfld_dsi_dpi.c
+++ b/drivers/staging/gma500/mdfld_dsi_dpi.c
@@ -777,10 +777,15 @@ struct mdfld_dsi_encoder *mdfld_dsi_dpi_init(struct drm_device *dev,
         /* Create drm encoder object */
         connector = &dsi_connector->base.base;
         encoder = &dpi_output->base.base;
+        /*
+         * On existing hardware this will be a panel of some form,
+         * if future devices also have HDMI bridges this will need
+         * revisiting
+         */
         drm_encoder_init(dev,
                         encoder,
                         p_funcs->encoder_funcs,
-                        DRM_MODE_ENCODER_MIPI);
+                        DRM_MODE_ENCODER_LVDS);
         drm_encoder_helper_add(encoder,
                                 p_funcs->encoder_helper_funcs);
         
diff --git a/drivers/staging/gma500/mdfld_dsi_output.c b/drivers/staging/gma500/mdfld_dsi_output.c
index 7536095c30a0..9050c0f78b15 100644
--- a/drivers/staging/gma500/mdfld_dsi_output.c
+++ b/drivers/staging/gma500/mdfld_dsi_output.c
@@ -955,7 +955,9 @@ void mdfld_dsi_output_init(struct drm_device *dev,
         psb_output->type = (pipe == 0) ? INTEL_OUTPUT_MIPI : INTEL_OUTPUT_MIPI2;
 
         connector = &psb_output->base;
-        drm_connector_init(dev, connector, &mdfld_dsi_connector_funcs, DRM_MODE_CONNECTOR_MIPI);
+        /* Revisit type if MIPI/HDMI bridges ever appear on Medfield */
+        drm_connector_init(dev, connector, &mdfld_dsi_connector_funcs,
+                                                DRM_MODE_CONNECTOR_LVDS);
         drm_connector_helper_add(connector, &mdfld_dsi_connector_helper_funcs);
         
         connector->display_info.subpixel_order = SubPixelHorizontalRGB;
diff --git a/drivers/staging/gma500/medfield.h b/drivers/staging/gma500/medfield.h
index 38165e8367e5..09e9687431f1 100644
--- a/drivers/staging/gma500/medfield.h
+++ b/drivers/staging/gma500/medfield.h
@@ -21,8 +21,6 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
-#define DRM_MODE_ENCODER_MIPI  5
-
 /* Medfield DSI controller registers */
 
 #define MIPIA_DEVICE_READY_REG                          0xb000
diff --git a/drivers/staging/gma500/psb_drv.h b/drivers/staging/gma500/psb_drv.h
index 72f487a2a1b7..fd4732dd783a 100644
--- a/drivers/staging/gma500/psb_drv.h
+++ b/drivers/staging/gma500/psb_drv.h
@@ -35,7 +35,6 @@
 
 /* Append new drm mode definition here, align with libdrm definition */
 #define DRM_MODE_SCALE_NO_SCALE         2
-#define DRM_MODE_CONNECTOR_MIPI         15
 
 enum {
         CHIP_PSB_8108 = 0,              /* Poulsbo */
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 3612574ca520..d286b2223181 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -325,7 +325,7 @@ static int blkvsc_do_operation(struct block_device_context *blkdev,
 
         page_buf = alloc_page(GFP_KERNEL);
         if (!page_buf) {
-                kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
+                kmem_cache_free(blkdev->request_pool, blkvsc_req);
                 return -ENOMEM;
         }
 
@@ -422,7 +422,7 @@ cleanup:
 
         __free_page(page_buf);
 
-        kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
+        kmem_cache_free(blkdev->request_pool, blkvsc_req);
 
         return ret;
 }
diff --git a/drivers/staging/iio/accel/adis16203_core.c b/drivers/staging/iio/accel/adis16203_core.c
index bf1988884e93..cf5d15da76ad 100644
--- a/drivers/staging/iio/accel/adis16203_core.c
+++ b/drivers/staging/iio/accel/adis16203_core.c
@@ -311,13 +311,17 @@ static int adis16203_read_raw(struct iio_dev *indio_dev,
                 mutex_lock(&indio_dev->mlock);
                 addr = adis16203_addresses[chan->address][0];
                 ret = adis16203_spi_read_reg_16(indio_dev, addr, &val16);
-                if (ret)
+                if (ret) {
+                        mutex_unlock(&indio_dev->mlock);
                         return ret;
+                }
 
                 if (val16 & ADIS16203_ERROR_ACTIVE) {
                         ret = adis16203_check_status(indio_dev);
-                        if (ret)
+                        if (ret) {
+                                mutex_unlock(&indio_dev->mlock);
                                 return ret;
+                        }
                 }
                 val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
                 if (chan->scan_type.sign == 's')
diff --git a/drivers/staging/iio/accel/adis16204_core.c b/drivers/staging/iio/accel/adis16204_core.c
index cfd09b3b9937..3e2b62654b7d 100644
--- a/drivers/staging/iio/accel/adis16204_core.c
+++ b/drivers/staging/iio/accel/adis16204_core.c
@@ -341,13 +341,17 @@ static int adis16204_read_raw(struct iio_dev *indio_dev,
                 mutex_lock(&indio_dev->mlock);
                 addr = adis16204_addresses[chan->address][0];
                 ret = adis16204_spi_read_reg_16(indio_dev, addr, &val16);
-                if (ret)
+                if (ret) {
+                        mutex_unlock(&indio_dev->mlock);
                         return ret;
+                }
 
                 if (val16 & ADIS16204_ERROR_ACTIVE) {
                         ret = adis16204_check_status(indio_dev);
-                        if (ret)
+                        if (ret) {
+                                mutex_unlock(&indio_dev->mlock);
                                 return ret;
+                        }
                 }
                 val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
                 if (chan->scan_type.sign == 's')
diff --git a/drivers/staging/iio/accel/adis16209_core.c b/drivers/staging/iio/accel/adis16209_core.c
index 55f3a7bcaf0a..bec1fa8de9b9 100644
--- a/drivers/staging/iio/accel/adis16209_core.c
+++ b/drivers/staging/iio/accel/adis16209_core.c
@@ -337,13 +337,17 @@ static int adis16209_read_raw(struct iio_dev *indio_dev,
                 mutex_lock(&indio_dev->mlock);
                 addr = adis16209_addresses[chan->address][0];
                 ret = adis16209_spi_read_reg_16(indio_dev, addr, &val16);
-                if (ret)
+                if (ret) {
+                        mutex_unlock(&indio_dev->mlock);
                         return ret;
+                }
 
                 if (val16 & ADIS16209_ERROR_ACTIVE) {
                         ret = adis16209_check_status(indio_dev);
-                        if (ret)
+                        if (ret) {
+                                mutex_unlock(&indio_dev->mlock);
                                 return ret;
+                        }
                 }
                 val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
                 if (chan->scan_type.sign == 's')
diff --git a/drivers/staging/iio/accel/adis16240_core.c b/drivers/staging/iio/accel/adis16240_core.c
index 4a4eafc58630..aee8b69173c4 100644
--- a/drivers/staging/iio/accel/adis16240_core.c
+++ b/drivers/staging/iio/accel/adis16240_core.c
@@ -370,13 +370,17 @@ static int adis16240_read_raw(struct iio_dev *indio_dev,
                 mutex_lock(&indio_dev->mlock);
                 addr = adis16240_addresses[chan->address][0];
                 ret = adis16240_spi_read_reg_16(indio_dev, addr, &val16);
-                if (ret)
+                if (ret) {
+                        mutex_unlock(&indio_dev->mlock);
                         return ret;
+                }
 
                 if (val16 & ADIS16240_ERROR_ACTIVE) {
                         ret = adis16240_check_status(indio_dev);
-                        if (ret)
+                        if (ret) {
+                                mutex_unlock(&indio_dev->mlock);
                                 return ret;
+                        }
                 }
                 val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
                 if (chan->scan_type.sign == 's')
diff --git a/drivers/staging/iio/gyro/adis16260_core.c b/drivers/staging/iio/gyro/adis16260_core.c
index 05797f404bea..f2d43cfcc493 100644
--- a/drivers/staging/iio/gyro/adis16260_core.c
+++ b/drivers/staging/iio/gyro/adis16260_core.c
@@ -446,13 +446,17 @@ static int adis16260_read_raw(struct iio_dev *indio_dev,
                 mutex_lock(&indio_dev->mlock);
                 addr = adis16260_addresses[chan->address][0];
                 ret = adis16260_spi_read_reg_16(indio_dev, addr, &val16);
-                if (ret)
+                if (ret) {
+                        mutex_unlock(&indio_dev->mlock);
                         return ret;
+                }
 
                 if (val16 & ADIS16260_ERROR_ACTIVE) {
                         ret = adis16260_check_status(indio_dev);
-                        if (ret)
+                        if (ret) {
+                                mutex_unlock(&indio_dev->mlock);
                                 return ret;
+                        }
                 }
                 val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
                 if (chan->scan_type.sign == 's')
diff --git a/drivers/staging/nvec/TODO b/drivers/staging/nvec/TODO
index 77b47f763f22..649d6b70deaa 100644
--- a/drivers/staging/nvec/TODO
+++ b/drivers/staging/nvec/TODO
@@ -4,5 +4,7 @@ ToDo list (incomplete, unordered)
         - add compile as module support
         - move nvec devices to mfd cells?
         - adjust to kernel style
-
-
+        - fix clk usage
+          should not be using clk_get_sys(), but clk_get(&pdev->dev, conn)
+          where conn is either NULL if the device only has one clock, or
+          the device specific name if it has multiple clocks.
diff --git a/drivers/staging/octeon/ethernet-rgmii.c b/drivers/staging/octeon/ethernet-rgmii.c
index 9c0d2936e486..c3d73f8431ae 100644
--- a/drivers/staging/octeon/ethernet-rgmii.c
+++ b/drivers/staging/octeon/ethernet-rgmii.c
@@ -26,6 +26,7 @@
 **********************************************************************/
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
+#include <linux/interrupt.h>
 #include <linux/phy.h>
 #include <linux/ratelimit.h>
 #include <net/dst.h>
diff --git a/drivers/staging/octeon/ethernet-spi.c b/drivers/staging/octeon/ethernet-spi.c
index 970825421884..d0e2d514968a 100644
--- a/drivers/staging/octeon/ethernet-spi.c
+++ b/drivers/staging/octeon/ethernet-spi.c
@@ -26,6 +26,7 @@
 **********************************************************************/
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
+#include <linux/interrupt.h>
 #include <net/dst.h>
 
 #include <asm/octeon/octeon.h>
diff --git a/drivers/staging/rtl8192u/r819xU_firmware.c b/drivers/staging/rtl8192u/r819xU_firmware.c
index 6766f468639f..4bb5fffca5b9 100644
--- a/drivers/staging/rtl8192u/r819xU_firmware.c
+++ b/drivers/staging/rtl8192u/r819xU_firmware.c
@@ -399,10 +399,7 @@ download_firmware_fail:
 
 }
 
-
-
-
-
-
-
+MODULE_FIRMWARE("RTL8192U/boot.img");
+MODULE_FIRMWARE("RTL8192U/main.img");
+MODULE_FIRMWARE("RTL8192U/data.img");
 
diff --git a/drivers/staging/rts_pstor/rtsx.c b/drivers/staging/rts_pstor/rtsx.c
index 5ff59f27d101..16c73fbff51f 100644
--- a/drivers/staging/rts_pstor/rtsx.c
+++ b/drivers/staging/rts_pstor/rtsx.c
@@ -66,12 +66,6 @@ static int msi_en;
 module_param(msi_en, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(msi_en, "enable msi");
 
-/* These are used to make sure the module doesn't unload before all the
- * threads have exited.
- */
-static atomic_t total_threads = ATOMIC_INIT(0);
-static DECLARE_COMPLETION(threads_gone);
-
 static irqreturn_t rtsx_interrupt(int irq, void *dev_id);
 
 /***********************************************************************
@@ -192,7 +186,7 @@ static int queuecommand_lck(struct scsi_cmnd *srb,
         /* enqueue the command and wake up the control thread */
         srb->scsi_done = done;
         chip->srb = srb;
-        up(&(dev->sema));
+        complete(&dev->cmnd_ready);
 
         return 0;
 }
@@ -475,7 +469,7 @@ static int rtsx_control_thread(void *__dev)
         current->flags |= PF_NOFREEZE;
 
         for (;;) {
-                if (down_interruptible(&dev->sema))
+                if (wait_for_completion_interruptible(&dev->cmnd_ready))
                         break;
 
                 /* lock the device pointers */
@@ -557,8 +551,6 @@ SkipForAbort:
                 mutex_unlock(&dev->dev_mutex);
         } /* for (;;) */
 
-        scsi_host_put(host);
-
         /* notify the exit routine that we're actually exiting now
          *
          * complete()/wait_for_completion() is similar to up()/down(),
@@ -573,7 +565,7 @@ SkipForAbort:
          * This is important in preemption kernels, which transfer the flow
          * of execution immediately upon a complete().
          */
-        complete_and_exit(&threads_gone, 0);
+        complete_and_exit(&dev->control_exit, 0);
 }
 
 
@@ -581,7 +573,6 @@ static int rtsx_polling_thread(void *__dev)
 {
         struct rtsx_dev *dev = (struct rtsx_dev *)__dev;
         struct rtsx_chip *chip = dev->chip;
-        struct Scsi_Host *host = rtsx_to_host(dev);
         struct sd_info *sd_card = &(chip->sd_card);
         struct xd_info *xd_card = &(chip->xd_card);
         struct ms_info *ms_card = &(chip->ms_card);
@@ -621,8 +612,7 @@ static int rtsx_polling_thread(void *__dev)
                 mutex_unlock(&dev->dev_mutex);
         }
 
-        scsi_host_put(host);
-        complete_and_exit(&threads_gone, 0);
+        complete_and_exit(&dev->polling_exit, 0);
 }
 
 /*
@@ -699,29 +689,38 @@ static void rtsx_release_resources(struct rtsx_dev *dev)
 {
         printk(KERN_INFO "-- %s\n", __func__);
 
+        /* Tell the control thread to exit.  The SCSI host must
+         * already have been removed so it won't try to queue
+         * any more commands.
+         */
+        printk(KERN_INFO "-- sending exit command to thread\n");
+        complete(&dev->cmnd_ready);
+        if (dev->ctl_thread)
+                wait_for_completion(&dev->control_exit);
+        if (dev->polling_thread)
+                wait_for_completion(&dev->polling_exit);
+
+        wait_timeout(200);
+
         if (dev->rtsx_resv_buf) {
-                dma_free_coherent(&(dev->pci->dev), HOST_CMDS_BUF_LEN,
+                dma_free_coherent(&(dev->pci->dev), RTSX_RESV_BUF_LEN,
                                 dev->rtsx_resv_buf, dev->rtsx_resv_buf_addr);
                 dev->chip->host_cmds_ptr = NULL;
                 dev->chip->host_sg_tbl_ptr = NULL;
         }
 
-        pci_disable_device(dev->pci);
-        pci_release_regions(dev->pci);
-
-        if (dev->irq > 0) {
+        if (dev->irq > 0)
                 free_irq(dev->irq, (void *)dev);
-        }
-        if (dev->chip->msi_en) {
+        if (dev->chip->msi_en)
                 pci_disable_msi(dev->pci);
-        }
+        if (dev->remap_addr)
+                iounmap(dev->remap_addr);
 
-        /* Tell the control thread to exit.  The SCSI host must
-         * already have been removed so it won't try to queue
-         * any more commands.
-         */
-        printk(KERN_INFO "-- sending exit command to thread\n");
-        up(&dev->sema);
+        pci_disable_device(dev->pci);
+        pci_release_regions(dev->pci);
+
+        rtsx_release_chip(dev->chip);
+        kfree(dev->chip);
 }
 
 /* First stage of disconnect processing: stop all commands and remove
@@ -739,6 +738,7 @@ static void quiesce_and_remove_host(struct rtsx_dev *dev)
         scsi_unlock(host);
         mutex_unlock(&dev->dev_mutex);
         wake_up(&dev->delay_wait);
+        wait_for_completion(&dev->scanning_done);
 
         /* Wait some time to let other threads exist */
         wait_timeout(100);
@@ -793,8 +793,7 @@ static int rtsx_scan_thread(void *__dev)
                 /* Should we unbind if no devices were detected? */
         }
 
-        scsi_host_put(rtsx_to_host(dev));
-        complete_and_exit(&threads_gone, 0);
+        complete_and_exit(&dev->scanning_done, 0);
 }
 
 static void rtsx_init_options(struct rtsx_chip *chip)
@@ -941,8 +940,11 @@ static int __devinit rtsx_probe(struct pci_dev *pci, const struct pci_device_id
 
         spin_lock_init(&dev->reg_lock);
         mutex_init(&(dev->dev_mutex));
-        sema_init(&(dev->sema), 0);
+        init_completion(&dev->cmnd_ready);
+        init_completion(&dev->control_exit);
+        init_completion(&dev->polling_exit);
         init_completion(&(dev->notify));
+        init_completion(&dev->scanning_done);
         init_waitqueue_head(&dev->delay_wait);
 
         dev->pci = pci;
@@ -992,28 +994,22 @@ static int __devinit rtsx_probe(struct pci_dev *pci, const struct pci_device_id
         pci_set_master(pci);
         synchronize_irq(dev->irq);
 
-        err = scsi_add_host(host, &pci->dev);
-        if (err) {
-                printk(KERN_ERR "Unable to add the scsi host\n");
-                goto errout;
-        }
-
         rtsx_init_chip(dev->chip);
 
         /* Start up our control thread */
-        th = kthread_create(rtsx_control_thread, dev, CR_DRIVER_NAME);
+        th = kthread_run(rtsx_control_thread, dev, CR_DRIVER_NAME);
         if (IS_ERR(th)) {
                 printk(KERN_ERR "Unable to start control thread\n");
                 err = PTR_ERR(th);
                 goto errout;
         }
+        dev->ctl_thread = th;
 
-        /* Take a reference to the host for the control thread and
-         * count it among all the threads we have launched.  Then
-         * start it up. */
-        scsi_host_get(rtsx_to_host(dev));
-        atomic_inc(&total_threads);
-        wake_up_process(th);
+        err = scsi_add_host(host, &pci->dev);
+        if (err) {
+                printk(KERN_ERR "Unable to add the scsi host\n");
+                goto errout;
+        }
 
         /* Start up the thread for delayed SCSI-device scanning */
         th = kthread_create(rtsx_scan_thread, dev, "rtsx-scan");
@@ -1024,28 +1020,17 @@ static int __devinit rtsx_probe(struct pci_dev *pci, const struct pci_device_id
                 goto errout;
         }
 
-        /* Take a reference to the host for the scanning thread and
-         * count it among all the threads we have launched.  Then
-         * start it up. */
-        scsi_host_get(rtsx_to_host(dev));
-        atomic_inc(&total_threads);
         wake_up_process(th);
 
         /* Start up the thread for polling thread */
-        th = kthread_create(rtsx_polling_thread, dev, "rtsx-polling");
+        th = kthread_run(rtsx_polling_thread, dev, "rtsx-polling");
         if (IS_ERR(th)) {
                 printk(KERN_ERR "Unable to start the device-polling thread\n");
                 quiesce_and_remove_host(dev);
                 err = PTR_ERR(th);
                 goto errout;
         }
-
-        /* Take a reference to the host for the polling thread and
-         * count it among all the threads we have launched.  Then
-         * start it up. */
-        scsi_host_get(rtsx_to_host(dev));
-        atomic_inc(&total_threads);
-        wake_up_process(th);
+        dev->polling_thread = th;
 
         pci_set_drvdata(pci, dev);
 
@@ -1108,16 +1093,6 @@ static void __exit rtsx_exit(void)
 
         pci_unregister_driver(&driver);
 
-        /* Don't return until all of our control and scanning threads
-         * have exited.  Since each thread signals threads_gone as its
-         * last act, we have to call wait_for_completion the right number
-         * of times.
-         */
-        while (atomic_read(&total_threads) > 0) {
-                wait_for_completion(&threads_gone);
-                atomic_dec(&total_threads);
-        }
-
         printk(KERN_INFO "%s module exit\n", CR_DRIVER_NAME);
 }
 
diff --git a/drivers/staging/rts_pstor/rtsx.h b/drivers/staging/rts_pstor/rtsx.h
index 247615ba1d2a..86e47c2e3e3c 100644
--- a/drivers/staging/rts_pstor/rtsx.h
+++ b/drivers/staging/rts_pstor/rtsx.h
@@ -112,9 +112,16 @@ struct rtsx_dev {
         /* locks */
         spinlock_t              reg_lock;
 
+        struct task_struct      *ctl_thread;     /* the control thread   */
+        struct task_struct      *polling_thread; /* the polling thread   */
+
         /* mutual exclusion and synchronization structures */
-        struct semaphore        sema;            /* to sleep thread on      */
+        struct completion       cmnd_ready;      /* to sleep thread on      */
+        struct completion       control_exit;    /* control thread exit     */
+        struct completion       polling_exit;    /* polling thread exit     */
         struct completion       notify;          /* thread begin/end        */
+        struct completion       scanning_done;   /* wait for scan thread    */
+
         wait_queue_head_t       delay_wait;      /* wait during scan, reset */
         struct mutex            dev_mutex;
 
diff --git a/drivers/staging/solo6x10/core.c b/drivers/staging/solo6x10/core.c
index 76779949f141..f974f6412ad7 100644
--- a/drivers/staging/solo6x10/core.c
+++ b/drivers/staging/solo6x10/core.c
@@ -21,6 +21,7 @@
 #include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 #include <linux/videodev2.h>
 #include "solo6x10.h"
 #include "tw28.h"
diff --git a/drivers/staging/solo6x10/enc.c b/drivers/staging/solo6x10/enc.c
index 285f7f350062..de502599bb19 100644
--- a/drivers/staging/solo6x10/enc.c
+++ b/drivers/staging/solo6x10/enc.c
@@ -18,6 +18,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include "solo6x10.h"
 #include "osd-font.h"
 
diff --git a/drivers/staging/solo6x10/g723.c b/drivers/staging/solo6x10/g723.c
index bd8eb92c94b1..59274bfca95b 100644
--- a/drivers/staging/solo6x10/g723.c
+++ b/drivers/staging/solo6x10/g723.c
@@ -21,6 +21,7 @@
 #include <linux/mempool.h>
 #include <linux/poll.h>
 #include <linux/kthread.h>
+#include <linux/slab.h>
 #include <linux/freezer.h>
 #include <sound/core.h>
 #include <sound/initval.h>
diff --git a/drivers/staging/solo6x10/p2m.c b/drivers/staging/solo6x10/p2m.c
index 5717eabb04a4..56210f0fc5ec 100644
--- a/drivers/staging/solo6x10/p2m.c
+++ b/drivers/staging/solo6x10/p2m.c
@@ -18,6 +18,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/scatterlist.h>
 #include "solo6x10.h"
 
diff --git a/drivers/staging/solo6x10/solo6x10.h b/drivers/staging/solo6x10/solo6x10.h
index 17c06bd6cc91..abee7213202f 100644
--- a/drivers/staging/solo6x10/solo6x10.h
+++ b/drivers/staging/solo6x10/solo6x10.h
@@ -28,6 +28,7 @@
 #include <linux/list.h>
 #include <linux/wait.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <asm/io.h>
 #include <linux/atomic.h>
 #include <linux/videodev2.h>
diff --git a/drivers/staging/speakup/devsynth.c b/drivers/staging/speakup/devsynth.c
index 39dc586fc8bb..940769ef883f 100644
--- a/drivers/staging/speakup/devsynth.c
+++ b/drivers/staging/speakup/devsynth.c
@@ -18,13 +18,14 @@ static ssize_t speakup_file_write(struct file *fp, const char *buffer,
 {
         size_t count = nbytes;
         const char *ptr = buffer;
-        int bytes;
+        size_t bytes;
         unsigned long flags;
         u_char buf[256];
+
         if (synth == NULL)
                 return -ENODEV;
         while (count > 0) {
-                bytes = min_t(size_t, count, sizeof(buf));
+                bytes = min(count, sizeof(buf));
                 if (copy_from_user(buf, ptr, bytes))
                         return -EFAULT;
                 count -= bytes;
diff --git a/drivers/staging/tidspbridge/core/dsp-clock.c b/drivers/staging/tidspbridge/core/dsp-clock.c
index 589a0554332e..3d1279c424a8 100644
--- a/drivers/staging/tidspbridge/core/dsp-clock.c
+++ b/drivers/staging/tidspbridge/core/dsp-clock.c
@@ -209,7 +209,6 @@ int dsp_clk_enable(enum dsp_clk_id clk_id)
                 break;
 #ifdef CONFIG_OMAP_MCBSP
         case MCBSP_CLK:
-                omap_mcbsp_set_io_type(MCBSP_ID(clk_id), OMAP_MCBSP_POLL_IO);
                 omap_mcbsp_request(MCBSP_ID(clk_id));
                 omap2_mcbsp_set_clks_src(MCBSP_ID(clk_id), MCBSP_CLKS_PAD_SRC);
                 break;
diff --git a/drivers/staging/zcache/Makefile b/drivers/staging/zcache/Makefile
index f5ec64f94470..60daa272c204 100644
--- a/drivers/staging/zcache/Makefile
+++ b/drivers/staging/zcache/Makefile
@@ -1,3 +1,3 @@
-zcache-y        :=      tmem.o
+zcache-y        :=      zcache-main.o tmem.o
 
 obj-$(CONFIG_ZCACHE)    +=      zcache.o
diff --git a/drivers/staging/zcache/tmem.c b/drivers/staging/zcache/tmem.c
index 975e34bcd722..1ca66ea9b281 100644
--- a/drivers/staging/zcache/tmem.c
+++ b/drivers/staging/zcache/tmem.c
@@ -604,7 +604,7 @@ int tmem_get(struct tmem_pool *pool, struct tmem_oid *oidp, uint32_t index,
         struct tmem_obj *obj;
         void *pampd;
         bool ephemeral = is_ephemeral(pool);
-        uint32_t ret = -1;
+        int ret = -1;
         struct tmem_hashbucket *hb;
         bool free = (get_and_free == 1) || ((get_and_free == 0) && ephemeral);
         bool lock_held = false;
diff --git a/drivers/staging/zcache/zcache.c b/drivers/staging/zcache/zcache-main.c
index 65a81a0d7c49..462fbc20561f 100644
--- a/drivers/staging/zcache/zcache.c
+++ b/drivers/staging/zcache/zcache-main.c
@@ -19,6 +19,7 @@
  *   http://marc.info/?l=linux-mm&m=127811271605009
  */
 
+#include <linux/module.h>
 #include <linux/cpu.h>
 #include <linux/highmem.h>
 #include <linux/list.h>
@@ -27,6 +28,7 @@
 #include <linux/spinlock.h>
 #include <linux/types.h>
 #include <linux/atomic.h>
+#include <linux/math64.h>
 #include "tmem.h"
 
 #include "../zram/xvmalloc.h" /* if built in drivers/staging */
@@ -53,6 +55,9 @@
 
 #define MAX_CLIENTS 16
 #define LOCAL_CLIENT ((uint16_t)-1)
+
+MODULE_LICENSE("GPL");
+
 struct zcache_client {
         struct tmem_pool *tmem_pools[MAX_POOLS_PER_CLIENT];
         struct xv_pool *xvpool;
@@ -1153,11 +1158,12 @@ static void *zcache_pampd_create(char *data, size_t size, bool raw, int eph,
         size_t clen;
         int ret;
         unsigned long count;
-        struct page *page = virt_to_page(data);
+        struct page *page = (struct page *)(data);
         struct zcache_client *cli = pool->client;
         uint16_t client_id = get_client_id_from_client(cli);
         unsigned long zv_mean_zsize;
         unsigned long curr_pers_pampd_count;
+        u64 total_zsize;
 
         if (eph) {
                 ret = zcache_compress(page, &cdata, &clen);
@@ -1190,8 +1196,9 @@ static void *zcache_pampd_create(char *data, size_t size, bool raw, int eph,
                 }
                 /* reject if mean compression is too poor */
                 if ((clen > zv_max_mean_zsize) && (curr_pers_pampd_count > 0)) {
-                        zv_mean_zsize = xv_get_total_size_bytes(cli->xvpool) /
-                                                curr_pers_pampd_count;
+                        total_zsize = xv_get_total_size_bytes(cli->xvpool);
+                        zv_mean_zsize = div_u64(total_zsize,
+                                                curr_pers_pampd_count);
                         if (zv_mean_zsize > zv_max_mean_zsize) {
                                 zcache_mean_compress_poor++;
                                 goto out;
@@ -1220,7 +1227,7 @@ static int zcache_pampd_get_data(char *data, size_t *bufsize, bool raw,
         int ret = 0;
 
         BUG_ON(is_ephemeral(pool));
-        zv_decompress(virt_to_page(data), pampd);
+        zv_decompress((struct page *)(data), pampd);
         return ret;
 }
 
@@ -1235,7 +1242,7 @@ static int zcache_pampd_get_data_and_free(char *data, size_t *bufsize, bool raw,
         int ret = 0;
 
         BUG_ON(!is_ephemeral(pool));
-        zbud_decompress(virt_to_page(data), pampd);
+        zbud_decompress((struct page *)(data), pampd);
         zbud_free_and_delist((struct zbud_hdr *)pampd);
         atomic_dec(&zcache_curr_eph_pampd_count);
         return ret;
@@ -1532,7 +1539,7 @@ static int zcache_put_page(int cli_id, int pool_id, struct tmem_oid *oidp,
                 goto out;
         if (!zcache_freeze && zcache_do_preload(pool) == 0) {
                 /* preload does preempt_disable on success */
-                ret = tmem_put(pool, oidp, index, page_address(page),
+                ret = tmem_put(pool, oidp, index, (char *)(page),
                                 PAGE_SIZE, 0, is_ephemeral(pool));
                 if (ret < 0) {
                         if (is_ephemeral(pool))
@@ -1565,7 +1572,7 @@ static int zcache_get_page(int cli_id, int pool_id, struct tmem_oid *oidp,
         pool = zcache_get_pool_by_id(cli_id, pool_id);
         if (likely(pool != NULL)) {
                 if (atomic_read(&pool->obj_count) > 0)
-                        ret = tmem_get(pool, oidp, index, page_address(page),
+                        ret = tmem_get(pool, oidp, index, (char *)(page),
                                         &size, 0, is_ephemeral(pool));
                 zcache_put_pool(pool);
         }
@@ -1929,9 +1936,9 @@ __setup("nofrontswap", no_frontswap);
 
 static int __init zcache_init(void)
 {
-#ifdef CONFIG_SYSFS
         int ret = 0;
 
+#ifdef CONFIG_SYSFS
         ret = sysfs_create_group(mm_kobj, &zcache_attr_group);
         if (ret) {
                 pr_err("zcache: can't create sysfs\n");
diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
index c24fb10de60b..6a4ea29c2f36 100644
--- a/drivers/target/iscsi/iscsi_target.c
+++ b/drivers/target/iscsi/iscsi_target.c
@@ -2243,7 +2243,6 @@ static int iscsit_handle_snack(
         case 0:
                 return iscsit_handle_recovery_datain_or_r2t(conn, buf,
                         hdr->itt, hdr->ttt, hdr->begrun, hdr->runlength);
-                return 0;
         case ISCSI_FLAG_SNACK_TYPE_STATUS:
                 return iscsit_handle_status_snack(conn, hdr->itt, hdr->ttt,
                         hdr->begrun, hdr->runlength);
diff --git a/drivers/target/iscsi/iscsi_target_configfs.c b/drivers/target/iscsi/iscsi_target_configfs.c
index f095e65b1ccf..f1643dbf6a92 100644
--- a/drivers/target/iscsi/iscsi_target_configfs.c
+++ b/drivers/target/iscsi/iscsi_target_configfs.c
@@ -268,7 +268,7 @@ struct se_tpg_np *lio_target_call_addnptotpg(
                                 ISCSI_TCP);
         if (IS_ERR(tpg_np)) {
                 iscsit_put_tpg(tpg);
-                return ERR_PTR(PTR_ERR(tpg_np));
+                return ERR_CAST(tpg_np);
         }
         pr_debug("LIO_Target_ConfigFS: addnptotpg done!\n");
 
@@ -1285,7 +1285,7 @@ struct se_wwn *lio_target_call_coreaddtiqn(
 
         tiqn = iscsit_add_tiqn((unsigned char *)name);
         if (IS_ERR(tiqn))
-                return ERR_PTR(PTR_ERR(tiqn));
+                return ERR_CAST(tiqn);
         /*
          * Setup struct iscsi_wwn_stat_grps for se_wwn->fabric_stat_group.
          */
diff --git a/drivers/target/iscsi/iscsi_target_erl1.c b/drivers/target/iscsi/iscsi_target_erl1.c
index 980650792cf6..c4c68da3e500 100644
--- a/drivers/target/iscsi/iscsi_target_erl1.c
+++ b/drivers/target/iscsi/iscsi_target_erl1.c
@@ -834,7 +834,7 @@ static int iscsit_attach_ooo_cmdsn(
                          */
                         list_for_each_entry(ooo_tmp, &sess->sess_ooo_cmdsn_list,
                                                 ooo_list) {
-                                while (ooo_tmp->cmdsn < ooo_cmdsn->cmdsn)
+                                if (ooo_tmp->cmdsn < ooo_cmdsn->cmdsn)
                                         continue;
 
                                 list_add(&ooo_cmdsn->ooo_list,
diff --git a/drivers/target/iscsi/iscsi_target_login.c b/drivers/target/iscsi/iscsi_target_login.c
index bcaf82f47037..daad362a93ce 100644
--- a/drivers/target/iscsi/iscsi_target_login.c
+++ b/drivers/target/iscsi/iscsi_target_login.c
@@ -1013,19 +1013,9 @@ static int __iscsi_target_login_thread(struct iscsi_np *np)
                                         ISCSI_LOGIN_STATUS_TARGET_ERROR);
                         goto new_sess_out;
                 }
-#if 0
-                if (!iscsi_ntop6((const unsigned char *)
-                                &sock_in6.sin6_addr.in6_u,
-                                (char *)&conn->ipv6_login_ip[0],
-                                IPV6_ADDRESS_SPACE)) {
-                        pr_err("iscsi_ntop6() failed\n");
-                        iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
-                                        ISCSI_LOGIN_STATUS_TARGET_ERROR);
-                        goto new_sess_out;
-                }
-#else
-                pr_debug("Skipping iscsi_ntop6()\n");
-#endif
+                snprintf(conn->login_ip, sizeof(conn->login_ip), "%pI6c",
+                                &sock_in6.sin6_addr.in6_u);
+                conn->login_port = ntohs(sock_in6.sin6_port);
         } else {
                 memset(&sock_in, 0, sizeof(struct sockaddr_in));
 
diff --git a/drivers/target/iscsi/iscsi_target_parameters.c b/drivers/target/iscsi/iscsi_target_parameters.c
index 252e246cf51e..5b773160200f 100644
--- a/drivers/target/iscsi/iscsi_target_parameters.c
+++ b/drivers/target/iscsi/iscsi_target_parameters.c
@@ -545,13 +545,13 @@ int iscsi_copy_param_list(
         struct iscsi_param_list *src_param_list,
         int leading)
 {
-        struct iscsi_param *new_param = NULL, *param = NULL;
+        struct iscsi_param *param = NULL;
+        struct iscsi_param *new_param = NULL;
         struct iscsi_param_list *param_list = NULL;
 
         param_list = kzalloc(sizeof(struct iscsi_param_list), GFP_KERNEL);
         if (!param_list) {
-                pr_err("Unable to allocate memory for"
-                                " struct iscsi_param_list.\n");
+                pr_err("Unable to allocate memory for struct iscsi_param_list.\n");
                 goto err_out;
         }
         INIT_LIST_HEAD(&param_list->param_list);
@@ -567,8 +567,17 @@ int iscsi_copy_param_list(
 
                 new_param = kzalloc(sizeof(struct iscsi_param), GFP_KERNEL);
                 if (!new_param) {
-                        pr_err("Unable to allocate memory for"
-                                " struct iscsi_param.\n");
+                        pr_err("Unable to allocate memory for struct iscsi_param.\n");
+                        goto err_out;
+                }
+
+                new_param->name = kstrdup(param->name, GFP_KERNEL);
+                new_param->value = kstrdup(param->value, GFP_KERNEL);
+                if (!new_param->value || !new_param->name) {
+                        kfree(new_param->value);
+                        kfree(new_param->name);
+                        kfree(new_param);
+                        pr_err("Unable to allocate memory for parameter name/value.\n");
                         goto err_out;
                 }
 
@@ -580,32 +589,12 @@ int iscsi_copy_param_list(
                 new_param->use = param->use;
                 new_param->type_range = param->type_range;
 
-                new_param->name = kzalloc(strlen(param->name) + 1, GFP_KERNEL);
-                if (!new_param->name) {
-                        pr_err("Unable to allocate memory for"
-                                " parameter name.\n");
-                        goto err_out;
-                }
-
-                new_param->value = kzalloc(strlen(param->value) + 1,
-                                GFP_KERNEL);
-                if (!new_param->value) {
-                        pr_err("Unable to allocate memory for"
-                                " parameter value.\n");
-                        goto err_out;
-                }
-
-                memcpy(new_param->name, param->name, strlen(param->name));
-                new_param->name[strlen(param->name)] = '\0';
-                memcpy(new_param->value, param->value, strlen(param->value));
-                new_param->value[strlen(param->value)] = '\0';
-
                 list_add_tail(&new_param->p_list, &param_list->param_list);
         }
 
-        if (!list_empty(&param_list->param_list))
+        if (!list_empty(&param_list->param_list)) {
                 *dst_param_list = param_list;
-        else {
+        } else {
                 pr_err("No parameters allocated.\n");
                 goto err_out;
         }
@@ -1441,7 +1430,7 @@ static int iscsi_enforce_integrity_rules(
         u8 DataSequenceInOrder = 0;
         u8 ErrorRecoveryLevel = 0, SessionType = 0;
         u8 IFMarker = 0, OFMarker = 0;
-        u8 IFMarkInt_Reject = 0, OFMarkInt_Reject = 0;
+        u8 IFMarkInt_Reject = 1, OFMarkInt_Reject = 1;
         u32 FirstBurstLength = 0, MaxBurstLength = 0;
         struct iscsi_param *param = NULL;
 
diff --git a/drivers/target/iscsi/iscsi_target_util.c b/drivers/target/iscsi/iscsi_target_util.c
index a1acb0167902..f00137f377b2 100644
--- a/drivers/target/iscsi/iscsi_target_util.c
+++ b/drivers/target/iscsi/iscsi_target_util.c
@@ -243,7 +243,7 @@ struct iscsi_cmd *iscsit_allocate_se_cmd_for_tmr(
         if (!cmd->tmr_req) {
                 pr_err("Unable to allocate memory for"
                         " Task Management command!\n");
-                return NULL;
+                goto out;
         }
         /*
          * TASK_REASSIGN for ERL=2 / connection stays inside of
@@ -298,8 +298,6 @@ struct iscsi_cmd *iscsit_allocate_se_cmd_for_tmr(
         return cmd;
 out:
         iscsit_release_cmd(cmd);
-        if (se_cmd)
-                transport_free_se_cmd(se_cmd);
         return NULL;
 }
 
@@ -877,40 +875,6 @@ void iscsit_inc_session_usage_count(struct iscsi_session *sess)
 }
 
 /*
- *      Used before iscsi_do[rx,tx]_data() to determine iov and [rx,tx]_marker
- *      array counts needed for sync and steering.
- */
-static int iscsit_determine_sync_and_steering_counts(
-        struct iscsi_conn *conn,
-        struct iscsi_data_count *count)
-{
-        u32 length = count->data_length;
-        u32 marker, markint;
-
-        count->sync_and_steering = 1;
-
-        marker = (count->type == ISCSI_RX_DATA) ?
-                        conn->of_marker : conn->if_marker;
-        markint = (count->type == ISCSI_RX_DATA) ?
-                        (conn->conn_ops->OFMarkInt * 4) :
-                        (conn->conn_ops->IFMarkInt * 4);
-        count->ss_iov_count = count->iov_count;
-
-        while (length > 0) {
-                if (length >= marker) {
-                        count->ss_iov_count += 3;
-                        count->ss_marker_count += 2;
-
-                        length -= marker;
-                        marker = markint;
-                } else
-                        length = 0;
-        }
-
-        return 0;
-}
-
-/*
  *      Setup conn->if_marker and conn->of_marker values based upon
  *      the initial marker-less interval. (see iSCSI v19 A.2)
  */
@@ -1292,7 +1256,7 @@ int iscsit_fe_sendpage_sg(
         struct kvec iov;
         u32 tx_hdr_size, data_len;
         u32 offset = cmd->first_data_sg_off;
-        int tx_sent;
+        int tx_sent, iov_off;
 
 send_hdr:
         tx_hdr_size = ISCSI_HDR_LEN;
@@ -1312,9 +1276,19 @@ send_hdr:
         }
 
         data_len = cmd->tx_size - tx_hdr_size - cmd->padding;
-        if (conn->conn_ops->DataDigest)
+        /*
+         * Set iov_off used by padding and data digest tx_data() calls below
+         * in order to determine proper offset into cmd->iov_data[]
+         */
+        if (conn->conn_ops->DataDigest) {
                 data_len -= ISCSI_CRC_LEN;
-
+                if (cmd->padding)
+                        iov_off = (cmd->iov_data_count - 2);
+                else
+                        iov_off = (cmd->iov_data_count - 1);
+        } else {
+                iov_off = (cmd->iov_data_count - 1);
+        }
         /*
          * Perform sendpage() for each page in the scatterlist
          */
@@ -1343,8 +1317,7 @@ send_pg:
 
 send_padding:
         if (cmd->padding) {
-                struct kvec *iov_p =
-                        &cmd->iov_data[cmd->iov_data_count-1];
+                struct kvec *iov_p = &cmd->iov_data[iov_off++];
 
                 tx_sent = tx_data(conn, iov_p, 1, cmd->padding);
                 if (cmd->padding != tx_sent) {
@@ -1358,8 +1331,7 @@ send_padding:
 
 send_datacrc:
         if (conn->conn_ops->DataDigest) {
-                struct kvec *iov_d =
-                        &cmd->iov_data[cmd->iov_data_count];
+                struct kvec *iov_d = &cmd->iov_data[iov_off];
 
                 tx_sent = tx_data(conn, iov_d, 1, ISCSI_CRC_LEN);
                 if (ISCSI_CRC_LEN != tx_sent) {
@@ -1433,8 +1405,7 @@ static int iscsit_do_rx_data(
         struct iscsi_data_count *count)
 {
         int data = count->data_length, rx_loop = 0, total_rx = 0, iov_len;
-        u32 rx_marker_val[count->ss_marker_count], rx_marker_iov = 0;
-        struct kvec iov[count->ss_iov_count], *iov_p;
+        struct kvec *iov_p;
         struct msghdr msg;
 
         if (!conn || !conn->sock || !conn->conn_ops)
@@ -1442,93 +1413,8 @@ static int iscsit_do_rx_data(
 
         memset(&msg, 0, sizeof(struct msghdr));
 
-        if (count->sync_and_steering) {
-                int size = 0;
-                u32 i, orig_iov_count = 0;
-                u32 orig_iov_len = 0, orig_iov_loc = 0;
-                u32 iov_count = 0, per_iov_bytes = 0;
-                u32 *rx_marker, old_rx_marker = 0;
-                struct kvec *iov_record;
-
-                memset(&rx_marker_val, 0,
-                                count->ss_marker_count * sizeof(u32));
-                memset(&iov, 0, count->ss_iov_count * sizeof(struct kvec));
-
-                iov_record = count->iov;
-                orig_iov_count = count->iov_count;
-                rx_marker = &conn->of_marker;
-
-                i = 0;
-                size = data;
-                orig_iov_len = iov_record[orig_iov_loc].iov_len;
-                while (size > 0) {
-                        pr_debug("rx_data: #1 orig_iov_len %u,"
-                        " orig_iov_loc %u\n", orig_iov_len, orig_iov_loc);
-                        pr_debug("rx_data: #2 rx_marker %u, size"
-                                " %u\n", *rx_marker, size);
-
-                        if (orig_iov_len >= *rx_marker) {
-                                iov[iov_count].iov_len = *rx_marker;
-                                iov[iov_count++].iov_base =
-                                        (iov_record[orig_iov_loc].iov_base +
-                                                per_iov_bytes);
-
-                                iov[iov_count].iov_len = (MARKER_SIZE / 2);
-                                iov[iov_count++].iov_base =
-                                        &rx_marker_val[rx_marker_iov++];
-                                iov[iov_count].iov_len = (MARKER_SIZE / 2);
-                                iov[iov_count++].iov_base =
-                                        &rx_marker_val[rx_marker_iov++];
-                                old_rx_marker = *rx_marker;
-
-                                /*
-                                 * OFMarkInt is in 32-bit words.
-                                 */
-                                *rx_marker = (conn->conn_ops->OFMarkInt * 4);
-                                size -= old_rx_marker;
-                                orig_iov_len -= old_rx_marker;
-                                per_iov_bytes += old_rx_marker;
-
-                                pr_debug("rx_data: #3 new_rx_marker"
-                                        " %u, size %u\n", *rx_marker, size);
-                        } else {
-                                iov[iov_count].iov_len = orig_iov_len;
-                                iov[iov_count++].iov_base =
-                                        (iov_record[orig_iov_loc].iov_base +
-                                                per_iov_bytes);
-
-                                per_iov_bytes = 0;
-                                *rx_marker -= orig_iov_len;
-                                size -= orig_iov_len;
-
-                                if (size)
-                                        orig_iov_len =
-                                        iov_record[++orig_iov_loc].iov_len;
-
-                                pr_debug("rx_data: #4 new_rx_marker"
-                                        " %u, size %u\n", *rx_marker, size);
-                        }
-                }
-                data += (rx_marker_iov * (MARKER_SIZE / 2));
-
-                iov_p   = &iov[0];
-                iov_len = iov_count;
-
-                if (iov_count > count->ss_iov_count) {
-                        pr_err("iov_count: %d, count->ss_iov_count:"
-                                " %d\n", iov_count, count->ss_iov_count);
-                        return -1;
-                }
-                if (rx_marker_iov > count->ss_marker_count) {
-                        pr_err("rx_marker_iov: %d, count->ss_marker"
-                                "_count: %d\n", rx_marker_iov,
-                                count->ss_marker_count);
-                        return -1;
-                }
-        } else {
-                iov_p = count->iov;
-                iov_len = count->iov_count;
-        }
+        iov_p = count->iov;
+        iov_len = count->iov_count;
 
         while (total_rx < data) {
                 rx_loop = kernel_recvmsg(conn->sock, &msg, iov_p, iov_len,
@@ -1543,16 +1429,6 @@ static int iscsit_do_rx_data(
                                 rx_loop, total_rx, data);
         }
 
-        if (count->sync_and_steering) {
-                int j;
-                for (j = 0; j < rx_marker_iov; j++) {
-                        pr_debug("rx_data: #5 j: %d, offset: %d\n",
-                                j, rx_marker_val[j]);
-                        conn->of_marker_offset = rx_marker_val[j];
-                }
-                total_rx -= (rx_marker_iov * (MARKER_SIZE / 2));
-        }
-
         return total_rx;
 }
 
@@ -1561,8 +1437,7 @@ static int iscsit_do_tx_data(
         struct iscsi_data_count *count)
 {
         int data = count->data_length, total_tx = 0, tx_loop = 0, iov_len;
-        u32 tx_marker_val[count->ss_marker_count], tx_marker_iov = 0;
-        struct kvec iov[count->ss_iov_count], *iov_p;
+        struct kvec *iov_p;
         struct msghdr msg;
 
         if (!conn || !conn->sock || !conn->conn_ops)
@@ -1575,98 +1450,8 @@ static int iscsit_do_tx_data(
 
         memset(&msg, 0, sizeof(struct msghdr));
 
-        if (count->sync_and_steering) {
-                int size = 0;
-                u32 i, orig_iov_count = 0;
-                u32 orig_iov_len = 0, orig_iov_loc = 0;
-                u32 iov_count = 0, per_iov_bytes = 0;
-                u32 *tx_marker, old_tx_marker = 0;
-                struct kvec *iov_record;
-
-                memset(&tx_marker_val, 0,
-                        count->ss_marker_count * sizeof(u32));
-                memset(&iov, 0, count->ss_iov_count * sizeof(struct kvec));
-
-                iov_record = count->iov;
-                orig_iov_count = count->iov_count;
-                tx_marker = &conn->if_marker;
-
-                i = 0;
-                size = data;
-                orig_iov_len = iov_record[orig_iov_loc].iov_len;
-                while (size > 0) {
-                        pr_debug("tx_data: #1 orig_iov_len %u,"
-                        " orig_iov_loc %u\n", orig_iov_len, orig_iov_loc);
-                        pr_debug("tx_data: #2 tx_marker %u, size"
-                                " %u\n", *tx_marker, size);
-
-                        if (orig_iov_len >= *tx_marker) {
-                                iov[iov_count].iov_len = *tx_marker;
-                                iov[iov_count++].iov_base =
-                                        (iov_record[orig_iov_loc].iov_base +
-                                                per_iov_bytes);
-
-                                tx_marker_val[tx_marker_iov] =
-                                                (size - *tx_marker);
-                                iov[iov_count].iov_len = (MARKER_SIZE / 2);
-                                iov[iov_count++].iov_base =
-                                        &tx_marker_val[tx_marker_iov++];
-                                iov[iov_count].iov_len = (MARKER_SIZE / 2);
-                                iov[iov_count++].iov_base =
-                                        &tx_marker_val[tx_marker_iov++];
-                                old_tx_marker = *tx_marker;
-
-                                /*
-                                 * IFMarkInt is in 32-bit words.
-                                 */
-                                *tx_marker = (conn->conn_ops->IFMarkInt * 4);
-                                size -= old_tx_marker;
-                                orig_iov_len -= old_tx_marker;
-                                per_iov_bytes += old_tx_marker;
-
-                                pr_debug("tx_data: #3 new_tx_marker"
-                                        " %u, size %u\n", *tx_marker, size);
-                                pr_debug("tx_data: #4 offset %u\n",
-                                        tx_marker_val[tx_marker_iov-1]);
-                        } else {
-                                iov[iov_count].iov_len = orig_iov_len;
-                                iov[iov_count++].iov_base
-                                        = (iov_record[orig_iov_loc].iov_base +
-                                                per_iov_bytes);
-
-                                per_iov_bytes = 0;
-                                *tx_marker -= orig_iov_len;
-                                size -= orig_iov_len;
-
-                                if (size)
-                                        orig_iov_len =
-                                        iov_record[++orig_iov_loc].iov_len;
-
-                                pr_debug("tx_data: #5 new_tx_marker"
-                                        " %u, size %u\n", *tx_marker, size);
-                        }
-                }
-
-                data += (tx_marker_iov * (MARKER_SIZE / 2));
-
-                iov_p = &iov[0];
-                iov_len = iov_count;
-
-                if (iov_count > count->ss_iov_count) {
-                        pr_err("iov_count: %d, count->ss_iov_count:"
-                                " %d\n", iov_count, count->ss_iov_count);
-                        return -1;
-                }
-                if (tx_marker_iov > count->ss_marker_count) {
-                        pr_err("tx_marker_iov: %d, count->ss_marker"
-                                "_count: %d\n", tx_marker_iov,
-                                count->ss_marker_count);
-                        return -1;
-                }
-        } else {
-                iov_p = count->iov;
-                iov_len = count->iov_count;
-        }
+        iov_p = count->iov;
+        iov_len = count->iov_count;
 
         while (total_tx < data) {
                 tx_loop = kernel_sendmsg(conn->sock, &msg, iov_p, iov_len,
@@ -1681,9 +1466,6 @@ static int iscsit_do_tx_data(
                                         tx_loop, total_tx, data);
         }
 
-        if (count->sync_and_steering)
-                total_tx -= (tx_marker_iov * (MARKER_SIZE / 2));
-
         return total_tx;
 }
 
@@ -1704,12 +1486,6 @@ int rx_data(
         c.data_length = data;
         c.type = ISCSI_RX_DATA;
 
-        if (conn->conn_ops->OFMarker &&
-           (conn->conn_state >= TARG_CONN_STATE_LOGGED_IN)) {
-                if (iscsit_determine_sync_and_steering_counts(conn, &c) < 0)
-                        return -1;
-        }
-
         return iscsit_do_rx_data(conn, &c);
 }
 
@@ -1730,12 +1506,6 @@ int tx_data(
         c.data_length = data;
         c.type = ISCSI_TX_DATA;
 
-        if (conn->conn_ops->IFMarker &&
-           (conn->conn_state >= TARG_CONN_STATE_LOGGED_IN)) {
-                if (iscsit_determine_sync_and_steering_counts(conn, &c) < 0)
-                        return -1;
-        }
-
         return iscsit_do_tx_data(conn, &c);
 }
 
diff --git a/drivers/target/target_core_cdb.c b/drivers/target/target_core_cdb.c
index 8ae09a1bdf74..f04d4ef99dca 100644
--- a/drivers/target/target_core_cdb.c
+++ b/drivers/target/target_core_cdb.c
@@ -24,6 +24,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/ctype.h>
 #include <asm/unaligned.h>
 #include <scsi/scsi.h>
 
@@ -67,6 +68,7 @@ target_emulate_inquiry_std(struct se_cmd *cmd)
 {
         struct se_lun *lun = cmd->se_lun;
         struct se_device *dev = cmd->se_dev;
+        struct se_portal_group *tpg = lun->lun_sep->sep_tpg;
         unsigned char *buf;
 
         /*
@@ -81,9 +83,13 @@ target_emulate_inquiry_std(struct se_cmd *cmd)
 
         buf = transport_kmap_first_data_page(cmd);
 
-        buf[0] = dev->transport->get_device_type(dev);
-        if (buf[0] == TYPE_TAPE)
-                buf[1] = 0x80;
+        if (dev == tpg->tpg_virt_lun0.lun_se_dev) {
+                buf[0] = 0x3f; /* Not connected */
+        } else {
+                buf[0] = dev->transport->get_device_type(dev);
+                if (buf[0] == TYPE_TAPE)
+                        buf[1] = 0x80;
+        }
         buf[2] = dev->transport->get_device_rev(dev);
 
         /*
@@ -149,6 +155,37 @@ target_emulate_evpd_80(struct se_cmd *cmd, unsigned char *buf)
         return 0;
 }
 
+static void
+target_parse_naa_6h_vendor_specific(struct se_device *dev, unsigned char *buf_off)
+{
+        unsigned char *p = &dev->se_sub_dev->t10_wwn.unit_serial[0];
+        unsigned char *buf = buf_off;
+        int cnt = 0, next = 1;
+        /*
+         * Generate up to 36 bits of VENDOR SPECIFIC IDENTIFIER starting on
+         * byte 3 bit 3-0 for NAA IEEE Registered Extended DESIGNATOR field
+         * format, followed by 64 bits of VENDOR SPECIFIC IDENTIFIER EXTENSION
+         * to complete the payload.  These are based from VPD=0x80 PRODUCT SERIAL
+         * NUMBER set via vpd_unit_serial in target_core_configfs.c to ensure
+         * per device uniqeness.
+         */
+        while (*p != '\0') {
+                if (cnt >= 13)
+                        break;
+                if (!isxdigit(*p)) {
+                        p++;
+                        continue;
+                }
+                if (next != 0) {
+                        buf[cnt++] |= hex_to_bin(*p++);
+                        next = 0;
+                } else {
+                        buf[cnt] = hex_to_bin(*p++) << 4;
+                        next = 1;
+                }
+        }
+}
+
 /*
  * Device identification VPD, for a complete list of
  * DESIGNATOR TYPEs see spc4r17 Table 459.
@@ -214,8 +251,7 @@ target_emulate_evpd_83(struct se_cmd *cmd, unsigned char *buf)
          * VENDOR_SPECIFIC_IDENTIFIER and
          * VENDOR_SPECIFIC_IDENTIFIER_EXTENTION
          */
-        buf[off++] |= hex_to_bin(dev->se_sub_dev->t10_wwn.unit_serial[0]);
-        hex2bin(&buf[off], &dev->se_sub_dev->t10_wwn.unit_serial[1], 12);
+        target_parse_naa_6h_vendor_specific(dev, &buf[off]);
 
         len = 20;
         off = (len + 4);
@@ -915,8 +951,8 @@ target_emulate_modesense(struct se_cmd *cmd, int ten)
                 length += target_modesense_control(dev, &buf[offset+length]);
                 break;
         default:
-                pr_err("Got Unknown Mode Page: 0x%02x\n",
-                                cdb[2] & 0x3f);
+                pr_err("MODE SENSE: unimplemented page/subpage: 0x%02x/0x%02x\n",
+                       cdb[2] & 0x3f, cdb[3]);
                 return PYX_TRANSPORT_UNKNOWN_MODE_PAGE;
         }
         offset += length;
@@ -1072,8 +1108,6 @@ target_emulate_unmap(struct se_task *task)
                 size -= 16;
         }
 
-        task->task_scsi_status = GOOD;
-        transport_complete_task(task, 1);
 err:
         transport_kunmap_first_data_page(cmd);
 
@@ -1085,24 +1119,17 @@ err:
  * Note this is not used for TCM/pSCSI passthrough
  */
 static int
-target_emulate_write_same(struct se_task *task, int write_same32)
+target_emulate_write_same(struct se_task *task, u32 num_blocks)
 {
         struct se_cmd *cmd = task->task_se_cmd;
         struct se_device *dev = cmd->se_dev;
         sector_t range;
         sector_t lba = cmd->t_task_lba;
-        unsigned int num_blocks;
         int ret;
         /*
-         * Extract num_blocks from the WRITE_SAME_* CDB.  Then use the explict
-         * range when non zero is supplied, otherwise calculate the remaining
-         * range based on ->get_blocks() - starting LBA.
+         * Use the explicit range when non zero is supplied, otherwise calculate
+         * the remaining range based on ->get_blocks() - starting LBA.
          */
-        if (write_same32)
-                num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]);
-        else
-                num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]);
-
         if (num_blocks != 0)
                 range = num_blocks;
         else
@@ -1117,8 +1144,6 @@ target_emulate_write_same(struct se_task *task, int write_same32)
                 return ret;
         }
 
-        task->task_scsi_status = GOOD;
-        transport_complete_task(task, 1);
         return 0;
 }
 
@@ -1165,13 +1190,23 @@ transport_emulate_control_cdb(struct se_task *task)
                 }
                 ret = target_emulate_unmap(task);
                 break;
+        case WRITE_SAME:
+                if (!dev->transport->do_discard) {
+                        pr_err("WRITE_SAME emulation not supported"
+                                        " for: %s\n", dev->transport->name);
+                        return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
+                }
+                ret = target_emulate_write_same(task,
+                                get_unaligned_be16(&cmd->t_task_cdb[7]));
+                break;
         case WRITE_SAME_16:
                 if (!dev->transport->do_discard) {
                         pr_err("WRITE_SAME_16 emulation not supported"
                                         " for: %s\n", dev->transport->name);
                         return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
                 }
-                ret = target_emulate_write_same(task, 0);
+                ret = target_emulate_write_same(task,
+                                get_unaligned_be32(&cmd->t_task_cdb[10]));
                 break;
         case VARIABLE_LENGTH_CMD:
                 service_action =
@@ -1184,7 +1219,8 @@ transport_emulate_control_cdb(struct se_task *task)
                                         dev->transport->name);
                                 return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
                         }
-                        ret = target_emulate_write_same(task, 1);
+                        ret = target_emulate_write_same(task,
+                                get_unaligned_be32(&cmd->t_task_cdb[28]));
                         break;
                 default:
                         pr_err("Unsupported VARIABLE_LENGTH_CMD SA:"
@@ -1219,8 +1255,14 @@ transport_emulate_control_cdb(struct se_task *task)
 
         if (ret < 0)
                 return ret;
-        task->task_scsi_status = GOOD;
-        transport_complete_task(task, 1);
+        /*
+         * Handle the successful completion here unless a caller
+         * has explictly requested an asychronous completion.
+         */
+        if (!(cmd->se_cmd_flags & SCF_EMULATE_CDB_ASYNC)) {
+                task->task_scsi_status = GOOD;
+                transport_complete_task(task, 1);
+        }
 
         return PYX_TRANSPORT_SENT_TO_TRANSPORT;
 }
diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
index b38b6c993e65..ca6e4a4df134 100644
--- a/drivers/target/target_core_device.c
+++ b/drivers/target/target_core_device.c
@@ -472,9 +472,9 @@ void core_clear_lun_from_tpg(struct se_lun *lun, struct se_portal_group *tpg)
         struct se_dev_entry *deve;
         u32 i;
 
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         list_for_each_entry(nacl, &tpg->acl_node_list, acl_list) {
-                spin_unlock_bh(&tpg->acl_node_lock);
+                spin_unlock_irq(&tpg->acl_node_lock);
 
                 spin_lock_irq(&nacl->device_list_lock);
                 for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
@@ -491,9 +491,9 @@ void core_clear_lun_from_tpg(struct se_lun *lun, struct se_portal_group *tpg)
                 }
                 spin_unlock_irq(&nacl->device_list_lock);
 
-                spin_lock_bh(&tpg->acl_node_lock);
+                spin_lock_irq(&tpg->acl_node_lock);
         }
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 }
 
 static struct se_port *core_alloc_port(struct se_device *dev)
@@ -839,6 +839,24 @@ int se_dev_check_shutdown(struct se_device *dev)
         return ret;
 }
 
+u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size)
+{
+        u32 tmp, aligned_max_sectors;
+        /*
+         * Limit max_sectors to a PAGE_SIZE aligned value for modern
+         * transport_allocate_data_tasks() operation.
+         */
+        tmp = rounddown((max_sectors * block_size), PAGE_SIZE);
+        aligned_max_sectors = (tmp / block_size);
+        if (max_sectors != aligned_max_sectors) {
+                printk(KERN_INFO "Rounding down aligned max_sectors from %u"
+                                " to %u\n", max_sectors, aligned_max_sectors);
+                return aligned_max_sectors;
+        }
+
+        return max_sectors;
+}
+
 void se_dev_set_default_attribs(
         struct se_device *dev,
         struct se_dev_limits *dev_limits)
@@ -878,6 +896,11 @@ void se_dev_set_default_attribs(
          * max_sectors is based on subsystem plugin dependent requirements.
          */
         dev->se_sub_dev->se_dev_attrib.hw_max_sectors = limits->max_hw_sectors;
+        /*
+         * Align max_sectors down to PAGE_SIZE to follow transport_allocate_data_tasks()
+         */
+        limits->max_sectors = se_dev_align_max_sectors(limits->max_sectors,
+                                                limits->logical_block_size);
         dev->se_sub_dev->se_dev_attrib.max_sectors = limits->max_sectors;
         /*
          * Set optimal_sectors from max_sectors, which can be lowered via
@@ -1242,6 +1265,11 @@ int se_dev_set_max_sectors(struct se_device *dev, u32 max_sectors)
                         return -EINVAL;
                 }
         }
+        /*
+         * Align max_sectors down to PAGE_SIZE to follow transport_allocate_data_tasks()
+         */
+        max_sectors = se_dev_align_max_sectors(max_sectors,
+                                dev->se_sub_dev->se_dev_attrib.block_size);
 
         dev->se_sub_dev->se_dev_attrib.max_sectors = max_sectors;
         pr_debug("dev[%p]: SE Device max_sectors changed to %u\n",
@@ -1344,15 +1372,17 @@ struct se_lun *core_dev_add_lun(
          */
         if (tpg->se_tpg_tfo->tpg_check_demo_mode(tpg)) {
                 struct se_node_acl *acl;
-                spin_lock_bh(&tpg->acl_node_lock);
+                spin_lock_irq(&tpg->acl_node_lock);
                 list_for_each_entry(acl, &tpg->acl_node_list, acl_list) {
-                        if (acl->dynamic_node_acl) {
-                                spin_unlock_bh(&tpg->acl_node_lock);
+                        if (acl->dynamic_node_acl &&
+                            (!tpg->se_tpg_tfo->tpg_check_demo_mode_login_only ||
+                             !tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg))) {
+                                spin_unlock_irq(&tpg->acl_node_lock);
                                 core_tpg_add_node_to_devs(acl, tpg);
-                                spin_lock_bh(&tpg->acl_node_lock);
+                                spin_lock_irq(&tpg->acl_node_lock);
                         }
                 }
-                spin_unlock_bh(&tpg->acl_node_lock);
+                spin_unlock_irq(&tpg->acl_node_lock);
         }
 
         return lun_p;
diff --git a/drivers/target/target_core_fabric_configfs.c b/drivers/target/target_core_fabric_configfs.c
index f1654694f4ea..55bbe0847a6d 100644
--- a/drivers/target/target_core_fabric_configfs.c
+++ b/drivers/target/target_core_fabric_configfs.c
@@ -481,7 +481,7 @@ static struct config_group *target_fabric_make_nodeacl(
 
         se_nacl = tf->tf_ops.fabric_make_nodeacl(se_tpg, group, name);
         if (IS_ERR(se_nacl))
-                return ERR_PTR(PTR_ERR(se_nacl));
+                return ERR_CAST(se_nacl);
 
         nacl_cg = &se_nacl->acl_group;
         nacl_cg->default_groups = se_nacl->acl_default_groups;
diff --git a/drivers/target/target_core_pr.c b/drivers/target/target_core_pr.c
index 1c1b849cd4fb..7fd3a161f7cc 100644
--- a/drivers/target/target_core_pr.c
+++ b/drivers/target/target_core_pr.c
@@ -1598,14 +1598,14 @@ static int core_scsi3_decode_spec_i_port(
                          * from the decoded fabric module specific TransportID
                          * at *i_str.
                          */
-                        spin_lock_bh(&tmp_tpg->acl_node_lock);
+                        spin_lock_irq(&tmp_tpg->acl_node_lock);
                         dest_node_acl = __core_tpg_get_initiator_node_acl(
                                                 tmp_tpg, i_str);
                         if (dest_node_acl) {
                                 atomic_inc(&dest_node_acl->acl_pr_ref_count);
                                 smp_mb__after_atomic_inc();
                         }
-                        spin_unlock_bh(&tmp_tpg->acl_node_lock);
+                        spin_unlock_irq(&tmp_tpg->acl_node_lock);
 
                         if (!dest_node_acl) {
                                 core_scsi3_tpg_undepend_item(tmp_tpg);
@@ -3496,14 +3496,14 @@ after_iport_check:
         /*
          * Locate the destination struct se_node_acl from the received Transport ID
          */
-        spin_lock_bh(&dest_se_tpg->acl_node_lock);
+        spin_lock_irq(&dest_se_tpg->acl_node_lock);
         dest_node_acl = __core_tpg_get_initiator_node_acl(dest_se_tpg,
                                 initiator_str);
         if (dest_node_acl) {
                 atomic_inc(&dest_node_acl->acl_pr_ref_count);
                 smp_mb__after_atomic_inc();
         }
-        spin_unlock_bh(&dest_se_tpg->acl_node_lock);
+        spin_unlock_irq(&dest_se_tpg->acl_node_lock);
 
         if (!dest_node_acl) {
                 pr_err("Unable to locate %s dest_node_acl for"
diff --git a/drivers/target/target_core_rd.c b/drivers/target/target_core_rd.c
index 3dd81d24d9a9..e567e129c697 100644
--- a/drivers/target/target_core_rd.c
+++ b/drivers/target/target_core_rd.c
@@ -390,12 +390,10 @@ static int rd_MEMCPY_read(struct rd_request *req)
                                 length = req->rd_size;
 
                         dst = sg_virt(&sg_d[i++]) + dst_offset;
-                        if (!dst)
-                                BUG();
+                        BUG_ON(!dst);
 
                         src = sg_virt(&sg_s[j]) + src_offset;
-                        if (!src)
-                                BUG();
+                        BUG_ON(!src);
 
                         dst_offset = 0;
                         src_offset = length;
@@ -415,8 +413,7 @@ static int rd_MEMCPY_read(struct rd_request *req)
                                 length = req->rd_size;
 
                         dst = sg_virt(&sg_d[i]) + dst_offset;
-                        if (!dst)
-                                BUG();
+                        BUG_ON(!dst);
 
                         if (sg_d[i].length == length) {
                                 i++;
@@ -425,8 +422,7 @@ static int rd_MEMCPY_read(struct rd_request *req)
                                 dst_offset = length;
 
                         src = sg_virt(&sg_s[j++]) + src_offset;
-                        if (!src)
-                                BUG();
+                        BUG_ON(!src);
 
                         src_offset = 0;
                         page_end = 1;
@@ -510,12 +506,10 @@ static int rd_MEMCPY_write(struct rd_request *req)
                                 length = req->rd_size;
 
                         src = sg_virt(&sg_s[i++]) + src_offset;
-                        if (!src)
-                                BUG();
+                        BUG_ON(!src);
 
                         dst = sg_virt(&sg_d[j]) + dst_offset;
-                        if (!dst)
-                                BUG();
+                        BUG_ON(!dst);
 
                         src_offset = 0;
                         dst_offset = length;
@@ -535,8 +529,7 @@ static int rd_MEMCPY_write(struct rd_request *req)
                                 length = req->rd_size;
 
                         src = sg_virt(&sg_s[i]) + src_offset;
-                        if (!src)
-                                BUG();
+                        BUG_ON(!src);
 
                         if (sg_s[i].length == length) {
                                 i++;
@@ -545,8 +538,7 @@ static int rd_MEMCPY_write(struct rd_request *req)
                                 src_offset = length;
 
                         dst = sg_virt(&sg_d[j++]) + dst_offset;
-                        if (!dst)
-                                BUG();
+                        BUG_ON(!dst);
 
                         dst_offset = 0;
                         page_end = 1;
diff --git a/drivers/target/target_core_tpg.c b/drivers/target/target_core_tpg.c
index 4f1ba4c5ef11..162b736c7342 100644
--- a/drivers/target/target_core_tpg.c
+++ b/drivers/target/target_core_tpg.c
@@ -137,15 +137,15 @@ struct se_node_acl *core_tpg_get_initiator_node_acl(
 {
         struct se_node_acl *acl;
 
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         list_for_each_entry(acl, &tpg->acl_node_list, acl_list) {
                 if (!strcmp(acl->initiatorname, initiatorname) &&
                     !acl->dynamic_node_acl) {
-                        spin_unlock_bh(&tpg->acl_node_lock);
+                        spin_unlock_irq(&tpg->acl_node_lock);
                         return acl;
                 }
         }
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 
         return NULL;
 }
@@ -298,13 +298,21 @@ struct se_node_acl *core_tpg_check_initiator_node_acl(
                 tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg, acl);
                 return NULL;
         }
+        /*
+         * Here we only create demo-mode MappedLUNs from the active
+         * TPG LUNs if the fabric is not explictly asking for
+         * tpg_check_demo_mode_login_only() == 1.
+         */
+        if ((tpg->se_tpg_tfo->tpg_check_demo_mode_login_only != NULL) &&
+            (tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg) == 1))
+                do { ; } while (0);
+        else
+                core_tpg_add_node_to_devs(acl, tpg);
 
-        core_tpg_add_node_to_devs(acl, tpg);
-
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         list_add_tail(&acl->acl_list, &tpg->acl_node_list);
         tpg->num_node_acls++;
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 
         pr_debug("%s_TPG[%u] - Added DYNAMIC ACL with TCQ Depth: %d for %s"
                 " Initiator Node: %s\n", tpg->se_tpg_tfo->get_fabric_name(),
@@ -354,7 +362,7 @@ struct se_node_acl *core_tpg_add_initiator_node_acl(
 {
         struct se_node_acl *acl = NULL;
 
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname);
         if (acl) {
                 if (acl->dynamic_node_acl) {
@@ -362,7 +370,7 @@ struct se_node_acl *core_tpg_add_initiator_node_acl(
                         pr_debug("%s_TPG[%u] - Replacing dynamic ACL"
                                 " for %s\n", tpg->se_tpg_tfo->get_fabric_name(),
                                 tpg->se_tpg_tfo->tpg_get_tag(tpg), initiatorname);
-                        spin_unlock_bh(&tpg->acl_node_lock);
+                        spin_unlock_irq(&tpg->acl_node_lock);
                         /*
                          * Release the locally allocated struct se_node_acl
                          * because * core_tpg_add_initiator_node_acl() returned
@@ -378,10 +386,10 @@ struct se_node_acl *core_tpg_add_initiator_node_acl(
                         " Node %s already exists for TPG %u, ignoring"
                         " request.\n",  tpg->se_tpg_tfo->get_fabric_name(),
                         initiatorname, tpg->se_tpg_tfo->tpg_get_tag(tpg));
-                spin_unlock_bh(&tpg->acl_node_lock);
+                spin_unlock_irq(&tpg->acl_node_lock);
                 return ERR_PTR(-EEXIST);
         }
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 
         if (!se_nacl) {
                 pr_err("struct se_node_acl pointer is NULL\n");
@@ -418,10 +426,10 @@ struct se_node_acl *core_tpg_add_initiator_node_acl(
                 return ERR_PTR(-EINVAL);
         }
 
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         list_add_tail(&acl->acl_list, &tpg->acl_node_list);
         tpg->num_node_acls++;
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 
 done:
         pr_debug("%s_TPG[%hu] - Added ACL with TCQ Depth: %d for %s"
@@ -445,14 +453,14 @@ int core_tpg_del_initiator_node_acl(
         struct se_session *sess, *sess_tmp;
         int dynamic_acl = 0;
 
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         if (acl->dynamic_node_acl) {
                 acl->dynamic_node_acl = 0;
                 dynamic_acl = 1;
         }
         list_del(&acl->acl_list);
         tpg->num_node_acls--;
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 
         spin_lock_bh(&tpg->session_lock);
         list_for_each_entry_safe(sess, sess_tmp,
@@ -503,21 +511,21 @@ int core_tpg_set_initiator_node_queue_depth(
         struct se_node_acl *acl;
         int dynamic_acl = 0;
 
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname);
         if (!acl) {
                 pr_err("Access Control List entry for %s Initiator"
                         " Node %s does not exists for TPG %hu, ignoring"
                         " request.\n", tpg->se_tpg_tfo->get_fabric_name(),
                         initiatorname, tpg->se_tpg_tfo->tpg_get_tag(tpg));
-                spin_unlock_bh(&tpg->acl_node_lock);
+                spin_unlock_irq(&tpg->acl_node_lock);
                 return -ENODEV;
         }
         if (acl->dynamic_node_acl) {
                 acl->dynamic_node_acl = 0;
                 dynamic_acl = 1;
         }
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 
         spin_lock_bh(&tpg->session_lock);
         list_for_each_entry(sess, &tpg->tpg_sess_list, sess_list) {
@@ -533,10 +541,10 @@ int core_tpg_set_initiator_node_queue_depth(
                                 tpg->se_tpg_tfo->get_fabric_name(), initiatorname);
                         spin_unlock_bh(&tpg->session_lock);
 
-                        spin_lock_bh(&tpg->acl_node_lock);
+                        spin_lock_irq(&tpg->acl_node_lock);
                         if (dynamic_acl)
                                 acl->dynamic_node_acl = 1;
-                        spin_unlock_bh(&tpg->acl_node_lock);
+                        spin_unlock_irq(&tpg->acl_node_lock);
                         return -EEXIST;
                 }
                 /*
@@ -571,10 +579,10 @@ int core_tpg_set_initiator_node_queue_depth(
                 if (init_sess)
                         tpg->se_tpg_tfo->close_session(init_sess);
 
-                spin_lock_bh(&tpg->acl_node_lock);
+                spin_lock_irq(&tpg->acl_node_lock);
                 if (dynamic_acl)
                         acl->dynamic_node_acl = 1;
-                spin_unlock_bh(&tpg->acl_node_lock);
+                spin_unlock_irq(&tpg->acl_node_lock);
                 return -EINVAL;
         }
         spin_unlock_bh(&tpg->session_lock);
@@ -590,10 +598,10 @@ int core_tpg_set_initiator_node_queue_depth(
                 initiatorname, tpg->se_tpg_tfo->get_fabric_name(),
                 tpg->se_tpg_tfo->tpg_get_tag(tpg));
 
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         if (dynamic_acl)
                 acl->dynamic_node_acl = 1;
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 
         return 0;
 }
@@ -717,20 +725,20 @@ int core_tpg_deregister(struct se_portal_group *se_tpg)
          * not been released because of TFO->tpg_check_demo_mode_cache() == 1
          * in transport_deregister_session().
          */
-        spin_lock_bh(&se_tpg->acl_node_lock);
+        spin_lock_irq(&se_tpg->acl_node_lock);
         list_for_each_entry_safe(nacl, nacl_tmp, &se_tpg->acl_node_list,
                         acl_list) {
                 list_del(&nacl->acl_list);
                 se_tpg->num_node_acls--;
-                spin_unlock_bh(&se_tpg->acl_node_lock);
+                spin_unlock_irq(&se_tpg->acl_node_lock);
 
                 core_tpg_wait_for_nacl_pr_ref(nacl);
                 core_free_device_list_for_node(nacl, se_tpg);
                 se_tpg->se_tpg_tfo->tpg_release_fabric_acl(se_tpg, nacl);
 
-                spin_lock_bh(&se_tpg->acl_node_lock);
+                spin_lock_irq(&se_tpg->acl_node_lock);
         }
-        spin_unlock_bh(&se_tpg->acl_node_lock);
+        spin_unlock_irq(&se_tpg->acl_node_lock);
 
         if (se_tpg->se_tpg_type == TRANSPORT_TPG_TYPE_NORMAL)
                 core_tpg_release_virtual_lun0(se_tpg);
diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index 89760329d5d0..a4b0a8d27f25 100644
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -389,17 +389,18 @@ void transport_deregister_session(struct se_session *se_sess)
 {
         struct se_portal_group *se_tpg = se_sess->se_tpg;
         struct se_node_acl *se_nacl;
+        unsigned long flags;
 
         if (!se_tpg) {
                 transport_free_session(se_sess);
                 return;
         }
 
-        spin_lock_bh(&se_tpg->session_lock);
+        spin_lock_irqsave(&se_tpg->session_lock, flags);
         list_del(&se_sess->sess_list);
         se_sess->se_tpg = NULL;
         se_sess->fabric_sess_ptr = NULL;
-        spin_unlock_bh(&se_tpg->session_lock);
+        spin_unlock_irqrestore(&se_tpg->session_lock, flags);
 
         /*
          * Determine if we need to do extra work for this initiator node's
@@ -407,22 +408,22 @@ void transport_deregister_session(struct se_session *se_sess)
          */
         se_nacl = se_sess->se_node_acl;
         if (se_nacl) {
-                spin_lock_bh(&se_tpg->acl_node_lock);
+                spin_lock_irqsave(&se_tpg->acl_node_lock, flags);
                 if (se_nacl->dynamic_node_acl) {
                         if (!se_tpg->se_tpg_tfo->tpg_check_demo_mode_cache(
                                         se_tpg)) {
                                 list_del(&se_nacl->acl_list);
                                 se_tpg->num_node_acls--;
-                                spin_unlock_bh(&se_tpg->acl_node_lock);
+                                spin_unlock_irqrestore(&se_tpg->acl_node_lock, flags);
 
                                 core_tpg_wait_for_nacl_pr_ref(se_nacl);
                                 core_free_device_list_for_node(se_nacl, se_tpg);
                                 se_tpg->se_tpg_tfo->tpg_release_fabric_acl(se_tpg,
                                                 se_nacl);
-                                spin_lock_bh(&se_tpg->acl_node_lock);
+                                spin_lock_irqsave(&se_tpg->acl_node_lock, flags);
                         }
                 }
-                spin_unlock_bh(&se_tpg->acl_node_lock);
+                spin_unlock_irqrestore(&se_tpg->acl_node_lock, flags);
         }
 
         transport_free_session(se_sess);
@@ -976,15 +977,17 @@ static void target_qf_do_work(struct work_struct *work)
 {
         struct se_device *dev = container_of(work, struct se_device,
                                         qf_work_queue);
+        LIST_HEAD(qf_cmd_list);
         struct se_cmd *cmd, *cmd_tmp;
 
         spin_lock_irq(&dev->qf_cmd_lock);
-        list_for_each_entry_safe(cmd, cmd_tmp, &dev->qf_cmd_list, se_qf_node) {
+        list_splice_init(&dev->qf_cmd_list, &qf_cmd_list);
+        spin_unlock_irq(&dev->qf_cmd_lock);
 
+        list_for_each_entry_safe(cmd, cmd_tmp, &qf_cmd_list, se_qf_node) {
                 list_del(&cmd->se_qf_node);
                 atomic_dec(&dev->dev_qf_count);
                 smp_mb__after_atomic_dec();
-                spin_unlock_irq(&dev->qf_cmd_lock);
 
                 pr_debug("Processing %s cmd: %p QUEUE_FULL in work queue"
                         " context: %s\n", cmd->se_tfo->get_fabric_name(), cmd,
@@ -996,10 +999,7 @@ static void target_qf_do_work(struct work_struct *work)
                  * has been added to head of queue
                  */
                 transport_add_cmd_to_queue(cmd, cmd->t_state);
-
-                spin_lock_irq(&dev->qf_cmd_lock);
         }
-        spin_unlock_irq(&dev->qf_cmd_lock);
 }
 
 unsigned char *transport_dump_cmd_direction(struct se_cmd *cmd)
@@ -2053,8 +2053,14 @@ static void transport_generic_request_failure(
                 cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE;
                 break;
         }
-
-        if (!sc)
+        /*
+         * If a fabric does not define a cmd->se_tfo->new_cmd_map caller,
+         * make the call to transport_send_check_condition_and_sense()
+         * directly.  Otherwise expect the fabric to make the call to
+         * transport_send_check_condition_and_sense() after handling
+         * possible unsoliticied write data payloads.
+         */
+        if (!sc && !cmd->se_tfo->new_cmd_map)
                 transport_new_cmd_failure(cmd);
         else {
                 ret = transport_send_check_condition_and_sense(cmd,
@@ -2847,12 +2853,42 @@ static int transport_cmd_get_valid_sectors(struct se_cmd *cmd)
                         " transport_dev_end_lba(): %llu\n",
                         cmd->t_task_lba, sectors,
                         transport_dev_end_lba(dev));
-                pr_err("  We should return CHECK_CONDITION"
-                       " but we don't yet\n");
-                return 0;
+                return -EINVAL;
         }
 
-        return sectors;
+        return 0;
+}
+
+static int target_check_write_same_discard(unsigned char *flags, struct se_device *dev)
+{
+        /*
+         * Determine if the received WRITE_SAME is used to for direct
+         * passthrough into Linux/SCSI with struct request via TCM/pSCSI
+         * or we are signaling the use of internal WRITE_SAME + UNMAP=1
+         * emulation for -> Linux/BLOCK disbard with TCM/IBLOCK code.
+         */
+        int passthrough = (dev->transport->transport_type ==
+                                TRANSPORT_PLUGIN_PHBA_PDEV);
+
+        if (!passthrough) {
+                if ((flags[0] & 0x04) || (flags[0] & 0x02)) {
+                        pr_err("WRITE_SAME PBDATA and LBDATA"
+                                " bits not supported for Block Discard"
+                                " Emulation\n");
+                        return -ENOSYS;
+                }
+                /*
+                 * Currently for the emulated case we only accept
+                 * tpws with the UNMAP=1 bit set.
+                 */
+                if (!(flags[0] & 0x08)) {
+                        pr_err("WRITE_SAME w/o UNMAP bit not"
+                                " supported for Block Discard Emulation\n");
+                        return -ENOSYS;
+                }
+        }
+
+        return 0;
 }
 
 /*      transport_generic_cmd_sequencer():
@@ -3065,7 +3101,7 @@ static int transport_generic_cmd_sequencer(
                                 goto out_unsupported_cdb;
 
                         if (sectors)
-                                size = transport_get_size(sectors, cdb, cmd);
+                                size = transport_get_size(1, cdb, cmd);
                         else {
                                 pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not"
                                        " supported\n");
@@ -3075,27 +3111,9 @@ static int transport_generic_cmd_sequencer(
                         cmd->t_task_lba = get_unaligned_be64(&cdb[12]);
                         cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
 
-                        /*
-                         * Skip the remaining assignments for TCM/PSCSI passthrough
-                         */
-                        if (passthrough)
-                                break;
-
-                        if ((cdb[10] & 0x04) || (cdb[10] & 0x02)) {
-                                pr_err("WRITE_SAME PBDATA and LBDATA"
-                                        " bits not supported for Block Discard"
-                                        " Emulation\n");
+                        if (target_check_write_same_discard(&cdb[10], dev) < 0)
                                 goto out_invalid_cdb_field;
-                        }
-                        /*
-                         * Currently for the emulated case we only accept
-                         * tpws with the UNMAP=1 bit set.
-                         */
-                        if (!(cdb[10] & 0x08)) {
-                                pr_err("WRITE_SAME w/o UNMAP bit not"
-                                        " supported for Block Discard Emulation\n");
-                                goto out_invalid_cdb_field;
-                        }
+
                         break;
                 default:
                         pr_err("VARIABLE_LENGTH_CMD service action"
@@ -3330,10 +3348,12 @@ static int transport_generic_cmd_sequencer(
                 cmd->se_cmd_flags |= SCF_EMULATE_CDB_ASYNC;
                 /*
                  * Check to ensure that LBA + Range does not exceed past end of
-                 * device.
+                 * device for IBLOCK and FILEIO ->do_sync_cache() backend calls
                  */
-                if (!transport_cmd_get_valid_sectors(cmd))
-                        goto out_invalid_cdb_field;
+                if ((cmd->t_task_lba != 0) || (sectors != 0)) {
+                        if (transport_cmd_get_valid_sectors(cmd) < 0)
+                                goto out_invalid_cdb_field;
+                }
                 break;
         case UNMAP:
                 size = get_unaligned_be16(&cdb[7]);
@@ -3345,40 +3365,38 @@ static int transport_generic_cmd_sequencer(
                         goto out_unsupported_cdb;
 
                 if (sectors)
-                        size = transport_get_size(sectors, cdb, cmd);
+                        size = transport_get_size(1, cdb, cmd);
                 else {
                         pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
                         goto out_invalid_cdb_field;
                 }
 
                 cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
-                passthrough = (dev->transport->transport_type ==
-                                TRANSPORT_PLUGIN_PHBA_PDEV);
-                /*
-                 * Determine if the received WRITE_SAME_16 is used to for direct
-                 * passthrough into Linux/SCSI with struct request via TCM/pSCSI
-                 * or we are signaling the use of internal WRITE_SAME + UNMAP=1
-                 * emulation for -> Linux/BLOCK disbard with TCM/IBLOCK and
-                 * TCM/FILEIO subsystem plugin backstores.
-                 */
-                if (!passthrough) {
-                        if ((cdb[1] & 0x04) || (cdb[1] & 0x02)) {
-                                pr_err("WRITE_SAME PBDATA and LBDATA"
-                                        " bits not supported for Block Discard"
-                                        " Emulation\n");
-                                goto out_invalid_cdb_field;
-                        }
-                        /*
-                         * Currently for the emulated case we only accept
-                         * tpws with the UNMAP=1 bit set.
-                         */
-                        if (!(cdb[1] & 0x08)) {
-                                pr_err("WRITE_SAME w/o UNMAP bit not "
-                                        " supported for Block Discard Emulation\n");
-                                goto out_invalid_cdb_field;
-                        }
+                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
+
+                if (target_check_write_same_discard(&cdb[1], dev) < 0)
+                        goto out_invalid_cdb_field;
+                break;
+        case WRITE_SAME:
+                sectors = transport_get_sectors_10(cdb, cmd, &sector_ret);
+                if (sector_ret)
+                        goto out_unsupported_cdb;
+
+                if (sectors)
+                        size = transport_get_size(1, cdb, cmd);
+                else {
+                        pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
+                        goto out_invalid_cdb_field;
                 }
+
+                cmd->t_task_lba = get_unaligned_be32(&cdb[2]);
                 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
+                /*
+                 * Follow sbcr26 with WRITE_SAME (10) and check for the existence
+                 * of byte 1 bit 3 UNMAP instead of original reserved field
+                 */
+                if (target_check_write_same_discard(&cdb[1], dev) < 0)
+                        goto out_invalid_cdb_field;
                 break;
         case ALLOW_MEDIUM_REMOVAL:
         case GPCMD_CLOSE_TRACK:
@@ -3873,9 +3891,7 @@ EXPORT_SYMBOL(transport_generic_map_mem_to_cmd);
 static int transport_new_cmd_obj(struct se_cmd *cmd)
 {
         struct se_device *dev = cmd->se_dev;
-        u32 task_cdbs;
-        u32 rc;
-        int set_counts = 1;
+        int set_counts = 1, rc, task_cdbs;
 
         /*
          * Setup any BIDI READ tasks and memory from
@@ -3893,7 +3909,7 @@ static int transport_new_cmd_obj(struct se_cmd *cmd)
                         cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
                         cmd->scsi_sense_reason =
                                 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
-                        return PYX_TRANSPORT_LU_COMM_FAILURE;
+                        return -EINVAL;
                 }
                 atomic_inc(&cmd->t_fe_count);
                 atomic_inc(&cmd->t_se_count);
@@ -3912,7 +3928,7 @@ static int transport_new_cmd_obj(struct se_cmd *cmd)
                 cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
                 cmd->scsi_sense_reason =
                         TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
-                return PYX_TRANSPORT_LU_COMM_FAILURE;
+                return -EINVAL;
         }
 
         if (set_counts) {
@@ -4028,8 +4044,6 @@ void transport_do_task_sg_chain(struct se_cmd *cmd)
                 if (!task->task_sg)
                         continue;
 
-                BUG_ON(!task->task_padded_sg);
-
                 if (!sg_first) {
                         sg_first = task->task_sg;
                         chained_nents = task->task_sg_nents;
@@ -4037,9 +4051,19 @@ void transport_do_task_sg_chain(struct se_cmd *cmd)
                         sg_chain(sg_prev, sg_prev_nents, task->task_sg);
                         chained_nents += task->task_sg_nents;
                 }
+                /*
+                 * For the padded tasks, use the extra SGL vector allocated
+                 * in transport_allocate_data_tasks() for the sg_prev_nents
+                 * offset into sg_chain() above..  The last task of a
+                 * multi-task list, or a single task will not have
+                 * task->task_sg_padded set..
+                 */
+                if (task->task_padded_sg)
+                        sg_prev_nents = (task->task_sg_nents + 1);
+                else
+                        sg_prev_nents = task->task_sg_nents;
 
                 sg_prev = task->task_sg;
-                sg_prev_nents = task->task_sg_nents;
         }
         /*
          * Setup the starting pointer and total t_tasks_sg_linked_no including
@@ -4091,7 +4115,7 @@ static int transport_allocate_data_tasks(
         
         cmd_sg = sgl;
         for (i = 0; i < task_count; i++) {
-                unsigned int task_size;
+                unsigned int task_size, task_sg_nents_padded;
                 int count;
 
                 task = transport_generic_get_task(cmd, data_direction);
@@ -4110,30 +4134,33 @@ static int transport_allocate_data_tasks(
 
                 /* Update new cdb with updated lba/sectors */
                 cmd->transport_split_cdb(task->task_lba, task->task_sectors, cdb);
-
+                /*
+                 * This now assumes that passed sg_ents are in PAGE_SIZE chunks
+                 * in order to calculate the number per task SGL entries
+                 */
+                task->task_sg_nents = DIV_ROUND_UP(task->task_size, PAGE_SIZE);
                 /*
                  * Check if the fabric module driver is requesting that all
                  * struct se_task->task_sg[] be chained together..  If so,
                  * then allocate an extra padding SG entry for linking and
-                 * marking the end of the chained SGL.
-                 * Possibly over-allocate task sgl size by using cmd sgl size.
-                 * It's so much easier and only a waste when task_count > 1.
-                 * That is extremely rare.
+                 * marking the end of the chained SGL for every task except
+                 * the last one for (task_count > 1) operation, or skipping
+                 * the extra padding for the (task_count == 1) case.
                  */
-                task->task_sg_nents = sgl_nents;
-                if (cmd->se_tfo->task_sg_chaining) {
-                        task->task_sg_nents++;
+                if (cmd->se_tfo->task_sg_chaining && (i < (task_count - 1))) {
+                        task_sg_nents_padded = (task->task_sg_nents + 1);
                         task->task_padded_sg = 1;
-                }
+                } else
+                        task_sg_nents_padded = task->task_sg_nents;
 
                 task->task_sg = kmalloc(sizeof(struct scatterlist) *
-                                        task->task_sg_nents, GFP_KERNEL);
+                                        task_sg_nents_padded, GFP_KERNEL);
                 if (!task->task_sg) {
                         cmd->se_dev->transport->free_task(task);
                         return -ENOMEM;
                 }
 
-                sg_init_table(task->task_sg, task->task_sg_nents);
+                sg_init_table(task->task_sg, task_sg_nents_padded);
 
                 task_size = task->task_size;
 
@@ -4230,10 +4257,13 @@ static u32 transport_allocate_tasks(
         struct scatterlist *sgl,
         unsigned int sgl_nents)
 {
-        if (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB)
+        if (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) {
+                if (transport_cmd_get_valid_sectors(cmd) < 0)
+                        return -EINVAL;
+
                 return transport_allocate_data_tasks(cmd, lba, data_direction,
                                                      sgl, sgl_nents);
-        else
+        } else
                 return transport_allocate_control_task(cmd);
 
 }
@@ -4726,6 +4756,13 @@ int transport_send_check_condition_and_sense(
          */
         switch (reason) {
         case TCM_NON_EXISTENT_LUN:
+                /* CURRENT ERROR */
+                buffer[offset] = 0x70;
+                /* ILLEGAL REQUEST */
+                buffer[offset+SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST;
+                /* LOGICAL UNIT NOT SUPPORTED */
+                buffer[offset+SPC_ASC_KEY_OFFSET] = 0x25;
+                break;
         case TCM_UNSUPPORTED_SCSI_OPCODE:
         case TCM_SECTOR_COUNT_TOO_MANY:
                 /* CURRENT ERROR */
diff --git a/drivers/target/tcm_fc/tcm_fc.h b/drivers/target/tcm_fc/tcm_fc.h
index bd4fe21a23b8..3749d8b4b423 100644
--- a/drivers/target/tcm_fc/tcm_fc.h
+++ b/drivers/target/tcm_fc/tcm_fc.h
@@ -98,8 +98,7 @@ struct ft_tpg {
         struct list_head list;          /* linkage in ft_lport_acl tpg_list */
         struct list_head lun_list;      /* head of LUNs */
         struct se_portal_group se_tpg;
-        struct task_struct *thread;     /* processing thread */
-        struct se_queue_obj qobj;       /* queue for processing thread */
+        struct workqueue_struct *workqueue;
 };
 
 struct ft_lport_acl {
@@ -110,16 +109,10 @@ struct ft_lport_acl {
         struct se_wwn fc_lport_wwn;
 };
 
-enum ft_cmd_state {
-        FC_CMD_ST_NEW = 0,
-        FC_CMD_ST_REJ
-};
-
 /*
  * Commands
  */
 struct ft_cmd {
-        enum ft_cmd_state state;
         u32 lun;                        /* LUN from request */
         struct ft_sess *sess;           /* session held for cmd */
         struct fc_seq *seq;             /* sequence in exchange mgr */
@@ -127,7 +120,7 @@ struct ft_cmd {
         struct fc_frame *req_frame;
         unsigned char *cdb;             /* pointer to CDB inside frame */
         u32 write_data_len;             /* data received on writes */
-        struct se_queue_req se_req;
+        struct work_struct work;
         /* Local sense buffer */
         unsigned char ft_sense_buffer[TRANSPORT_SENSE_BUFFER];
         u32 was_ddp_setup:1;            /* Set only if ddp is setup */
@@ -177,7 +170,6 @@ int ft_is_state_remove(struct se_cmd *);
 /*
  * other internal functions.
  */
-int ft_thread(void *);
 void ft_recv_req(struct ft_sess *, struct fc_frame *);
 struct ft_tpg *ft_lport_find_tpg(struct fc_lport *);
 struct ft_node_acl *ft_acl_get(struct ft_tpg *, struct fc_rport_priv *);
diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
index 5654dc22f7ae..80fbcde00cb6 100644
--- a/drivers/target/tcm_fc/tfc_cmd.c
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -62,8 +62,8 @@ void ft_dump_cmd(struct ft_cmd *cmd, const char *caller)
         int count;
 
         se_cmd = &cmd->se_cmd;
-        pr_debug("%s: cmd %p state %d sess %p seq %p se_cmd %p\n",
-                caller, cmd, cmd->state, cmd->sess, cmd->seq, se_cmd);
+        pr_debug("%s: cmd %p sess %p seq %p se_cmd %p\n",
+                caller, cmd, cmd->sess, cmd->seq, se_cmd);
         pr_debug("%s: cmd %p cdb %p\n",
                 caller, cmd, cmd->cdb);
         pr_debug("%s: cmd %p lun %d\n", caller, cmd, cmd->lun);
@@ -90,38 +90,6 @@ void ft_dump_cmd(struct ft_cmd *cmd, const char *caller)
                 16, 4, cmd->cdb, MAX_COMMAND_SIZE, 0);
 }
 
-static void ft_queue_cmd(struct ft_sess *sess, struct ft_cmd *cmd)
-{
-        struct ft_tpg *tpg = sess->tport->tpg;
-        struct se_queue_obj *qobj = &tpg->qobj;
-        unsigned long flags;
-
-        qobj = &sess->tport->tpg->qobj;
-        spin_lock_irqsave(&qobj->cmd_queue_lock, flags);
-        list_add_tail(&cmd->se_req.qr_list, &qobj->qobj_list);
-        atomic_inc(&qobj->queue_cnt);
-        spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
-
-        wake_up_process(tpg->thread);
-}
-
-static struct ft_cmd *ft_dequeue_cmd(struct se_queue_obj *qobj)
-{
-        unsigned long flags;
-        struct se_queue_req *qr;
-
-        spin_lock_irqsave(&qobj->cmd_queue_lock, flags);
-        if (list_empty(&qobj->qobj_list)) {
-                spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
-                return NULL;
-        }
-        qr = list_first_entry(&qobj->qobj_list, struct se_queue_req, qr_list);
-        list_del(&qr->qr_list);
-        atomic_dec(&qobj->queue_cnt);
-        spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
-        return container_of(qr, struct ft_cmd, se_req);
-}
-
 static void ft_free_cmd(struct ft_cmd *cmd)
 {
         struct fc_frame *fp;
@@ -282,9 +250,7 @@ u32 ft_get_task_tag(struct se_cmd *se_cmd)
 
 int ft_get_cmd_state(struct se_cmd *se_cmd)
 {
-        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
-
-        return cmd->state;
+        return 0;
 }
 
 int ft_is_state_remove(struct se_cmd *se_cmd)
@@ -505,6 +471,8 @@ int ft_queue_tm_resp(struct se_cmd *se_cmd)
         return 0;
 }
 
+static void ft_send_work(struct work_struct *work);
+
 /*
  * Handle incoming FCP command.
  */
@@ -523,7 +491,9 @@ static void ft_recv_cmd(struct ft_sess *sess, struct fc_frame *fp)
                 goto busy;
         }
         cmd->req_frame = fp;            /* hold frame during cmd */
-        ft_queue_cmd(sess, cmd);
+
+        INIT_WORK(&cmd->work, ft_send_work);
+        queue_work(sess->tport->tpg->workqueue, &cmd->work);
         return;
 
 busy:
@@ -563,12 +533,13 @@ void ft_recv_req(struct ft_sess *sess, struct fc_frame *fp)
 /*
  * Send new command to target.
  */
-static void ft_send_cmd(struct ft_cmd *cmd)
+static void ft_send_work(struct work_struct *work)
 {
+        struct ft_cmd *cmd = container_of(work, struct ft_cmd, work);
         struct fc_frame_header *fh = fc_frame_header_get(cmd->req_frame);
         struct se_cmd *se_cmd;
         struct fcp_cmnd *fcp;
-        int data_dir;
+        int data_dir = 0;
         u32 data_len;
         int task_attr;
         int ret;
@@ -675,42 +646,3 @@ static void ft_send_cmd(struct ft_cmd *cmd)
 err:
         ft_send_resp_code_and_free(cmd, FCP_CMND_FIELDS_INVALID);
 }
-
-/*
- * Handle request in the command thread.
- */
-static void ft_exec_req(struct ft_cmd *cmd)
-{
-        pr_debug("cmd state %x\n", cmd->state);
-        switch (cmd->state) {
-        case FC_CMD_ST_NEW:
-                ft_send_cmd(cmd);
-                break;
-        default:
-                break;
-        }
-}
-
-/*
- * Processing thread.
- * Currently one thread per tpg.
- */
-int ft_thread(void *arg)
-{
-        struct ft_tpg *tpg = arg;
-        struct se_queue_obj *qobj = &tpg->qobj;
-        struct ft_cmd *cmd;
-
-        while (!kthread_should_stop()) {
-                schedule_timeout_interruptible(MAX_SCHEDULE_TIMEOUT);
-                if (kthread_should_stop())
-                        goto out;
-
-                cmd = ft_dequeue_cmd(qobj);
-                if (cmd)
-                        ft_exec_req(cmd);
-        }
-
-out:
-        return 0;
-}
diff --git a/drivers/target/tcm_fc/tfc_conf.c b/drivers/target/tcm_fc/tfc_conf.c
index 8781d1e423df..8fa39b74f22c 100644
--- a/drivers/target/tcm_fc/tfc_conf.c
+++ b/drivers/target/tcm_fc/tfc_conf.c
@@ -256,7 +256,7 @@ struct ft_node_acl *ft_acl_get(struct ft_tpg *tpg, struct fc_rport_priv *rdata)
         struct se_portal_group *se_tpg = &tpg->se_tpg;
         struct se_node_acl *se_acl;
 
-        spin_lock_bh(&se_tpg->acl_node_lock);
+        spin_lock_irq(&se_tpg->acl_node_lock);
         list_for_each_entry(se_acl, &se_tpg->acl_node_list, acl_list) {
                 acl = container_of(se_acl, struct ft_node_acl, se_node_acl);
                 pr_debug("acl %p port_name %llx\n",
@@ -270,7 +270,7 @@ struct ft_node_acl *ft_acl_get(struct ft_tpg *tpg, struct fc_rport_priv *rdata)
                         break;
                 }
         }
-        spin_unlock_bh(&se_tpg->acl_node_lock);
+        spin_unlock_irq(&se_tpg->acl_node_lock);
         return found;
 }
 
@@ -327,7 +327,6 @@ static struct se_portal_group *ft_add_tpg(
         tpg->index = index;
         tpg->lport_acl = lacl;
         INIT_LIST_HEAD(&tpg->lun_list);
-        transport_init_queue_obj(&tpg->qobj);
 
         ret = core_tpg_register(&ft_configfs->tf_ops, wwn, &tpg->se_tpg,
                                 tpg, TRANSPORT_TPG_TYPE_NORMAL);
@@ -336,8 +335,8 @@ static struct se_portal_group *ft_add_tpg(
                 return NULL;
         }
 
-        tpg->thread = kthread_run(ft_thread, tpg, "ft_tpg%lu", index);
-        if (IS_ERR(tpg->thread)) {
+        tpg->workqueue = alloc_workqueue("tcm_fc", 0, 1);
+        if (!tpg->workqueue) {
                 kfree(tpg);
                 return NULL;
         }
@@ -356,7 +355,7 @@ static void ft_del_tpg(struct se_portal_group *se_tpg)
         pr_debug("del tpg %s\n",
                     config_item_name(&tpg->se_tpg.tpg_group.cg_item));
 
-        kthread_stop(tpg->thread);
+        destroy_workqueue(tpg->workqueue);
 
         /* Wait for sessions to be freed thru RCU, for BUG_ON below */
         synchronize_rcu();
@@ -655,9 +654,7 @@ static void __exit ft_exit(void)
         synchronize_rcu();
 }
 
-#ifdef MODULE
 MODULE_DESCRIPTION("FC TCM fabric driver " FT_VERSION);
 MODULE_LICENSE("GPL");
 module_init(ft_init);
 module_exit(ft_exit);
-#endif /* MODULE */
diff --git a/drivers/target/tcm_fc/tfc_io.c b/drivers/target/tcm_fc/tfc_io.c
index c37f4cd96452..d35ea5a3d56c 100644
--- a/drivers/target/tcm_fc/tfc_io.c
+++ b/drivers/target/tcm_fc/tfc_io.c
@@ -219,43 +219,41 @@ void ft_recv_write_data(struct ft_cmd *cmd, struct fc_frame *fp)
         if (cmd->was_ddp_setup) {
                 BUG_ON(!ep);
                 BUG_ON(!lport);
-        }
-
-        /*
-         * Doesn't expect payload if DDP is setup. Payload
-         * is expected to be copied directly to user buffers
-         * due to DDP (Large Rx offload),
-         */
-        buf = fc_frame_payload_get(fp, 1);
-        if (buf)
-                pr_err("%s: xid 0x%x, f_ctl 0x%x, cmd->sg %p, "
+                /*
+                 * Since DDP (Large Rx offload) was setup for this request,
+                 * payload is expected to be copied directly to user buffers.
+                 */
+                buf = fc_frame_payload_get(fp, 1);
+                if (buf)
+                        pr_err("%s: xid 0x%x, f_ctl 0x%x, cmd->sg %p, "
                                 "cmd->sg_cnt 0x%x. DDP was setup"
                                 " hence not expected to receive frame with "
-                                "payload, Frame will be dropped if "
-                                "'Sequence Initiative' bit in f_ctl is "
+                                "payload, Frame will be dropped if"
+                                "'Sequence Initiative' bit in f_ctl is"
                                 "not set\n", __func__, ep->xid, f_ctl,
                                 cmd->sg, cmd->sg_cnt);
-        /*
-         * Invalidate HW DDP context if it was setup for respective
-         * command. Invalidation of HW DDP context is requited in both
-         * situation (success and error). 
-         */
-        ft_invl_hw_context(cmd);
+                /*
+                 * Invalidate HW DDP context if it was setup for respective
+                 * command. Invalidation of HW DDP context is requited in both
+                 * situation (success and error).
+                 */
+                ft_invl_hw_context(cmd);
 
-        /*
-         * If "Sequence Initiative (TSI)" bit set in f_ctl, means last
-         * write data frame is received successfully where payload is
-         * posted directly to user buffer and only the last frame's
-         * header is posted in receive queue.
-         *
-         * If "Sequence Initiative (TSI)" bit is not set, means error
-         * condition w.r.t. DDP, hence drop the packet and let explict
-         * ABORTS from other end of exchange timer trigger the recovery.
-         */
-        if (f_ctl & FC_FC_SEQ_INIT)
-                goto last_frame;
-        else
-                goto drop;
+                /*
+                 * If "Sequence Initiative (TSI)" bit set in f_ctl, means last
+                 * write data frame is received successfully where payload is
+                 * posted directly to user buffer and only the last frame's
+                 * header is posted in receive queue.
+                 *
+                 * If "Sequence Initiative (TSI)" bit is not set, means error
+                 * condition w.r.t. DDP, hence drop the packet and let explict
+                 * ABORTS from other end of exchange timer trigger the recovery.
+                 */
+                if (f_ctl & FC_FC_SEQ_INIT)
+                        goto last_frame;
+                else
+                        goto drop;
+        }
 
         rel_off = ntohl(fh->fh_parm_offset);
         frame_len = fr_len(fp);
diff --git a/drivers/tty/pty.c b/drivers/tty/pty.c
index 98b6e3bdb000..e809e9d4683c 100644
--- a/drivers/tty/pty.c
+++ b/drivers/tty/pty.c
@@ -446,8 +446,19 @@ static inline void legacy_pty_init(void) { }
 int pty_limit = NR_UNIX98_PTY_DEFAULT;
 static int pty_limit_min;
 static int pty_limit_max = NR_UNIX98_PTY_MAX;
+static int tty_count;
 static int pty_count;
 
+static inline void pty_inc_count(void)
+{
+        pty_count = (++tty_count) / 2;
+}
+
+static inline void pty_dec_count(void)
+{
+        pty_count = (--tty_count) / 2;
+}
+
 static struct cdev ptmx_cdev;
 
 static struct ctl_table pty_table[] = {
@@ -542,6 +553,7 @@ static struct tty_struct *pts_unix98_lookup(struct tty_driver *driver,
 
 static void pty_unix98_shutdown(struct tty_struct *tty)
 {
+        tty_driver_remove_tty(tty->driver, tty);
         /* We have our own method as we don't use the tty index */
         kfree(tty->termios);
 }
@@ -588,7 +600,8 @@ static int pty_unix98_install(struct tty_driver *driver, struct tty_struct *tty)
          */
         tty_driver_kref_get(driver);
         tty->count++;
-        pty_count++;
+        pty_inc_count(); /* tty */
+        pty_inc_count(); /* tty->link */
         return 0;
 err_free_mem:
         deinitialize_tty_struct(o_tty);
@@ -602,7 +615,7 @@ err_free_tty:
 
 static void pty_unix98_remove(struct tty_driver *driver, struct tty_struct *tty)
 {
-        pty_count--;
+        pty_dec_count();
 }
 
 static const struct tty_operations ptm_unix98_ops = {
diff --git a/drivers/tty/serial/8250.c b/drivers/tty/serial/8250.c
index f2dfec82faf8..7f50999eebc2 100644
--- a/drivers/tty/serial/8250.c
+++ b/drivers/tty/serial/8250.c
@@ -1819,6 +1819,8 @@ static void serial8250_backup_timeout(unsigned long data)
         unsigned int iir, ier = 0, lsr;
         unsigned long flags;
 
+        spin_lock_irqsave(&up->port.lock, flags);
+
         /*
          * Must disable interrupts or else we risk racing with the interrupt
          * based handler.
@@ -1836,10 +1838,8 @@ static void serial8250_backup_timeout(unsigned long data)
          * the "Diva" UART used on the management processor on many HP
          * ia64 and parisc boxes.
          */
-        spin_lock_irqsave(&up->port.lock, flags);
         lsr = serial_in(up, UART_LSR);
         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
-        spin_unlock_irqrestore(&up->port.lock, flags);
         if ((iir & UART_IIR_NO_INT) && (up->ier & UART_IER_THRI) &&
             (!uart_circ_empty(&up->port.state->xmit) || up->port.x_char) &&
             (lsr & UART_LSR_THRE)) {
@@ -1848,11 +1848,13 @@ static void serial8250_backup_timeout(unsigned long data)
         }
 
         if (!(iir & UART_IIR_NO_INT))
-                serial8250_handle_port(up);
+                transmit_chars(up);
 
         if (is_real_interrupt(up->port.irq))
                 serial_out(up, UART_IER, ier);
 
+        spin_unlock_irqrestore(&up->port.lock, flags);
+
         /* Standard timer interval plus 0.2s to keep the port running */
         mod_timer(&up->timer,
                 jiffies + uart_poll_timeout(&up->port) + HZ / 5);
diff --git a/drivers/tty/serial/8250_pci.c b/drivers/tty/serial/8250_pci.c
index 6b887d90a205..3abeca2a2a1b 100644
--- a/drivers/tty/serial/8250_pci.c
+++ b/drivers/tty/serial/8250_pci.c
@@ -1599,11 +1599,6 @@ static struct pci_serial_quirk pci_serial_quirks[] __refdata = {
                 .device         = 0x800D,
                 .init           = pci_eg20t_init,
         },
-        {
-                .vendor         = 0x10DB,
-                .device         = 0x800D,
-                .init           = pci_eg20t_init,
-        },
         /*
          * Cronyx Omega PCI (PLX-chip based)
          */
@@ -4021,7 +4016,7 @@ static struct pci_device_id serial_pci_tbl[] = {
                 0, 0, pbn_NETMOS9900_2s_115200 },
 
         /*
-         * Best Connectivity PCI Multi I/O cards
+         * Best Connectivity and Rosewill PCI Multi I/O cards
          */
 
         {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
@@ -4029,6 +4024,10 @@ static struct pci_device_id serial_pci_tbl[] = {
                 0, 0, pbn_b0_1_115200 },
 
         {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
+                0xA000, 0x3002,
+                0, 0, pbn_b0_bt_2_115200 },
+
+        {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
                 0xA000, 0x3004,
                 0, 0, pbn_b0_bt_4_115200 },
         /* Intel CE4100 */
diff --git a/drivers/tty/serial/8250_pnp.c b/drivers/tty/serial/8250_pnp.c
index fc301f6722e1..a2f236510ff1 100644
--- a/drivers/tty/serial/8250_pnp.c
+++ b/drivers/tty/serial/8250_pnp.c
@@ -109,6 +109,9 @@ static const struct pnp_device_id pnp_dev_table[] = {
         /* IBM */
         /* IBM Thinkpad 701 Internal Modem Voice */
         {       "IBM0033",              0       },
+        /* Intermec */
+        /* Intermec CV60 touchscreen port */
+        {       "PNP4972",              0       },
         /* Intertex */
         /* Intertex 28k8 33k6 Voice EXT PnP */
         {       "IXDC801",              0       },
diff --git a/drivers/tty/serial/atmel_serial.c b/drivers/tty/serial/atmel_serial.c
index af9b7814965a..caba6730a943 100644
--- a/drivers/tty/serial/atmel_serial.c
+++ b/drivers/tty/serial/atmel_serial.c
@@ -46,7 +46,7 @@
 
 #ifdef CONFIG_ARM
 #include <mach/cpu.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #endif
 
 #define PDC_BUFFER_SIZE         512
@@ -1609,9 +1609,11 @@ static struct console atmel_console = {
 static int __init atmel_console_init(void)
 {
         if (atmel_default_console_device) {
-                add_preferred_console(ATMEL_DEVICENAME,
-                                      atmel_default_console_device->id, NULL);
-                atmel_init_port(&atmel_ports[atmel_default_console_device->id],
+                struct atmel_uart_data *pdata =
+                        atmel_default_console_device->dev.platform_data;
+
+                add_preferred_console(ATMEL_DEVICENAME, pdata->num, NULL);
+                atmel_init_port(&atmel_ports[pdata->num],
                                 atmel_default_console_device);
                 register_console(&atmel_console);
         }
diff --git a/drivers/tty/serial/crisv10.c b/drivers/tty/serial/crisv10.c
index 225123b37f19..58be715913cd 100644
--- a/drivers/tty/serial/crisv10.c
+++ b/drivers/tty/serial/crisv10.c
@@ -4450,7 +4450,7 @@ static int __init rs_init(void)
 
 #if defined(CONFIG_ETRAX_RS485)
 #if defined(CONFIG_ETRAX_RS485_ON_PA)
-        if (cris_io_interface_allocate_pins(if_ser0, 'a', rs485_pa_bit,
+        if (cris_io_interface_allocate_pins(if_serial_0, 'a', rs485_pa_bit,
                         rs485_pa_bit)) {
                 printk(KERN_CRIT "ETRAX100LX serial: Could not allocate "
                         "RS485 pin\n");
@@ -4459,7 +4459,7 @@ static int __init rs_init(void)
         }
 #endif
 #if defined(CONFIG_ETRAX_RS485_ON_PORT_G)
-        if (cris_io_interface_allocate_pins(if_ser0, 'g', rs485_pa_bit,
+        if (cris_io_interface_allocate_pins(if_serial_0, 'g', rs485_pa_bit,
                         rs485_port_g_bit)) {
                 printk(KERN_CRIT "ETRAX100LX serial: Could not allocate "
                         "RS485 pin\n");
diff --git a/drivers/tty/serial/max3107-aava.c b/drivers/tty/serial/max3107-aava.c
index a1fe304f2f52..d73aadd7a9ad 100644
--- a/drivers/tty/serial/max3107-aava.c
+++ b/drivers/tty/serial/max3107-aava.c
@@ -340,5 +340,5 @@ module_exit(max3107_exit);
 
 MODULE_DESCRIPTION("MAX3107 driver");
 MODULE_AUTHOR("Aavamobile");
-MODULE_ALIAS("aava-max3107-spi");
+MODULE_ALIAS("spi:aava-max3107");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/tty/serial/max3107.c b/drivers/tty/serial/max3107.c
index 750b4f627315..a8164601c0ea 100644
--- a/drivers/tty/serial/max3107.c
+++ b/drivers/tty/serial/max3107.c
@@ -1209,5 +1209,5 @@ module_exit(max3107_exit);
 
 MODULE_DESCRIPTION("MAX3107 driver");
 MODULE_AUTHOR("Aavamobile");
-MODULE_ALIAS("max3107-spi");
+MODULE_ALIAS("spi:max3107");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/tty/serial/mrst_max3110.c b/drivers/tty/serial/mrst_max3110.c
index a764bf99743b..23bc743f2a22 100644
--- a/drivers/tty/serial/mrst_max3110.c
+++ b/drivers/tty/serial/mrst_max3110.c
@@ -917,4 +917,4 @@ module_init(serial_m3110_init);
 module_exit(serial_m3110_exit);
 
 MODULE_LICENSE("GPL v2");
-MODULE_ALIAS("max3110-uart");
+MODULE_ALIAS("spi:max3110-uart");
diff --git a/drivers/tty/serial/omap-serial.c b/drivers/tty/serial/omap-serial.c
index c37df8d0fa28..5e713d3ef1f4 100644
--- a/drivers/tty/serial/omap-serial.c
+++ b/drivers/tty/serial/omap-serial.c
@@ -806,8 +806,7 @@ serial_omap_set_termios(struct uart_port *port, struct ktermios *termios,
 
         serial_omap_set_mctrl(&up->port, up->port.mctrl);
         /* Software Flow Control Configuration */
-        if (termios->c_iflag & (IXON | IXOFF))
-                serial_omap_configure_xonxoff(up, termios);
+        serial_omap_configure_xonxoff(up, termios);
 
         spin_unlock_irqrestore(&up->port.lock, flags);
         dev_dbg(up->port.dev, "serial_omap_set_termios+%d\n", up->pdev->id);
diff --git a/drivers/tty/serial/pch_uart.c b/drivers/tty/serial/pch_uart.c
index 846dfcd3ce0d..b46218d679e2 100644
--- a/drivers/tty/serial/pch_uart.c
+++ b/drivers/tty/serial/pch_uart.c
@@ -598,7 +598,8 @@ static void pch_request_dma(struct uart_port *port)
         dma_cap_zero(mask);
         dma_cap_set(DMA_SLAVE, mask);
 
-        dma_dev = pci_get_bus_and_slot(2, PCI_DEVFN(0xa, 0)); /* Get DMA's dev
+        dma_dev = pci_get_bus_and_slot(priv->pdev->bus->number,
+                                       PCI_DEVFN(0xa, 0)); /* Get DMA's dev
                                                                 information */
         /* Set Tx DMA */
         param = &priv->param_tx;
diff --git a/drivers/tty/serial/samsung.c b/drivers/tty/serial/samsung.c
index afc629423152..6edafb5ace18 100644
--- a/drivers/tty/serial/samsung.c
+++ b/drivers/tty/serial/samsung.c
@@ -1225,15 +1225,19 @@ static const struct dev_pm_ops s3c24xx_serial_pm_ops = {
         .suspend = s3c24xx_serial_suspend,
         .resume = s3c24xx_serial_resume,
 };
+#define SERIAL_SAMSUNG_PM_OPS   (&s3c24xx_serial_pm_ops)
+
 #else /* !CONFIG_PM_SLEEP */
-#define s3c24xx_serial_pm_ops   NULL
+
+#define SERIAL_SAMSUNG_PM_OPS   NULL
 #endif /* CONFIG_PM_SLEEP */
 
 int s3c24xx_serial_init(struct platform_driver *drv,
                         struct s3c24xx_uart_info *info)
 {
         dbg("s3c24xx_serial_init(%p,%p)\n", drv, info);
-        drv->driver.pm = &s3c24xx_serial_pm_ops;
+
+        drv->driver.pm = SERIAL_SAMSUNG_PM_OPS;
 
         return platform_driver_register(drv);
 }
diff --git a/drivers/tty/serial/serial_core.c b/drivers/tty/serial/serial_core.c
index db7912cb7ae0..a3efbea5dbba 100644
--- a/drivers/tty/serial/serial_core.c
+++ b/drivers/tty/serial/serial_core.c
@@ -200,6 +200,11 @@ static int uart_startup(struct tty_struct *tty, struct uart_state *state, int in
                 clear_bit(TTY_IO_ERROR, &tty->flags);
         }
 
+        /*
+         * This is to allow setserial on this port. People may want to set
+         * port/irq/type and then reconfigure the port properly if it failed
+         * now.
+         */
         if (retval && capable(CAP_SYS_ADMIN))
                 retval = 0;
 
diff --git a/drivers/tty/serial/sh-sci.c b/drivers/tty/serial/sh-sci.c
index 2ec57b2fb278..5ea6ec3442e6 100644
--- a/drivers/tty/serial/sh-sci.c
+++ b/drivers/tty/serial/sh-sci.c
@@ -47,6 +47,7 @@
 #include <linux/ctype.h>
 #include <linux/err.h>
 #include <linux/dmaengine.h>
+#include <linux/dma-mapping.h>
 #include <linux/scatterlist.h>
 #include <linux/slab.h>
 
@@ -95,6 +96,12 @@ struct sci_port {
 #endif
 
         struct notifier_block           freq_transition;
+
+#ifdef CONFIG_SERIAL_SH_SCI_CONSOLE
+        unsigned short saved_smr;
+        unsigned short saved_fcr;
+        unsigned char saved_brr;
+#endif
 };
 
 /* Function prototypes */
@@ -1076,7 +1083,7 @@ static unsigned int sci_get_mctrl(struct uart_port *port)
         /* This routine is used for getting signals of: DTR, DCD, DSR, RI,
            and CTS/RTS */
 
-        return TIOCM_DTR | TIOCM_RTS | TIOCM_DSR;
+        return TIOCM_DTR | TIOCM_RTS | TIOCM_CTS | TIOCM_DSR;
 }
 
 #ifdef CONFIG_SERIAL_SH_SCI_DMA
@@ -1633,11 +1640,25 @@ static unsigned int sci_scbrr_calc(unsigned int algo_id, unsigned int bps,
         return ((freq + 16 * bps) / (32 * bps) - 1);
 }
 
+static void sci_reset(struct uart_port *port)
+{
+        unsigned int status;
+
+        do {
+                status = sci_in(port, SCxSR);
+        } while (!(status & SCxSR_TEND(port)));
+
+        sci_out(port, SCSCR, 0x00);     /* TE=0, RE=0, CKE1=0 */
+
+        if (port->type != PORT_SCI)
+                sci_out(port, SCFCR, SCFCR_RFRST | SCFCR_TFRST);
+}
+
 static void sci_set_termios(struct uart_port *port, struct ktermios *termios,
                             struct ktermios *old)
 {
         struct sci_port *s = to_sci_port(port);
-        unsigned int status, baud, smr_val, max_baud;
+        unsigned int baud, smr_val, max_baud;
         int t = -1;
         u16 scfcr = 0;
 
@@ -1657,14 +1678,7 @@ static void sci_set_termios(struct uart_port *port, struct ktermios *termios,
 
         sci_port_enable(s);
 
-        do {
-                status = sci_in(port, SCxSR);
-        } while (!(status & SCxSR_TEND(port)));
-
-        sci_out(port, SCSCR, 0x00);     /* TE=0, RE=0, CKE1=0 */
-
-        if (port->type != PORT_SCI)
-                sci_out(port, SCFCR, scfcr | SCFCR_RFRST | SCFCR_TFRST);
+        sci_reset(port);
 
         smr_val = sci_in(port, SCSMR) & 3;
 
@@ -1913,6 +1927,7 @@ static int __devinit sci_init_single(struct platform_device *dev,
 
                 port->dev = &dev->dev;
 
+                pm_runtime_irq_safe(&dev->dev);
                 pm_runtime_enable(&dev->dev);
         }
 
@@ -2036,7 +2051,8 @@ static int __devinit serial_console_setup(struct console *co, char *options)
         if (options)
                 uart_parse_options(options, &baud, &parity, &bits, &flow);
 
-        /* TODO: disable clock */
+        sci_port_disable(sci_port);
+
         return uart_set_options(port, co, baud, parity, bits, flow);
 }
 
@@ -2079,6 +2095,36 @@ static int __devinit sci_probe_earlyprintk(struct platform_device *pdev)
         return 0;
 }
 
+#define uart_console(port)      ((port)->cons->index == (port)->line)
+
+static int sci_runtime_suspend(struct device *dev)
+{
+        struct sci_port *sci_port = dev_get_drvdata(dev);
+        struct uart_port *port = &sci_port->port;
+
+        if (uart_console(port)) {
+                sci_port->saved_smr = sci_in(port, SCSMR);
+                sci_port->saved_brr = sci_in(port, SCBRR);
+                sci_port->saved_fcr = sci_in(port, SCFCR);
+        }
+        return 0;
+}
+
+static int sci_runtime_resume(struct device *dev)
+{
+        struct sci_port *sci_port = dev_get_drvdata(dev);
+        struct uart_port *port = &sci_port->port;
+
+        if (uart_console(port)) {
+                sci_reset(port);
+                sci_out(port, SCSMR, sci_port->saved_smr);
+                sci_out(port, SCBRR, sci_port->saved_brr);
+                sci_out(port, SCFCR, sci_port->saved_fcr);
+                sci_out(port, SCSCR, sci_port->cfg->scscr);
+        }
+        return 0;
+}
+
 #define SCI_CONSOLE     (&serial_console)
 
 #else
@@ -2088,6 +2134,8 @@ static inline int __devinit sci_probe_earlyprintk(struct platform_device *pdev)
 }
 
 #define SCI_CONSOLE     NULL
+#define sci_runtime_suspend     NULL
+#define sci_runtime_resume      NULL
 
 #endif /* CONFIG_SERIAL_SH_SCI_CONSOLE */
 
@@ -2203,6 +2251,8 @@ static int sci_resume(struct device *dev)
 }
 
 static const struct dev_pm_ops sci_dev_pm_ops = {
+        .runtime_suspend = sci_runtime_suspend,
+        .runtime_resume = sci_runtime_resume,
         .suspend        = sci_suspend,
         .resume         = sci_resume,
 };
diff --git a/drivers/tty/serial/ucc_uart.c b/drivers/tty/serial/ucc_uart.c
index c327218cad44..9af9f0879a24 100644
--- a/drivers/tty/serial/ucc_uart.c
+++ b/drivers/tty/serial/ucc_uart.c
@@ -235,7 +235,7 @@ static inline void *qe2cpu_addr(dma_addr_t addr, struct uart_qe_port *qe_port)
                 return qe_port->bd_virt + (addr - qe_port->bd_dma_addr);
 
         /* something nasty happened */
-        printk(KERN_ERR "%s: addr=%x\n", __func__, addr);
+        printk(KERN_ERR "%s: addr=%llx\n", __func__, (u64)addr);
         BUG();
         return NULL;
 }
diff --git a/drivers/tty/tty_io.c b/drivers/tty/tty_io.c
index 150e4f747c7d..4f1fc81112e6 100644
--- a/drivers/tty/tty_io.c
+++ b/drivers/tty/tty_io.c
@@ -1295,8 +1295,7 @@ static int tty_driver_install_tty(struct tty_driver *driver,
  *
  *      Locking: tty_mutex for now
  */
-static void tty_driver_remove_tty(struct tty_driver *driver,
-                                                struct tty_struct *tty)
+void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
 {
         if (driver->ops->remove)
                 driver->ops->remove(driver, tty);
diff --git a/drivers/usb/class/usbtmc.c b/drivers/usb/class/usbtmc.c
index 385acb895ab3..3f94ac34dce3 100644
--- a/drivers/usb/class/usbtmc.c
+++ b/drivers/usb/class/usbtmc.c
@@ -268,7 +268,7 @@ usbtmc_abort_bulk_in_status:
                                 dev_err(dev, "usb_bulk_msg returned %d\n", rv);
                                 goto exit;
                         }
-                } while ((actual = max_size) &&
+                } while ((actual == max_size) &&
                          (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN));
 
         if (actual == max_size) {
diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index c962608b4b9a..26678cadfb21 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -123,10 +123,11 @@ static void usb_parse_ss_endpoint_companion(struct device *ddev, int cfgno,
         }
 
         if (usb_endpoint_xfer_isoc(&ep->desc))
-                max_tx = ep->desc.wMaxPacketSize * (desc->bMaxBurst + 1) *
-                        (desc->bmAttributes + 1);
+                max_tx = (desc->bMaxBurst + 1) * (desc->bmAttributes + 1) *
+                        le16_to_cpu(ep->desc.wMaxPacketSize);
         else if (usb_endpoint_xfer_int(&ep->desc))
-                max_tx = ep->desc.wMaxPacketSize * (desc->bMaxBurst + 1);
+                max_tx = le16_to_cpu(ep->desc.wMaxPacketSize) *
+                        (desc->bMaxBurst + 1);
         else
                 max_tx = 999999;
         if (le16_to_cpu(desc->wBytesPerInterval) > max_tx) {
@@ -134,10 +135,10 @@ static void usb_parse_ss_endpoint_companion(struct device *ddev, int cfgno,
                                 "config %d interface %d altsetting %d ep %d: "
                                 "setting to %d\n",
                                 usb_endpoint_xfer_isoc(&ep->desc) ? "Isoc" : "Int",
-                                desc->wBytesPerInterval,
+                                le16_to_cpu(desc->wBytesPerInterval),
                                 cfgno, inum, asnum, ep->desc.bEndpointAddress,
                                 max_tx);
-                ep->ss_ep_comp.wBytesPerInterval = max_tx;
+                ep->ss_ep_comp.wBytesPerInterval = cpu_to_le16(max_tx);
         }
 }
 
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 8669ba3fe794..73cbbd85219f 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -1775,6 +1775,8 @@ int usb_hcd_alloc_bandwidth(struct usb_device *udev,
                 struct usb_interface *iface = usb_ifnum_to_if(udev,
                                 cur_alt->desc.bInterfaceNumber);
 
+                if (!iface)
+                        return -EINVAL;
                 if (iface->resetting_device) {
                         /*
                          * The USB core just reset the device, so the xHCI host
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 44b6b40aafb4..5a084b9cfa3c 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -310,7 +310,7 @@ config USB_PXA_U2O
 # musb builds in ../musb along with host support
 config USB_GADGET_MUSB_HDRC
         tristate "Inventra HDRC USB Peripheral (TI, ADI, ...)"
-        depends on USB_MUSB_HDRC && (USB_MUSB_PERIPHERAL || USB_MUSB_OTG)
+        depends on USB_MUSB_HDRC
         select USB_GADGET_DUALSPEED
         help
           This OTG-capable silicon IP is used in dual designs including
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index 98cbc06c30fd..ddb118a76807 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -35,6 +35,7 @@
 #include <linux/list.h>
 #include <linux/interrupt.h>
 #include <linux/proc_fs.h>
+#include <linux/prefetch.h>
 #include <linux/clk.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index 5ef87794fd32..aef47414f5d5 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -1079,10 +1079,12 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                         cdev->desc.bMaxPacketSize0 =
                                 cdev->gadget->ep0->maxpacket;
                         if (gadget_is_superspeed(gadget)) {
-                                if (gadget->speed >= USB_SPEED_SUPER)
+                                if (gadget->speed >= USB_SPEED_SUPER) {
                                         cdev->desc.bcdUSB = cpu_to_le16(0x0300);
-                                else
+                                        cdev->desc.bMaxPacketSize0 = 9;
+                                } else {
                                         cdev->desc.bcdUSB = cpu_to_le16(0x0210);
+                                }
                         }
 
                         value = min(w_length, (u16) sizeof cdev->desc);
diff --git a/drivers/usb/gadget/f_hid.c b/drivers/usb/gadget/f_hid.c
index 403a48bcf560..83a266bdb40e 100644
--- a/drivers/usb/gadget/f_hid.c
+++ b/drivers/usb/gadget/f_hid.c
@@ -367,6 +367,13 @@ static int hidg_setup(struct usb_function *f,
         case ((USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_INTERFACE) << 8
                   | USB_REQ_GET_DESCRIPTOR):
                 switch (value >> 8) {
+                case HID_DT_HID:
+                        VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: HID\n");
+                        length = min_t(unsigned short, length,
+                                                   hidg_desc.bLength);
+                        memcpy(req->buf, &hidg_desc, length);
+                        goto respond;
+                        break;
                 case HID_DT_REPORT:
                         VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: REPORT\n");
                         length = min_t(unsigned short, length,
diff --git a/drivers/usb/gadget/f_phonet.c b/drivers/usb/gadget/f_phonet.c
index 8f8d3f6cd89e..8f3eab1af885 100644
--- a/drivers/usb/gadget/f_phonet.c
+++ b/drivers/usb/gadget/f_phonet.c
@@ -434,6 +434,7 @@ static int pn_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                             config_ep_by_speed(gadget, f, fp->out_ep)) {
                                 fp->in_ep->desc = NULL;
                                 fp->out_ep->desc = NULL;
+                                spin_unlock(&port->lock);
                                 return -EINVAL;
                         }
                         usb_ep_enable(fp->out_ep);
diff --git a/drivers/usb/gadget/fusb300_udc.c b/drivers/usb/gadget/fusb300_udc.c
index 24a924330c81..4ec888f90002 100644
--- a/drivers/usb/gadget/fusb300_udc.c
+++ b/drivers/usb/gadget/fusb300_udc.c
@@ -609,107 +609,6 @@ void fusb300_rdcxf(struct fusb300 *fusb300,
         }
 }
 
-#if 0
-static void fusb300_dbg_fifo(struct fusb300_ep *ep,
-                                u8 entry, u16 length)
-{
-        u32 reg;
-        u32 i = 0;
-        u32 j = 0;
-
-        reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_GTM);
-        reg &= ~(FUSB300_GTM_TST_EP_ENTRY(0xF) |
-                FUSB300_GTM_TST_EP_NUM(0xF) | FUSB300_GTM_TST_FIFO_DEG);
-        reg |= (FUSB300_GTM_TST_EP_ENTRY(entry) |
-                FUSB300_GTM_TST_EP_NUM(ep->epnum) | FUSB300_GTM_TST_FIFO_DEG);
-        iowrite32(reg, ep->fusb300->reg + FUSB300_OFFSET_GTM);
-
-        for (i = 0; i < (length >> 2); i++) {
-                if (i * 4 == 1024)
-                        break;
-                reg = ioread32(ep->fusb300->reg +
-                        FUSB300_OFFSET_BUFDBG_START + i * 4);
-                printk(KERN_DEBUG"  0x%-8x", reg);
-                j++;
-                if ((j % 4)  == 0)
-                        printk(KERN_DEBUG "\n");
-        }
-
-        if (length % 4) {
-                reg = ioread32(ep->fusb300->reg +
-                        FUSB300_OFFSET_BUFDBG_START + i * 4);
-                printk(KERN_DEBUG "  0x%x\n", reg);
-        }
-
-        if ((j % 4)  != 0)
-                printk(KERN_DEBUG "\n");
-
-        fusb300_disable_bit(ep->fusb300, FUSB300_OFFSET_GTM,
-                FUSB300_GTM_TST_FIFO_DEG);
-}
-
-static void fusb300_cmp_dbg_fifo(struct fusb300_ep *ep,
-                                u8 entry, u16 length, u8 *golden)
-{
-        u32 reg;
-        u32 i = 0;
-        u32 golden_value;
-        u8 *tmp;
-
-        tmp = golden;
-
-        printk(KERN_DEBUG "fusb300_cmp_dbg_fifo (entry %d) : start\n", entry);
-
-        reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_GTM);
-        reg &= ~(FUSB300_GTM_TST_EP_ENTRY(0xF) |
-                FUSB300_GTM_TST_EP_NUM(0xF) | FUSB300_GTM_TST_FIFO_DEG);
-        reg |= (FUSB300_GTM_TST_EP_ENTRY(entry) |
-                FUSB300_GTM_TST_EP_NUM(ep->epnum) | FUSB300_GTM_TST_FIFO_DEG);
-        iowrite32(reg, ep->fusb300->reg + FUSB300_OFFSET_GTM);
-
-        for (i = 0; i < (length >> 2); i++) {
-                if (i * 4 == 1024)
-                        break;
-                golden_value = *tmp | *(tmp + 1) << 8 |
-                                *(tmp + 2) << 16 | *(tmp + 3) << 24;
-
-                reg = ioread32(ep->fusb300->reg +
-                        FUSB300_OFFSET_BUFDBG_START + i*4);
-
-                if (reg != golden_value) {
-                        printk(KERN_DEBUG "0x%x  :  ", (u32)(ep->fusb300->reg +
-                                FUSB300_OFFSET_BUFDBG_START + i*4));
-                        printk(KERN_DEBUG "    golden = 0x%x, reg = 0x%x\n",
-                                golden_value, reg);
-                }
-                tmp += 4;
-        }
-
-        switch (length % 4) {
-        case 1:
-                golden_value = *tmp;
-        case 2:
-                golden_value = *tmp | *(tmp + 1) << 8;
-        case 3:
-                golden_value = *tmp | *(tmp + 1) << 8 | *(tmp + 2) << 16;
-        default:
-                break;
-
-        reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_BUFDBG_START + i*4);
-        if (reg != golden_value) {
-                printk(KERN_DEBUG "0x%x:", (u32)(ep->fusb300->reg +
-                        FUSB300_OFFSET_BUFDBG_START + i*4));
-                printk(KERN_DEBUG "  golden = 0x%x, reg = 0x%x\n",
-                        golden_value, reg);
-        }
-        }
-
-        printk(KERN_DEBUG "fusb300_cmp_dbg_fifo : end\n");
-        fusb300_disable_bit(ep->fusb300, FUSB300_OFFSET_GTM,
-                FUSB300_GTM_TST_FIFO_DEG);
-}
-#endif
-
 static void fusb300_rdfifo(struct fusb300_ep *ep,
                           struct fusb300_request *req,
                           u32 length)
diff --git a/drivers/usb/gadget/net2272.c b/drivers/usb/gadget/net2272.c
index 7c7b0e120d88..ab98ea926a11 100644
--- a/drivers/usb/gadget/net2272.c
+++ b/drivers/usb/gadget/net2272.c
@@ -27,13 +27,13 @@
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/ioport.h>
-#include <linux/irq.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/pci.h>
 #include <linux/platform_device.h>
+#include <linux/prefetch.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/timer.h>
diff --git a/drivers/usb/gadget/s3c2410_udc.c b/drivers/usb/gadget/s3c2410_udc.c
index 85c1b0d66293..8d31848aab09 100644
--- a/drivers/usb/gadget/s3c2410_udc.c
+++ b/drivers/usb/gadget/s3c2410_udc.c
@@ -2060,6 +2060,7 @@ static int s3c2410_udc_resume(struct platform_device *pdev)
 static const struct platform_device_id s3c_udc_ids[] = {
         { "s3c2410-usbgadget", },
         { "s3c2440-usbgadget", },
+        { }
 };
 MODULE_DEVICE_TABLE(platform, s3c_udc_ids);
 
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index bf2c8f65e1ae..4c32cb19b405 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -343,7 +343,7 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
         u32                     temp;
         u32                     power_okay;
         int                     i;
-        u8                      resume_needed = 0;
+        unsigned long           resume_needed = 0;
 
         if (time_before (jiffies, ehci->next_statechange))
                 msleep(5);
@@ -416,7 +416,7 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
                 if (test_bit(i, &ehci->bus_suspended) &&
                                 (temp & PORT_SUSPEND)) {
                         temp |= PORT_RESUME;
-                        resume_needed = 1;
+                        set_bit(i, &resume_needed);
                 }
                 ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
         }
@@ -431,8 +431,7 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
         i = HCS_N_PORTS (ehci->hcs_params);
         while (i--) {
                 temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
-                if (test_bit(i, &ehci->bus_suspended) &&
-                                (temp & PORT_SUSPEND)) {
+                if (test_bit(i, &resume_needed)) {
                         temp &= ~(PORT_RWC_BITS | PORT_RESUME);
                         ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
                         ehci_vdbg (ehci, "resumed port %d\n", i + 1);
@@ -1046,7 +1045,19 @@ static int ehci_hub_control (
                         if (!selector || selector > 5)
                                 goto error;
                         ehci_quiesce(ehci);
+
+                        /* Put all enabled ports into suspend */
+                        while (ports--) {
+                                u32 __iomem *sreg =
+                                                &ehci->regs->port_status[ports];
+
+                                temp = ehci_readl(ehci, sreg) & ~PORT_RWC_BITS;
+                                if (temp & PORT_PE)
+                                        ehci_writel(ehci, temp | PORT_SUSPEND,
+                                                        sreg);
+                        }
                         ehci_halt(ehci);
+                        temp = ehci_readl(ehci, status_reg);
                         temp |= selector << 16;
                         ehci_writel(ehci, temp, status_reg);
                         break;
diff --git a/drivers/usb/host/ehci-mxc.c b/drivers/usb/host/ehci-mxc.c
index 0c058be35a38..555a73c864b5 100644
--- a/drivers/usb/host/ehci-mxc.c
+++ b/drivers/usb/host/ehci-mxc.c
@@ -24,6 +24,7 @@
 #include <linux/usb/ulpi.h>
 #include <linux/slab.h>
 
+#include <mach/hardware.h>
 #include <mach/mxc_ehci.h>
 
 #include <asm/mach-types.h>
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index 55a57c23dd0f..45240321ca09 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -98,6 +98,18 @@ static void omap_ehci_soft_phy_reset(struct platform_device *pdev, u8 port)
         }
 }
 
+static void disable_put_regulator(
+                struct ehci_hcd_omap_platform_data *pdata)
+{
+        int i;
+
+        for (i = 0 ; i < OMAP3_HS_USB_PORTS ; i++) {
+                if (pdata->regulator[i]) {
+                        regulator_disable(pdata->regulator[i]);
+                        regulator_put(pdata->regulator[i]);
+                }
+        }
+}
 
 /* configure so an HC device and id are always provided */
 /* always called with process context; sleeping is OK */
@@ -231,9 +243,11 @@ err_add_hcd:
         omap_usbhs_disable(dev);
 
 err_enable:
+        disable_put_regulator(pdata);
         usb_put_hcd(hcd);
 
 err_io:
+        iounmap(regs);
         return ret;
 }
 
@@ -253,6 +267,8 @@ static int ehci_hcd_omap_remove(struct platform_device *pdev)
 
         usb_remove_hcd(hcd);
         omap_usbhs_disable(dev);
+        disable_put_regulator(dev->platform_data);
+        iounmap(hcd->regs);
         usb_put_hcd(hcd);
         return 0;
 }
diff --git a/drivers/usb/host/ehci-s5p.c b/drivers/usb/host/ehci-s5p.c
index b3958b3d3163..9e77f1c8bdbd 100644
--- a/drivers/usb/host/ehci-s5p.c
+++ b/drivers/usb/host/ehci-s5p.c
@@ -86,6 +86,7 @@ static int __devinit s5p_ehci_probe(struct platform_device *pdev)
                 goto fail_hcd;
         }
 
+        s5p_ehci->hcd = hcd;
         s5p_ehci->clk = clk_get(&pdev->dev, "usbhost");
 
         if (IS_ERR(s5p_ehci->clk)) {
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index 55d3d5859ac5..840beda66dd9 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -1583,6 +1583,9 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
         int retval = 0;
 
         spin_lock_irqsave(&priv->lock, spinflags);
+        retval = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (retval)
+                goto out;
 
         qh = urb->ep->hcpriv;
         if (!qh) {
diff --git a/drivers/usb/host/ohci-pnx4008.c b/drivers/usb/host/ohci-pnx4008.c
index 653d6a60edb5..d1b41933199e 100644
--- a/drivers/usb/host/ohci-pnx4008.c
+++ b/drivers/usb/host/ohci-pnx4008.c
@@ -26,7 +26,7 @@
 
 #include <mach/platform.h>
 #include <mach/irqs.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 
 #define USB_CTRL        IO_ADDRESS(PNX4008_PWRMAN_BASE + 0x64)
 
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
index a9d315906e3d..629a96813fd6 100644
--- a/drivers/usb/host/pci-quirks.c
+++ b/drivers/usb/host/pci-quirks.c
@@ -535,7 +535,7 @@ static void __devinit quirk_usb_handoff_ohci(struct pci_dev *pdev)
         iounmap(base);
 }
 
-static const struct dmi_system_id __initconst ehci_dmi_nohandoff_table[] = {
+static const struct dmi_system_id __devinitconst ehci_dmi_nohandoff_table[] = {
         {
                 /*  Pegatron Lucid (ExoPC) */
                 .matches = {
@@ -817,7 +817,7 @@ static void __devinit quirk_usb_handoff_xhci(struct pci_dev *pdev)
 
         /* If the BIOS owns the HC, signal that the OS wants it, and wait */
         if (val & XHCI_HC_BIOS_OWNED) {
-                writel(val & XHCI_HC_OS_OWNED, base + ext_cap_offset);
+                writel(val | XHCI_HC_OS_OWNED, base + ext_cap_offset);
 
                 /* Wait for 5 seconds with 10 microsecond polling interval */
                 timeout = handshake(base + ext_cap_offset, XHCI_HC_BIOS_OWNED,
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 0be788cc2fdb..723f8231193d 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -463,11 +463,12 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                         && (temp & PORT_POWER))
                                 status |= USB_PORT_STAT_SUSPEND;
                 }
-                if ((temp & PORT_PLS_MASK) == XDEV_RESUME) {
+                if ((temp & PORT_PLS_MASK) == XDEV_RESUME &&
+                                !DEV_SUPERSPEED(temp)) {
                         if ((temp & PORT_RESET) || !(temp & PORT_PE))
                                 goto error;
-                        if (!DEV_SUPERSPEED(temp) && time_after_eq(jiffies,
-                                                bus_state->resume_done[wIndex])) {
+                        if (time_after_eq(jiffies,
+                                        bus_state->resume_done[wIndex])) {
                                 xhci_dbg(xhci, "Resume USB2 port %d\n",
                                         wIndex + 1);
                                 bus_state->resume_done[wIndex] = 0;
@@ -487,6 +488,14 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                 xhci_ring_device(xhci, slot_id);
                                 bus_state->port_c_suspend |= 1 << wIndex;
                                 bus_state->suspended_ports &= ~(1 << wIndex);
+                        } else {
+                                /*
+                                 * The resume has been signaling for less than
+                                 * 20ms. Report the port status as SUSPEND,
+                                 * let the usbcore check port status again
+                                 * and clear resume signaling later.
+                                 */
+                                status |= USB_PORT_STAT_SUSPEND;
                         }
                 }
                 if ((temp & PORT_PLS_MASK) == XDEV_U0
@@ -664,7 +673,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         xhci_dbg(xhci, "PORTSC %04x\n", temp);
                         if (temp & PORT_RESET)
                                 goto error;
-                        if (temp & XDEV_U3) {
+                        if ((temp & PORT_PLS_MASK) == XDEV_U3) {
                                 if ((temp & PORT_PE) == 0)
                                         goto error;
 
@@ -752,7 +761,7 @@ int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
         memset(buf, 0, retval);
         status = 0;
 
-        mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC;
+        mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC | PORT_WRC;
 
         spin_lock_irqsave(&xhci->lock, flags);
         /* For each port, did anything change?  If so, set that bit in buf. */
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 7113d16e2d3a..952e2ded61af 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -514,8 +514,12 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                         (unsigned long long) addr);
 }
 
+/* flip_cycle means flip the cycle bit of all but the first and last TRB.
+ * (The last TRB actually points to the ring enqueue pointer, which is not part
+ * of this TD.)  This is used to remove partially enqueued isoc TDs from a ring.
+ */
 static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
-                struct xhci_td *cur_td)
+                struct xhci_td *cur_td, bool flip_cycle)
 {
         struct xhci_segment *cur_seg;
         union xhci_trb *cur_trb;
@@ -528,6 +532,12 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                          * leave the pointers intact.
                          */
                         cur_trb->generic.field[3] &= cpu_to_le32(~TRB_CHAIN);
+                        /* Flip the cycle bit (link TRBs can't be the first
+                         * or last TRB).
+                         */
+                        if (flip_cycle)
+                                cur_trb->generic.field[3] ^=
+                                        cpu_to_le32(TRB_CYCLE);
                         xhci_dbg(xhci, "Cancel (unchain) link TRB\n");
                         xhci_dbg(xhci, "Address = %p (0x%llx dma); "
                                         "in seg %p (0x%llx dma)\n",
@@ -541,6 +551,11 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                         cur_trb->generic.field[2] = 0;
                         /* Preserve only the cycle bit of this TRB */
                         cur_trb->generic.field[3] &= cpu_to_le32(TRB_CYCLE);
+                        /* Flip the cycle bit except on the first or last TRB */
+                        if (flip_cycle && cur_trb != cur_td->first_trb &&
+                                        cur_trb != cur_td->last_trb)
+                                cur_trb->generic.field[3] ^=
+                                        cpu_to_le32(TRB_CYCLE);
                         cur_trb->generic.field[3] |= cpu_to_le32(
                                 TRB_TYPE(TRB_TR_NOOP));
                         xhci_dbg(xhci, "Cancel TRB %p (0x%llx dma) "
@@ -719,14 +734,14 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
                                         cur_td->urb->stream_id,
                                         cur_td, &deq_state);
                 else
-                        td_to_noop(xhci, ep_ring, cur_td);
+                        td_to_noop(xhci, ep_ring, cur_td, false);
 remove_finished_td:
                 /*
                  * The event handler won't see a completion for this TD anymore,
                  * so remove it from the endpoint ring's TD list.  Keep it in
                  * the cancelled TD list for URB completion later.
                  */
-                list_del(&cur_td->td_list);
+                list_del_init(&cur_td->td_list);
         }
         last_unlinked_td = cur_td;
         xhci_stop_watchdog_timer_in_irq(xhci, ep);
@@ -754,7 +769,7 @@ remove_finished_td:
         do {
                 cur_td = list_entry(ep->cancelled_td_list.next,
                                 struct xhci_td, cancelled_td_list);
-                list_del(&cur_td->cancelled_td_list);
+                list_del_init(&cur_td->cancelled_td_list);
 
                 /* Clean up the cancelled URB */
                 /* Doesn't matter what we pass for status, since the core will
@@ -862,9 +877,9 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
                                 cur_td = list_first_entry(&ring->td_list,
                                                 struct xhci_td,
                                                 td_list);
-                                list_del(&cur_td->td_list);
+                                list_del_init(&cur_td->td_list);
                                 if (!list_empty(&cur_td->cancelled_td_list))
-                                        list_del(&cur_td->cancelled_td_list);
+                                        list_del_init(&cur_td->cancelled_td_list);
                                 xhci_giveback_urb_in_irq(xhci, cur_td,
                                                 -ESHUTDOWN, "killed");
                         }
@@ -873,7 +888,7 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
                                                 &temp_ep->cancelled_td_list,
                                                 struct xhci_td,
                                                 cancelled_td_list);
-                                list_del(&cur_td->cancelled_td_list);
+                                list_del_init(&cur_td->cancelled_td_list);
                                 xhci_giveback_urb_in_irq(xhci, cur_td,
                                                 -ESHUTDOWN, "killed");
                         }
@@ -1565,10 +1580,10 @@ td_cleanup:
                         else
                                 *status = 0;
                 }
-                list_del(&td->td_list);
+                list_del_init(&td->td_list);
                 /* Was this TD slated to be cancelled but completed anyway? */
                 if (!list_empty(&td->cancelled_td_list))
-                        list_del(&td->cancelled_td_list);
+                        list_del_init(&td->cancelled_td_list);
 
                 urb_priv->td_cnt++;
                 /* Giveback the urb when all the tds are completed */
@@ -1919,8 +1934,10 @@ static int handle_tx_event(struct xhci_hcd *xhci,
         int status = -EINPROGRESS;
         struct urb_priv *urb_priv;
         struct xhci_ep_ctx *ep_ctx;
+        struct list_head *tmp;
         u32 trb_comp_code;
         int ret = 0;
+        int td_num = 0;
 
         slot_id = TRB_TO_SLOT_ID(le32_to_cpu(event->flags));
         xdev = xhci->devs[slot_id];
@@ -1942,6 +1959,12 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 return -ENODEV;
         }
 
+        /* Count current td numbers if ep->skip is set */
+        if (ep->skip) {
+                list_for_each(tmp, &ep_ring->td_list)
+                        td_num++;
+        }
+
         event_dma = le64_to_cpu(event->buffer);
         trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
         /* Look for common error cases */
@@ -2053,7 +2076,18 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                         goto cleanup;
                 }
 
+                /* We've skipped all the TDs on the ep ring when ep->skip set */
+                if (ep->skip && td_num == 0) {
+                        ep->skip = false;
+                        xhci_dbg(xhci, "All tds on the ep_ring skipped. "
+                                                "Clear skip flag.\n");
+                        ret = 0;
+                        goto cleanup;
+                }
+
                 td = list_entry(ep_ring->td_list.next, struct xhci_td, td_list);
+                if (ep->skip)
+                        td_num--;
 
                 /* Is this a TRB in the currently executing TD? */
                 event_seg = trb_in_td(ep_ring->deq_seg, ep_ring->dequeue,
@@ -2500,11 +2534,8 @@ static int prepare_transfer(struct xhci_hcd *xhci,
 
         if (td_index == 0) {
                 ret = usb_hcd_link_urb_to_ep(bus_to_hcd(urb->dev->bus), urb);
-                if (unlikely(ret)) {
-                        xhci_urb_free_priv(xhci, urb_priv);
-                        urb->hcpriv = NULL;
+                if (unlikely(ret))
                         return ret;
-                }
         }
 
         td->urb = urb;
@@ -2672,6 +2703,10 @@ static u32 xhci_v1_0_td_remainder(int running_total, int trb_buff_len,
 {
         int packets_transferred;
 
+        /* One TRB with a zero-length data packet. */
+        if (running_total == 0 && trb_buff_len == 0)
+                return 0;
+
         /* All the TRB queueing functions don't count the current TRB in
          * running_total.
          */
@@ -3113,20 +3148,15 @@ static int count_isoc_trbs_needed(struct xhci_hcd *xhci,
                 struct urb *urb, int i)
 {
         int num_trbs = 0;
-        u64 addr, td_len, running_total;
+        u64 addr, td_len;
 
         addr = (u64) (urb->transfer_dma + urb->iso_frame_desc[i].offset);
         td_len = urb->iso_frame_desc[i].length;
 
-        running_total = TRB_MAX_BUFF_SIZE - (addr & (TRB_MAX_BUFF_SIZE - 1));
-        running_total &= TRB_MAX_BUFF_SIZE - 1;
-        if (running_total != 0)
-                num_trbs++;
-
-        while (running_total < td_len) {
+        num_trbs = DIV_ROUND_UP(td_len + (addr & (TRB_MAX_BUFF_SIZE - 1)),
+                        TRB_MAX_BUFF_SIZE);
+        if (num_trbs == 0)
                 num_trbs++;
-                running_total += TRB_MAX_BUFF_SIZE;
-        }
 
         return num_trbs;
 }
@@ -3226,6 +3256,7 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         start_trb = &ep_ring->enqueue->generic;
         start_cycle = ep_ring->cycle_state;
 
+        urb_priv = urb->hcpriv;
         /* Queue the first TRB, even if it's zero-length */
         for (i = 0; i < num_tds; i++) {
                 unsigned int total_packet_count;
@@ -3237,9 +3268,11 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 addr = start_addr + urb->iso_frame_desc[i].offset;
                 td_len = urb->iso_frame_desc[i].length;
                 td_remain_len = td_len;
-                /* FIXME: Ignoring zero-length packets, can those happen? */
                 total_packet_count = roundup(td_len,
                                 le16_to_cpu(urb->ep->desc.wMaxPacketSize));
+                /* A zero-length transfer still involves at least one packet. */
+                if (total_packet_count == 0)
+                        total_packet_count++;
                 burst_count = xhci_get_burst_count(xhci, urb->dev, urb,
                                 total_packet_count);
                 residue = xhci_get_last_burst_packet_count(xhci,
@@ -3249,12 +3282,13 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
 
                 ret = prepare_transfer(xhci, xhci->devs[slot_id], ep_index,
                                 urb->stream_id, trbs_per_td, urb, i, mem_flags);
-                if (ret < 0)
-                        return ret;
+                if (ret < 0) {
+                        if (i == 0)
+                                return ret;
+                        goto cleanup;
+                }
 
-                urb_priv = urb->hcpriv;
                 td = urb_priv->td[i];
-
                 for (j = 0; j < trbs_per_td; j++) {
                         u32 remainder = 0;
                         field = TRB_TBC(burst_count) | TRB_TLBPC(residue);
@@ -3344,6 +3378,27 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         giveback_first_trb(xhci, slot_id, ep_index, urb->stream_id,
                         start_cycle, start_trb);
         return 0;
+cleanup:
+        /* Clean up a partially enqueued isoc transfer. */
+
+        for (i--; i >= 0; i--)
+                list_del_init(&urb_priv->td[i]->td_list);
+
+        /* Use the first TD as a temporary variable to turn the TDs we've queued
+         * into No-ops with a software-owned cycle bit. That way the hardware
+         * won't accidentally start executing bogus TDs when we partially
+         * overwrite them.  td->first_trb and td->start_seg are already set.
+         */
+        urb_priv->td[0]->last_trb = ep_ring->enqueue;
+        /* Every TRB except the first & last will have its cycle bit flipped. */
+        td_to_noop(xhci, ep_ring, urb_priv->td[0], true);
+
+        /* Reset the ring enqueue back to the first TRB and its cycle bit. */
+        ep_ring->enqueue = urb_priv->td[0]->first_trb;
+        ep_ring->enq_seg = urb_priv->td[0]->start_seg;
+        ep_ring->cycle_state = start_cycle;
+        usb_hcd_unlink_urb_from_ep(bus_to_hcd(urb->dev->bus), urb);
+        return ret;
 }
 
 /*
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 763f484bc092..3a0f695138f4 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -345,7 +345,8 @@ static void xhci_event_ring_work(unsigned long arg)
         spin_lock_irqsave(&xhci->lock, flags);
         temp = xhci_readl(xhci, &xhci->op_regs->status);
         xhci_dbg(xhci, "op reg status = 0x%x\n", temp);
-        if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING)) {
+        if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING) ||
+                        (xhci->xhc_state & XHCI_STATE_HALTED)) {
                 xhci_dbg(xhci, "HW died, polling stopped.\n");
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 return;
@@ -939,8 +940,11 @@ static int xhci_check_args(struct usb_hcd *hcd, struct usb_device *udev,
                 return 0;
         }
 
+        xhci = hcd_to_xhci(hcd);
+        if (xhci->xhc_state & XHCI_STATE_HALTED)
+                return -ENODEV;
+
         if (check_virt_dev) {
-                xhci = hcd_to_xhci(hcd);
                 if (!udev->slot_id || !xhci->devs
                         || !xhci->devs[udev->slot_id]) {
                         printk(KERN_DEBUG "xHCI %s called with unaddressed "
@@ -1081,8 +1085,11 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                 if (urb->dev->speed == USB_SPEED_FULL) {
                         ret = xhci_check_maxpacket(xhci, slot_id,
                                         ep_index, urb);
-                        if (ret < 0)
+                        if (ret < 0) {
+                                xhci_urb_free_priv(xhci, urb_priv);
+                                urb->hcpriv = NULL;
                                 return ret;
+                        }
                 }
 
                 /* We have a spinlock and interrupts disabled, so we must pass
@@ -1093,6 +1100,8 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                         goto dying;
                 ret = xhci_queue_ctrl_tx(xhci, GFP_ATOMIC, urb,
                                 slot_id, ep_index);
+                if (ret)
+                        goto free_priv;
                 spin_unlock_irqrestore(&xhci->lock, flags);
         } else if (usb_endpoint_xfer_bulk(&urb->ep->desc)) {
                 spin_lock_irqsave(&xhci->lock, flags);
@@ -1113,6 +1122,8 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                         ret = xhci_queue_bulk_tx(xhci, GFP_ATOMIC, urb,
                                         slot_id, ep_index);
                 }
+                if (ret)
+                        goto free_priv;
                 spin_unlock_irqrestore(&xhci->lock, flags);
         } else if (usb_endpoint_xfer_int(&urb->ep->desc)) {
                 spin_lock_irqsave(&xhci->lock, flags);
@@ -1120,6 +1131,8 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                         goto dying;
                 ret = xhci_queue_intr_tx(xhci, GFP_ATOMIC, urb,
                                 slot_id, ep_index);
+                if (ret)
+                        goto free_priv;
                 spin_unlock_irqrestore(&xhci->lock, flags);
         } else {
                 spin_lock_irqsave(&xhci->lock, flags);
@@ -1127,18 +1140,22 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                         goto dying;
                 ret = xhci_queue_isoc_tx_prepare(xhci, GFP_ATOMIC, urb,
                                 slot_id, ep_index);
+                if (ret)
+                        goto free_priv;
                 spin_unlock_irqrestore(&xhci->lock, flags);
         }
 exit:
         return ret;
 dying:
-        xhci_urb_free_priv(xhci, urb_priv);
-        urb->hcpriv = NULL;
         xhci_dbg(xhci, "Ep 0x%x: URB %p submitted for "
                         "non-responsive xHCI host.\n",
                         urb->ep->desc.bEndpointAddress, urb);
+        ret = -ESHUTDOWN;
+free_priv:
+        xhci_urb_free_priv(xhci, urb_priv);
+        urb->hcpriv = NULL;
         spin_unlock_irqrestore(&xhci->lock, flags);
-        return -ESHUTDOWN;
+        return ret;
 }
 
 /* Get the right ring for the given URB.
@@ -1235,6 +1252,13 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
         if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_HALTED)) {
                 xhci_dbg(xhci, "HW died, freeing TD.\n");
                 urb_priv = urb->hcpriv;
+                for (i = urb_priv->td_cnt; i < urb_priv->length; i++) {
+                        td = urb_priv->td[i];
+                        if (!list_empty(&td->td_list))
+                                list_del_init(&td->td_list);
+                        if (!list_empty(&td->cancelled_td_list))
+                                list_del_init(&td->cancelled_td_list);
+                }
 
                 usb_hcd_unlink_urb_from_ep(hcd, urb);
                 spin_unlock_irqrestore(&xhci->lock, flags);
@@ -1242,7 +1266,8 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
                 xhci_urb_free_priv(xhci, urb_priv);
                 return ret;
         }
-        if (xhci->xhc_state & XHCI_STATE_DYING) {
+        if ((xhci->xhc_state & XHCI_STATE_DYING) ||
+                        (xhci->xhc_state & XHCI_STATE_HALTED)) {
                 xhci_dbg(xhci, "Ep 0x%x: URB %p to be canceled on "
                                 "non-responsive xHCI host.\n",
                                 urb->ep->desc.bEndpointAddress, urb);
@@ -2665,7 +2690,10 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
         int i, ret;
 
         ret = xhci_check_args(hcd, udev, NULL, 0, true, __func__);
-        if (ret <= 0)
+        /* If the host is halted due to driver unload, we still need to free the
+         * device.
+         */
+        if (ret <= 0 && ret != -ENODEV)
                 return;
 
         virt_dev = xhci->devs[udev->slot_id];
@@ -2679,7 +2707,8 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
         spin_lock_irqsave(&xhci->lock, flags);
         /* Don't disable the slot if the host controller is dead. */
         state = xhci_readl(xhci, &xhci->op_regs->status);
-        if (state == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING)) {
+        if (state == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING) ||
+                        (xhci->xhc_state & XHCI_STATE_HALTED)) {
                 xhci_free_virt_device(xhci, udev->slot_id);
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 return;
diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
index 6192b45959f4..fc34b8b11910 100644
--- a/drivers/usb/musb/Kconfig
+++ b/drivers/usb/musb/Kconfig
@@ -3,9 +3,6 @@
 # for silicon based on Mentor Graphics INVENTRA designs
 #
 
-comment "Enable Host or Gadget support to see Inventra options"
-        depends on !USB && USB_GADGET=n
-
 # (M)HDRC = (Multipoint) Highspeed Dual-Role Controller
 config USB_MUSB_HDRC
         depends on USB && USB_GADGET
diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c
index ae8c39617743..5e7cfba5b079 100644
--- a/drivers/usb/musb/blackfin.c
+++ b/drivers/usb/musb/blackfin.c
@@ -17,6 +17,7 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
+#include <linux/prefetch.h>
 
 #include <asm/cacheflush.h>
 
diff --git a/drivers/usb/musb/cppi_dma.c b/drivers/usb/musb/cppi_dma.c
index 149f3f310a0a..318fb4e8a885 100644
--- a/drivers/usb/musb/cppi_dma.c
+++ b/drivers/usb/musb/cppi_dma.c
@@ -226,8 +226,10 @@ static int cppi_controller_stop(struct dma_controller *c)
         struct cppi             *controller;
         void __iomem            *tibase;
         int                     i;
+        struct musb             *musb;
 
         controller = container_of(c, struct cppi, controller);
+        musb = controller->musb;
 
         tibase = controller->tibase;
         /* DISABLE INDIVIDUAL CHANNEL Interrupts */
@@ -289,9 +291,11 @@ cppi_channel_allocate(struct dma_controller *c,
         u8                      index;
         struct cppi_channel     *cppi_ch;
         void __iomem            *tibase;
+        struct musb             *musb;
 
         controller = container_of(c, struct cppi, controller);
         tibase = controller->tibase;
+        musb = controller->musb;
 
         /* ep0 doesn't use DMA; remember cppi indices are 0..N-1 */
         index = ep->epnum - 1;
@@ -339,7 +343,8 @@ static void cppi_channel_release(struct dma_channel *channel)
         c = container_of(channel, struct cppi_channel, channel);
         tibase = c->controller->tibase;
         if (!c->hw_ep)
-                dev_dbg(musb->controller, "releasing idle DMA channel %p\n", c);
+                dev_dbg(c->controller->musb->controller,
+                        "releasing idle DMA channel %p\n", c);
         else if (!c->transmit)
                 core_rxirq_enable(tibase, c->index + 1);
 
@@ -357,10 +362,11 @@ cppi_dump_rx(int level, struct cppi_channel *c, const char *tag)
 
         musb_ep_select(base, c->index + 1);
 
-        DBG(level, "RX DMA%d%s: %d left, csr %04x, "
-                        "%08x H%08x S%08x C%08x, "
-                        "B%08x L%08x %08x .. %08x"
-                        "\n",
+        dev_dbg(c->controller->musb->controller,
+                "RX DMA%d%s: %d left, csr %04x, "
+                "%08x H%08x S%08x C%08x, "
+                "B%08x L%08x %08x .. %08x"
+                "\n",
                 c->index, tag,
                 musb_readl(c->controller->tibase,
                         DAVINCI_RXCPPI_BUFCNT0_REG + 4 * c->index),
@@ -387,10 +393,11 @@ cppi_dump_tx(int level, struct cppi_channel *c, const char *tag)
 
         musb_ep_select(base, c->index + 1);
 
-        DBG(level, "TX DMA%d%s: csr %04x, "
-                        "H%08x S%08x C%08x %08x, "
-                        "F%08x L%08x .. %08x"
-                        "\n",
+        dev_dbg(c->controller->musb->controller,
+                "TX DMA%d%s: csr %04x, "
+                "H%08x S%08x C%08x %08x, "
+                "F%08x L%08x .. %08x"
+                "\n",
                 c->index, tag,
                 musb_readw(c->hw_ep->regs, MUSB_TXCSR),
 
@@ -1022,6 +1029,7 @@ static bool cppi_rx_scan(struct cppi *cppi, unsigned ch)
         int                             i;
         dma_addr_t                      safe2ack;
         void __iomem                    *regs = rx->hw_ep->regs;
+        struct musb                     *musb = cppi->musb;
 
         cppi_dump_rx(6, rx, "/K");
 
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index 8bdf25a8b023..f9a3f62a83b5 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -35,7 +35,7 @@
 
 #include <mach/hardware.h>
 #include <mach/memory.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include <mach/cputype.h>
 
 #include <asm/mach-types.h>
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index 668eeef601ae..b3c065ab9dbc 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -172,7 +172,8 @@ enum musb_g_ep0_state {
 #endif
 
 /* TUSB mapping: "flat" plus ep0 special cases */
-#if     defined(CONFIG_USB_MUSB_TUSB6010)
+#if defined(CONFIG_USB_MUSB_TUSB6010) || \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
 #define musb_ep_select(_mbase, _epnum) \
         musb_writeb((_mbase), MUSB_INDEX, (_epnum))
 #define MUSB_EP_OFFSET                  MUSB_TUSB_OFFSET
@@ -241,7 +242,8 @@ struct musb_hw_ep {
         void __iomem            *fifo;
         void __iomem            *regs;
 
-#ifdef CONFIG_USB_MUSB_TUSB6010
+#if defined(CONFIG_USB_MUSB_TUSB6010) || \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
         void __iomem            *conf;
 #endif
 
@@ -258,7 +260,8 @@ struct musb_hw_ep {
         struct dma_channel      *tx_channel;
         struct dma_channel      *rx_channel;
 
-#ifdef CONFIG_USB_MUSB_TUSB6010
+#if defined(CONFIG_USB_MUSB_TUSB6010) || \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
         /* TUSB has "asynchronous" and "synchronous" dma modes */
         dma_addr_t              fifo_async;
         dma_addr_t              fifo_sync;
@@ -356,7 +359,8 @@ struct musb {
         void __iomem            *ctrl_base;
         void __iomem            *mregs;
 
-#ifdef CONFIG_USB_MUSB_TUSB6010
+#if defined(CONFIG_USB_MUSB_TUSB6010) || \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
         dma_addr_t              async;
         dma_addr_t              sync;
         void __iomem            *sync_va;
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index b67a062f556b..e81820370d6f 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -1698,6 +1698,8 @@ static int musb_gadget_pullup(struct usb_gadget *gadget, int is_on)
 
         is_on = !!is_on;
 
+        pm_runtime_get_sync(musb->controller);
+
         /* NOTE: this assumes we are sensing vbus; we'd rather
          * not pullup unless the B-session is active.
          */
@@ -1707,6 +1709,9 @@ static int musb_gadget_pullup(struct usb_gadget *gadget, int is_on)
                 musb_pullup(musb, is_on);
         }
         spin_unlock_irqrestore(&musb->lock, flags);
+
+        pm_runtime_put(musb->controller);
+
         return 0;
 }
 
@@ -1851,6 +1856,7 @@ int __init musb_gadget_setup(struct musb *musb)
 
         return 0;
 err:
+        musb->g.dev.parent = NULL;
         device_unregister(&musb->g.dev);
         return status;
 }
@@ -1858,7 +1864,8 @@ err:
 void musb_gadget_cleanup(struct musb *musb)
 {
         usb_del_gadget_udc(&musb->g);
-        device_unregister(&musb->g.dev);
+        if (musb->g.dev.parent)
+                device_unregister(&musb->g.dev);
 }
 
 /*
diff --git a/drivers/usb/musb/musb_regs.h b/drivers/usb/musb/musb_regs.h
index 82410703dcd3..03f2655af290 100644
--- a/drivers/usb/musb/musb_regs.h
+++ b/drivers/usb/musb/musb_regs.h
@@ -234,7 +234,8 @@
 #define MUSB_TESTMODE           0x0F    /* 8 bit */
 
 /* Get offset for a given FIFO from musb->mregs */
-#ifdef  CONFIG_USB_MUSB_TUSB6010
+#if defined(CONFIG_USB_MUSB_TUSB6010) ||        \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
 #define MUSB_FIFO_OFFSET(epnum) (0x200 + ((epnum) * 0x20))
 #else
 #define MUSB_FIFO_OFFSET(epnum) (0x20 + ((epnum) * 4))
@@ -295,7 +296,8 @@
 #define MUSB_FLAT_OFFSET(_epnum, _offset)       \
         (0x100 + (0x10*(_epnum)) + (_offset))
 
-#ifdef CONFIG_USB_MUSB_TUSB6010
+#if defined(CONFIG_USB_MUSB_TUSB6010) ||        \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
 /* TUSB6010 EP0 configuration register is special */
 #define MUSB_TUSB_OFFSET(_epnum, _offset)       \
         (0x10 + _offset)
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index 9eec41fbf3a4..ec1480191f78 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -18,6 +18,7 @@
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/init.h>
+#include <linux/prefetch.h>
 #include <linux/usb.h>
 #include <linux/irq.h>
 #include <linux/platform_device.h>
diff --git a/drivers/usb/musb/tusb6010_omap.c b/drivers/usb/musb/tusb6010_omap.c
index c784e6c03aac..b67b4bc596c1 100644
--- a/drivers/usb/musb/tusb6010_omap.c
+++ b/drivers/usb/musb/tusb6010_omap.c
@@ -20,6 +20,7 @@
 #include <plat/mux.h>
 
 #include "musb_core.h"
+#include "tusb6010.h"
 
 #define to_chdat(c)             ((struct tusb_omap_dma_ch *)(c)->private_data)
 
@@ -89,7 +90,7 @@ static inline int tusb_omap_use_shared_dmareq(struct tusb_omap_dma_ch *chdat)
         u32             reg = musb_readl(chdat->tbase, TUSB_DMA_EP_MAP);
 
         if (reg != 0) {
-                dev_dbg(musb->controller, "ep%i dmareq0 is busy for ep%i\n",
+                dev_dbg(chdat->musb->controller, "ep%i dmareq0 is busy for ep%i\n",
                         chdat->epnum, reg & 0xf);
                 return -EAGAIN;
         }
diff --git a/drivers/usb/musb/ux500_dma.c b/drivers/usb/musb/ux500_dma.c
index cecace411832..ef4333f4bbe0 100644
--- a/drivers/usb/musb/ux500_dma.c
+++ b/drivers/usb/musb/ux500_dma.c
@@ -65,7 +65,8 @@ static void ux500_tx_work(struct work_struct *data)
         struct musb *musb = hw_ep->musb;
         unsigned long flags;
 
-        DBG(4, "DMA tx transfer done on hw_ep=%d\n", hw_ep->epnum);
+        dev_dbg(musb->controller, "DMA tx transfer done on hw_ep=%d\n",
+                hw_ep->epnum);
 
         spin_lock_irqsave(&musb->lock, flags);
         ux500_channel->channel.actual_len = ux500_channel->cur_len;
@@ -84,7 +85,8 @@ static void ux500_rx_work(struct work_struct *data)
         struct musb *musb = hw_ep->musb;
         unsigned long flags;
 
-        DBG(4, "DMA rx transfer done on hw_ep=%d\n", hw_ep->epnum);
+        dev_dbg(musb->controller, "DMA rx transfer done on hw_ep=%d\n",
+                hw_ep->epnum);
 
         spin_lock_irqsave(&musb->lock, flags);
         ux500_channel->channel.actual_len = ux500_channel->cur_len;
@@ -116,9 +118,11 @@ static bool ux500_configure_channel(struct dma_channel *channel,
         enum dma_slave_buswidth addr_width;
         dma_addr_t usb_fifo_addr = (MUSB_FIFO_OFFSET(hw_ep->epnum) +
                                         ux500_channel->controller->phy_base);
+        struct musb *musb = ux500_channel->controller->private_data;
 
-        DBG(4, "packet_sz=%d, mode=%d, dma_addr=0x%x, len=%d is_tx=%d\n",
-                        packet_sz, mode, dma_addr, len, ux500_channel->is_tx);
+        dev_dbg(musb->controller,
+                "packet_sz=%d, mode=%d, dma_addr=0x%x, len=%d is_tx=%d\n",
+                packet_sz, mode, dma_addr, len, ux500_channel->is_tx);
 
         ux500_channel->cur_len = len;
 
@@ -133,15 +137,13 @@ static bool ux500_configure_channel(struct dma_channel *channel,
                                         DMA_SLAVE_BUSWIDTH_4_BYTES;
 
         slave_conf.direction = direction;
-        if (direction == DMA_FROM_DEVICE) {
-                slave_conf.src_addr = usb_fifo_addr;
-                slave_conf.src_addr_width = addr_width;
-                slave_conf.src_maxburst = 16;
-        } else {
-                slave_conf.dst_addr = usb_fifo_addr;
-                slave_conf.dst_addr_width = addr_width;
-                slave_conf.dst_maxburst = 16;
-        }
+        slave_conf.src_addr = usb_fifo_addr;
+        slave_conf.src_addr_width = addr_width;
+        slave_conf.src_maxburst = 16;
+        slave_conf.dst_addr = usb_fifo_addr;
+        slave_conf.dst_addr_width = addr_width;
+        slave_conf.dst_maxburst = 16;
+
         dma_chan->device->device_control(dma_chan, DMA_SLAVE_CONFIG,
                                              (unsigned long) &slave_conf);
 
@@ -166,6 +168,7 @@ static struct dma_channel *ux500_dma_channel_allocate(struct dma_controller *c,
         struct ux500_dma_controller *controller = container_of(c,
                         struct ux500_dma_controller, controller);
         struct ux500_dma_channel *ux500_channel = NULL;
+        struct musb *musb = controller->private_data;
         u8 ch_num = hw_ep->epnum - 1;
         u32 max_ch;
 
@@ -192,7 +195,7 @@ static struct dma_channel *ux500_dma_channel_allocate(struct dma_controller *c,
         ux500_channel->hw_ep = hw_ep;
         ux500_channel->is_allocated = 1;
 
-        DBG(7, "hw_ep=%d, is_tx=0x%x, channel=%d\n",
+        dev_dbg(musb->controller, "hw_ep=%d, is_tx=0x%x, channel=%d\n",
                 hw_ep->epnum, is_tx, ch_num);
 
         return &(ux500_channel->channel);
@@ -201,8 +204,9 @@ static struct dma_channel *ux500_dma_channel_allocate(struct dma_controller *c,
 static void ux500_dma_channel_release(struct dma_channel *channel)
 {
         struct ux500_dma_channel *ux500_channel = channel->private_data;
+        struct musb *musb = ux500_channel->controller->private_data;
 
-        DBG(7, "channel=%d\n", ux500_channel->ch_num);
+        dev_dbg(musb->controller, "channel=%d\n", ux500_channel->ch_num);
 
         if (ux500_channel->is_allocated) {
                 ux500_channel->is_allocated = 0;
@@ -252,8 +256,8 @@ static int ux500_dma_channel_abort(struct dma_channel *channel)
         void __iomem *epio = musb->endpoints[ux500_channel->hw_ep->epnum].regs;
         u16 csr;
 
-        DBG(4, "channel=%d, is_tx=%d\n", ux500_channel->ch_num,
-                                                ux500_channel->is_tx);
+        dev_dbg(musb->controller, "channel=%d, is_tx=%d\n",
+                ux500_channel->ch_num, ux500_channel->is_tx);
 
         if (channel->status == MUSB_DMA_STATUS_BUSY) {
                 if (ux500_channel->is_tx) {
diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
index ba79dbf5adbc..cb2d451d511e 100644
--- a/drivers/usb/renesas_usbhs/mod_gadget.c
+++ b/drivers/usb/renesas_usbhs/mod_gadget.c
@@ -14,6 +14,7 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */
+#include <linux/dma-mapping.h>
 #include <linux/io.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
@@ -76,7 +77,7 @@ struct usbhsg_recip_handle {
                 struct usbhsg_gpriv, mod)
 
 #define __usbhsg_for_each_uep(start, pos, g, i) \
-        for (i = start, pos = (g)->uep;         \
+        for (i = start, pos = (g)->uep + i;     \
              i < (g)->uep_size;                 \
              i++, pos = (g)->uep + i)
 
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 2e06b90aa1f8..5fc13e717911 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -101,6 +101,7 @@ static int   ftdi_jtag_probe(struct usb_serial *serial);
 static int   ftdi_mtxorb_hack_setup(struct usb_serial *serial);
 static int   ftdi_NDI_device_setup(struct usb_serial *serial);
 static int   ftdi_stmclite_probe(struct usb_serial *serial);
+static int   ftdi_8u2232c_probe(struct usb_serial *serial);
 static void  ftdi_USB_UIRT_setup(struct ftdi_private *priv);
 static void  ftdi_HE_TIRA1_setup(struct ftdi_private *priv);
 
@@ -128,6 +129,10 @@ static struct ftdi_sio_quirk ftdi_stmclite_quirk = {
         .probe  = ftdi_stmclite_probe,
 };
 
+static struct ftdi_sio_quirk ftdi_8u2232c_quirk = {
+        .probe  = ftdi_8u2232c_probe,
+};
+
 /*
  * The 8U232AM has the same API as the sio except for:
  * - it can support MUCH higher baudrates; up to:
@@ -151,6 +156,7 @@ static struct ftdi_sio_quirk ftdi_stmclite_quirk = {
  * /sys/bus/usb/ftdi_sio/new_id, then send patch/report!
  */
 static struct usb_device_id id_table_combined [] = {
+        { USB_DEVICE(FTDI_VID, FTDI_ZEITCONTROL_TAGTRACE_MIFARE_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_CTI_MINI_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_CTI_NANO_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
@@ -177,7 +183,8 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_8U232AM_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_8U232AM_ALT_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_232RL_PID) },
-        { USB_DEVICE(FTDI_VID, FTDI_8U2232C_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_8U2232C_PID) ,
+                .driver_info = (kernel_ulong_t)&ftdi_8u2232c_quirk },
         { USB_DEVICE(FTDI_VID, FTDI_4232H_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_232H_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_MICRO_CHAMELEON_PID) },
@@ -1171,7 +1178,7 @@ static __u32 get_ftdi_divisor(struct tty_struct *tty,
         case FT2232H: /* FT2232H chip */
         case FT4232H: /* FT4232H chip */
         case FT232H:  /* FT232H chip */
-                if ((baud <= 12000000) & (baud >= 1200)) {
+                if ((baud <= 12000000) && (baud >= 1200)) {
                         div_value = ftdi_2232h_baud_to_divisor(baud);
                 } else if (baud < 1200) {
                         div_value = ftdi_232bm_baud_to_divisor(baud);
@@ -1205,7 +1212,10 @@ static int change_speed(struct tty_struct *tty, struct usb_serial_port *port)
         urb_index_value = get_ftdi_divisor(tty, port);
         urb_value = (__u16)urb_index_value;
         urb_index = (__u16)(urb_index_value >> 16);
-        if (priv->interface) {  /* FT2232C */
+        if ((priv->chip_type == FT2232C) || (priv->chip_type == FT2232H) ||
+                (priv->chip_type == FT4232H) || (priv->chip_type == FT232H)) {
+                /* Probably the BM type needs the MSB of the encoded fractional
+                 * divider also moved like for the chips above. Any infos? */
                 urb_index = (__u16)((urb_index << 8) | priv->interface);
         }
 
@@ -1733,6 +1743,18 @@ static int ftdi_jtag_probe(struct usb_serial *serial)
         return 0;
 }
 
+static int ftdi_8u2232c_probe(struct usb_serial *serial)
+{
+        struct usb_device *udev = serial->dev;
+
+        dbg("%s", __func__);
+
+        if (strcmp(udev->manufacturer, "CALAO Systems") == 0)
+                return ftdi_jtag_probe(serial);
+
+        return 0;
+}
+
 /*
  * First and second port on STMCLiteadaptors is reserved for JTAG interface
  * and the forth port for pio
diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
index 19156d1049fe..bf5227ad3ef7 100644
--- a/drivers/usb/serial/ftdi_sio_ids.h
+++ b/drivers/usb/serial/ftdi_sio_ids.h
@@ -1159,4 +1159,8 @@
 /* USB-Nano-485*/
 #define FTDI_CTI_NANO_PID       0xF60B
 
-
+/*
+ * ZeitControl cardsystems GmbH rfid-readers http://zeitconrol.de
+ */
+/* TagTracer MIFARE*/
+#define FTDI_ZEITCONTROL_TAGTRACE_MIFARE_PID    0xF7C0
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 60b25d8ea0e2..fe22e90bc879 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -148,6 +148,12 @@ static void option_instat_callback(struct urb *urb);
 #define HUAWEI_PRODUCT_K4505                    0x1464
 #define HUAWEI_PRODUCT_K3765                    0x1465
 #define HUAWEI_PRODUCT_E14AC                    0x14AC
+#define HUAWEI_PRODUCT_K3806                    0x14AE
+#define HUAWEI_PRODUCT_K4605                    0x14C6
+#define HUAWEI_PRODUCT_K3770                    0x14C9
+#define HUAWEI_PRODUCT_K3771                    0x14CA
+#define HUAWEI_PRODUCT_K4510                    0x14CB
+#define HUAWEI_PRODUCT_K4511                    0x14CC
 #define HUAWEI_PRODUCT_ETS1220                  0x1803
 #define HUAWEI_PRODUCT_E353                     0x1506
 
@@ -412,6 +418,56 @@ static void option_instat_callback(struct urb *urb);
 #define SAMSUNG_VENDOR_ID                       0x04e8
 #define SAMSUNG_PRODUCT_GT_B3730                0x6889
 
+/* YUGA products  www.yuga-info.com*/
+#define YUGA_VENDOR_ID                          0x257A
+#define YUGA_PRODUCT_CEM600                     0x1601
+#define YUGA_PRODUCT_CEM610                     0x1602
+#define YUGA_PRODUCT_CEM500                     0x1603
+#define YUGA_PRODUCT_CEM510                     0x1604
+#define YUGA_PRODUCT_CEM800                     0x1605
+#define YUGA_PRODUCT_CEM900                     0x1606
+
+#define YUGA_PRODUCT_CEU818                     0x1607
+#define YUGA_PRODUCT_CEU816                     0x1608
+#define YUGA_PRODUCT_CEU828                     0x1609
+#define YUGA_PRODUCT_CEU826                     0x160A
+#define YUGA_PRODUCT_CEU518                     0x160B
+#define YUGA_PRODUCT_CEU516                     0x160C
+#define YUGA_PRODUCT_CEU528                     0x160D
+#define YUGA_PRODUCT_CEU526                     0x160F
+
+#define YUGA_PRODUCT_CWM600                     0x2601
+#define YUGA_PRODUCT_CWM610                     0x2602
+#define YUGA_PRODUCT_CWM500                     0x2603
+#define YUGA_PRODUCT_CWM510                     0x2604
+#define YUGA_PRODUCT_CWM800                     0x2605
+#define YUGA_PRODUCT_CWM900                     0x2606
+
+#define YUGA_PRODUCT_CWU718                     0x2607
+#define YUGA_PRODUCT_CWU716                     0x2608
+#define YUGA_PRODUCT_CWU728                     0x2609
+#define YUGA_PRODUCT_CWU726                     0x260A
+#define YUGA_PRODUCT_CWU518                     0x260B
+#define YUGA_PRODUCT_CWU516                     0x260C
+#define YUGA_PRODUCT_CWU528                     0x260D
+#define YUGA_PRODUCT_CWU526                     0x260F
+
+#define YUGA_PRODUCT_CLM600                     0x2601
+#define YUGA_PRODUCT_CLM610                     0x2602
+#define YUGA_PRODUCT_CLM500                     0x2603
+#define YUGA_PRODUCT_CLM510                     0x2604
+#define YUGA_PRODUCT_CLM800                     0x2605
+#define YUGA_PRODUCT_CLM900                     0x2606
+
+#define YUGA_PRODUCT_CLU718                     0x2607
+#define YUGA_PRODUCT_CLU716                     0x2608
+#define YUGA_PRODUCT_CLU728                     0x2609
+#define YUGA_PRODUCT_CLU726                     0x260A
+#define YUGA_PRODUCT_CLU518                     0x260B
+#define YUGA_PRODUCT_CLU516                     0x260C
+#define YUGA_PRODUCT_CLU528                     0x260D
+#define YUGA_PRODUCT_CLU526                     0x260F
+
 /* some devices interfaces need special handling due to a number of reasons */
 enum option_blacklist_reason {
                 OPTION_BLACKLIST_NONE = 0,
@@ -547,6 +603,16 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3765, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_ETS1220, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E14AC, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3806, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4605, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3770, 0xff, 0x02, 0x31) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3770, 0xff, 0x02, 0x32) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3771, 0xff, 0x02, 0x31) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3771, 0xff, 0x02, 0x32) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4510, 0xff, 0x01, 0x31) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4510, 0xff, 0x01, 0x32) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4511, 0xff, 0x01, 0x31) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4511, 0xff, 0x01, 0x32) },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E353, 0xff, 0x01, 0x01) },
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V640) },
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V620) },
@@ -993,6 +1059,48 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE(CELOT_VENDOR_ID, CELOT_PRODUCT_CT680M) }, /* CT-650 CDMA 450 1xEVDO modem */
         { USB_DEVICE(ONDA_VENDOR_ID, ONDA_MT825UP) }, /* ONDA MT825UP modem */
         { USB_DEVICE_AND_INTERFACE_INFO(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_GT_B3730, USB_CLASS_CDC_DATA, 0x00, 0x00) }, /* Samsung GT-B3730 LTE USB modem.*/
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM600) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM610) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM500) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM510) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM800) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM900) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU818) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU816) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU828) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU826) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU518) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU516) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU528) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU526) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM600) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM610) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM500) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM510) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM800) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM900) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU718) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU716) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU728) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU726) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU518) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU516) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU528) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU526) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM600) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM610) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM500) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM510) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM800) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM900) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU718) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU716) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU728) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU726) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU518) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU516) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU528) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU526) },
         { } /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, option_ids);
@@ -1122,11 +1230,13 @@ static int option_probe(struct usb_serial *serial,
                 serial->interface->cur_altsetting->desc.bInterfaceClass != 0xff)
                 return -ENODEV;
 
-        /* Don't bind network interfaces on Huawei K3765 & K4505 */
+        /* Don't bind network interfaces on Huawei K3765, K4505 & K4605 */
         if (serial->dev->descriptor.idVendor == HUAWEI_VENDOR_ID &&
                 (serial->dev->descriptor.idProduct == HUAWEI_PRODUCT_K3765 ||
-                        serial->dev->descriptor.idProduct == HUAWEI_PRODUCT_K4505) &&
-                serial->interface->cur_altsetting->desc.bInterfaceNumber == 1)
+                        serial->dev->descriptor.idProduct == HUAWEI_PRODUCT_K4505 ||
+                        serial->dev->descriptor.idProduct == HUAWEI_PRODUCT_K4605) &&
+                (serial->interface->cur_altsetting->desc.bInterfaceNumber == 1 ||
+                        serial->interface->cur_altsetting->desc.bInterfaceNumber == 2))
                 return -ENODEV;
 
         /* Don't bind network interface on Samsung GT-B3730, it is handled by a separate module */
diff --git a/drivers/usb/serial/qcserial.c b/drivers/usb/serial/qcserial.c
index 54a9dab1f33b..aeccc7f0a93c 100644
--- a/drivers/usb/serial/qcserial.c
+++ b/drivers/usb/serial/qcserial.c
@@ -45,6 +45,7 @@ static const struct usb_device_id id_table[] = {
         {USB_DEVICE(0x05c6, 0x9203)},   /* Generic Gobi Modem device */
         {USB_DEVICE(0x05c6, 0x9222)},   /* Generic Gobi Modem device */
         {USB_DEVICE(0x05c6, 0x9008)},   /* Generic Gobi QDL device */
+        {USB_DEVICE(0x05c6, 0x9009)},   /* Generic Gobi Modem device */
         {USB_DEVICE(0x05c6, 0x9201)},   /* Generic Gobi QDL device */
         {USB_DEVICE(0x05c6, 0x9221)},   /* Generic Gobi QDL device */
         {USB_DEVICE(0x05c6, 0x9231)},   /* Generic Gobi QDL device */
@@ -78,6 +79,7 @@ static const struct usb_device_id id_table[] = {
         {USB_DEVICE(0x1199, 0x9008)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
         {USB_DEVICE(0x1199, 0x9009)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
         {USB_DEVICE(0x1199, 0x900a)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
+        {USB_DEVICE(0x1199, 0x9011)},   /* Sierra Wireless Gobi 2000 Modem device (MC8305) */
         {USB_DEVICE(0x16d8, 0x8001)},   /* CMDTech Gobi 2000 QDL device (VU922) */
         {USB_DEVICE(0x16d8, 0x8002)},   /* CMDTech Gobi 2000 Modem device (VU922) */
         {USB_DEVICE(0x05c6, 0x9204)},   /* Gobi 2000 QDL device */
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index ccff3483eebc..3041a974faf3 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -1988,6 +1988,16 @@ UNUSUAL_DEV(  0x4146, 0xba01, 0x0100, 0x0100,
                 "Micro Mini 1GB",
                 USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ),
 
+/*
+ * Nick Bowler <nbowler@elliptictech.com>
+ * SCSI stack spams (otherwise harmless) error messages.
+ */
+UNUSUAL_DEV(  0xc251, 0x4003, 0x0100, 0x0100,
+                "Keil Software, Inc.",
+                "V2M MotherBoard",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_NOT_LOCKABLE),
+
 /* Reported by Andrew Simmons <andrew.simmons@gmail.com> */
 UNUSUAL_DEV(  0xed06, 0x4500, 0x0001, 0x0001,
                 "DataStor",
diff --git a/drivers/video/atmel_lcdfb.c b/drivers/video/atmel_lcdfb.c
index 817ab60f7537..dda920623c6a 100644
--- a/drivers/video/atmel_lcdfb.c
+++ b/drivers/video/atmel_lcdfb.c
@@ -21,7 +21,7 @@
 
 #include <mach/board.h>
 #include <mach/cpu.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 
 #include <video/atmel_lcdc.h>
 
diff --git a/drivers/video/backlight/adp8870_bl.c b/drivers/video/backlight/adp8870_bl.c
index 05a8832bb3eb..d06886a2bfb5 100644
--- a/drivers/video/backlight/adp8870_bl.c
+++ b/drivers/video/backlight/adp8870_bl.c
@@ -1009,4 +1009,4 @@ module_exit(adp8870_exit);
 MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 MODULE_DESCRIPTION("ADP8870 Backlight driver");
-MODULE_ALIAS("platform:adp8870-backlight");
+MODULE_ALIAS("i2c:adp8870-backlight");
diff --git a/drivers/video/backlight/backlight.c b/drivers/video/backlight/backlight.c
index 80d292fb92d8..7363c1b169e8 100644
--- a/drivers/video/backlight/backlight.c
+++ b/drivers/video/backlight/backlight.c
@@ -19,7 +19,7 @@
 #include <asm/backlight.h>
 #endif
 
-static const char const *backlight_types[] = {
+static const char *const backlight_types[] = {
         [BACKLIGHT_RAW] = "raw",
         [BACKLIGHT_PLATFORM] = "platform",
         [BACKLIGHT_FIRMWARE] = "firmware",
diff --git a/drivers/video/backlight/ep93xx_bl.c b/drivers/video/backlight/ep93xx_bl.c
index 9f1e389d51d2..b0582917f0c8 100644
--- a/drivers/video/backlight/ep93xx_bl.c
+++ b/drivers/video/backlight/ep93xx_bl.c
@@ -11,7 +11,7 @@
  * BRIGHT, on the Cirrus EP9307, EP9312, and EP9315 processors.
  */
 
-
+#include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
 #include <linux/fb.h>
diff --git a/drivers/video/backlight/pwm_bl.c b/drivers/video/backlight/pwm_bl.c
index b8f38ec6eb18..8b5b2a4124c7 100644
--- a/drivers/video/backlight/pwm_bl.c
+++ b/drivers/video/backlight/pwm_bl.c
@@ -28,6 +28,8 @@ struct pwm_bl_data {
         unsigned int            lth_brightness;
         int                     (*notify)(struct device *,
                                           int brightness);
+        void                    (*notify_after)(struct device *,
+                                        int brightness);
         int                     (*check_fb)(struct device *, struct fb_info *);
 };
 
@@ -55,6 +57,10 @@ static int pwm_backlight_update_status(struct backlight_device *bl)
                 pwm_config(pb->pwm, brightness, pb->period);
                 pwm_enable(pb->pwm);
         }
+
+        if (pb->notify_after)
+                pb->notify_after(pb->dev, brightness);
+
         return 0;
 }
 
@@ -105,6 +111,7 @@ static int pwm_backlight_probe(struct platform_device *pdev)
 
         pb->period = data->pwm_period_ns;
         pb->notify = data->notify;
+        pb->notify_after = data->notify_after;
         pb->check_fb = data->check_fb;
         pb->lth_brightness = data->lth_brightness *
                 (data->pwm_period_ns / data->max_brightness);
@@ -172,6 +179,8 @@ static int pwm_backlight_suspend(struct platform_device *pdev,
                 pb->notify(pb->dev, 0);
         pwm_config(pb->pwm, 0, pb->period);
         pwm_disable(pb->pwm);
+        if (pb->notify_after)
+                pb->notify_after(pb->dev, 0);
         return 0;
 }
 
diff --git a/drivers/video/omap/lcd_apollon.c b/drivers/video/omap/lcd_apollon.c
index 10459d8bd9a0..4b24f549f9b9 100644
--- a/drivers/video/omap/lcd_apollon.c
+++ b/drivers/video/omap/lcd_apollon.c
@@ -24,7 +24,7 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
 
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 
 #include "omapfb.h"
 
diff --git a/drivers/video/omap/lcd_h3.c b/drivers/video/omap/lcd_h3.c
index 8df688748b5a..622ad839fd9d 100644
--- a/drivers/video/omap/lcd_h3.c
+++ b/drivers/video/omap/lcd_h3.c
@@ -23,7 +23,7 @@
 #include <linux/platform_device.h>
 #include <linux/i2c/tps65010.h>
 
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include "omapfb.h"
 
 #define MODULE_NAME     "omapfb-lcd_h3"
diff --git a/drivers/video/omap/lcd_inn1610.c b/drivers/video/omap/lcd_inn1610.c
index 9fff86f67bde..12cc52a70f96 100644
--- a/drivers/video/omap/lcd_inn1610.c
+++ b/drivers/video/omap/lcd_inn1610.c
@@ -22,7 +22,7 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
 
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include "omapfb.h"
 
 #define MODULE_NAME     "omapfb-lcd_h3"
diff --git a/drivers/video/omap/lcd_ldp.c b/drivers/video/omap/lcd_ldp.c
index 0f5952cae85e..062466402c0e 100644
--- a/drivers/video/omap/lcd_ldp.c
+++ b/drivers/video/omap/lcd_ldp.c
@@ -26,7 +26,7 @@
 #include <linux/delay.h>
 #include <linux/i2c/twl.h>
 
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include <plat/mux.h>
 #include <asm/mach-types.h>
 
diff --git a/drivers/video/omap/lcd_osk.c b/drivers/video/omap/lcd_osk.c
index b87e8b83f29c..6f8d13c41202 100644
--- a/drivers/video/omap/lcd_osk.c
+++ b/drivers/video/omap/lcd_osk.c
@@ -23,7 +23,7 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
 
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include <plat/mux.h>
 #include "omapfb.h"
 
diff --git a/drivers/video/omap/lcd_overo.c b/drivers/video/omap/lcd_overo.c
index 564933ffac6e..b8fd5b2ec29c 100644
--- a/drivers/video/omap/lcd_overo.c
+++ b/drivers/video/omap/lcd_overo.c
@@ -23,7 +23,7 @@
 #include <linux/platform_device.h>
 #include <linux/i2c/twl.h>
 
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include <plat/mux.h>
 #include <asm/mach-types.h>
 
diff --git a/drivers/video/omap/lcd_palmtt.c b/drivers/video/omap/lcd_palmtt.c
index ff0e6d7ab3a2..b51b332e5a2b 100644
--- a/drivers/video/omap/lcd_palmtt.c
+++ b/drivers/video/omap/lcd_palmtt.c
@@ -29,7 +29,7 @@ GPIO13 - screen blanking
 #include <linux/module.h>
 #include <linux/io.h>
 
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 #include "omapfb.h"
 
 static int palmtt_panel_init(struct lcd_panel *panel,
diff --git a/drivers/video/pnx4008/sdum.c b/drivers/video/pnx4008/sdum.c
index 5ec4f2d439c9..50e00395240f 100644
--- a/drivers/video/pnx4008/sdum.c
+++ b/drivers/video/pnx4008/sdum.c
@@ -30,7 +30,7 @@
 #include <linux/clk.h>
 #include <linux/gfp.h>
 #include <asm/uaccess.h>
-#include <mach/gpio.h>
+#include <asm/gpio.h>
 
 #include "sdum.h"
 #include "fbcommon.h"
diff --git a/drivers/w1/masters/ds2490.c b/drivers/w1/masters/ds2490.c
index 02bf7bf7160b..b5abaae38e97 100644
--- a/drivers/w1/masters/ds2490.c
+++ b/drivers/w1/masters/ds2490.c
@@ -1,7 +1,7 @@
 /*
  *      dscore.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
@@ -1024,5 +1024,5 @@ module_init(ds_init);
 module_exit(ds_fini);
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
+MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
 MODULE_DESCRIPTION("DS2490 USB <-> W1 bus master driver (DS9490*)");
diff --git a/drivers/w1/masters/matrox_w1.c b/drivers/w1/masters/matrox_w1.c
index 334d1ccf9c92..f667c26b2195 100644
--- a/drivers/w1/masters/matrox_w1.c
+++ b/drivers/w1/masters/matrox_w1.c
@@ -1,7 +1,7 @@
 /*
  *      matrox_w1.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
@@ -39,7 +39,7 @@
 #include "../w1_log.h"
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
+MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
 MODULE_DESCRIPTION("Driver for transport(Dallas 1-wire prtocol) over VGA DDC(matrox gpio).");
 
 static struct pci_device_id matrox_w1_tbl[] = {
diff --git a/drivers/w1/slaves/w1_ds2408.c b/drivers/w1/slaves/w1_ds2408.c
index c37781899d90..7c8cdb8aed26 100644
--- a/drivers/w1/slaves/w1_ds2408.c
+++ b/drivers/w1/slaves/w1_ds2408.c
@@ -373,7 +373,7 @@ static int w1_f29_add_slave(struct w1_slave *sl)
 static void w1_f29_remove_slave(struct w1_slave *sl)
 {
         int i;
-        for (i = NB_SYSFS_BIN_FILES; i <= 0; --i)
+        for (i = NB_SYSFS_BIN_FILES - 1; i >= 0; --i)
                 sysfs_remove_bin_file(&sl->dev.kobj,
                         &(w1_f29_sysfs_bin_files[i]));
 }
diff --git a/drivers/w1/slaves/w1_smem.c b/drivers/w1/slaves/w1_smem.c
index cc8c02e92593..84655625c870 100644
--- a/drivers/w1/slaves/w1_smem.c
+++ b/drivers/w1/slaves/w1_smem.c
@@ -1,7 +1,7 @@
 /*
  *      w1_smem.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
@@ -32,7 +32,7 @@
 #include "../w1_family.h"
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
+MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol, 64bit memory family.");
 
 static struct w1_family w1_smem_family_01 = {
diff --git a/drivers/w1/slaves/w1_therm.c b/drivers/w1/slaves/w1_therm.c
index 402928b135d1..a1ef9b5b38cf 100644
--- a/drivers/w1/slaves/w1_therm.c
+++ b/drivers/w1/slaves/w1_therm.c
@@ -1,7 +1,7 @@
 /*
  *      w1_therm.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
@@ -34,7 +34,7 @@
 #include "../w1_family.h"
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
+MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol, temperature family.");
 
 /* Allow the strong pullup to be disabled, but default to enabled.
diff --git a/drivers/w1/w1.c b/drivers/w1/w1.c
index 6c136c19e982..c37497823851 100644
--- a/drivers/w1/w1.c
+++ b/drivers/w1/w1.c
@@ -1,7 +1,7 @@
 /*
  *      w1.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
@@ -42,7 +42,7 @@
 #include "w1_netlink.h"
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
+MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol.");
 
 static int w1_timeout = 10;
diff --git a/drivers/w1/w1.h b/drivers/w1/w1.h
index 1ce23fc6186c..4d012ca3f32c 100644
--- a/drivers/w1/w1.h
+++ b/drivers/w1/w1.h
@@ -1,7 +1,7 @@
 /*
  *      w1.h
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_family.c b/drivers/w1/w1_family.c
index 4a099041f28a..63359797c8b1 100644
--- a/drivers/w1/w1_family.c
+++ b/drivers/w1/w1_family.c
@@ -1,7 +1,7 @@
 /*
  *      w1_family.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_family.h b/drivers/w1/w1_family.h
index 98a1ac0f4693..490cda2281bc 100644
--- a/drivers/w1/w1_family.h
+++ b/drivers/w1/w1_family.h
@@ -1,7 +1,7 @@
 /*
  *      w1_family.h
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_int.c b/drivers/w1/w1_int.c
index b50be3f1073d..d220bce2cee4 100644
--- a/drivers/w1/w1_int.c
+++ b/drivers/w1/w1_int.c
@@ -1,7 +1,7 @@
 /*
  *      w1_int.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_int.h b/drivers/w1/w1_int.h
index 4274082d2262..2ad7d4414bed 100644
--- a/drivers/w1/w1_int.h
+++ b/drivers/w1/w1_int.h
@@ -1,7 +1,7 @@
 /*
  *      w1_int.h
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_io.c b/drivers/w1/w1_io.c
index 8e8b64cfafb6..765b37b62a4f 100644
--- a/drivers/w1/w1_io.c
+++ b/drivers/w1/w1_io.c
@@ -1,7 +1,7 @@
 /*
  *      w1_io.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_log.h b/drivers/w1/w1_log.h
index e6ab7cf08f88..9c7bd62e6bdc 100644
--- a/drivers/w1/w1_log.h
+++ b/drivers/w1/w1_log.h
@@ -1,7 +1,7 @@
 /*
  *      w1_log.h
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_netlink.c b/drivers/w1/w1_netlink.c
index 55aabd927c60..40788c925d1c 100644
--- a/drivers/w1/w1_netlink.c
+++ b/drivers/w1/w1_netlink.c
@@ -1,7 +1,7 @@
 /*
  * w1_netlink.c
  *
- * Copyright (c) 2003 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2003 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_netlink.h b/drivers/w1/w1_netlink.h
index 27e950f935b1..b0922dc29658 100644
--- a/drivers/w1/w1_netlink.h
+++ b/drivers/w1/w1_netlink.h
@@ -1,7 +1,7 @@
 /*
  * w1_netlink.h
  *
- * Copyright (c) 2003 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2003 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/watchdog/hpwdt.c b/drivers/watchdog/hpwdt.c
index 410fba45378d..809cbda03d7a 100644
--- a/drivers/watchdog/hpwdt.c
+++ b/drivers/watchdog/hpwdt.c
@@ -494,15 +494,16 @@ static int hpwdt_pretimeout(struct notifier_block *nb, unsigned long ulReason,
                 asminline_call(&cmn_regs, cru_rom_addr);
         die_nmi_called = 1;
         spin_unlock_irqrestore(&rom_lock, rom_pl);
+
+        if (allow_kdump)
+                hpwdt_stop();
+
         if (!is_icru) {
                 if (cmn_regs.u1.ral == 0) {
-                        printk(KERN_WARNING "hpwdt: An NMI occurred, "
+                        panic("An NMI occurred, "
                                 "but unable to determine source.\n");
                 }
         }
-
-        if (allow_kdump)
-                hpwdt_stop();
         panic("An NMI occurred, please see the Integrated "
                 "Management Log for details.\n");
 
diff --git a/drivers/watchdog/lantiq_wdt.c b/drivers/watchdog/lantiq_wdt.c
index 7d82adac1cb2..102aed0efbf1 100644
--- a/drivers/watchdog/lantiq_wdt.c
+++ b/drivers/watchdog/lantiq_wdt.c
@@ -51,16 +51,16 @@ static int ltq_wdt_ok_to_close;
 static void
 ltq_wdt_enable(void)
 {
-        ltq_wdt_timeout = ltq_wdt_timeout *
+        unsigned long int timeout = ltq_wdt_timeout *
                         (ltq_io_region_clk_rate / LTQ_WDT_DIVIDER) + 0x1000;
-        if (ltq_wdt_timeout > LTQ_MAX_TIMEOUT)
-                ltq_wdt_timeout = LTQ_MAX_TIMEOUT;
+        if (timeout > LTQ_MAX_TIMEOUT)
+                timeout = LTQ_MAX_TIMEOUT;
 
         /* write the first password magic */
         ltq_w32(LTQ_WDT_PW1, ltq_wdt_membase + LTQ_WDT_CR);
         /* write the second magic plus the configuration and new timeout */
         ltq_w32(LTQ_WDT_SR_EN | LTQ_WDT_SR_PWD | LTQ_WDT_SR_CLKDIV |
-                LTQ_WDT_PW2 | ltq_wdt_timeout, ltq_wdt_membase + LTQ_WDT_CR);
+                LTQ_WDT_PW2 | timeout, ltq_wdt_membase + LTQ_WDT_CR);
 }
 
 static void
diff --git a/drivers/watchdog/sbc_epx_c3.c b/drivers/watchdog/sbc_epx_c3.c
index 3066a5127ca8..eaca366b7234 100644
--- a/drivers/watchdog/sbc_epx_c3.c
+++ b/drivers/watchdog/sbc_epx_c3.c
@@ -173,7 +173,7 @@ static struct notifier_block epx_c3_notifier = {
         .notifier_call = epx_c3_notify_sys,
 };
 
-static const char banner[] __initdata = KERN_INFO PFX
+static const char banner[] __initconst = KERN_INFO PFX
         "Hardware Watchdog Timer for Winsystems EPX-C3 SBC: 0.1\n";
 
 static int __init watchdog_init(void)
diff --git a/drivers/watchdog/watchdog_dev.c b/drivers/watchdog/watchdog_dev.c
index d33520d0b4c9..1199da0f98cf 100644
--- a/drivers/watchdog/watchdog_dev.c
+++ b/drivers/watchdog/watchdog_dev.c
@@ -59,7 +59,7 @@ static struct watchdog_device *wdd;
 
 static int watchdog_ping(struct watchdog_device *wddev)
 {
-        if (test_bit(WDOG_ACTIVE, &wdd->status)) {
+        if (test_bit(WDOG_ACTIVE, &wddev->status)) {
                 if (wddev->ops->ping)
                         return wddev->ops->ping(wddev);  /* ping the watchdog */
                 else
@@ -81,12 +81,12 @@ static int watchdog_start(struct watchdog_device *wddev)
 {
         int err;
 
-        if (!test_bit(WDOG_ACTIVE, &wdd->status)) {
+        if (!test_bit(WDOG_ACTIVE, &wddev->status)) {
                 err = wddev->ops->start(wddev);
                 if (err < 0)
                         return err;
 
-                set_bit(WDOG_ACTIVE, &wdd->status);
+                set_bit(WDOG_ACTIVE, &wddev->status);
         }
         return 0;
 }
@@ -105,18 +105,18 @@ static int watchdog_stop(struct watchdog_device *wddev)
 {
         int err = -EBUSY;
 
-        if (test_bit(WDOG_NO_WAY_OUT, &wdd->status)) {
+        if (test_bit(WDOG_NO_WAY_OUT, &wddev->status)) {
                 pr_info("%s: nowayout prevents watchdog to be stopped!\n",
-                                                        wdd->info->identity);
+                                                        wddev->info->identity);
                 return err;
         }
 
-        if (test_bit(WDOG_ACTIVE, &wdd->status)) {
+        if (test_bit(WDOG_ACTIVE, &wddev->status)) {
                 err = wddev->ops->stop(wddev);
                 if (err < 0)
                         return err;
 
-                clear_bit(WDOG_ACTIVE, &wdd->status);
+                clear_bit(WDOG_ACTIVE, &wddev->status);
         }
         return 0;
 }
diff --git a/drivers/xen/events.c b/drivers/xen/events.c
index da70f5c32eb9..7523719bf8a4 100644
--- a/drivers/xen/events.c
+++ b/drivers/xen/events.c
@@ -54,7 +54,7 @@
  * This lock protects updates to the following mapping and reference-count
  * arrays. The lock does not need to be acquired to read the mapping tables.
  */
-static DEFINE_SPINLOCK(irq_mapping_update_lock);
+static DEFINE_MUTEX(irq_mapping_update_lock);
 
 static LIST_HEAD(xen_irq_list_head);
 
@@ -631,7 +631,7 @@ int xen_bind_pirq_gsi_to_irq(unsigned gsi,
         int irq = -1;
         struct physdev_irq irq_op;
 
-        spin_lock(&irq_mapping_update_lock);
+        mutex_lock(&irq_mapping_update_lock);
 
         irq = find_irq_by_gsi(gsi);
         if (irq != -1) {
@@ -684,7 +684,7 @@ int xen_bind_pirq_gsi_to_irq(unsigned gsi,
                                 handle_edge_irq, name);
 
 out:
-        spin_unlock(&irq_mapping_update_lock);
+        mutex_unlock(&irq_mapping_update_lock);
 
         return irq;
 }
@@ -710,7 +710,7 @@ int xen_bind_pirq_msi_to_irq(struct pci_dev *dev, struct msi_desc *msidesc,
 {
         int irq, ret;
 
-        spin_lock(&irq_mapping_update_lock);
+        mutex_lock(&irq_mapping_update_lock);
 
         irq = xen_allocate_irq_dynamic();
         if (irq == -1)
@@ -724,10 +724,10 @@ int xen_bind_pirq_msi_to_irq(struct pci_dev *dev, struct msi_desc *msidesc,
         if (ret < 0)
                 goto error_irq;
 out:
-        spin_unlock(&irq_mapping_update_lock);
+        mutex_unlock(&irq_mapping_update_lock);
         return irq;
 error_irq:
-        spin_unlock(&irq_mapping_update_lock);
+        mutex_unlock(&irq_mapping_update_lock);
         xen_free_irq(irq);
         return -1;
 }
@@ -740,7 +740,7 @@ int xen_destroy_irq(int irq)
         struct irq_info *info = info_for_irq(irq);
         int rc = -ENOENT;
 
-        spin_lock(&irq_mapping_update_lock);
+        mutex_lock(&irq_mapping_update_lock);
 
         desc = irq_to_desc(irq);
         if (!desc)
@@ -766,7 +766,7 @@ int xen_destroy_irq(int irq)
         xen_free_irq(irq);
 
 out:
-        spin_unlock(&irq_mapping_update_lock);
+        mutex_unlock(&irq_mapping_update_lock);
         return rc;
 }
 
@@ -776,7 +776,7 @@ int xen_irq_from_pirq(unsigned pirq)
 
         struct irq_info *info;
 
-        spin_lock(&irq_mapping_update_lock);
+        mutex_lock(&irq_mapping_update_lock);
 
         list_for_each_entry(info, &xen_irq_list_head, list) {
                 if (info == NULL || info->type != IRQT_PIRQ)
@@ -787,7 +787,7 @@ int xen_irq_from_pirq(unsigned pirq)
         }
         irq = -1;
 out:
-        spin_unlock(&irq_mapping_update_lock);
+        mutex_unlock(&irq_mapping_update_lock);
 
         return irq;
 }
@@ -802,7 +802,7 @@ int bind_evtchn_to_irq(unsigned int evtchn)
 {
         int irq;
 
-        spin_lock(&irq_mapping_update_lock);
+        mutex_lock(&irq_mapping_update_lock);
 
         irq = evtchn_to_irq[evtchn];
 
@@ -818,7 +818,7 @@ int bind_evtchn_to_irq(unsigned int evtchn)
         }
 
 out:
-        spin_unlock(&irq_mapping_update_lock);
+        mutex_unlock(&irq_mapping_update_lock);
 
         return irq;
 }
@@ -829,7 +829,7 @@ static int bind_ipi_to_irq(unsigned int ipi, unsigned int cpu)
         struct evtchn_bind_ipi bind_ipi;
         int evtchn, irq;
 
-        spin_lock(&irq_mapping_update_lock);
+        mutex_lock(&irq_mapping_update_lock);
 
         irq = per_cpu(ipi_to_irq, cpu)[ipi];
 
@@ -853,7 +853,7 @@ static int bind_ipi_to_irq(unsigned int ipi, unsigned int cpu)
         }
 
  out:
-        spin_unlock(&irq_mapping_update_lock);
+        mutex_unlock(&irq_mapping_update_lock);
         return irq;
 }
 
@@ -878,7 +878,7 @@ int bind_virq_to_irq(unsigned int virq, unsigned int cpu)
         struct evtchn_bind_virq bind_virq;
         int evtchn, irq;
 
-        spin_lock(&irq_mapping_update_lock);
+        mutex_lock(&irq_mapping_update_lock);
 
         irq = per_cpu(virq_to_irq, cpu)[virq];
 
@@ -903,7 +903,7 @@ int bind_virq_to_irq(unsigned int virq, unsigned int cpu)
         }
 
 out:
-        spin_unlock(&irq_mapping_update_lock);
+        mutex_unlock(&irq_mapping_update_lock);
 
         return irq;
 }
@@ -913,7 +913,7 @@ static void unbind_from_irq(unsigned int irq)
         struct evtchn_close close;
         int evtchn = evtchn_from_irq(irq);
 
-        spin_lock(&irq_mapping_update_lock);
+        mutex_lock(&irq_mapping_update_lock);
 
         if (VALID_EVTCHN(evtchn)) {
                 close.port = evtchn;
@@ -943,7 +943,7 @@ static void unbind_from_irq(unsigned int irq)
 
         xen_free_irq(irq);
 
-        spin_unlock(&irq_mapping_update_lock);
+        mutex_unlock(&irq_mapping_update_lock);
 }
 
 int bind_evtchn_to_irqhandler(unsigned int evtchn,
@@ -1279,7 +1279,7 @@ void rebind_evtchn_irq(int evtchn, int irq)
            will also be masked. */
         disable_irq(irq);
 
-        spin_lock(&irq_mapping_update_lock);
+        mutex_lock(&irq_mapping_update_lock);
 
         /* After resume the irq<->evtchn mappings are all cleared out */
         BUG_ON(evtchn_to_irq[evtchn] != -1);
@@ -1289,7 +1289,7 @@ void rebind_evtchn_irq(int evtchn, int irq)
 
         xen_irq_info_evtchn_init(irq, evtchn);
 
-        spin_unlock(&irq_mapping_update_lock);
+        mutex_unlock(&irq_mapping_update_lock);
 
         /* new event channels are always bound to cpu 0 */
         irq_set_affinity(irq, cpumask_of(0));
diff --git a/drivers/xen/xen-selfballoon.c b/drivers/xen/xen-selfballoon.c
index 1b4afd81f872..6ea852e25162 100644
--- a/drivers/xen/xen-selfballoon.c
+++ b/drivers/xen/xen-selfballoon.c
@@ -70,6 +70,7 @@
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/mman.h>
+#include <linux/module.h>
 #include <linux/workqueue.h>
 #include <xen/balloon.h>
 #include <xen/tmem.h>
diff --git a/drivers/zorro/zorro.c b/drivers/zorro/zorro.c
index e0c2807b0970..181fa8158a8b 100644
--- a/drivers/zorro/zorro.c
+++ b/drivers/zorro/zorro.c
@@ -148,10 +148,10 @@ static int __init amiga_zorro_probe(struct platform_device *pdev)
         }
         platform_set_drvdata(pdev, bus);
 
-        /* Register all devices */
         pr_info("Zorro: Probing AutoConfig expansion devices: %u device%s\n",
                  zorro_num_autocon, zorro_num_autocon == 1 ? "" : "s");
 
+        /* First identify all devices ... */
         for (i = 0; i < zorro_num_autocon; i++) {
                 z = &zorro_autocon[i];
                 z->id = (z->rom.er_Manufacturer<<16) | (z->rom.er_Product<<8);
@@ -172,6 +172,11 @@ static int __init amiga_zorro_probe(struct platform_device *pdev)
                 dev_set_name(&z->dev, "%02x", i);
                 z->dev.parent = &bus->dev;
                 z->dev.bus = &zorro_bus_type;
+        }
+
+        /* ... then register them */
+        for (i = 0; i < zorro_num_autocon; i++) {
+                z = &zorro_autocon[i];
                 error = device_register(&z->dev);
                 if (error) {
                         dev_err(&bus->dev, "Error registering device %s\n",