Merge tag 'v3.7-rc8' into spi/next

Linux 3.7-rc8

186 files changed, 1778 insertions, 1412 deletions

diff --git a/drivers/ata/ahci_platform.c b/drivers/ata/ahci_platform.c
index b1ae48054dc5..b7078afddb74 100644
--- a/drivers/ata/ahci_platform.c
+++ b/drivers/ata/ahci_platform.c
@@ -238,7 +238,7 @@ static int __devexit ahci_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int ahci_suspend(struct device *dev)
 {
         struct ahci_platform_data *pdata = dev_get_platdata(dev);
diff --git a/drivers/ata/libata-acpi.c b/drivers/ata/libata-acpi.c
index fd9ecf74e631..5b0ba3f20edc 100644
--- a/drivers/ata/libata-acpi.c
+++ b/drivers/ata/libata-acpi.c
@@ -1105,10 +1105,15 @@ static int ata_acpi_bind_device(struct ata_port *ap, struct scsi_device *sdev,
         struct acpi_device *acpi_dev;
         struct acpi_device_power_state *states;
 
-        if (ap->flags & ATA_FLAG_ACPI_SATA)
-                ata_dev = &ap->link.device[sdev->channel];
-        else
+        if (ap->flags & ATA_FLAG_ACPI_SATA) {
+                if (!sata_pmp_attached(ap))
+                        ata_dev = &ap->link.device[sdev->id];
+                else
+                        ata_dev = &ap->pmp_link[sdev->channel].device[sdev->id];
+        }
+        else {
                 ata_dev = &ap->link.device[sdev->id];
+        }
 
         *handle = ata_dev_acpi_handle(ata_dev);
 
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 3cc7096cfda7..f46fbd3bd3fb 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -2942,6 +2942,10 @@ const struct ata_timing *ata_timing_find_mode(u8 xfer_mode)
 
         if (xfer_mode == t->mode)
                 return t;
+
+        WARN_ONCE(true, "%s: unable to find timing for xfer_mode 0x%x\n",
+                        __func__, xfer_mode);
+
         return NULL;
 }
 
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index e3bda074fa12..a6df6a351d6e 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -1052,6 +1052,8 @@ static void ata_scsi_sdev_config(struct scsi_device *sdev)
 {
         sdev->use_10_for_rw = 1;
         sdev->use_10_for_ms = 1;
+        sdev->no_report_opcodes = 1;
+        sdev->no_write_same = 1;
 
         /* Schedule policy is determined by ->qc_defer() callback and
          * it needs to see every deferred qc.  Set dev_blocked to 1 to
diff --git a/drivers/ata/pata_arasan_cf.c b/drivers/ata/pata_arasan_cf.c
index 26201ebef3ca..371fd2c698b7 100644
--- a/drivers/ata/pata_arasan_cf.c
+++ b/drivers/ata/pata_arasan_cf.c
@@ -317,6 +317,12 @@ static int cf_init(struct arasan_cf_dev *acdev)
                 return ret;
         }
 
+        ret = clk_set_rate(acdev->clk, 166000000);
+        if (ret) {
+                dev_warn(acdev->host->dev, "clock set rate failed");
+                return ret;
+        }
+
         spin_lock_irqsave(&acdev->host->lock, flags);
         /* configure CF interface clock */
         writel((pdata->cf_if_clk <= CF_IF_CLK_200M) ? pdata->cf_if_clk :
@@ -908,7 +914,7 @@ static int __devexit arasan_cf_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int arasan_cf_suspend(struct device *dev)
 {
         struct ata_host *host = dev_get_drvdata(dev);
diff --git a/drivers/ata/sata_highbank.c b/drivers/ata/sata_highbank.c
index 0d7c4c2cd26f..400bf1c3e982 100644
--- a/drivers/ata/sata_highbank.c
+++ b/drivers/ata/sata_highbank.c
@@ -260,7 +260,7 @@ static const struct of_device_id ahci_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, ahci_of_match);
 
-static int __init ahci_highbank_probe(struct platform_device *pdev)
+static int __devinit ahci_highbank_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
         struct ahci_host_priv *hpriv;
@@ -378,7 +378,7 @@ static int __devexit ahci_highbank_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int ahci_highbank_suspend(struct device *dev)
 {
         struct ata_host *host = dev_get_drvdata(dev);
diff --git a/drivers/ata/sata_svw.c b/drivers/ata/sata_svw.c
index 44a4256533e1..08608de87e4e 100644
--- a/drivers/ata/sata_svw.c
+++ b/drivers/ata/sata_svw.c
@@ -142,6 +142,39 @@ static int k2_sata_scr_write(struct ata_link *link,
         return 0;
 }
 
+static int k2_sata_softreset(struct ata_link *link,
+                             unsigned int *class, unsigned long deadline)
+{
+        u8 dmactl;
+        void __iomem *mmio = link->ap->ioaddr.bmdma_addr;
+
+        dmactl = readb(mmio + ATA_DMA_CMD);
+
+        /* Clear the start bit */
+        if (dmactl & ATA_DMA_START) {
+                dmactl &= ~ATA_DMA_START;
+                writeb(dmactl, mmio + ATA_DMA_CMD);
+        }
+
+        return ata_sff_softreset(link, class, deadline);
+}
+
+static int k2_sata_hardreset(struct ata_link *link,
+                             unsigned int *class, unsigned long deadline)
+{
+        u8 dmactl;
+        void __iomem *mmio = link->ap->ioaddr.bmdma_addr;
+
+        dmactl = readb(mmio + ATA_DMA_CMD);
+
+        /* Clear the start bit */
+        if (dmactl & ATA_DMA_START) {
+                dmactl &= ~ATA_DMA_START;
+                writeb(dmactl, mmio + ATA_DMA_CMD);
+        }
+
+        return sata_sff_hardreset(link, class, deadline);
+}
 
 static void k2_sata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
 {
@@ -346,6 +379,8 @@ static struct scsi_host_template k2_sata_sht = {
 
 static struct ata_port_operations k2_sata_ops = {
         .inherits               = &ata_bmdma_port_ops,
+        .softreset              = k2_sata_softreset,
+        .hardreset              = k2_sata_hardreset,
         .sff_tf_load            = k2_sata_tf_load,
         .sff_tf_read            = k2_sata_tf_read,
         .sff_check_status       = k2_stat_check_status,
diff --git a/drivers/atm/ambassador.c b/drivers/atm/ambassador.c
index 89b30f32ba68..ff7bb8a42ed6 100644
--- a/drivers/atm/ambassador.c
+++ b/drivers/atm/ambassador.c
@@ -1961,6 +1961,7 @@ static int __devinit ucode_init (loader_block * lb, amb_dev * dev) {
     res = loader_verify(lb, dev, rec);
     if (res)
       break;
+    rec = ihex_next_binrec(rec);
   }
   release_firmware(fw);
   if (!res)
diff --git a/drivers/base/power/qos.c b/drivers/base/power/qos.c
index 74a67e0019a2..fbbd4ed2edf2 100644
--- a/drivers/base/power/qos.c
+++ b/drivers/base/power/qos.c
@@ -451,7 +451,7 @@ int dev_pm_qos_add_ancestor_request(struct device *dev,
         if (ancestor)
                 error = dev_pm_qos_add_request(ancestor, req, value);
 
-        if (error)
+        if (error < 0)
                 req->dev = NULL;
 
         return error;
diff --git a/drivers/block/aoe/aoecmd.c b/drivers/block/aoe/aoecmd.c
index 3804a0af3ef1..9fe4f1865558 100644
--- a/drivers/block/aoe/aoecmd.c
+++ b/drivers/block/aoe/aoecmd.c
@@ -935,7 +935,7 @@ aoe_end_request(struct aoedev *d, struct request *rq, int fastfail)
 
         /* cf. http://lkml.org/lkml/2006/10/31/28 */
         if (!fastfail)
-                q->request_fn(q);
+                __blk_run_queue(q);
 }
 
 static void
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 1c49d7173966..2ddd64a9ffde 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -4330,6 +4330,7 @@ out_unreg_region:
 out_unreg_blkdev:
         unregister_blkdev(FLOPPY_MAJOR, "fd");
 out_put_disk:
+        destroy_workqueue(floppy_wq);
         for (drive = 0; drive < N_DRIVE; drive++) {
                 if (!disks[drive])
                         break;
@@ -4340,7 +4341,6 @@ out_put_disk:
                 }
                 put_disk(disks[drive]);
         }
-        destroy_workqueue(floppy_wq);
         return err;
 }
 
@@ -4555,6 +4555,8 @@ static void __exit floppy_module_exit(void)
         unregister_blkdev(FLOPPY_MAJOR, "fd");
         platform_driver_unregister(&floppy_driver);
 
+        destroy_workqueue(floppy_wq);
+
         for (drive = 0; drive < N_DRIVE; drive++) {
                 del_timer_sync(&motor_off_timer[drive]);
 
@@ -4578,7 +4580,6 @@ static void __exit floppy_module_exit(void)
 
         cancel_delayed_work_sync(&fd_timeout);
         cancel_delayed_work_sync(&fd_timer);
-        destroy_workqueue(floppy_wq);
 
         if (atomic_read(&usage_count))
                 floppy_release_irq_and_dma();
diff --git a/drivers/block/mtip32xx/mtip32xx.c b/drivers/block/mtip32xx/mtip32xx.c
index adc6f36564cf..9694dd99bbbc 100644
--- a/drivers/block/mtip32xx/mtip32xx.c
+++ b/drivers/block/mtip32xx/mtip32xx.c
@@ -559,7 +559,7 @@ static void mtip_timeout_function(unsigned long int data)
         struct mtip_cmd *command;
         int tag, cmdto_cnt = 0;
         unsigned int bit, group;
-        unsigned int num_command_slots = port->dd->slot_groups * 32;
+        unsigned int num_command_slots;
         unsigned long to, tagaccum[SLOTBITS_IN_LONGS];
 
         if (unlikely(!port))
@@ -572,6 +572,7 @@ static void mtip_timeout_function(unsigned long int data)
         }
         /* clear the tag accumulator */
         memset(tagaccum, 0, SLOTBITS_IN_LONGS * sizeof(long));
+        num_command_slots = port->dd->slot_groups * 32;
 
         for (tag = 0; tag < num_command_slots; tag++) {
                 /*
@@ -2218,8 +2219,8 @@ static int exec_drive_taskfile(struct driver_data *dd,
                 fis.device);
 
         /* check for erase mode support during secure erase.*/
-        if ((fis.command == ATA_CMD_SEC_ERASE_UNIT)
-                                        && (outbuf[0] & MTIP_SEC_ERASE_MODE)) {
+        if ((fis.command == ATA_CMD_SEC_ERASE_UNIT) && outbuf &&
+                                        (outbuf[0] & MTIP_SEC_ERASE_MODE)) {
                 erasemode = 1;
         }
 
@@ -2439,7 +2440,7 @@ static int mtip_hw_ioctl(struct driver_data *dd, unsigned int cmd,
  * return value
  *      None
  */
-static void mtip_hw_submit_io(struct driver_data *dd, sector_t start,
+static void mtip_hw_submit_io(struct driver_data *dd, sector_t sector,
                               int nsect, int nents, int tag, void *callback,
                               void *data, int dir)
 {
@@ -2447,6 +2448,7 @@ static void mtip_hw_submit_io(struct driver_data *dd, sector_t start,
         struct mtip_port *port = dd->port;
         struct mtip_cmd *command = &port->commands[tag];
         int dma_dir = (dir == READ) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
+        u64 start = sector;
 
         /* Map the scatter list for DMA access */
         nents = dma_map_sg(&dd->pdev->dev, command->sg, nents, dma_dir);
@@ -2465,8 +2467,12 @@ static void mtip_hw_submit_io(struct driver_data *dd, sector_t start,
         fis->opts        = 1 << 7;
         fis->command     =
                 (dir == READ ? ATA_CMD_FPDMA_READ : ATA_CMD_FPDMA_WRITE);
-        *((unsigned int *) &fis->lba_low) = (start & 0xFFFFFF);
-        *((unsigned int *) &fis->lba_low_ex) = ((start >> 24) & 0xFFFFFF);
+        fis->lba_low     = start & 0xFF;
+        fis->lba_mid     = (start >> 8) & 0xFF;
+        fis->lba_hi      = (start >> 16) & 0xFF;
+        fis->lba_low_ex  = (start >> 24) & 0xFF;
+        fis->lba_mid_ex  = (start >> 32) & 0xFF;
+        fis->lba_hi_ex   = (start >> 40) & 0xFF;
         fis->device      = 1 << 6;
         fis->features    = nsect & 0xFF;
         fis->features_ex = (nsect >> 8) & 0xFF;
diff --git a/drivers/block/mtip32xx/mtip32xx.h b/drivers/block/mtip32xx/mtip32xx.h
index 5f4a917bd8bb..b1742640556a 100644
--- a/drivers/block/mtip32xx/mtip32xx.h
+++ b/drivers/block/mtip32xx/mtip32xx.h
@@ -34,7 +34,7 @@
 #define PCIE_CONFIG_EXT_DEVICE_CONTROL_OFFSET   0x48
 
 /* check for erase mode support during secure erase */
-#define MTIP_SEC_ERASE_MODE     0x3
+#define MTIP_SEC_ERASE_MODE     0x2
 
 /* # of times to retry timed out/failed IOs */
 #define MTIP_MAX_RETRIES        2
@@ -155,14 +155,14 @@ enum {
         MTIP_DDF_REBUILD_FAILED_BIT = 8,
 };
 
-__packed struct smart_attr{
+struct smart_attr {
         u8 attr_id;
         u16 flags;
         u8 cur;
         u8 worst;
         u32 data;
         u8 res[3];
-};
+} __packed;
 
 /* Register Frame Information Structure (FIS), host to device. */
 struct host_to_dev_fis {
diff --git a/drivers/bluetooth/ath3k.c b/drivers/bluetooth/ath3k.c
index fc2de5528dcc..b00000e8aef6 100644
--- a/drivers/bluetooth/ath3k.c
+++ b/drivers/bluetooth/ath3k.c
@@ -67,6 +67,7 @@ static struct usb_device_id ath3k_table[] = {
         { USB_DEVICE(0x13d3, 0x3304) },
         { USB_DEVICE(0x0930, 0x0215) },
         { USB_DEVICE(0x0489, 0xE03D) },
+        { USB_DEVICE(0x0489, 0xE027) },
 
         /* Atheros AR9285 Malbec with sflash firmware */
         { USB_DEVICE(0x03F0, 0x311D) },
diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c
index debda27df9b0..ee82f2fb65f0 100644
--- a/drivers/bluetooth/btusb.c
+++ b/drivers/bluetooth/btusb.c
@@ -124,6 +124,7 @@ static struct usb_device_id blacklist_table[] = {
         { USB_DEVICE(0x13d3, 0x3304), .driver_info = BTUSB_IGNORE },
         { USB_DEVICE(0x0930, 0x0215), .driver_info = BTUSB_IGNORE },
         { USB_DEVICE(0x0489, 0xe03d), .driver_info = BTUSB_IGNORE },
+        { USB_DEVICE(0x0489, 0xe027), .driver_info = BTUSB_IGNORE },
 
         /* Atheros AR9285 Malbec with sflash firmware */
         { USB_DEVICE(0x03f0, 0x311d), .driver_info = BTUSB_IGNORE },
diff --git a/drivers/bus/omap-ocp2scp.c b/drivers/bus/omap-ocp2scp.c
index ff63560b8467..0c48b0e05ed6 100644
--- a/drivers/bus/omap-ocp2scp.c
+++ b/drivers/bus/omap-ocp2scp.c
@@ -22,6 +22,26 @@
 #include <linux/pm_runtime.h>
 #include <linux/of.h>
 #include <linux/of_platform.h>
+#include <linux/platform_data/omap_ocp2scp.h>
+
+/**
+ * _count_resources - count for the number of resources
+ * @res: struct resource *
+ *
+ * Count and return the number of resources populated for the device that is
+ * connected to ocp2scp.
+ */
+static unsigned _count_resources(struct resource *res)
+{
+        int cnt = 0;
+
+        while (res->start != res->end) {
+                cnt++;
+                res++;
+        }
+
+        return cnt;
+}
 
 static int ocp2scp_remove_devices(struct device *dev, void *c)
 {
@@ -34,20 +54,62 @@ static int ocp2scp_remove_devices(struct device *dev, void *c)
 
 static int __devinit omap_ocp2scp_probe(struct platform_device *pdev)
 {
-        int                     ret;
-        struct device_node      *np = pdev->dev.of_node;
+        int ret;
+        unsigned res_cnt, i;
+        struct device_node *np = pdev->dev.of_node;
+        struct platform_device *pdev_child;
+        struct omap_ocp2scp_platform_data *pdata = pdev->dev.platform_data;
+        struct omap_ocp2scp_dev *dev;
 
         if (np) {
                 ret = of_platform_populate(np, NULL, NULL, &pdev->dev);
                 if (ret) {
-                        dev_err(&pdev->dev, "failed to add resources for ocp2scp child\n");
+                        dev_err(&pdev->dev,
+                            "failed to add resources for ocp2scp child\n");
                         goto err0;
                 }
+        } else if (pdata) {
+                for (i = 0, dev = *pdata->devices; i < pdata->dev_cnt; i++,
+                    dev++) {
+                        res_cnt = _count_resources(dev->res);
+
+                        pdev_child = platform_device_alloc(dev->drv_name,
+                            PLATFORM_DEVID_AUTO);
+                        if (!pdev_child) {
+                                dev_err(&pdev->dev,
+                                  "failed to allocate mem for ocp2scp child\n");
+                                goto err0;
+                        }
+
+                        ret = platform_device_add_resources(pdev_child,
+                            dev->res, res_cnt);
+                        if (ret) {
+                                dev_err(&pdev->dev,
+                                 "failed to add resources for ocp2scp child\n");
+                                goto err1;
+                        }
+
+                        pdev_child->dev.parent  = &pdev->dev;
+
+                        ret = platform_device_add(pdev_child);
+                        if (ret) {
+                                dev_err(&pdev->dev,
+                                   "failed to register ocp2scp child device\n");
+                                goto err1;
+                        }
+                }
+        } else {
+                dev_err(&pdev->dev, "OCP2SCP initialized without plat data\n");
+                return -EINVAL;
         }
+
         pm_runtime_enable(&pdev->dev);
 
         return 0;
 
+err1:
+        platform_device_put(pdev_child);
+
 err0:
         device_for_each_child(&pdev->dev, NULL, ocp2scp_remove_devices);
 
diff --git a/drivers/char/hw_random/Kconfig b/drivers/char/hw_random/Kconfig
index fbd9b2b850ef..c58ea9b80b1a 100644
--- a/drivers/char/hw_random/Kconfig
+++ b/drivers/char/hw_random/Kconfig
@@ -127,12 +127,12 @@ config HW_RANDOM_VIA
           If unsure, say Y.
 
 config HW_RANDOM_IXP4XX
-        tristate "Intel IXP4xx NPU HW Random Number Generator support"
+        tristate "Intel IXP4xx NPU HW Pseudo-Random Number Generator support"
         depends on HW_RANDOM && ARCH_IXP4XX
         default HW_RANDOM
         ---help---
-          This driver provides kernel-side support for the Random
-          Number Generator hardware found on the Intel IXP4xx NPU.
+          This driver provides kernel-side support for the Pseudo-Random
+          Number Generator hardware found on the Intel IXP45x/46x NPU.
 
           To compile this driver as a module, choose M here: the
           module will be called ixp4xx-rng.
diff --git a/drivers/char/hw_random/ixp4xx-rng.c b/drivers/char/hw_random/ixp4xx-rng.c
index 263567f5f392..beec1627db3c 100644
--- a/drivers/char/hw_random/ixp4xx-rng.c
+++ b/drivers/char/hw_random/ixp4xx-rng.c
@@ -45,6 +45,9 @@ static int __init ixp4xx_rng_init(void)
         void __iomem * rng_base;
         int err;
 
+        if (!cpu_is_ixp46x()) /* includes IXP455 */
+                return -ENOSYS;
+
         rng_base = ioremap(0x70002100, 4);
         if (!rng_base)
                 return -ENOMEM;
@@ -68,5 +71,5 @@ module_init(ixp4xx_rng_init);
 module_exit(ixp4xx_rng_exit);
 
 MODULE_AUTHOR("Deepak Saxena <dsaxena@plexity.net>");
-MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver for IXP4xx");
+MODULE_DESCRIPTION("H/W Pseudo-Random Number Generator (RNG) driver for IXP45x/46x");
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index 0bb207eaef2f..54a3a6d09819 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -285,7 +285,7 @@ static long raw_ctl_compat_ioctl(struct file *file, unsigned int cmd,
 
 static const struct file_operations raw_fops = {
         .read           = do_sync_read,
-        .aio_read       = blkdev_aio_read,
+        .aio_read       = generic_file_aio_read,
         .write          = do_sync_write,
         .aio_write      = blkdev_aio_write,
         .fsync          = blkdev_fsync,
diff --git a/drivers/clk/ux500/u8500_clk.c b/drivers/clk/ux500/u8500_clk.c
index ca4a25ed844c..e2c17d187d98 100644
--- a/drivers/clk/ux500/u8500_clk.c
+++ b/drivers/clk/ux500/u8500_clk.c
@@ -40,7 +40,7 @@ void u8500_clk_init(void)
                                 CLK_IS_ROOT|CLK_IGNORE_UNUSED,
                                 32768);
         clk_register_clkdev(clk, "clk32k", NULL);
-        clk_register_clkdev(clk, NULL, "rtc-pl031");
+        clk_register_clkdev(clk, "apb_pclk", "rtc-pl031");
 
         /* PRCMU clocks */
         fw_version = prcmu_get_fw_version();
@@ -228,10 +228,17 @@ void u8500_clk_init(void)
 
         clk = clk_reg_prcc_pclk("p1_pclk2", "per1clk", U8500_CLKRST1_BASE,
                                 BIT(2), 0);
+        clk_register_clkdev(clk, "apb_pclk", "nmk-i2c.1");
+
         clk = clk_reg_prcc_pclk("p1_pclk3", "per1clk", U8500_CLKRST1_BASE,
                                 BIT(3), 0);
+        clk_register_clkdev(clk, "apb_pclk", "msp0");
+        clk_register_clkdev(clk, "apb_pclk", "ux500-msp-i2s.0");
+
         clk = clk_reg_prcc_pclk("p1_pclk4", "per1clk", U8500_CLKRST1_BASE,
                                 BIT(4), 0);
+        clk_register_clkdev(clk, "apb_pclk", "msp1");
+        clk_register_clkdev(clk, "apb_pclk", "ux500-msp-i2s.1");
 
         clk = clk_reg_prcc_pclk("p1_pclk5", "per1clk", U8500_CLKRST1_BASE,
                                 BIT(5), 0);
@@ -239,6 +246,7 @@ void u8500_clk_init(void)
 
         clk = clk_reg_prcc_pclk("p1_pclk6", "per1clk", U8500_CLKRST1_BASE,
                                 BIT(6), 0);
+        clk_register_clkdev(clk, "apb_pclk", "nmk-i2c.2");
 
         clk = clk_reg_prcc_pclk("p1_pclk7", "per1clk", U8500_CLKRST1_BASE,
                                 BIT(7), 0);
@@ -246,6 +254,7 @@ void u8500_clk_init(void)
 
         clk = clk_reg_prcc_pclk("p1_pclk8", "per1clk", U8500_CLKRST1_BASE,
                                 BIT(8), 0);
+        clk_register_clkdev(clk, "apb_pclk", "slimbus0");
 
         clk = clk_reg_prcc_pclk("p1_pclk9", "per1clk", U8500_CLKRST1_BASE,
                                 BIT(9), 0);
@@ -255,11 +264,16 @@ void u8500_clk_init(void)
 
         clk = clk_reg_prcc_pclk("p1_pclk10", "per1clk", U8500_CLKRST1_BASE,
                                 BIT(10), 0);
+        clk_register_clkdev(clk, "apb_pclk", "nmk-i2c.4");
+
         clk = clk_reg_prcc_pclk("p1_pclk11", "per1clk", U8500_CLKRST1_BASE,
                                 BIT(11), 0);
+        clk_register_clkdev(clk, "apb_pclk", "msp3");
+        clk_register_clkdev(clk, "apb_pclk", "ux500-msp-i2s.3");
 
         clk = clk_reg_prcc_pclk("p2_pclk0", "per2clk", U8500_CLKRST2_BASE,
                                 BIT(0), 0);
+        clk_register_clkdev(clk, "apb_pclk", "nmk-i2c.3");
 
         clk = clk_reg_prcc_pclk("p2_pclk1", "per2clk", U8500_CLKRST2_BASE,
                                 BIT(1), 0);
@@ -279,12 +293,13 @@ void u8500_clk_init(void)
 
         clk = clk_reg_prcc_pclk("p2_pclk5", "per2clk", U8500_CLKRST2_BASE,
                                 BIT(5), 0);
+        clk_register_clkdev(clk, "apb_pclk", "msp2");
+        clk_register_clkdev(clk, "apb_pclk", "ux500-msp-i2s.2");
 
         clk = clk_reg_prcc_pclk("p2_pclk6", "per2clk", U8500_CLKRST2_BASE,
                                 BIT(6), 0);
         clk_register_clkdev(clk, "apb_pclk", "sdi1");
 
-
         clk = clk_reg_prcc_pclk("p2_pclk7", "per2clk", U8500_CLKRST2_BASE,
                                 BIT(7), 0);
         clk_register_clkdev(clk, "apb_pclk", "sdi3");
@@ -316,10 +331,15 @@ void u8500_clk_init(void)
 
         clk = clk_reg_prcc_pclk("p3_pclk1", "per3clk", U8500_CLKRST3_BASE,
                                 BIT(1), 0);
+        clk_register_clkdev(clk, "apb_pclk", "ssp0");
+
         clk = clk_reg_prcc_pclk("p3_pclk2", "per3clk", U8500_CLKRST3_BASE,
                                 BIT(2), 0);
+        clk_register_clkdev(clk, "apb_pclk", "ssp1");
+
         clk = clk_reg_prcc_pclk("p3_pclk3", "per3clk", U8500_CLKRST3_BASE,
                                 BIT(3), 0);
+        clk_register_clkdev(clk, "apb_pclk", "nmk-i2c.0");
 
         clk = clk_reg_prcc_pclk("p3_pclk4", "per3clk", U8500_CLKRST3_BASE,
                                 BIT(4), 0);
@@ -401,10 +421,17 @@ void u8500_clk_init(void)
 
         clk = clk_reg_prcc_kclk("p1_i2c1_kclk", "i2cclk",
                         U8500_CLKRST1_BASE, BIT(2), CLK_SET_RATE_GATE);
+        clk_register_clkdev(clk, NULL, "nmk-i2c.1");
+
         clk = clk_reg_prcc_kclk("p1_msp0_kclk", "msp02clk",
                         U8500_CLKRST1_BASE, BIT(3), CLK_SET_RATE_GATE);
+        clk_register_clkdev(clk, NULL, "msp0");
+        clk_register_clkdev(clk, NULL, "ux500-msp-i2s.0");
+
         clk = clk_reg_prcc_kclk("p1_msp1_kclk", "msp1clk",
                         U8500_CLKRST1_BASE, BIT(4), CLK_SET_RATE_GATE);
+        clk_register_clkdev(clk, NULL, "msp1");
+        clk_register_clkdev(clk, NULL, "ux500-msp-i2s.1");
 
         clk = clk_reg_prcc_kclk("p1_sdi0_kclk", "sdmmcclk",
                         U8500_CLKRST1_BASE, BIT(5), CLK_SET_RATE_GATE);
@@ -412,17 +439,25 @@ void u8500_clk_init(void)
 
         clk = clk_reg_prcc_kclk("p1_i2c2_kclk", "i2cclk",
                         U8500_CLKRST1_BASE, BIT(6), CLK_SET_RATE_GATE);
+        clk_register_clkdev(clk, NULL, "nmk-i2c.2");
+
         clk = clk_reg_prcc_kclk("p1_slimbus0_kclk", "slimclk",
-                        U8500_CLKRST1_BASE, BIT(3), CLK_SET_RATE_GATE);
-        /* FIXME: Redefinition of BIT(3). */
+                        U8500_CLKRST1_BASE, BIT(8), CLK_SET_RATE_GATE);
+        clk_register_clkdev(clk, NULL, "slimbus0");
+
         clk = clk_reg_prcc_kclk("p1_i2c4_kclk", "i2cclk",
                         U8500_CLKRST1_BASE, BIT(9), CLK_SET_RATE_GATE);
+        clk_register_clkdev(clk, NULL, "nmk-i2c.4");
+
         clk = clk_reg_prcc_kclk("p1_msp3_kclk", "msp1clk",
                         U8500_CLKRST1_BASE, BIT(10), CLK_SET_RATE_GATE);
+        clk_register_clkdev(clk, NULL, "msp3");
+        clk_register_clkdev(clk, NULL, "ux500-msp-i2s.3");
 
         /* Periph2 */
         clk = clk_reg_prcc_kclk("p2_i2c3_kclk", "i2cclk",
                         U8500_CLKRST2_BASE, BIT(0), CLK_SET_RATE_GATE);
+        clk_register_clkdev(clk, NULL, "nmk-i2c.3");
 
         clk = clk_reg_prcc_kclk("p2_sdi4_kclk", "sdmmcclk",
                         U8500_CLKRST2_BASE, BIT(2), CLK_SET_RATE_GATE);
@@ -430,6 +465,8 @@ void u8500_clk_init(void)
 
         clk = clk_reg_prcc_kclk("p2_msp2_kclk", "msp02clk",
                         U8500_CLKRST2_BASE, BIT(3), CLK_SET_RATE_GATE);
+        clk_register_clkdev(clk, NULL, "msp2");
+        clk_register_clkdev(clk, NULL, "ux500-msp-i2s.2");
 
         clk = clk_reg_prcc_kclk("p2_sdi1_kclk", "sdmmcclk",
                         U8500_CLKRST2_BASE, BIT(4), CLK_SET_RATE_GATE);
@@ -450,10 +487,15 @@ void u8500_clk_init(void)
         /* Periph3 */
         clk = clk_reg_prcc_kclk("p3_ssp0_kclk", "sspclk",
                         U8500_CLKRST3_BASE, BIT(1), CLK_SET_RATE_GATE);
+        clk_register_clkdev(clk, NULL, "ssp0");
+
         clk = clk_reg_prcc_kclk("p3_ssp1_kclk", "sspclk",
                         U8500_CLKRST3_BASE, BIT(2), CLK_SET_RATE_GATE);
+        clk_register_clkdev(clk, NULL, "ssp1");
+
         clk = clk_reg_prcc_kclk("p3_i2c0_kclk", "i2cclk",
                         U8500_CLKRST3_BASE, BIT(3), CLK_SET_RATE_GATE);
+        clk_register_clkdev(clk, NULL, "nmk-i2c.0");
 
         clk = clk_reg_prcc_kclk("p3_sdi2_kclk", "sdmmcclk",
                         U8500_CLKRST3_BASE, BIT(4), CLK_SET_RATE_GATE);
diff --git a/drivers/crypto/Kconfig b/drivers/crypto/Kconfig
index 308c7fb92a60..f6644f59fd9d 100644
--- a/drivers/crypto/Kconfig
+++ b/drivers/crypto/Kconfig
@@ -224,7 +224,7 @@ config CRYPTO_DEV_TALITOS
 
 config CRYPTO_DEV_IXP4XX
         tristate "Driver for IXP4xx crypto hardware acceleration"
-        depends on ARCH_IXP4XX
+        depends on ARCH_IXP4XX && IXP4XX_QMGR && IXP4XX_NPE
         select CRYPTO_DES
         select CRYPTO_ALGAPI
         select CRYPTO_AUTHENC
diff --git a/drivers/crypto/ixp4xx_crypto.c b/drivers/crypto/ixp4xx_crypto.c
index 8f3f74ce8c7f..21180d6cad6e 100644
--- a/drivers/crypto/ixp4xx_crypto.c
+++ b/drivers/crypto/ixp4xx_crypto.c
@@ -750,12 +750,12 @@ static int setup_cipher(struct crypto_tfm *tfm, int encrypt,
         }
         if (cipher_cfg & MOD_AES) {
                 switch (key_len) {
-                        case 16: keylen_cfg = MOD_AES128 | KEYLEN_128; break;
-                        case 24: keylen_cfg = MOD_AES192 | KEYLEN_192; break;
-                        case 32: keylen_cfg = MOD_AES256 | KEYLEN_256; break;
-                        default:
-                                *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
-                                return -EINVAL;
+                case 16: keylen_cfg = MOD_AES128; break;
+                case 24: keylen_cfg = MOD_AES192; break;
+                case 32: keylen_cfg = MOD_AES256; break;
+                default:
+                        *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
+                        return -EINVAL;
                 }
                 cipher_cfg |= keylen_cfg;
         } else if (cipher_cfg & MOD_3DES) {
diff --git a/drivers/edac/amd64_edac.h b/drivers/edac/amd64_edac.h
index 8d4804732bac..8c4139647efc 100644
--- a/drivers/edac/amd64_edac.h
+++ b/drivers/edac/amd64_edac.h
@@ -33,7 +33,7 @@
  *              detection. The mods to Rev F required more family
  *              information detection.
  *
- *      Changes/Fixes by Borislav Petkov <borislav.petkov@amd.com>:
+ *      Changes/Fixes by Borislav Petkov <bp@alien8.de>:
  *              - misc fixes and code cleanups
  *
  * This module is based on the following documents
diff --git a/drivers/edac/edac_mc.c b/drivers/edac/edac_mc.c
index 90f0b730e9bb..75c0a1a85fc3 100644
--- a/drivers/edac/edac_mc.c
+++ b/drivers/edac/edac_mc.c
@@ -416,10 +416,18 @@ struct mem_ctl_info *edac_mc_alloc(unsigned mc_num,
                 dimm->cschannel = chn;
 
                 /* Increment csrow location */
-                row++;
-                if (row == tot_csrows) {
-                        row = 0;
+                if (layers[0].is_virt_csrow) {
                         chn++;
+                        if (chn == tot_channels) {
+                                chn = 0;
+                                row++;
+                        }
+                } else {
+                        row++;
+                        if (row == tot_csrows) {
+                                row = 0;
+                                chn++;
+                        }
                 }
 
                 /* Increment dimm location */
diff --git a/drivers/edac/edac_stub.c b/drivers/edac/edac_stub.c
index 6c86f6e54558..351945fa2ecd 100644
--- a/drivers/edac/edac_stub.c
+++ b/drivers/edac/edac_stub.c
@@ -5,7 +5,7 @@
  *
  * 2007 (c) MontaVista Software, Inc.
  * 2010 (c) Advanced Micro Devices Inc.
- *          Borislav Petkov <borislav.petkov@amd.com>
+ *          Borislav Petkov <bp@alien8.de>
  *
  * This file is licensed under the terms of the GNU General Public
  * License version 2. This program is licensed "as is" without any
diff --git a/drivers/edac/i7300_edac.c b/drivers/edac/i7300_edac.c
index a09d0667f72a..9d669cd43618 100644
--- a/drivers/edac/i7300_edac.c
+++ b/drivers/edac/i7300_edac.c
@@ -197,8 +197,8 @@ static const char *ferr_fat_fbd_name[] = {
         [0]  = "Memory Write error on non-redundant retry or "
                "FBD configuration Write error on retry",
 };
-#define GET_FBD_FAT_IDX(fbderr) (fbderr & (3 << 28))
-#define FERR_FAT_FBD_ERR_MASK ((1 << 0) | (1 << 1) | (1 << 2) | (1 << 3))
+#define GET_FBD_FAT_IDX(fbderr) (((fbderr) >> 28) & 3)
+#define FERR_FAT_FBD_ERR_MASK ((1 << 0) | (1 << 1) | (1 << 2) | (1 << 22))
 
 #define FERR_NF_FBD     0xa0
 static const char *ferr_nf_fbd_name[] = {
@@ -225,7 +225,7 @@ static const char *ferr_nf_fbd_name[] = {
         [1]  = "Aliased Uncorrectable Non-Mirrored Demand Data ECC",
         [0]  = "Uncorrectable Data ECC on Replay",
 };
-#define GET_FBD_NF_IDX(fbderr)  (fbderr & (3 << 28))
+#define GET_FBD_NF_IDX(fbderr)  (((fbderr) >> 28) & 3)
 #define FERR_NF_FBD_ERR_MASK ((1 << 24) | (1 << 23) | (1 << 22) | (1 << 21) |\
                               (1 << 18) | (1 << 17) | (1 << 16) | (1 << 15) |\
                               (1 << 14) | (1 << 13) | (1 << 11) | (1 << 10) |\
@@ -464,7 +464,7 @@ static void i7300_process_fbd_error(struct mem_ctl_info *mci)
                 errnum = find_first_bit(&errors,
                                         ARRAY_SIZE(ferr_nf_fbd_name));
                 specific = GET_ERR_FROM_TABLE(ferr_nf_fbd_name, errnum);
-                branch = (GET_FBD_FAT_IDX(error_reg) == 2) ? 1 : 0;
+                branch = (GET_FBD_NF_IDX(error_reg) == 2) ? 1 : 0;
 
                 pci_read_config_dword(pvt->pci_dev_16_1_fsb_addr_map,
                         REDMEMA, &syndrome);
diff --git a/drivers/edac/i7core_edac.c b/drivers/edac/i7core_edac.c
index 3672101023bd..10c8c00d6469 100644
--- a/drivers/edac/i7core_edac.c
+++ b/drivers/edac/i7core_edac.c
@@ -816,7 +816,7 @@ static ssize_t i7core_inject_store_##param(			\
         struct device_attribute *mattr,                         \
         const char *data, size_t count)                         \
 {                                                               \
-        struct mem_ctl_info *mci = to_mci(dev);                 \
+        struct mem_ctl_info *mci = dev_get_drvdata(dev);        \
         struct i7core_pvt *pvt;                                 \
         long value;                                             \
         int rc;                                                 \
@@ -845,7 +845,7 @@ static ssize_t i7core_inject_show_##param(			\
         struct device_attribute *mattr,                         \
         char *data)                                             \
 {                                                               \
-        struct mem_ctl_info *mci = to_mci(dev);                 \
+        struct mem_ctl_info *mci = dev_get_drvdata(dev);        \
         struct i7core_pvt *pvt;                                 \
                                                                 \
         pvt = mci->pvt_info;                                    \
@@ -1052,7 +1052,7 @@ static ssize_t i7core_show_counter_##param(			\
         struct device_attribute *mattr,                         \
         char *data)                                             \
 {                                                               \
-        struct mem_ctl_info *mci = to_mci(dev);                 \
+        struct mem_ctl_info *mci = dev_get_drvdata(dev);        \
         struct i7core_pvt *pvt = mci->pvt_info;                 \
                                                                 \
         edac_dbg(1, "\n");                                      \
diff --git a/drivers/edac/i82975x_edac.c b/drivers/edac/i82975x_edac.c
index 069e26c11c4f..a98020409fa9 100644
--- a/drivers/edac/i82975x_edac.c
+++ b/drivers/edac/i82975x_edac.c
@@ -370,10 +370,6 @@ static enum dev_type i82975x_dram_type(void __iomem *mch_window, int rank)
 static void i82975x_init_csrows(struct mem_ctl_info *mci,
                 struct pci_dev *pdev, void __iomem *mch_window)
 {
-        static const char *labels[4] = {
-                                                        "DIMM A1", "DIMM A2",
-                                                        "DIMM B1", "DIMM B2"
-                                                };
         struct csrow_info *csrow;
         unsigned long last_cumul_size;
         u8 value;
@@ -423,9 +419,10 @@ static void i82975x_init_csrows(struct mem_ctl_info *mci,
                         dimm = mci->csrows[index]->channels[chan]->dimm;
 
                         dimm->nr_pages = nr_pages / csrow->nr_channels;
-                        strncpy(csrow->channels[chan]->dimm->label,
-                                        labels[(index >> 1) + (chan * 2)],
-                                        EDAC_MC_LABEL_LEN);
+
+                        snprintf(csrow->channels[chan]->dimm->label, EDAC_MC_LABEL_LEN, "DIMM %c%d",
+                                 (chan == 0) ? 'A' : 'B',
+                                 index);
                         dimm->grain = 1 << 7;   /* 128Byte cache-line resolution */
                         dimm->dtype = i82975x_dram_type(mch_window, index);
                         dimm->mtype = MEM_DDR2; /* I82975x supports only DDR2 */
diff --git a/drivers/edac/mce_amd_inj.c b/drivers/edac/mce_amd_inj.c
index 66b5151c1080..2ae78f20cc28 100644
--- a/drivers/edac/mce_amd_inj.c
+++ b/drivers/edac/mce_amd_inj.c
@@ -6,7 +6,7 @@
  * This file may be distributed under the terms of the GNU General Public
  * License version 2.
  *
- * Copyright (c) 2010:  Borislav Petkov <borislav.petkov@amd.com>
+ * Copyright (c) 2010:  Borislav Petkov <bp@alien8.de>
  *                      Advanced Micro Devices Inc.
  */
 
@@ -168,6 +168,6 @@ module_init(edac_init_mce_inject);
 module_exit(edac_exit_mce_inject);
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Borislav Petkov <borislav.petkov@amd.com>");
+MODULE_AUTHOR("Borislav Petkov <bp@alien8.de>");
 MODULE_AUTHOR("AMD Inc.");
 MODULE_DESCRIPTION("MCE injection facility for testing MCE decoding");
diff --git a/drivers/firewire/sbp2.c b/drivers/firewire/sbp2.c
index 1162d6b3bf85..bb1b392f5cda 100644
--- a/drivers/firewire/sbp2.c
+++ b/drivers/firewire/sbp2.c
@@ -1546,6 +1546,8 @@ static int sbp2_scsi_slave_configure(struct scsi_device *sdev)
         struct sbp2_logical_unit *lu = sdev->hostdata;
 
         sdev->use_10_for_rw = 1;
+        sdev->no_report_opcodes = 1;
+        sdev->no_write_same = 1;
 
         if (sbp2_param_exclusive_login)
                 sdev->manage_start_stop = 1;
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index f11d8e3b4041..47150f5ded04 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -466,7 +466,7 @@ config GPIO_ADP5588_IRQ
 
 config GPIO_ADNP
         tristate "Avionic Design N-bit GPIO expander"
-        depends on I2C && OF
+        depends on I2C && OF_GPIO
         help
           This option enables support for N GPIOs found on Avionic Design
           I2C GPIO expanders. The register space will be extended by powers
diff --git a/drivers/gpio/gpio-mcp23s08.c b/drivers/gpio/gpio-mcp23s08.c
index 0f425189de11..ce1c84760076 100644
--- a/drivers/gpio/gpio-mcp23s08.c
+++ b/drivers/gpio/gpio-mcp23s08.c
@@ -77,7 +77,7 @@ struct mcp23s08_driver_data {
 
 /*----------------------------------------------------------------------*/
 
-#ifdef CONFIG_I2C
+#if IS_ENABLED(CONFIG_I2C)
 
 static int mcp23008_read(struct mcp23s08 *mcp, unsigned reg)
 {
@@ -399,7 +399,7 @@ static int mcp23s08_probe_one(struct mcp23s08 *mcp, struct device *dev,
                 break;
 #endif /* CONFIG_SPI_MASTER */
 
-#ifdef CONFIG_I2C
+#if IS_ENABLED(CONFIG_I2C)
         case MCP_TYPE_008:
                 mcp->ops = &mcp23008_ops;
                 mcp->chip.ngpio = 8;
@@ -473,7 +473,7 @@ fail:
 
 /*----------------------------------------------------------------------*/
 
-#ifdef CONFIG_I2C
+#if IS_ENABLED(CONFIG_I2C)
 
 static int __devinit mcp230xx_probe(struct i2c_client *client,
                                     const struct i2c_device_id *id)
diff --git a/drivers/gpio/gpio-mvebu.c b/drivers/gpio/gpio-mvebu.c
index cf7afb9eb61a..be65c0451ad5 100644
--- a/drivers/gpio/gpio-mvebu.c
+++ b/drivers/gpio/gpio-mvebu.c
@@ -92,6 +92,11 @@ static inline void __iomem *mvebu_gpioreg_out(struct mvebu_gpio_chip *mvchip)
         return mvchip->membase + GPIO_OUT_OFF;
 }
 
+static inline void __iomem *mvebu_gpioreg_blink(struct mvebu_gpio_chip *mvchip)
+{
+        return mvchip->membase + GPIO_BLINK_EN_OFF;
+}
+
 static inline void __iomem *mvebu_gpioreg_io_conf(struct mvebu_gpio_chip *mvchip)
 {
         return mvchip->membase + GPIO_IO_CONF_OFF;
@@ -206,6 +211,23 @@ static int mvebu_gpio_get(struct gpio_chip *chip, unsigned pin)
         return (u >> pin) & 1;
 }
 
+static void mvebu_gpio_blink(struct gpio_chip *chip, unsigned pin, int value)
+{
+        struct mvebu_gpio_chip *mvchip =
+                container_of(chip, struct mvebu_gpio_chip, chip);
+        unsigned long flags;
+        u32 u;
+
+        spin_lock_irqsave(&mvchip->lock, flags);
+        u = readl_relaxed(mvebu_gpioreg_blink(mvchip));
+        if (value)
+                u |= 1 << pin;
+        else
+                u &= ~(1 << pin);
+        writel_relaxed(u, mvebu_gpioreg_blink(mvchip));
+        spin_unlock_irqrestore(&mvchip->lock, flags);
+}
+
 static int mvebu_gpio_direction_input(struct gpio_chip *chip, unsigned pin)
 {
         struct mvebu_gpio_chip *mvchip =
@@ -244,6 +266,7 @@ static int mvebu_gpio_direction_output(struct gpio_chip *chip, unsigned pin,
         if (ret)
                 return ret;
 
+        mvebu_gpio_blink(chip, pin, 0);
         mvebu_gpio_set(chip, pin, value);
 
         spin_lock_irqsave(&mvchip->lock, flags);
diff --git a/drivers/gpu/drm/exynos/exynos_drm_encoder.c b/drivers/gpu/drm/exynos/exynos_drm_encoder.c
index 241ad1eeec64..f2df06c603f7 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_encoder.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_encoder.c
@@ -226,6 +226,12 @@ static void exynos_drm_encoder_commit(struct drm_encoder *encoder)
          * already updated or not by exynos_drm_encoder_dpms function.
          */
         exynos_encoder->updated = true;
+
+        /*
+         * In case of setcrtc, there is no way to update encoder's dpms
+         * so update it here.
+         */
+        exynos_encoder->dpms = DRM_MODE_DPMS_ON;
 }
 
 static void exynos_drm_encoder_disable(struct drm_encoder *encoder)
@@ -507,6 +513,6 @@ void exynos_drm_encoder_plane_disable(struct drm_encoder *encoder, void *data)
          * because the setting for disabling the overlay will be updated
          * at vsync.
          */
-        if (overlay_ops->wait_for_vblank)
+        if (overlay_ops && overlay_ops->wait_for_vblank)
                 overlay_ops->wait_for_vblank(manager->dev);
 }
diff --git a/drivers/gpu/drm/exynos/exynos_drm_fbdev.c b/drivers/gpu/drm/exynos/exynos_drm_fbdev.c
index 67eb6ba56edf..e7466c4414cb 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_fbdev.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_fbdev.c
@@ -87,7 +87,8 @@ static int exynos_drm_fbdev_update(struct drm_fb_helper *helper,
 
         dev->mode_config.fb_base = (resource_size_t)buffer->dma_addr;
         fbi->screen_base = buffer->kvaddr + offset;
-        fbi->fix.smem_start = (unsigned long)(buffer->dma_addr + offset);
+        fbi->fix.smem_start = (unsigned long)(page_to_phys(buffer->pages[0]) +
+                                offset);
         fbi->screen_size = size;
         fbi->fix.smem_len = size;
 
diff --git a/drivers/gpu/drm/exynos/exynos_drm_fimd.c b/drivers/gpu/drm/exynos/exynos_drm_fimd.c
index 130a2b510d4a..e08478f19f1a 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_fimd.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_fimd.c
@@ -61,11 +61,11 @@ struct fimd_driver_data {
         unsigned int timing_base;
 };
 
-struct fimd_driver_data exynos4_fimd_driver_data = {
+static struct fimd_driver_data exynos4_fimd_driver_data = {
         .timing_base = 0x0,
 };
 
-struct fimd_driver_data exynos5_fimd_driver_data = {
+static struct fimd_driver_data exynos5_fimd_driver_data = {
         .timing_base = 0x20000,
 };
 
diff --git a/drivers/gpu/drm/exynos/exynos_drm_plane.c b/drivers/gpu/drm/exynos/exynos_drm_plane.c
index 60b877a388c2..862ca1eb2102 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_plane.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_plane.c
@@ -204,7 +204,6 @@ exynos_update_plane(struct drm_plane *plane, struct drm_crtc *crtc,
                 return ret;
 
         plane->crtc = crtc;
-        plane->fb = crtc->fb;
 
         exynos_plane_commit(plane);
         exynos_plane_dpms(plane, DRM_MODE_DPMS_ON);
diff --git a/drivers/gpu/drm/i915/intel_bios.c b/drivers/gpu/drm/i915/intel_bios.c
index 0ed6baff4b0c..56846ed5ee55 100644
--- a/drivers/gpu/drm/i915/intel_bios.c
+++ b/drivers/gpu/drm/i915/intel_bios.c
@@ -499,12 +499,8 @@ parse_edp(struct drm_i915_private *dev_priv, struct bdb_header *bdb)
 
         edp = find_section(bdb, BDB_EDP);
         if (!edp) {
-                if (SUPPORTS_EDP(dev_priv->dev) && dev_priv->edp.support) {
-                        DRM_DEBUG_KMS("No eDP BDB found but eDP panel "
-                                      "supported, assume %dbpp panel color "
-                                      "depth.\n",
-                                      dev_priv->edp.bpp);
-                }
+                if (SUPPORTS_EDP(dev_priv->dev) && dev_priv->edp.support)
+                        DRM_DEBUG_KMS("No eDP BDB found but eDP panel supported.\n");
                 return;
         }
 
@@ -657,9 +653,6 @@ init_vbt_defaults(struct drm_i915_private *dev_priv)
         dev_priv->lvds_use_ssc = 1;
         dev_priv->lvds_ssc_freq = intel_bios_ssc_frequency(dev, 1);
         DRM_DEBUG_KMS("Set default to SSC at %dMHz\n", dev_priv->lvds_ssc_freq);
-
-        /* eDP data */
-        dev_priv->edp.bpp = 18;
 }
 
 static int __init intel_no_opregion_vbt_callback(const struct dmi_system_id *id)
diff --git a/drivers/gpu/drm/i915/intel_crt.c b/drivers/gpu/drm/i915/intel_crt.c
index b726b478a4f5..6345878ae1e7 100644
--- a/drivers/gpu/drm/i915/intel_crt.c
+++ b/drivers/gpu/drm/i915/intel_crt.c
@@ -143,7 +143,7 @@ static void intel_crt_dpms(struct drm_connector *connector, int mode)
         int old_dpms;
 
         /* PCH platforms and VLV only support on/off. */
-        if (INTEL_INFO(dev)->gen < 5 && mode != DRM_MODE_DPMS_ON)
+        if (INTEL_INFO(dev)->gen >= 5 && mode != DRM_MODE_DPMS_ON)
                 mode = DRM_MODE_DPMS_OFF;
 
         if (mode == connector->dpms)
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 461a637f1ef7..b426d44a2b05 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -3841,6 +3841,17 @@ static bool intel_choose_pipe_bpp_dither(struct drm_crtc *crtc,
                         }
                 }
 
+                if (intel_encoder->type == INTEL_OUTPUT_EDP) {
+                        /* Use VBT settings if we have an eDP panel */
+                        unsigned int edp_bpc = dev_priv->edp.bpp / 3;
+
+                        if (edp_bpc && edp_bpc < display_bpc) {
+                                DRM_DEBUG_KMS("clamping display bpc (was %d) to eDP (%d)\n", display_bpc, edp_bpc);
+                                display_bpc = edp_bpc;
+                        }
+                        continue;
+                }
+
                 /*
                  * HDMI is either 12 or 8, so if the display lets 10bpc sneak
                  * through, clamp it down.  (Note: >12bpc will be caught below.)
diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c
index 72f41aaa71ff..442968f8b201 100644
--- a/drivers/gpu/drm/i915/intel_pm.c
+++ b/drivers/gpu/drm/i915/intel_pm.c
@@ -2373,15 +2373,9 @@ int intel_enable_rc6(const struct drm_device *dev)
         if (i915_enable_rc6 >= 0)
                 return i915_enable_rc6;
 
-        if (INTEL_INFO(dev)->gen == 5) {
-#ifdef CONFIG_INTEL_IOMMU
-                /* Disable rc6 on ilk if VT-d is on. */
-                if (intel_iommu_gfx_mapped)
-                        return false;
-#endif
-                DRM_DEBUG_DRIVER("Ironlake: only RC6 available\n");
-                return INTEL_RC6_ENABLE;
-        }
+        /* Disable RC6 on Ironlake */
+        if (INTEL_INFO(dev)->gen == 5)
+                return 0;
 
         if (IS_HASWELL(dev)) {
                 DRM_DEBUG_DRIVER("Haswell: only RC6 available\n");
diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c
index 79d308da29ff..a6ac0b416964 100644
--- a/drivers/gpu/drm/i915/intel_sdvo.c
+++ b/drivers/gpu/drm/i915/intel_sdvo.c
@@ -2201,7 +2201,6 @@ intel_sdvo_dvi_init(struct intel_sdvo *intel_sdvo, int device)
                 connector->connector_type = DRM_MODE_CONNECTOR_HDMIA;
                 intel_sdvo->is_hdmi = true;
         }
-        intel_sdvo->base.cloneable = true;
 
         intel_sdvo_connector_init(intel_sdvo_connector, intel_sdvo);
         if (intel_sdvo->is_hdmi)
@@ -2232,7 +2231,6 @@ intel_sdvo_tv_init(struct intel_sdvo *intel_sdvo, int type)
 
         intel_sdvo->is_tv = true;
         intel_sdvo->base.needs_tv_clock = true;
-        intel_sdvo->base.cloneable = false;
 
         intel_sdvo_connector_init(intel_sdvo_connector, intel_sdvo);
 
@@ -2275,8 +2273,6 @@ intel_sdvo_analog_init(struct intel_sdvo *intel_sdvo, int device)
                 intel_sdvo_connector->output_flag = SDVO_OUTPUT_RGB1;
         }
 
-        intel_sdvo->base.cloneable = true;
-
         intel_sdvo_connector_init(intel_sdvo_connector,
                                   intel_sdvo);
         return true;
@@ -2307,9 +2303,6 @@ intel_sdvo_lvds_init(struct intel_sdvo *intel_sdvo, int device)
                 intel_sdvo_connector->output_flag = SDVO_OUTPUT_LVDS1;
         }
 
-        /* SDVO LVDS is not cloneable because the input mode gets adjusted by the encoder */
-        intel_sdvo->base.cloneable = false;
-
         intel_sdvo_connector_init(intel_sdvo_connector, intel_sdvo);
         if (!intel_sdvo_create_enhance_property(intel_sdvo, intel_sdvo_connector))
                 goto err;
@@ -2382,6 +2375,18 @@ intel_sdvo_output_setup(struct intel_sdvo *intel_sdvo, uint16_t flags)
         return true;
 }
 
+static void intel_sdvo_output_cleanup(struct intel_sdvo *intel_sdvo)
+{
+        struct drm_device *dev = intel_sdvo->base.base.dev;
+        struct drm_connector *connector, *tmp;
+
+        list_for_each_entry_safe(connector, tmp,
+                                 &dev->mode_config.connector_list, head) {
+                if (intel_attached_encoder(connector) == &intel_sdvo->base)
+                        intel_sdvo_destroy(connector);
+        }
+}
+
 static bool intel_sdvo_tv_create_property(struct intel_sdvo *intel_sdvo,
                                           struct intel_sdvo_connector *intel_sdvo_connector,
                                           int type)
@@ -2705,9 +2710,20 @@ bool intel_sdvo_init(struct drm_device *dev, uint32_t sdvo_reg, bool is_sdvob)
                                     intel_sdvo->caps.output_flags) != true) {
                 DRM_DEBUG_KMS("SDVO output failed to setup on %s\n",
                               SDVO_NAME(intel_sdvo));
-                goto err;
+                /* Output_setup can leave behind connectors! */
+                goto err_output;
         }
 
+        /*
+         * Cloning SDVO with anything is often impossible, since the SDVO
+         * encoder can request a special input timing mode. And even if that's
+         * not the case we have evidence that cloning a plain unscaled mode with
+         * VGA doesn't really work. Furthermore the cloning flags are way too
+         * simplistic anyway to express such constraints, so just give up on
+         * cloning for SDVO encoders.
+         */
+        intel_sdvo->base.cloneable = false;
+
         /* Only enable the hotplug irq if we need it, to work around noisy
          * hotplug lines.
          */
@@ -2718,12 +2734,12 @@ bool intel_sdvo_init(struct drm_device *dev, uint32_t sdvo_reg, bool is_sdvob)
 
         /* Set the input timing to the screen. Assume always input 0. */
         if (!intel_sdvo_set_target_input(intel_sdvo))
-                goto err;
+                goto err_output;
 
         if (!intel_sdvo_get_input_pixel_clock_range(intel_sdvo,
                                                     &intel_sdvo->pixel_clock_min,
                                                     &intel_sdvo->pixel_clock_max))
-                goto err;
+                goto err_output;
 
         DRM_DEBUG_KMS("%s device VID/DID: %02X:%02X.%02X, "
                         "clock range %dMHz - %dMHz, "
@@ -2743,6 +2759,9 @@ bool intel_sdvo_init(struct drm_device *dev, uint32_t sdvo_reg, bool is_sdvob)
                         (SDVO_OUTPUT_TMDS1 | SDVO_OUTPUT_RGB1) ? 'Y' : 'N');
         return true;
 
+err_output:
+        intel_sdvo_output_cleanup(intel_sdvo);
+
 err:
         drm_encoder_cleanup(&intel_encoder->base);
         i2c_del_adapter(&intel_sdvo->ddc);
diff --git a/drivers/gpu/drm/nouveau/core/engine/disp/nv50.c b/drivers/gpu/drm/nouveau/core/engine/disp/nv50.c
index 05a909a17cee..15b182c84ce8 100644
--- a/drivers/gpu/drm/nouveau/core/engine/disp/nv50.c
+++ b/drivers/gpu/drm/nouveau/core/engine/disp/nv50.c
@@ -49,13 +49,7 @@ nv50_disp_intr_vblank(struct nv50_disp_priv *priv, int crtc)
                 if (chan->vblank.crtc != crtc)
                         continue;
 
-                if (nv_device(priv)->chipset == 0x50) {
-                        nv_wr32(priv, 0x001704, chan->vblank.channel);
-                        nv_wr32(priv, 0x001710, 0x80000000 | chan->vblank.ctxdma);
-                        bar->flush(bar);
-                        nv_wr32(priv, 0x001570, chan->vblank.offset);
-                        nv_wr32(priv, 0x001574, chan->vblank.value);
-                } else {
+                if (nv_device(priv)->chipset >= 0xc0) {
                         nv_wr32(priv, 0x001718, 0x80000000 | chan->vblank.channel);
                         bar->flush(bar);
                         nv_wr32(priv, 0x06000c,
@@ -63,6 +57,17 @@ nv50_disp_intr_vblank(struct nv50_disp_priv *priv, int crtc)
                         nv_wr32(priv, 0x060010,
                                 lower_32_bits(chan->vblank.offset));
                         nv_wr32(priv, 0x060014, chan->vblank.value);
+                } else {
+                        nv_wr32(priv, 0x001704, chan->vblank.channel);
+                        nv_wr32(priv, 0x001710, 0x80000000 | chan->vblank.ctxdma);
+                        bar->flush(bar);
+                        if (nv_device(priv)->chipset == 0x50) {
+                                nv_wr32(priv, 0x001570, chan->vblank.offset);
+                                nv_wr32(priv, 0x001574, chan->vblank.value);
+                        } else {
+                                nv_wr32(priv, 0x060010, chan->vblank.offset);
+                                nv_wr32(priv, 0x060014, chan->vblank.value);
+                        }
                 }
 
                 list_del(&chan->vblank.head);
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/ctxnv40.c b/drivers/gpu/drm/nouveau/core/engine/graph/ctxnv40.c
index e45035efb8ca..7bbb1e1b7a8d 100644
--- a/drivers/gpu/drm/nouveau/core/engine/graph/ctxnv40.c
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/ctxnv40.c
@@ -669,21 +669,27 @@ nv40_grctx_fill(struct nouveau_device *device, struct nouveau_gpuobj *mem)
                            });
 }
 
-void
+int
 nv40_grctx_init(struct nouveau_device *device, u32 *size)
 {
-        u32 ctxprog[256], i;
+        u32 *ctxprog = kmalloc(256 * 4, GFP_KERNEL), i;
         struct nouveau_grctx ctx = {
                 .device = device,
                 .mode = NOUVEAU_GRCTX_PROG,
                 .data = ctxprog,
-                .ctxprog_max = ARRAY_SIZE(ctxprog)
+                .ctxprog_max = 256,
         };
 
+        if (!ctxprog)
+                return -ENOMEM;
+
         nv40_grctx_generate(&ctx);
 
         nv_wr32(device, 0x400324, 0);
         for (i = 0; i < ctx.ctxprog_len; i++)
                 nv_wr32(device, 0x400328, ctxprog[i]);
         *size = ctx.ctxvals_pos * 4;
+
+        kfree(ctxprog);
+        return 0;
 }
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nv40.c b/drivers/gpu/drm/nouveau/core/engine/graph/nv40.c
index 425001204a89..cc6574eeb80e 100644
--- a/drivers/gpu/drm/nouveau/core/engine/graph/nv40.c
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nv40.c
@@ -346,7 +346,9 @@ nv40_graph_init(struct nouveau_object *object)
                 return ret;
 
         /* generate and upload context program */
-        nv40_grctx_init(nv_device(priv), &priv->size);
+        ret = nv40_grctx_init(nv_device(priv), &priv->size);
+        if (ret)
+                return ret;
 
         /* No context present currently */
         nv_wr32(priv, NV40_PGRAPH_CTXCTL_CUR, 0x00000000);
diff --git a/drivers/gpu/drm/nouveau/core/engine/graph/nv40.h b/drivers/gpu/drm/nouveau/core/engine/graph/nv40.h
index d2ac975afc2e..7da35a4e7970 100644
--- a/drivers/gpu/drm/nouveau/core/engine/graph/nv40.h
+++ b/drivers/gpu/drm/nouveau/core/engine/graph/nv40.h
@@ -15,7 +15,7 @@ nv44_graph_class(void *priv)
         return !(0x0baf & (1 << (device->chipset & 0x0f)));
 }
 
-void nv40_grctx_init(struct nouveau_device *, u32 *size);
+int  nv40_grctx_init(struct nouveau_device *, u32 *size);
 void nv40_grctx_fill(struct nouveau_device *, struct nouveau_gpuobj *);
 
 #endif
diff --git a/drivers/gpu/drm/nouveau/core/include/core/object.h b/drivers/gpu/drm/nouveau/core/include/core/object.h
index 818feabbf4a0..486f1a9217fd 100644
--- a/drivers/gpu/drm/nouveau/core/include/core/object.h
+++ b/drivers/gpu/drm/nouveau/core/include/core/object.h
@@ -175,14 +175,18 @@ nv_mo32(void *obj, u32 addr, u32 mask, u32 data)
         return temp;
 }
 
-static inline bool
-nv_strncmp(void *obj, u32 addr, u32 len, const char *str)
+static inline int
+nv_memcmp(void *obj, u32 addr, const char *str, u32 len)
 {
+        unsigned char c1, c2;
+
         while (len--) {
-                if (nv_ro08(obj, addr++) != *(str++))
-                        return false;
+                c1 = nv_ro08(obj, addr++);
+                c2 = *(str++);
+                if (c1 != c2)
+                        return c1 - c2;
         }
-        return true;
+        return 0;
 }
 
 #endif
diff --git a/drivers/gpu/drm/nouveau/core/include/subdev/clock.h b/drivers/gpu/drm/nouveau/core/include/subdev/clock.h
index 39e73b91d360..41b7a6a76f19 100644
--- a/drivers/gpu/drm/nouveau/core/include/subdev/clock.h
+++ b/drivers/gpu/drm/nouveau/core/include/subdev/clock.h
@@ -54,6 +54,7 @@ int nv04_clock_pll_calc(struct nouveau_clock *, struct nvbios_pll *,
                         int clk, struct nouveau_pll_vals *);
 int nv04_clock_pll_prog(struct nouveau_clock *, u32 reg1,
                         struct nouveau_pll_vals *);
-
+int nva3_clock_pll_calc(struct nouveau_clock *, struct nvbios_pll *,
+                        int clk, struct nouveau_pll_vals *);
 
 #endif
diff --git a/drivers/gpu/drm/nouveau/core/subdev/bios/dcb.c b/drivers/gpu/drm/nouveau/core/subdev/bios/dcb.c
index 7d750382a833..c51197157749 100644
--- a/drivers/gpu/drm/nouveau/core/subdev/bios/dcb.c
+++ b/drivers/gpu/drm/nouveau/core/subdev/bios/dcb.c
@@ -64,7 +64,7 @@ dcb_table(struct nouveau_bios *bios, u8 *ver, u8 *hdr, u8 *cnt, u8 *len)
                 }
         } else
         if (*ver >= 0x15) {
-                if (!nv_strncmp(bios, dcb - 7, 7, "DEV_REC")) {
+                if (!nv_memcmp(bios, dcb - 7, "DEV_REC", 7)) {
                         u16 i2c = nv_ro16(bios, dcb + 2);
                         *hdr = 4;
                         *cnt = (i2c - dcb) / 10;
diff --git a/drivers/gpu/drm/nouveau/core/subdev/clock/nva3.c b/drivers/gpu/drm/nouveau/core/subdev/clock/nva3.c
index cc8d7d162d7c..9068c98b96f6 100644
--- a/drivers/gpu/drm/nouveau/core/subdev/clock/nva3.c
+++ b/drivers/gpu/drm/nouveau/core/subdev/clock/nva3.c
@@ -66,6 +66,24 @@ nva3_clock_pll_set(struct nouveau_clock *clk, u32 type, u32 freq)
         return ret;
 }
 
+int
+nva3_clock_pll_calc(struct nouveau_clock *clock, struct nvbios_pll *info,
+                    int clk, struct nouveau_pll_vals *pv)
+{
+        int ret, N, M, P;
+
+        ret = nva3_pll_calc(clock, info, clk, &N, NULL, &M, &P);
+
+        if (ret > 0) {
+                pv->refclk = info->refclk;
+                pv->N1 = N;
+                pv->M1 = M;
+                pv->log2P = P;
+        }
+        return ret;
+}
+
+
 static int
 nva3_clock_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
                 struct nouveau_oclass *oclass, void *data, u32 size,
@@ -80,6 +98,7 @@ nva3_clock_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
                 return ret;
 
         priv->base.pll_set = nva3_clock_pll_set;
+        priv->base.pll_calc = nva3_clock_pll_calc;
         return 0;
 }
 
diff --git a/drivers/gpu/drm/nouveau/core/subdev/clock/nvc0.c b/drivers/gpu/drm/nouveau/core/subdev/clock/nvc0.c
index 5ccce0b17bf3..f6962c9b6c36 100644
--- a/drivers/gpu/drm/nouveau/core/subdev/clock/nvc0.c
+++ b/drivers/gpu/drm/nouveau/core/subdev/clock/nvc0.c
@@ -79,6 +79,7 @@ nvc0_clock_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
                 return ret;
 
         priv->base.pll_set = nvc0_clock_pll_set;
+        priv->base.pll_calc = nva3_clock_pll_calc;
         return 0;
 }
 
diff --git a/drivers/gpu/drm/nouveau/nouveau_abi16.c b/drivers/gpu/drm/nouveau/nouveau_abi16.c
index cc79c796afee..cbf1fc60a386 100644
--- a/drivers/gpu/drm/nouveau/nouveau_abi16.c
+++ b/drivers/gpu/drm/nouveau/nouveau_abi16.c
@@ -241,6 +241,10 @@ nouveau_abi16_ioctl_channel_alloc(ABI16_IOCTL_ARGS)
 
         if (unlikely(!abi16))
                 return -ENOMEM;
+
+        if (!drm->channel)
+                return nouveau_abi16_put(abi16, -ENODEV);
+
         client = nv_client(abi16->client);
 
         if (init->fb_ctxdma_handle == ~0 || init->tt_ctxdma_handle == ~0)
diff --git a/drivers/gpu/drm/nouveau/nouveau_drm.c b/drivers/gpu/drm/nouveau/nouveau_drm.c
index 0910125cbbc3..8503b2ea570a 100644
--- a/drivers/gpu/drm/nouveau/nouveau_drm.c
+++ b/drivers/gpu/drm/nouveau/nouveau_drm.c
@@ -129,7 +129,8 @@ nouveau_accel_init(struct nouveau_drm *drm)
 
         /* initialise synchronisation routines */
         if      (device->card_type < NV_10) ret = nv04_fence_create(drm);
-        else if (device->chipset   <  0x84) ret = nv10_fence_create(drm);
+        else if (device->card_type < NV_50) ret = nv10_fence_create(drm);
+        else if (device->chipset   <  0x84) ret = nv50_fence_create(drm);
         else if (device->card_type < NV_C0) ret = nv84_fence_create(drm);
         else                                ret = nvc0_fence_create(drm);
         if (ret) {
diff --git a/drivers/gpu/drm/radeon/atombios_crtc.c b/drivers/gpu/drm/radeon/atombios_crtc.c
index 3bce0299f64a..24d932f53203 100644
--- a/drivers/gpu/drm/radeon/atombios_crtc.c
+++ b/drivers/gpu/drm/radeon/atombios_crtc.c
@@ -1696,42 +1696,22 @@ static int radeon_atom_pick_pll(struct drm_crtc *crtc)
                         return ATOM_PPLL2;
                 DRM_ERROR("unable to allocate a PPLL\n");
                 return ATOM_PPLL_INVALID;
-        } else if (ASIC_IS_AVIVO(rdev)) {
-                /* in DP mode, the DP ref clock can come from either PPLL
-                 * depending on the asic:
-                 * DCE3: PPLL1 or PPLL2
-                 */
-                if (ENCODER_MODE_IS_DP(atombios_get_encoder_mode(radeon_crtc->encoder))) {
-                        /* use the same PPLL for all DP monitors */
-                        pll = radeon_get_shared_dp_ppll(crtc);
-                        if (pll != ATOM_PPLL_INVALID)
-                                return pll;
-                } else {
-                        /* use the same PPLL for all monitors with the same clock */
-                        pll = radeon_get_shared_nondp_ppll(crtc);
-                        if (pll != ATOM_PPLL_INVALID)
-                                return pll;
-                }
-                /* all other cases */
-                pll_in_use = radeon_get_pll_use_mask(crtc);
-                /* the order shouldn't matter here, but we probably
-                 * need this until we have atomic modeset
-                 */
-                if (rdev->flags & RADEON_IS_IGP) {
-                        if (!(pll_in_use & (1 << ATOM_PPLL1)))
-                                return ATOM_PPLL1;
-                        if (!(pll_in_use & (1 << ATOM_PPLL2)))
-                                return ATOM_PPLL2;
-                } else {
-                        if (!(pll_in_use & (1 << ATOM_PPLL2)))
-                                return ATOM_PPLL2;
-                        if (!(pll_in_use & (1 << ATOM_PPLL1)))
-                                return ATOM_PPLL1;
-                }
-                DRM_ERROR("unable to allocate a PPLL\n");
-                return ATOM_PPLL_INVALID;
         } else {
                 /* on pre-R5xx asics, the crtc to pll mapping is hardcoded */
+                /* some atombios (observed in some DCE2/DCE3) code have a bug,
+                 * the matching btw pll and crtc is done through
+                 * PCLK_CRTC[1|2]_CNTL (0x480/0x484) but atombios code use the
+                 * pll (1 or 2) to select which register to write. ie if using
+                 * pll1 it will use PCLK_CRTC1_CNTL (0x480) and if using pll2
+                 * it will use PCLK_CRTC2_CNTL (0x484), it then use crtc id to
+                 * choose which value to write. Which is reverse order from
+                 * register logic. So only case that works is when pllid is
+                 * same as crtcid or when both pll and crtc are enabled and
+                 * both use same clock.
+                 *
+                 * So just return crtc id as if crtc and pll were hard linked
+                 * together even if they aren't
+                 */
                 return radeon_crtc->crtc_id;
         }
 }
diff --git a/drivers/gpu/drm/radeon/atombios_encoders.c b/drivers/gpu/drm/radeon/atombios_encoders.c
index ba498f8e47a2..010bae19554a 100644
--- a/drivers/gpu/drm/radeon/atombios_encoders.c
+++ b/drivers/gpu/drm/radeon/atombios_encoders.c
@@ -1625,7 +1625,7 @@ radeon_atom_encoder_dpms_dig(struct drm_encoder *encoder, int mode)
                         atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_SETUP, 0, 0);
                         atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_ENABLE, 0, 0);
                         /* some early dce3.2 boards have a bug in their transmitter control table */
-                        if ((rdev->family != CHIP_RV710) || (rdev->family != CHIP_RV730))
+                        if ((rdev->family != CHIP_RV710) && (rdev->family != CHIP_RV730))
                                 atombios_dig_transmitter_setup(encoder, ATOM_TRANSMITTER_ACTION_ENABLE_OUTPUT, 0, 0);
                 }
                 if (ENCODER_MODE_IS_DP(atombios_get_encoder_mode(encoder)) && connector) {
diff --git a/drivers/gpu/drm/radeon/evergreen.c b/drivers/gpu/drm/radeon/evergreen.c
index af31f829f4a8..219942c660d7 100644
--- a/drivers/gpu/drm/radeon/evergreen.c
+++ b/drivers/gpu/drm/radeon/evergreen.c
@@ -1330,6 +1330,8 @@ void evergreen_mc_stop(struct radeon_device *rdev, struct evergreen_mc_save *sav
                                         break;
                                 udelay(1);
                         }
+                } else {
+                        save->crtc_enabled[i] = false;
                 }
         }
 
diff --git a/drivers/gpu/drm/radeon/radeon_agp.c b/drivers/gpu/drm/radeon/radeon_agp.c
index 10ea17a6b2a6..42433344cb1b 100644
--- a/drivers/gpu/drm/radeon/radeon_agp.c
+++ b/drivers/gpu/drm/radeon/radeon_agp.c
@@ -69,9 +69,12 @@ static struct radeon_agpmode_quirk radeon_agpmode_quirk_list[] = {
         /* Intel 82830 830 Chipset Host Bridge / Mobility M6 LY Needs AGPMode 2 (fdo #17360)*/
         { PCI_VENDOR_ID_INTEL, 0x3575, PCI_VENDOR_ID_ATI, 0x4c59,
                 PCI_VENDOR_ID_DELL, 0x00e3, 2},
-        /* Intel 82852/82855 host bridge / Mobility FireGL 9000 R250 Needs AGPMode 1 (lp #296617) */
+        /* Intel 82852/82855 host bridge / Mobility FireGL 9000 RV250 Needs AGPMode 1 (lp #296617) */
         { PCI_VENDOR_ID_INTEL, 0x3580, PCI_VENDOR_ID_ATI, 0x4c66,
                 PCI_VENDOR_ID_DELL, 0x0149, 1},
+        /* Intel 82855PM host bridge / Mobility FireGL 9000 RV250 Needs AGPMode 1 for suspend/resume */
+        { PCI_VENDOR_ID_INTEL, 0x3340, PCI_VENDOR_ID_ATI, 0x4c66,
+                PCI_VENDOR_ID_IBM, 0x0531, 1},
         /* Intel 82852/82855 host bridge / Mobility 9600 M10 RV350 Needs AGPMode 1 (deb #467460) */
         { PCI_VENDOR_ID_INTEL, 0x3580, PCI_VENDOR_ID_ATI, 0x4e50,
                 0x1025, 0x0061, 1},
diff --git a/drivers/gpu/drm/ttm/ttm_page_alloc.c b/drivers/gpu/drm/ttm/ttm_page_alloc.c
index 860dc4813e99..bd2a3b40cd12 100644
--- a/drivers/gpu/drm/ttm/ttm_page_alloc.c
+++ b/drivers/gpu/drm/ttm/ttm_page_alloc.c
@@ -749,7 +749,10 @@ static int ttm_get_pages(struct page **pages, unsigned npages, int flags,
         /* clear the pages coming from the pool if requested */
         if (flags & TTM_PAGE_FLAG_ZERO_ALLOC) {
                 list_for_each_entry(p, &plist, lru) {
-                        clear_page(page_address(p));
+                        if (PageHighMem(p))
+                                clear_highpage(p);
+                        else
+                                clear_page(page_address(p));
                 }
         }
 
diff --git a/drivers/gpu/drm/ttm/ttm_tt.c b/drivers/gpu/drm/ttm/ttm_tt.c
index bf8260133ea9..7d759a430294 100644
--- a/drivers/gpu/drm/ttm/ttm_tt.c
+++ b/drivers/gpu/drm/ttm/ttm_tt.c
@@ -308,9 +308,7 @@ int ttm_tt_swapin(struct ttm_tt *ttm)
                 if (unlikely(to_page == NULL))
                         goto out_err;
 
-                preempt_disable();
                 copy_highpage(to_page, from_page);
-                preempt_enable();
                 page_cache_release(from_page);
         }
 
@@ -358,9 +356,7 @@ int ttm_tt_swapout(struct ttm_tt *ttm, struct file *persistent_swap_storage)
                         ret = PTR_ERR(to_page);
                         goto out_err;
                 }
-                preempt_disable();
                 copy_highpage(to_page, from_page);
-                preempt_enable();
                 set_page_dirty(to_page);
                 mark_page_accessed(to_page);
                 page_cache_release(to_page);
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c b/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c
index b07ca2e4d04b..7290811f89be 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c
@@ -110,6 +110,8 @@ int vmw_get_cap_3d_ioctl(struct drm_device *dev, void *data,
         memcpy_fromio(bounce, &fifo_mem[SVGA_FIFO_3D_CAPS], size);
 
         ret = copy_to_user(buffer, bounce, size);
+        if (ret)
+                ret = -EFAULT;
         vfree(bounce);
 
         if (unlikely(ret != 0))
diff --git a/drivers/hid/hid-microsoft.c b/drivers/hid/hid-microsoft.c
index f676c01bb471..6fcd466d0825 100644
--- a/drivers/hid/hid-microsoft.c
+++ b/drivers/hid/hid-microsoft.c
@@ -46,9 +46,9 @@ static __u8 *ms_report_fixup(struct hid_device *hdev, __u8 *rdesc,
                 rdesc[559] = 0x45;
         }
         /* the same as above (s/usage/physical/) */
-        if ((quirks & MS_RDESC_3K) && *rsize == 106 &&
-                        !memcmp((char []){ 0x19, 0x00, 0x29, 0xff },
-                                &rdesc[94], 4)) {
+        if ((quirks & MS_RDESC_3K) && *rsize == 106 && rdesc[94] == 0x19 &&
+                        rdesc[95] == 0x00 && rdesc[96] == 0x29 &&
+                        rdesc[97] == 0xff) {
                 rdesc[94] = 0x35;
                 rdesc[96] = 0x45;
         }
diff --git a/drivers/i2c/busses/i2c-at91.c b/drivers/i2c/busses/i2c-at91.c
index aa59a254be2c..c02bf208084f 100644
--- a/drivers/i2c/busses/i2c-at91.c
+++ b/drivers/i2c/busses/i2c-at91.c
@@ -39,6 +39,7 @@
 #define AT91_TWI_STOP           0x0002  /* Send a Stop Condition */
 #define AT91_TWI_MSEN           0x0004  /* Master Transfer Enable */
 #define AT91_TWI_SVDIS          0x0020  /* Slave Transfer Disable */
+#define AT91_TWI_QUICK          0x0040  /* SMBus quick command */
 #define AT91_TWI_SWRST          0x0080  /* Software Reset */
 
 #define AT91_TWI_MMR            0x0004  /* Master Mode Register */
@@ -212,7 +213,11 @@ static int at91_do_twi_transfer(struct at91_twi_dev *dev)
 
         INIT_COMPLETION(dev->cmd_complete);
         dev->transfer_status = 0;
-        if (dev->msg->flags & I2C_M_RD) {
+
+        if (!dev->buf_len) {
+                at91_twi_write(dev, AT91_TWI_CR, AT91_TWI_QUICK);
+                at91_twi_write(dev, AT91_TWI_IER, AT91_TWI_TXCOMP);
+        } else if (dev->msg->flags & I2C_M_RD) {
                 unsigned start_flags = AT91_TWI_START;
 
                 if (at91_twi_read(dev, AT91_TWI_SR) & AT91_TWI_RXRDY) {
diff --git a/drivers/i2c/busses/i2c-mxs.c b/drivers/i2c/busses/i2c-mxs.c
index 286ca1917820..0670da79ee5e 100644
--- a/drivers/i2c/busses/i2c-mxs.c
+++ b/drivers/i2c/busses/i2c-mxs.c
@@ -287,12 +287,14 @@ read_init_dma_fail:
 select_init_dma_fail:
         dma_unmap_sg(i2c->dev, &i2c->sg_io[0], 1, DMA_TO_DEVICE);
 select_init_pio_fail:
+        dmaengine_terminate_all(i2c->dmach);
         return -EINVAL;
 
 /* Write failpath. */
 write_init_dma_fail:
         dma_unmap_sg(i2c->dev, i2c->sg_io, 2, DMA_TO_DEVICE);
 write_init_pio_fail:
+        dmaengine_terminate_all(i2c->dmach);
         return -EINVAL;
 }
 
diff --git a/drivers/i2c/busses/i2c-omap.c b/drivers/i2c/busses/i2c-omap.c
index db31eaed6ea5..3525c9e62cb0 100644
--- a/drivers/i2c/busses/i2c-omap.c
+++ b/drivers/i2c/busses/i2c-omap.c
@@ -43,7 +43,6 @@
 #include <linux/slab.h>
 #include <linux/i2c-omap.h>
 #include <linux/pm_runtime.h>
-#include <linux/pm_qos.h>
 
 /* I2C controller revisions */
 #define OMAP_I2C_OMAP1_REV_2            0x20
@@ -187,8 +186,9 @@ struct omap_i2c_dev {
         int                     reg_shift;      /* bit shift for I2C register addresses */
         struct completion       cmd_complete;
         struct resource         *ioarea;
-        u32                     latency;        /* maximum MPU wkup latency */
-        struct pm_qos_request   pm_qos_request;
+        u32                     latency;        /* maximum mpu wkup latency */
+        void                    (*set_mpu_wkup_lat)(struct device *dev,
+                                                    long latency);
         u32                     speed;          /* Speed of bus in kHz */
         u32                     dtrev;          /* extra revision from DT */
         u32                     flags;
@@ -494,7 +494,9 @@ static void omap_i2c_resize_fifo(struct omap_i2c_dev *dev, u8 size, bool is_rx)
                 dev->b_hw = 1; /* Enable hardware fixes */
 
         /* calculate wakeup latency constraint for MPU */
-        dev->latency = (1000000 * dev->threshold) / (1000 * dev->speed / 8);
+        if (dev->set_mpu_wkup_lat != NULL)
+                dev->latency = (1000000 * dev->threshold) /
+                        (1000 * dev->speed / 8);
 }
 
 /*
@@ -522,6 +524,9 @@ static int omap_i2c_xfer_msg(struct i2c_adapter *adap,
         dev->buf = msg->buf;
         dev->buf_len = msg->len;
 
+        /* make sure writes to dev->buf_len are ordered */
+        barrier();
+
         omap_i2c_write_reg(dev, OMAP_I2C_CNT_REG, dev->buf_len);
 
         /* Clear the FIFO Buffers */
@@ -579,7 +584,6 @@ static int omap_i2c_xfer_msg(struct i2c_adapter *adap,
          */
         timeout = wait_for_completion_timeout(&dev->cmd_complete,
                                                 OMAP_I2C_TIMEOUT);
-        dev->buf_len = 0;
         if (timeout == 0) {
                 dev_err(dev->dev, "controller timed out\n");
                 omap_i2c_init(dev);
@@ -629,16 +633,8 @@ omap_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
         if (r < 0)
                 goto out;
 
-        /*
-         * When waiting for completion of a i2c transfer, we need to
-         * set a wake up latency constraint for the MPU. This is to
-         * ensure quick enough wakeup from idle, when transfer
-         * completes.
-         */
-        if (dev->latency)
-                pm_qos_add_request(&dev->pm_qos_request,
-                                   PM_QOS_CPU_DMA_LATENCY,
-                                   dev->latency);
+        if (dev->set_mpu_wkup_lat != NULL)
+                dev->set_mpu_wkup_lat(dev->dev, dev->latency);
 
         for (i = 0; i < num; i++) {
                 r = omap_i2c_xfer_msg(adap, &msgs[i], (i == (num - 1)));
@@ -646,8 +642,8 @@ omap_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
                         break;
         }
 
-        if (dev->latency)
-                pm_qos_remove_request(&dev->pm_qos_request);
+        if (dev->set_mpu_wkup_lat != NULL)
+                dev->set_mpu_wkup_lat(dev->dev, -1);
 
         if (r == 0)
                 r = num;
@@ -1104,6 +1100,7 @@ omap_i2c_probe(struct platform_device *pdev)
         } else if (pdata != NULL) {
                 dev->speed = pdata->clkrate;
                 dev->flags = pdata->flags;
+                dev->set_mpu_wkup_lat = pdata->set_mpu_wkup_lat;
                 dev->dtrev = pdata->rev;
         }
 
@@ -1159,8 +1156,9 @@ omap_i2c_probe(struct platform_device *pdev)
                         dev->b_hw = 1; /* Enable hardware fixes */
 
                 /* calculate wakeup latency constraint for MPU */
-                dev->latency = (1000000 * dev->fifo_size) /
-                               (1000 * dev->speed / 8);
+                if (dev->set_mpu_wkup_lat != NULL)
+                        dev->latency = (1000000 * dev->fifo_size) /
+                                       (1000 * dev->speed / 8);
         }
 
         /* reset ASAP, clearing any IRQs */
diff --git a/drivers/i2c/busses/i2c-s3c2410.c b/drivers/i2c/busses/i2c-s3c2410.c
index 3e0335f1fc60..9d902725bac9 100644
--- a/drivers/i2c/busses/i2c-s3c2410.c
+++ b/drivers/i2c/busses/i2c-s3c2410.c
@@ -806,6 +806,7 @@ static int s3c24xx_i2c_parse_dt_gpio(struct s3c24xx_i2c *i2c)
                         dev_err(i2c->dev, "invalid gpio[%d]: %d\n", idx, gpio);
                         goto free_gpio;
                 }
+                i2c->gpios[idx] = gpio;
 
                 ret = gpio_request(gpio, "i2c-bus");
                 if (ret) {
diff --git a/drivers/i2c/muxes/i2c-mux-pinctrl.c b/drivers/i2c/muxes/i2c-mux-pinctrl.c
index 5f097f309b9f..7fa5b24b16db 100644
--- a/drivers/i2c/muxes/i2c-mux-pinctrl.c
+++ b/drivers/i2c/muxes/i2c-mux-pinctrl.c
@@ -169,7 +169,7 @@ static int __devinit i2c_mux_pinctrl_probe(struct platform_device *pdev)
         mux->busses = devm_kzalloc(&pdev->dev,
                                    sizeof(mux->busses) * mux->pdata->bus_count,
                                    GFP_KERNEL);
-        if (!mux->states) {
+        if (!mux->busses) {
                 dev_err(&pdev->dev, "Cannot allocate busses\n");
                 ret = -ENOMEM;
                 goto err;
diff --git a/drivers/input/input-mt.c b/drivers/input/input-mt.c
index c0ec7d42c3be..1abbc170d8b7 100644
--- a/drivers/input/input-mt.c
+++ b/drivers/input/input-mt.c
@@ -26,10 +26,14 @@ static void copy_abs(struct input_dev *dev, unsigned int dst, unsigned int src)
  * input_mt_init_slots() - initialize MT input slots
  * @dev: input device supporting MT events and finger tracking
  * @num_slots: number of slots used by the device
+ * @flags: mt tasks to handle in core
  *
  * This function allocates all necessary memory for MT slot handling
  * in the input device, prepares the ABS_MT_SLOT and
  * ABS_MT_TRACKING_ID events for use and sets up appropriate buffers.
+ * Depending on the flags set, it also performs pointer emulation and
+ * frame synchronization.
+ *
  * May be called repeatedly. Returns -EINVAL if attempting to
  * reinitialize with a different number of slots.
  */
diff --git a/drivers/input/mousedev.c b/drivers/input/mousedev.c
index 8f02e3d0e712..4c842c320c2e 100644
--- a/drivers/input/mousedev.c
+++ b/drivers/input/mousedev.c
@@ -12,8 +12,8 @@
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #define MOUSEDEV_MINOR_BASE     32
-#define MOUSEDEV_MINORS         32
-#define MOUSEDEV_MIX            31
+#define MOUSEDEV_MINORS         31
+#define MOUSEDEV_MIX            63
 
 #include <linux/sched.h>
 #include <linux/slab.h>
diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c
index f02028ec3db6..78e5d9ab0ba7 100644
--- a/drivers/input/touchscreen/ads7846.c
+++ b/drivers/input/touchscreen/ads7846.c
@@ -955,7 +955,8 @@ static int ads7846_resume(struct device *dev)
 
 static SIMPLE_DEV_PM_OPS(ads7846_pm, ads7846_suspend, ads7846_resume);
 
-static int __devinit ads7846_setup_pendown(struct spi_device *spi, struct ads7846 *ts)
+static int __devinit ads7846_setup_pendown(struct spi_device *spi,
+                                           struct ads7846 *ts)
 {
         struct ads7846_platform_data *pdata = spi->dev.platform_data;
         int err;
@@ -981,6 +982,9 @@ static int __devinit ads7846_setup_pendown(struct spi_device *spi, struct ads784
 
                 ts->gpio_pendown = pdata->gpio_pendown;
 
+                if (pdata->gpio_pendown_debounce)
+                        gpio_set_debounce(pdata->gpio_pendown,
+                                          pdata->gpio_pendown_debounce);
         } else {
                 dev_err(&spi->dev, "no get_pendown_state nor gpio_pendown?\n");
                 return -EINVAL;
diff --git a/drivers/iommu/intel-iommu.c b/drivers/iommu/intel-iommu.c
index d4a4cd445cab..0badfa48b32b 100644
--- a/drivers/iommu/intel-iommu.c
+++ b/drivers/iommu/intel-iommu.c
@@ -4108,7 +4108,7 @@ static void swap_pci_ref(struct pci_dev **from, struct pci_dev *to)
 static int intel_iommu_add_device(struct device *dev)
 {
         struct pci_dev *pdev = to_pci_dev(dev);
-        struct pci_dev *bridge, *dma_pdev;
+        struct pci_dev *bridge, *dma_pdev = NULL;
         struct iommu_group *group;
         int ret;
 
@@ -4122,7 +4122,7 @@ static int intel_iommu_add_device(struct device *dev)
                         dma_pdev = pci_get_domain_bus_and_slot(
                                                 pci_domain_nr(pdev->bus),
                                                 bridge->subordinate->number, 0);
-                else
+                if (!dma_pdev)
                         dma_pdev = pci_dev_get(bridge);
         } else
                 dma_pdev = pci_dev_get(pdev);
diff --git a/drivers/iommu/tegra-smmu.c b/drivers/iommu/tegra-smmu.c
index a649f146d17b..c0f7a4266263 100644
--- a/drivers/iommu/tegra-smmu.c
+++ b/drivers/iommu/tegra-smmu.c
@@ -1054,6 +1054,7 @@ static int smmu_debugfs_stats_show(struct seq_file *s, void *v)
                         stats[i], val, offs);
         }
         seq_printf(s, "\n");
+        dput(dent);
 
         return 0;
 }
diff --git a/drivers/irqchip/irq-bcm2835.c b/drivers/irqchip/irq-bcm2835.c
index dc670ccc6978..16c78f1c5ef2 100644
--- a/drivers/irqchip/irq-bcm2835.c
+++ b/drivers/irqchip/irq-bcm2835.c
@@ -168,7 +168,8 @@ static int __init armctrl_of_init(struct device_node *node,
 }
 
 static struct of_device_id irq_of_match[] __initconst = {
-        { .compatible = "brcm,bcm2835-armctrl-ic", .data = armctrl_of_init }
+        { .compatible = "brcm,bcm2835-armctrl-ic", .data = armctrl_of_init },
+        { }
 };
 
 void __init bcm2835_init_irq(void)
diff --git a/drivers/leds/ledtrig-cpu.c b/drivers/leds/ledtrig-cpu.c
index b312056da14d..4239b3955ff0 100644
--- a/drivers/leds/ledtrig-cpu.c
+++ b/drivers/leds/ledtrig-cpu.c
@@ -33,8 +33,6 @@
 struct led_trigger_cpu {
         char name[MAX_NAME_LEN];
         struct led_trigger *_trig;
-        struct mutex lock;
-        int lock_is_inited;
 };
 
 static DEFINE_PER_CPU(struct led_trigger_cpu, cpu_trig);
@@ -50,12 +48,6 @@ void ledtrig_cpu(enum cpu_led_event ledevt)
 {
         struct led_trigger_cpu *trig = &__get_cpu_var(cpu_trig);
 
-        /* mutex lock should be initialized before calling mutex_call() */
-        if (!trig->lock_is_inited)
-                return;
-
-        mutex_lock(&trig->lock);
-
         /* Locate the correct CPU LED */
         switch (ledevt) {
         case CPU_LED_IDLE_END:
@@ -75,8 +67,6 @@ void ledtrig_cpu(enum cpu_led_event ledevt)
                 /* Will leave the LED as it is */
                 break;
         }
-
-        mutex_unlock(&trig->lock);
 }
 EXPORT_SYMBOL(ledtrig_cpu);
 
@@ -117,14 +107,9 @@ static int __init ledtrig_cpu_init(void)
         for_each_possible_cpu(cpu) {
                 struct led_trigger_cpu *trig = &per_cpu(cpu_trig, cpu);
 
-                mutex_init(&trig->lock);
-
                 snprintf(trig->name, MAX_NAME_LEN, "cpu%d", cpu);
 
-                mutex_lock(&trig->lock);
                 led_trigger_register_simple(trig->name, &trig->_trig);
-                trig->lock_is_inited = 1;
-                mutex_unlock(&trig->lock);
         }
 
         register_syscore_ops(&ledtrig_cpu_syscore_ops);
@@ -142,15 +127,9 @@ static void __exit ledtrig_cpu_exit(void)
         for_each_possible_cpu(cpu) {
                 struct led_trigger_cpu *trig = &per_cpu(cpu_trig, cpu);
 
-                mutex_lock(&trig->lock);
-
                 led_trigger_unregister_simple(trig->_trig);
                 trig->_trig = NULL;
                 memset(trig->name, 0, MAX_NAME_LEN);
-                trig->lock_is_inited = 0;
-
-                mutex_unlock(&trig->lock);
-                mutex_destroy(&trig->lock);
         }
 
         unregister_syscore_ops(&ledtrig_cpu_syscore_ops);
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 02db9183ca01..77e6eff41cae 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -740,8 +740,14 @@ static void rq_completed(struct mapped_device *md, int rw, int run_queue)
         if (!md_in_flight(md))
                 wake_up(&md->wait);
 
+        /*
+         * Run this off this callpath, as drivers could invoke end_io while
+         * inside their request_fn (and holding the queue lock). Calling
+         * back into ->request_fn() could deadlock attempting to grab the
+         * queue lock again.
+         */
         if (run_queue)
-                blk_run_queue(md->queue);
+                blk_run_queue_async(md->queue);
 
         /*
          * dm_put() must be at the end of this function. See the comment above
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 9ab768acfb62..61200717687b 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1817,10 +1817,10 @@ retry:
                         memset(bbp, 0xff, PAGE_SIZE);
 
                         for (i = 0 ; i < bb->count ; i++) {
-                                u64 internal_bb = *p++;
+                                u64 internal_bb = p[i];
                                 u64 store_bb = ((BB_OFFSET(internal_bb) << 10)
                                                 | BB_LEN(internal_bb));
-                                *bbp++ = cpu_to_le64(store_bb);
+                                bbp[i] = cpu_to_le64(store_bb);
                         }
                         bb->changed = 0;
                         if (read_seqretry(&bb->lock, seq))
@@ -5294,7 +5294,7 @@ void md_stop_writes(struct mddev *mddev)
 }
 EXPORT_SYMBOL_GPL(md_stop_writes);
 
-void md_stop(struct mddev *mddev)
+static void __md_stop(struct mddev *mddev)
 {
         mddev->ready = 0;
         mddev->pers->stop(mddev);
@@ -5304,6 +5304,18 @@ void md_stop(struct mddev *mddev)
         mddev->pers = NULL;
         clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
 }
+
+void md_stop(struct mddev *mddev)
+{
+        /* stop the array and free an attached data structures.
+         * This is called from dm-raid
+         */
+        __md_stop(mddev);
+        bitmap_destroy(mddev);
+        if (mddev->bio_set)
+                bioset_free(mddev->bio_set);
+}
+
 EXPORT_SYMBOL_GPL(md_stop);
 
 static int md_set_readonly(struct mddev *mddev, struct block_device *bdev)
@@ -5364,7 +5376,7 @@ static int do_md_stop(struct mddev * mddev, int mode,
                         set_disk_ro(disk, 0);
 
                 __md_stop_writes(mddev);
-                md_stop(mddev);
+                __md_stop(mddev);
                 mddev->queue->merge_bvec_fn = NULL;
                 mddev->queue->backing_dev_info.congested_fn = NULL;
 
@@ -7936,9 +7948,9 @@ int md_is_badblock(struct badblocks *bb, sector_t s, int sectors,
                    sector_t *first_bad, int *bad_sectors)
 {
         int hi;
-        int lo = 0;
+        int lo;
         u64 *p = bb->page;
-        int rv = 0;
+        int rv;
         sector_t target = s + sectors;
         unsigned seq;
 
@@ -7953,7 +7965,8 @@ int md_is_badblock(struct badblocks *bb, sector_t s, int sectors,
 
 retry:
         seq = read_seqbegin(&bb->lock);
-
+        lo = 0;
+        rv = 0;
         hi = bb->count;
 
         /* Binary search between lo and hi for 'target'
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 636bae0405e8..a0f73092176e 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -963,7 +963,7 @@ static void raid1_unplug(struct blk_plug_cb *cb, bool from_schedule)
         struct r1conf *conf = mddev->private;
         struct bio *bio;
 
-        if (from_schedule) {
+        if (from_schedule || current->bio_list) {
                 spin_lock_irq(&conf->device_lock);
                 bio_list_merge(&conf->pending_bio_list, &plug->pending);
                 conf->pending_count += plug->pending_cnt;
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index d1295aff4173..c9acbd717131 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -499,7 +499,7 @@ static void raid10_end_write_request(struct bio *bio, int error)
          */
         one_write_done(r10_bio);
         if (dec_rdev)
-                rdev_dec_pending(conf->mirrors[dev].rdev, conf->mddev);
+                rdev_dec_pending(rdev, conf->mddev);
 }
 
 /*
@@ -1069,7 +1069,7 @@ static void raid10_unplug(struct blk_plug_cb *cb, bool from_schedule)
         struct r10conf *conf = mddev->private;
         struct bio *bio;
 
-        if (from_schedule) {
+        if (from_schedule || current->bio_list) {
                 spin_lock_irq(&conf->device_lock);
                 bio_list_merge(&conf->pending_bio_list, &plug->pending);
                 conf->pending_count += plug->pending_cnt;
@@ -1334,18 +1334,21 @@ retry_write:
                         blocked_rdev = rrdev;
                         break;
                 }
+                if (rdev && (test_bit(Faulty, &rdev->flags)
+                             || test_bit(Unmerged, &rdev->flags)))
+                        rdev = NULL;
                 if (rrdev && (test_bit(Faulty, &rrdev->flags)
                               || test_bit(Unmerged, &rrdev->flags)))
                         rrdev = NULL;
 
                 r10_bio->devs[i].bio = NULL;
                 r10_bio->devs[i].repl_bio = NULL;
-                if (!rdev || test_bit(Faulty, &rdev->flags) ||
-                    test_bit(Unmerged, &rdev->flags)) {
+
+                if (!rdev && !rrdev) {
                         set_bit(R10BIO_Degraded, &r10_bio->state);
                         continue;
                 }
-                if (test_bit(WriteErrorSeen, &rdev->flags)) {
+                if (rdev && test_bit(WriteErrorSeen, &rdev->flags)) {
                         sector_t first_bad;
                         sector_t dev_sector = r10_bio->devs[i].addr;
                         int bad_sectors;
@@ -1387,8 +1390,10 @@ retry_write:
                                         max_sectors = good_sectors;
                         }
                 }
-                r10_bio->devs[i].bio = bio;
-                atomic_inc(&rdev->nr_pending);
+                if (rdev) {
+                        r10_bio->devs[i].bio = bio;
+                        atomic_inc(&rdev->nr_pending);
+                }
                 if (rrdev) {
                         r10_bio->devs[i].repl_bio = bio;
                         atomic_inc(&rrdev->nr_pending);
@@ -1444,69 +1449,71 @@ retry_write:
         for (i = 0; i < conf->copies; i++) {
                 struct bio *mbio;
                 int d = r10_bio->devs[i].devnum;
-                if (!r10_bio->devs[i].bio)
-                        continue;
+                if (r10_bio->devs[i].bio) {
+                        struct md_rdev *rdev = conf->mirrors[d].rdev;
+                        mbio = bio_clone_mddev(bio, GFP_NOIO, mddev);
+                        md_trim_bio(mbio, r10_bio->sector - bio->bi_sector,
+                                    max_sectors);
+                        r10_bio->devs[i].bio = mbio;
+
+                        mbio->bi_sector = (r10_bio->devs[i].addr+
+                                           choose_data_offset(r10_bio,
+                                                              rdev));
+                        mbio->bi_bdev = rdev->bdev;
+                        mbio->bi_end_io = raid10_end_write_request;
+                        mbio->bi_rw = WRITE | do_sync | do_fua | do_discard;
+                        mbio->bi_private = r10_bio;
 
-                mbio = bio_clone_mddev(bio, GFP_NOIO, mddev);
-                md_trim_bio(mbio, r10_bio->sector - bio->bi_sector,
-                            max_sectors);
-                r10_bio->devs[i].bio = mbio;
+                        atomic_inc(&r10_bio->remaining);
 
-                mbio->bi_sector = (r10_bio->devs[i].addr+
-                                   choose_data_offset(r10_bio,
-                                                      conf->mirrors[d].rdev));
-                mbio->bi_bdev = conf->mirrors[d].rdev->bdev;
-                mbio->bi_end_io = raid10_end_write_request;
-                mbio->bi_rw = WRITE | do_sync | do_fua | do_discard;
-                mbio->bi_private = r10_bio;
+                        cb = blk_check_plugged(raid10_unplug, mddev,
+                                               sizeof(*plug));
+                        if (cb)
+                                plug = container_of(cb, struct raid10_plug_cb,
+                                                    cb);
+                        else
+                                plug = NULL;
+                        spin_lock_irqsave(&conf->device_lock, flags);
+                        if (plug) {
+                                bio_list_add(&plug->pending, mbio);
+                                plug->pending_cnt++;
+                        } else {
+                                bio_list_add(&conf->pending_bio_list, mbio);
+                                conf->pending_count++;
+                        }
+                        spin_unlock_irqrestore(&conf->device_lock, flags);
+                        if (!plug)
+                                md_wakeup_thread(mddev->thread);
+                }
 
-                atomic_inc(&r10_bio->remaining);
+                if (r10_bio->devs[i].repl_bio) {
+                        struct md_rdev *rdev = conf->mirrors[d].replacement;
+                        if (rdev == NULL) {
+                                /* Replacement just got moved to main 'rdev' */
+                                smp_mb();
+                                rdev = conf->mirrors[d].rdev;
+                        }
+                        mbio = bio_clone_mddev(bio, GFP_NOIO, mddev);
+                        md_trim_bio(mbio, r10_bio->sector - bio->bi_sector,
+                                    max_sectors);
+                        r10_bio->devs[i].repl_bio = mbio;
+
+                        mbio->bi_sector = (r10_bio->devs[i].addr +
+                                           choose_data_offset(
+                                                   r10_bio, rdev));
+                        mbio->bi_bdev = rdev->bdev;
+                        mbio->bi_end_io = raid10_end_write_request;
+                        mbio->bi_rw = WRITE | do_sync | do_fua | do_discard;
+                        mbio->bi_private = r10_bio;
 
-                cb = blk_check_plugged(raid10_unplug, mddev, sizeof(*plug));
-                if (cb)
-                        plug = container_of(cb, struct raid10_plug_cb, cb);
-                else
-                        plug = NULL;
-                spin_lock_irqsave(&conf->device_lock, flags);
-                if (plug) {
-                        bio_list_add(&plug->pending, mbio);
-                        plug->pending_cnt++;
-                } else {
+                        atomic_inc(&r10_bio->remaining);
+                        spin_lock_irqsave(&conf->device_lock, flags);
                         bio_list_add(&conf->pending_bio_list, mbio);
                         conf->pending_count++;
+                        spin_unlock_irqrestore(&conf->device_lock, flags);
+                        if (!mddev_check_plugged(mddev))
+                                md_wakeup_thread(mddev->thread);
                 }
-                spin_unlock_irqrestore(&conf->device_lock, flags);
-                if (!plug)
-                        md_wakeup_thread(mddev->thread);
-
-                if (!r10_bio->devs[i].repl_bio)
-                        continue;
-
-                mbio = bio_clone_mddev(bio, GFP_NOIO, mddev);
-                md_trim_bio(mbio, r10_bio->sector - bio->bi_sector,
-                            max_sectors);
-                r10_bio->devs[i].repl_bio = mbio;
-
-                /* We are actively writing to the original device
-                 * so it cannot disappear, so the replacement cannot
-                 * become NULL here
-                 */
-                mbio->bi_sector = (r10_bio->devs[i].addr +
-                                   choose_data_offset(
-                                           r10_bio,
-                                           conf->mirrors[d].replacement));
-                mbio->bi_bdev = conf->mirrors[d].replacement->bdev;
-                mbio->bi_end_io = raid10_end_write_request;
-                mbio->bi_rw = WRITE | do_sync | do_fua | do_discard;
-                mbio->bi_private = r10_bio;
-
-                atomic_inc(&r10_bio->remaining);
-                spin_lock_irqsave(&conf->device_lock, flags);
-                bio_list_add(&conf->pending_bio_list, mbio);
-                conf->pending_count++;
-                spin_unlock_irqrestore(&conf->device_lock, flags);
-                if (!mddev_check_plugged(mddev))
-                        md_wakeup_thread(mddev->thread);
         }
 
         /* Don't remove the bias on 'remaining' (one_write_done) until
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index c5439dce0295..a4502686e7a8 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -2774,10 +2774,12 @@ static void handle_stripe_clean_event(struct r5conf *conf,
                         dev = &sh->dev[i];
                         if (!test_bit(R5_LOCKED, &dev->flags) &&
                             (test_bit(R5_UPTODATE, &dev->flags) ||
-                             test_and_clear_bit(R5_Discard, &dev->flags))) {
+                             test_bit(R5_Discard, &dev->flags))) {
                                 /* We can return any write requests */
                                 struct bio *wbi, *wbi2;
                                 pr_debug("Return write for disc %d\n", i);
+                                if (test_and_clear_bit(R5_Discard, &dev->flags))
+                                        clear_bit(R5_UPTODATE, &dev->flags);
                                 wbi = dev->written;
                                 dev->written = NULL;
                                 while (wbi && wbi->bi_sector <
@@ -2795,7 +2797,8 @@ static void handle_stripe_clean_event(struct r5conf *conf,
                                          !test_bit(STRIPE_DEGRADED, &sh->state),
                                                 0);
                         }
-                }
+                } else if (test_bit(R5_Discard, &sh->dev[i].flags))
+                        clear_bit(R5_Discard, &sh->dev[i].flags);
 
         if (test_and_clear_bit(STRIPE_FULL_WRITE, &sh->state))
                 if (atomic_dec_and_test(&conf->pending_full_writes))
@@ -3490,40 +3493,6 @@ static void handle_stripe(struct stripe_head *sh)
                         handle_failed_sync(conf, sh, &s);
         }
 
-        /*
-         * might be able to return some write requests if the parity blocks
-         * are safe, or on a failed drive
-         */
-        pdev = &sh->dev[sh->pd_idx];
-        s.p_failed = (s.failed >= 1 && s.failed_num[0] == sh->pd_idx)
-                || (s.failed >= 2 && s.failed_num[1] == sh->pd_idx);
-        qdev = &sh->dev[sh->qd_idx];
-        s.q_failed = (s.failed >= 1 && s.failed_num[0] == sh->qd_idx)
-                || (s.failed >= 2 && s.failed_num[1] == sh->qd_idx)
-                || conf->level < 6;
-
-        if (s.written &&
-            (s.p_failed || ((test_bit(R5_Insync, &pdev->flags)
-                             && !test_bit(R5_LOCKED, &pdev->flags)
-                             && (test_bit(R5_UPTODATE, &pdev->flags) ||
-                                 test_bit(R5_Discard, &pdev->flags))))) &&
-            (s.q_failed || ((test_bit(R5_Insync, &qdev->flags)
-                             && !test_bit(R5_LOCKED, &qdev->flags)
-                             && (test_bit(R5_UPTODATE, &qdev->flags) ||
-                                 test_bit(R5_Discard, &qdev->flags))))))
-                handle_stripe_clean_event(conf, sh, disks, &s.return_bi);
-
-        /* Now we might consider reading some blocks, either to check/generate
-         * parity, or to satisfy requests
-         * or to load a block that is being partially written.
-         */
-        if (s.to_read || s.non_overwrite
-            || (conf->level == 6 && s.to_write && s.failed)
-            || (s.syncing && (s.uptodate + s.compute < disks))
-            || s.replacing
-            || s.expanding)
-                handle_stripe_fill(sh, &s, disks);
-
         /* Now we check to see if any write operations have recently
          * completed
          */
@@ -3561,6 +3530,40 @@ static void handle_stripe(struct stripe_head *sh)
                         s.dec_preread_active = 1;
         }
 
+        /*
+         * might be able to return some write requests if the parity blocks
+         * are safe, or on a failed drive
+         */
+        pdev = &sh->dev[sh->pd_idx];
+        s.p_failed = (s.failed >= 1 && s.failed_num[0] == sh->pd_idx)
+                || (s.failed >= 2 && s.failed_num[1] == sh->pd_idx);
+        qdev = &sh->dev[sh->qd_idx];
+        s.q_failed = (s.failed >= 1 && s.failed_num[0] == sh->qd_idx)
+                || (s.failed >= 2 && s.failed_num[1] == sh->qd_idx)
+                || conf->level < 6;
+
+        if (s.written &&
+            (s.p_failed || ((test_bit(R5_Insync, &pdev->flags)
+                             && !test_bit(R5_LOCKED, &pdev->flags)
+                             && (test_bit(R5_UPTODATE, &pdev->flags) ||
+                                 test_bit(R5_Discard, &pdev->flags))))) &&
+            (s.q_failed || ((test_bit(R5_Insync, &qdev->flags)
+                             && !test_bit(R5_LOCKED, &qdev->flags)
+                             && (test_bit(R5_UPTODATE, &qdev->flags) ||
+                                 test_bit(R5_Discard, &qdev->flags))))))
+                handle_stripe_clean_event(conf, sh, disks, &s.return_bi);
+
+        /* Now we might consider reading some blocks, either to check/generate
+         * parity, or to satisfy requests
+         * or to load a block that is being partially written.
+         */
+        if (s.to_read || s.non_overwrite
+            || (conf->level == 6 && s.to_write && s.failed)
+            || (s.syncing && (s.uptodate + s.compute < disks))
+            || s.replacing
+            || s.expanding)
+                handle_stripe_fill(sh, &s, disks);
+
         /* Now to consider new write requests and what else, if anything
          * should be read.  We do not handle new writes when:
          * 1/ A 'write' operation (copy+xor) is already in flight.
@@ -5529,6 +5532,10 @@ static int run(struct mddev *mddev)
                  * discard data disk but write parity disk
                  */
                 stripe = stripe * PAGE_SIZE;
+                /* Round up to power of 2, as discard handling
+                 * currently assumes that */
+                while ((stripe-1) & stripe)
+                        stripe = (stripe | (stripe-1)) + 1;
                 mddev->queue->limits.discard_alignment = stripe;
                 mddev->queue->limits.discard_granularity = stripe;
                 /*
diff --git a/drivers/media/dvb-frontends/stv0900_core.c b/drivers/media/dvb-frontends/stv0900_core.c
index 262dfa503c2a..b551ca350e00 100644
--- a/drivers/media/dvb-frontends/stv0900_core.c
+++ b/drivers/media/dvb-frontends/stv0900_core.c
@@ -300,15 +300,15 @@ static enum fe_stv0900_error stv0900_set_mclk(struct stv0900_internal *intp, u32
 {
         u32 m_div, clk_sel;
 
-        dprintk("%s: Mclk set to %d, Quartz = %d\n", __func__, mclk,
-                        intp->quartz);
-
         if (intp == NULL)
                 return STV0900_INVALID_HANDLE;
 
         if (intp->errs)
                 return STV0900_I2C_ERROR;
 
+        dprintk("%s: Mclk set to %d, Quartz = %d\n", __func__, mclk,
+                        intp->quartz);
+
         clk_sel = ((stv0900_get_bits(intp, F0900_SELX1RATIO) == 1) ? 4 : 6);
         m_div = ((clk_sel * mclk) / intp->quartz) - 1;
         stv0900_write_bits(intp, F0900_M_DIV, m_div);
diff --git a/drivers/media/i2c/adv7604.c b/drivers/media/i2c/adv7604.c
index 109bc9b12e74..05f8950f6f91 100644
--- a/drivers/media/i2c/adv7604.c
+++ b/drivers/media/i2c/adv7604.c
@@ -53,8 +53,7 @@ MODULE_LICENSE("GPL");
 /* ADV7604 system clock frequency */
 #define ADV7604_fsc (28636360)
 
-#define DIGITAL_INPUT ((state->prim_mode == ADV7604_PRIM_MODE_HDMI_COMP) || \
-                        (state->prim_mode == ADV7604_PRIM_MODE_HDMI_GR))
+#define DIGITAL_INPUT (state->mode == ADV7604_MODE_HDMI)
 
 /*
  **********************************************************************
@@ -68,7 +67,7 @@ struct adv7604_state {
         struct v4l2_subdev sd;
         struct media_pad pad;
         struct v4l2_ctrl_handler hdl;
-        enum adv7604_prim_mode prim_mode;
+        enum adv7604_mode mode;
         struct v4l2_dv_timings timings;
         u8 edid[256];
         unsigned edid_blocks;
@@ -77,6 +76,7 @@ struct adv7604_state {
         struct workqueue_struct *work_queues;
         struct delayed_work delayed_work_enable_hotplug;
         bool connector_hdmi;
+        bool restart_stdi_once;
 
         /* i2c clients */
         struct i2c_client *i2c_avlink;
@@ -106,7 +106,6 @@ static const struct v4l2_dv_timings adv7604_timings[] = {
         V4L2_DV_BT_CEA_720X576P50,
         V4L2_DV_BT_CEA_1280X720P24,
         V4L2_DV_BT_CEA_1280X720P25,
-        V4L2_DV_BT_CEA_1280X720P30,
         V4L2_DV_BT_CEA_1280X720P50,
         V4L2_DV_BT_CEA_1280X720P60,
         V4L2_DV_BT_CEA_1920X1080P24,
@@ -115,6 +114,7 @@ static const struct v4l2_dv_timings adv7604_timings[] = {
         V4L2_DV_BT_CEA_1920X1080P50,
         V4L2_DV_BT_CEA_1920X1080P60,
 
+        /* sorted by DMT ID */
         V4L2_DV_BT_DMT_640X350P85,
         V4L2_DV_BT_DMT_640X400P85,
         V4L2_DV_BT_DMT_720X400P85,
@@ -164,6 +164,89 @@ static const struct v4l2_dv_timings adv7604_timings[] = {
         { },
 };
 
+struct adv7604_video_standards {
+        struct v4l2_dv_timings timings;
+        u8 vid_std;
+        u8 v_freq;
+};
+
+/* sorted by number of lines */
+static const struct adv7604_video_standards adv7604_prim_mode_comp[] = {
+        /* { V4L2_DV_BT_CEA_720X480P59_94, 0x0a, 0x00 }, TODO flickering */
+        { V4L2_DV_BT_CEA_720X576P50, 0x0b, 0x00 },
+        { V4L2_DV_BT_CEA_1280X720P50, 0x19, 0x01 },
+        { V4L2_DV_BT_CEA_1280X720P60, 0x19, 0x00 },
+        { V4L2_DV_BT_CEA_1920X1080P24, 0x1e, 0x04 },
+        { V4L2_DV_BT_CEA_1920X1080P25, 0x1e, 0x03 },
+        { V4L2_DV_BT_CEA_1920X1080P30, 0x1e, 0x02 },
+        { V4L2_DV_BT_CEA_1920X1080P50, 0x1e, 0x01 },
+        { V4L2_DV_BT_CEA_1920X1080P60, 0x1e, 0x00 },
+        /* TODO add 1920x1080P60_RB (CVT timing) */
+        { },
+};
+
+/* sorted by number of lines */
+static const struct adv7604_video_standards adv7604_prim_mode_gr[] = {
+        { V4L2_DV_BT_DMT_640X480P60, 0x08, 0x00 },
+        { V4L2_DV_BT_DMT_640X480P72, 0x09, 0x00 },
+        { V4L2_DV_BT_DMT_640X480P75, 0x0a, 0x00 },
+        { V4L2_DV_BT_DMT_640X480P85, 0x0b, 0x00 },
+        { V4L2_DV_BT_DMT_800X600P56, 0x00, 0x00 },
+        { V4L2_DV_BT_DMT_800X600P60, 0x01, 0x00 },
+        { V4L2_DV_BT_DMT_800X600P72, 0x02, 0x00 },
+        { V4L2_DV_BT_DMT_800X600P75, 0x03, 0x00 },
+        { V4L2_DV_BT_DMT_800X600P85, 0x04, 0x00 },
+        { V4L2_DV_BT_DMT_1024X768P60, 0x0c, 0x00 },
+        { V4L2_DV_BT_DMT_1024X768P70, 0x0d, 0x00 },
+        { V4L2_DV_BT_DMT_1024X768P75, 0x0e, 0x00 },
+        { V4L2_DV_BT_DMT_1024X768P85, 0x0f, 0x00 },
+        { V4L2_DV_BT_DMT_1280X1024P60, 0x05, 0x00 },
+        { V4L2_DV_BT_DMT_1280X1024P75, 0x06, 0x00 },
+        { V4L2_DV_BT_DMT_1360X768P60, 0x12, 0x00 },
+        { V4L2_DV_BT_DMT_1366X768P60, 0x13, 0x00 },
+        { V4L2_DV_BT_DMT_1400X1050P60, 0x14, 0x00 },
+        { V4L2_DV_BT_DMT_1400X1050P75, 0x15, 0x00 },
+        { V4L2_DV_BT_DMT_1600X1200P60, 0x16, 0x00 }, /* TODO not tested */
+        /* TODO add 1600X1200P60_RB (not a DMT timing) */
+        { V4L2_DV_BT_DMT_1680X1050P60, 0x18, 0x00 },
+        { V4L2_DV_BT_DMT_1920X1200P60_RB, 0x19, 0x00 }, /* TODO not tested */
+        { },
+};
+
+/* sorted by number of lines */
+static const struct adv7604_video_standards adv7604_prim_mode_hdmi_comp[] = {
+        { V4L2_DV_BT_CEA_720X480P59_94, 0x0a, 0x00 },
+        { V4L2_DV_BT_CEA_720X576P50, 0x0b, 0x00 },
+        { V4L2_DV_BT_CEA_1280X720P50, 0x13, 0x01 },
+        { V4L2_DV_BT_CEA_1280X720P60, 0x13, 0x00 },
+        { V4L2_DV_BT_CEA_1920X1080P24, 0x1e, 0x04 },
+        { V4L2_DV_BT_CEA_1920X1080P25, 0x1e, 0x03 },
+        { V4L2_DV_BT_CEA_1920X1080P30, 0x1e, 0x02 },
+        { V4L2_DV_BT_CEA_1920X1080P50, 0x1e, 0x01 },
+        { V4L2_DV_BT_CEA_1920X1080P60, 0x1e, 0x00 },
+        { },
+};
+
+/* sorted by number of lines */
+static const struct adv7604_video_standards adv7604_prim_mode_hdmi_gr[] = {
+        { V4L2_DV_BT_DMT_640X480P60, 0x08, 0x00 },
+        { V4L2_DV_BT_DMT_640X480P72, 0x09, 0x00 },
+        { V4L2_DV_BT_DMT_640X480P75, 0x0a, 0x00 },
+        { V4L2_DV_BT_DMT_640X480P85, 0x0b, 0x00 },
+        { V4L2_DV_BT_DMT_800X600P56, 0x00, 0x00 },
+        { V4L2_DV_BT_DMT_800X600P60, 0x01, 0x00 },
+        { V4L2_DV_BT_DMT_800X600P72, 0x02, 0x00 },
+        { V4L2_DV_BT_DMT_800X600P75, 0x03, 0x00 },
+        { V4L2_DV_BT_DMT_800X600P85, 0x04, 0x00 },
+        { V4L2_DV_BT_DMT_1024X768P60, 0x0c, 0x00 },
+        { V4L2_DV_BT_DMT_1024X768P70, 0x0d, 0x00 },
+        { V4L2_DV_BT_DMT_1024X768P75, 0x0e, 0x00 },
+        { V4L2_DV_BT_DMT_1024X768P85, 0x0f, 0x00 },
+        { V4L2_DV_BT_DMT_1280X1024P60, 0x05, 0x00 },
+        { V4L2_DV_BT_DMT_1280X1024P75, 0x06, 0x00 },
+        { },
+};
+
 /* ----------------------------------------------------------------------- */
 
 static inline struct adv7604_state *to_state(struct v4l2_subdev *sd)
@@ -672,64 +755,144 @@ static int adv7604_s_detect_tx_5v_ctrl(struct v4l2_subdev *sd)
                                 ((io_read(sd, 0x6f) & 0x10) >> 4));
 }
 
-static void configure_free_run(struct v4l2_subdev *sd, const struct v4l2_bt_timings *timings)
+static int find_and_set_predefined_video_timings(struct v4l2_subdev *sd,
+                u8 prim_mode,
+                const struct adv7604_video_standards *predef_vid_timings,
+                const struct v4l2_dv_timings *timings)
+{
+        struct adv7604_state *state = to_state(sd);
+        int i;
+
+        for (i = 0; predef_vid_timings[i].timings.bt.width; i++) {
+                if (!v4l_match_dv_timings(timings, &predef_vid_timings[i].timings,
+                                        DIGITAL_INPUT ? 250000 : 1000000))
+                        continue;
+                io_write(sd, 0x00, predef_vid_timings[i].vid_std); /* video std */
+                io_write(sd, 0x01, (predef_vid_timings[i].v_freq << 4) +
+                                prim_mode); /* v_freq and prim mode */
+                return 0;
+        }
+
+        return -1;
+}
+
+static int configure_predefined_video_timings(struct v4l2_subdev *sd,
+                struct v4l2_dv_timings *timings)
 {
+        struct adv7604_state *state = to_state(sd);
+        int err;
+
+        v4l2_dbg(1, debug, sd, "%s", __func__);
+
+        /* reset to default values */
+        io_write(sd, 0x16, 0x43);
+        io_write(sd, 0x17, 0x5a);
+        /* disable embedded syncs for auto graphics mode */
+        cp_write_and_or(sd, 0x81, 0xef, 0x00);
+        cp_write(sd, 0x8f, 0x00);
+        cp_write(sd, 0x90, 0x00);
+        cp_write(sd, 0xa2, 0x00);
+        cp_write(sd, 0xa3, 0x00);
+        cp_write(sd, 0xa4, 0x00);
+        cp_write(sd, 0xa5, 0x00);
+        cp_write(sd, 0xa6, 0x00);
+        cp_write(sd, 0xa7, 0x00);
+        cp_write(sd, 0xab, 0x00);
+        cp_write(sd, 0xac, 0x00);
+
+        switch (state->mode) {
+        case ADV7604_MODE_COMP:
+        case ADV7604_MODE_GR:
+                err = find_and_set_predefined_video_timings(sd,
+                                0x01, adv7604_prim_mode_comp, timings);
+                if (err)
+                        err = find_and_set_predefined_video_timings(sd,
+                                        0x02, adv7604_prim_mode_gr, timings);
+                break;
+        case ADV7604_MODE_HDMI:
+                err = find_and_set_predefined_video_timings(sd,
+                                0x05, adv7604_prim_mode_hdmi_comp, timings);
+                if (err)
+                        err = find_and_set_predefined_video_timings(sd,
+                                        0x06, adv7604_prim_mode_hdmi_gr, timings);
+                break;
+        default:
+                v4l2_dbg(2, debug, sd, "%s: Unknown mode %d\n",
+                                __func__, state->mode);
+                err = -1;
+                break;
+        }
+
+
+        return err;
+}
+
+static void configure_custom_video_timings(struct v4l2_subdev *sd,
+                const struct v4l2_bt_timings *bt)
+{
+        struct adv7604_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
-        u32 width = htotal(timings);
-        u32 height = vtotal(timings);
-        u16 ch1_fr_ll = (((u32)timings->pixelclock / 100) > 0) ?
-                ((width * (ADV7604_fsc / 100)) / ((u32)timings->pixelclock / 100)) : 0;
+        u32 width = htotal(bt);
+        u32 height = vtotal(bt);
+        u16 cp_start_sav = bt->hsync + bt->hbackporch - 4;
+        u16 cp_start_eav = width - bt->hfrontporch;
+        u16 cp_start_vbi = height - bt->vfrontporch;
+        u16 cp_end_vbi = bt->vsync + bt->vbackporch;
+        u16 ch1_fr_ll = (((u32)bt->pixelclock / 100) > 0) ?
+                ((width * (ADV7604_fsc / 100)) / ((u32)bt->pixelclock / 100)) : 0;
+        const u8 pll[2] = {
+                0xc0 | ((width >> 8) & 0x1f),
+                width & 0xff
+        };
 
         v4l2_dbg(2, debug, sd, "%s\n", __func__);
 
-        cp_write(sd, 0x8f, (ch1_fr_ll >> 8) & 0x7);     /* CH1_FR_LL */
-        cp_write(sd, 0x90, ch1_fr_ll & 0xff);           /* CH1_FR_LL */
-        cp_write(sd, 0xab, (height >> 4) & 0xff); /* CP_LCOUNT_MAX */
-        cp_write(sd, 0xac, (height & 0x0f) << 4); /* CP_LCOUNT_MAX */
-        /* TODO support interlaced */
-        cp_write(sd, 0x91, 0x10);       /* INTERLACED */
-
-        /* Should only be set in auto-graphics mode [REF_02 p. 91-92] */
-        if ((io_read(sd, 0x00) == 0x07) && (io_read(sd, 0x01) == 0x02)) {
-                u16 cp_start_sav, cp_start_eav, cp_start_vbi, cp_end_vbi;
-                const u8 pll[2] = {
-                        (0xc0 | ((width >> 8) & 0x1f)),
-                        (width & 0xff)
-                };
+        switch (state->mode) {
+        case ADV7604_MODE_COMP:
+        case ADV7604_MODE_GR:
+                /* auto graphics */
+                io_write(sd, 0x00, 0x07); /* video std */
+                io_write(sd, 0x01, 0x02); /* prim mode */
+                /* enable embedded syncs for auto graphics mode */
+                cp_write_and_or(sd, 0x81, 0xef, 0x10);
 
+                /* Should only be set in auto-graphics mode [REF_02, p. 91-92] */
                 /* setup PLL_DIV_MAN_EN and PLL_DIV_RATIO */
                 /* IO-map reg. 0x16 and 0x17 should be written in sequence */
                 if (adv_smbus_write_i2c_block_data(client, 0x16, 2, pll)) {
                         v4l2_err(sd, "writing to reg 0x16 and 0x17 failed\n");
-                        return;
+                        break;
                 }
 
                 /* active video - horizontal timing */
-                cp_start_sav = timings->hsync + timings->hbackporch - 4;
-                cp_start_eav = width - timings->hfrontporch;
                 cp_write(sd, 0xa2, (cp_start_sav >> 4) & 0xff);
-                cp_write(sd, 0xa3, ((cp_start_sav & 0x0f) << 4) | ((cp_start_eav >> 8) & 0x0f));
+                cp_write(sd, 0xa3, ((cp_start_sav & 0x0f) << 4) |
+                                        ((cp_start_eav >> 8) & 0x0f));
                 cp_write(sd, 0xa4, cp_start_eav & 0xff);
 
                 /* active video - vertical timing */
-                cp_start_vbi = height - timings->vfrontporch;
-                cp_end_vbi = timings->vsync + timings->vbackporch;
                 cp_write(sd, 0xa5, (cp_start_vbi >> 4) & 0xff);
-                cp_write(sd, 0xa6, ((cp_start_vbi & 0xf) << 4) | ((cp_end_vbi >> 8) & 0xf));
+                cp_write(sd, 0xa6, ((cp_start_vbi & 0xf) << 4) |
+                                        ((cp_end_vbi >> 8) & 0xf));
                 cp_write(sd, 0xa7, cp_end_vbi & 0xff);
-        } else {
-                /* reset to default values */
-                io_write(sd, 0x16, 0x43);
-                io_write(sd, 0x17, 0x5a);
-                cp_write(sd, 0xa2, 0x00);
-                cp_write(sd, 0xa3, 0x00);
-                cp_write(sd, 0xa4, 0x00);
-                cp_write(sd, 0xa5, 0x00);
-                cp_write(sd, 0xa6, 0x00);
-                cp_write(sd, 0xa7, 0x00);
+                break;
+        case ADV7604_MODE_HDMI:
+                /* set default prim_mode/vid_std for HDMI
+                   accoring to [REF_03, c. 4.2] */
+                io_write(sd, 0x00, 0x02); /* video std */
+                io_write(sd, 0x01, 0x06); /* prim mode */
+                break;
+        default:
+                v4l2_dbg(2, debug, sd, "%s: Unknown mode %d\n",
+                                __func__, state->mode);
+                break;
         }
-}
 
+        cp_write(sd, 0x8f, (ch1_fr_ll >> 8) & 0x7);
+        cp_write(sd, 0x90, ch1_fr_ll & 0xff);
+        cp_write(sd, 0xab, (height >> 4) & 0xff);
+        cp_write(sd, 0xac, (height & 0x0f) << 4);
+}
 
 static void set_rgb_quantization_range(struct v4l2_subdev *sd)
 {
@@ -738,12 +901,7 @@ static void set_rgb_quantization_range(struct v4l2_subdev *sd)
         switch (state->rgb_quantization_range) {
         case V4L2_DV_RGB_RANGE_AUTO:
                 /* automatic */
-                if ((hdmi_read(sd, 0x05) & 0x80) ||
-                                (state->prim_mode == ADV7604_PRIM_MODE_COMP) ||
-                                (state->prim_mode == ADV7604_PRIM_MODE_RGB)) {
-                        /* receiving HDMI or analog signal */
-                        io_write_and_or(sd, 0x02, 0x0f, 0xf0);
-                } else {
+                if (DIGITAL_INPUT && !(hdmi_read(sd, 0x05) & 0x80)) {
                         /* receiving DVI-D signal */
 
                         /* ADV7604 selects RGB limited range regardless of
@@ -756,6 +914,9 @@ static void set_rgb_quantization_range(struct v4l2_subdev *sd)
                                 /* RGB full range (0-255) */
                                 io_write_and_or(sd, 0x02, 0x0f, 0x10);
                         }
+                } else {
+                        /* receiving HDMI or analog signal, set automode */
+                        io_write_and_or(sd, 0x02, 0x0f, 0xf0);
                 }
                 break;
         case V4L2_DV_RGB_RANGE_LIMITED:
@@ -967,8 +1128,10 @@ static int stdi2dv_timings(struct v4l2_subdev *sd,
                         state->aspect_ratio, timings))
                 return 0;
 
-        v4l2_dbg(2, debug, sd, "%s: No format candidate found for lcf=%d, bl = %d\n",
-                        __func__, stdi->lcf, stdi->bl);
+        v4l2_dbg(2, debug, sd,
+                "%s: No format candidate found for lcvs = %d, lcf=%d, bl = %d, %chsync, %cvsync\n",
+                __func__, stdi->lcvs, stdi->lcf, stdi->bl,
+                stdi->hs_pol, stdi->vs_pol);
         return -1;
 }
 
@@ -1123,7 +1286,7 @@ static int adv7604_query_dv_timings(struct v4l2_subdev *sd,
                 adv7604_fill_optional_dv_timings_fields(sd, timings);
         } else {
                 /* find format
-                 * Since LCVS values are inaccurate (REF_03, page 275-276),
+                 * Since LCVS values are inaccurate [REF_03, p. 275-276],
                  * stdi2dv_timings() is called with lcvs +-1 if the first attempt fails.
                  */
                 if (!stdi2dv_timings(sd, &stdi, timings))
@@ -1135,9 +1298,31 @@ static int adv7604_query_dv_timings(struct v4l2_subdev *sd,
                 stdi.lcvs -= 2;
                 v4l2_dbg(1, debug, sd, "%s: lcvs - 1 = %d\n", __func__, stdi.lcvs);
                 if (stdi2dv_timings(sd, &stdi, timings)) {
+                        /*
+                         * The STDI block may measure wrong values, especially
+                         * for lcvs and lcf. If the driver can not find any
+                         * valid timing, the STDI block is restarted to measure
+                         * the video timings again. The function will return an
+                         * error, but the restart of STDI will generate a new
+                         * STDI interrupt and the format detection process will
+                         * restart.
+                         */
+                        if (state->restart_stdi_once) {
+                                v4l2_dbg(1, debug, sd, "%s: restart STDI\n", __func__);
+                                /* TODO restart STDI for Sync Channel 2 */
+                                /* enter one-shot mode */
+                                cp_write_and_or(sd, 0x86, 0xf9, 0x00);
+                                /* trigger STDI restart */
+                                cp_write_and_or(sd, 0x86, 0xf9, 0x04);
+                                /* reset to continuous mode */
+                                cp_write_and_or(sd, 0x86, 0xf9, 0x02);
+                                state->restart_stdi_once = false;
+                                return -ENOLINK;
+                        }
                         v4l2_dbg(1, debug, sd, "%s: format not supported\n", __func__);
                         return -ERANGE;
                 }
+                state->restart_stdi_once = true;
         }
 found:
 
@@ -1166,6 +1351,7 @@ static int adv7604_s_dv_timings(struct v4l2_subdev *sd,
 {
         struct adv7604_state *state = to_state(sd);
         struct v4l2_bt_timings *bt;
+        int err;
 
         if (!timings)
                 return -EINVAL;
@@ -1178,12 +1364,20 @@ static int adv7604_s_dv_timings(struct v4l2_subdev *sd,
                                 __func__, (u32)bt->pixelclock);
                 return -ERANGE;
         }
+
         adv7604_fill_optional_dv_timings_fields(sd, timings);
 
         state->timings = *timings;
 
-        /* freerun */
-        configure_free_run(sd, bt);
+        cp_write(sd, 0x91, bt->interlaced ? 0x50 : 0x10);
+
+        /* Use prim_mode and vid_std when available */
+        err = configure_predefined_video_timings(sd, timings);
+        if (err) {
+                /* custom settings when the video format
+                 does not have prim_mode/vid_std */
+                configure_custom_video_timings(sd, bt);
+        }
 
         set_rgb_quantization_range(sd);
 
@@ -1203,24 +1397,25 @@ static int adv7604_g_dv_timings(struct v4l2_subdev *sd,
         return 0;
 }
 
-static void enable_input(struct v4l2_subdev *sd, enum adv7604_prim_mode prim_mode)
+static void enable_input(struct v4l2_subdev *sd)
 {
-        switch (prim_mode) {
-        case ADV7604_PRIM_MODE_COMP:
-        case ADV7604_PRIM_MODE_RGB:
+        struct adv7604_state *state = to_state(sd);
+
+        switch (state->mode) {
+        case ADV7604_MODE_COMP:
+        case ADV7604_MODE_GR:
                 /* enable */
                 io_write(sd, 0x15, 0xb0);   /* Disable Tristate of Pins (no audio) */
                 break;
-        case ADV7604_PRIM_MODE_HDMI_COMP:
-        case ADV7604_PRIM_MODE_HDMI_GR:
+        case ADV7604_MODE_HDMI:
                 /* enable */
                 hdmi_write(sd, 0x1a, 0x0a); /* Unmute audio */
                 hdmi_write(sd, 0x01, 0x00); /* Enable HDMI clock terminators */
                 io_write(sd, 0x15, 0xa0);   /* Disable Tristate of Pins */
                 break;
         default:
-                v4l2_err(sd, "%s: reserved primary mode 0x%0x\n",
-                                __func__, prim_mode);
+                v4l2_dbg(2, debug, sd, "%s: Unknown mode %d\n",
+                                __func__, state->mode);
                 break;
         }
 }
@@ -1233,17 +1428,13 @@ static void disable_input(struct v4l2_subdev *sd)
         hdmi_write(sd, 0x01, 0x78); /* Disable HDMI clock terminators */
 }
 
-static void select_input(struct v4l2_subdev *sd, enum adv7604_prim_mode prim_mode)
+static void select_input(struct v4l2_subdev *sd)
 {
-        switch (prim_mode) {
-        case ADV7604_PRIM_MODE_COMP:
-        case ADV7604_PRIM_MODE_RGB:
-                /* set mode and select free run resolution */
-                io_write(sd, 0x00, 0x07); /* video std */
-                io_write(sd, 0x01, 0x02); /* prim mode */
-                /* enable embedded syncs for auto graphics mode */
-                cp_write_and_or(sd, 0x81, 0xef, 0x10);
+        struct adv7604_state *state = to_state(sd);
 
+        switch (state->mode) {
+        case ADV7604_MODE_COMP:
+        case ADV7604_MODE_GR:
                 /* reset ADI recommended settings for HDMI: */
                 /* "ADV7604 Register Settings Recommendations (rev. 2.5, June 2010)" p. 4. */
                 hdmi_write(sd, 0x0d, 0x04); /* HDMI filter optimization */
@@ -1271,16 +1462,7 @@ static void select_input(struct v4l2_subdev *sd, enum adv7604_prim_mode prim_mod
                 cp_write(sd, 0x40, 0x5c); /* CP core pre-gain control. Graphics mode */
                 break;
 
-        case ADV7604_PRIM_MODE_HDMI_COMP:
-        case ADV7604_PRIM_MODE_HDMI_GR:
-                /* set mode and select free run resolution */
-                /* video std */
-                io_write(sd, 0x00,
-                        (prim_mode == ADV7604_PRIM_MODE_HDMI_GR) ? 0x02 : 0x1e);
-                io_write(sd, 0x01, prim_mode); /* prim mode */
-                /* disable embedded syncs for auto graphics mode */
-                cp_write_and_or(sd, 0x81, 0xef, 0x00);
-
+        case ADV7604_MODE_HDMI:
                 /* set ADI recommended settings for HDMI: */
                 /* "ADV7604 Register Settings Recommendations (rev. 2.5, June 2010)" p. 4. */
                 hdmi_write(sd, 0x0d, 0x84); /* HDMI filter optimization */
@@ -1309,7 +1491,8 @@ static void select_input(struct v4l2_subdev *sd, enum adv7604_prim_mode prim_mod
 
                 break;
         default:
-                v4l2_err(sd, "%s: reserved primary mode 0x%0x\n", __func__, prim_mode);
+                v4l2_dbg(2, debug, sd, "%s: Unknown mode %d\n",
+                                __func__, state->mode);
                 break;
         }
 }
@@ -1321,26 +1504,13 @@ static int adv7604_s_routing(struct v4l2_subdev *sd,
 
         v4l2_dbg(2, debug, sd, "%s: input %d", __func__, input);
 
-        switch (input) {
-        case 0:
-                /* TODO select HDMI_COMP or HDMI_GR */
-                state->prim_mode = ADV7604_PRIM_MODE_HDMI_COMP;
-                break;
-        case 1:
-                state->prim_mode = ADV7604_PRIM_MODE_RGB;
-                break;
-        case 2:
-                state->prim_mode = ADV7604_PRIM_MODE_COMP;
-                break;
-        default:
-                return -EINVAL;
-        }
+        state->mode = input;
 
         disable_input(sd);
 
-        select_input(sd, state->prim_mode);
+        select_input(sd);
 
-        enable_input(sd, state->prim_mode);
+        enable_input(sd);
 
         return 0;
 }
@@ -1549,8 +1719,9 @@ static int adv7604_log_status(struct v4l2_subdev *sd)
         v4l2_info(sd, "CP locked: %s\n", no_lock_cp(sd) ? "false" : "true");
         v4l2_info(sd, "CP free run: %s\n",
                         (!!(cp_read(sd, 0xff) & 0x10) ? "on" : "off"));
-        v4l2_info(sd, "Prim-mode = 0x%x, video std = 0x%x\n",
-                        io_read(sd, 0x01) & 0x0f, io_read(sd, 0x00) & 0x3f);
+        v4l2_info(sd, "Prim-mode = 0x%x, video std = 0x%x, v_freq = 0x%x\n",
+                        io_read(sd, 0x01) & 0x0f, io_read(sd, 0x00) & 0x3f,
+                        (io_read(sd, 0x01) & 0x70) >> 4);
 
         v4l2_info(sd, "-----Video Timings-----\n");
         if (read_stdi(sd, &stdi))
@@ -1712,9 +1883,9 @@ static int adv7604_core_init(struct v4l2_subdev *sd)
         cp_write(sd, 0xba, (pdata->hdmi_free_run_mode << 1) | 0x01); /* HDMI free run */
         cp_write(sd, 0xf3, 0xdc); /* Low threshold to enter/exit free run mode */
         cp_write(sd, 0xf9, 0x23); /*  STDI ch. 1 - LCVS change threshold -
-                                      ADI recommended setting [REF_01 c. 2.3.3] */
+                                      ADI recommended setting [REF_01, c. 2.3.3] */
         cp_write(sd, 0x45, 0x23); /*  STDI ch. 2 - LCVS change threshold -
-                                      ADI recommended setting [REF_01 c. 2.3.3] */
+                                      ADI recommended setting [REF_01, c. 2.3.3] */
         cp_write(sd, 0xc9, 0x2d); /* use prim_mode and vid_std as free run resolution
                                      for digital formats */
 
@@ -1724,11 +1895,6 @@ static int adv7604_core_init(struct v4l2_subdev *sd)
         afe_write(sd, 0x02, pdata->ain_sel); /* Select analog input muxing mode */
         io_write_and_or(sd, 0x30, ~(1 << 4), pdata->output_bus_lsb_to_msb << 4);
 
-        state->prim_mode = pdata->prim_mode;
-        select_input(sd, pdata->prim_mode);
-
-        enable_input(sd, pdata->prim_mode);
-
         /* interrupts */
         io_write(sd, 0x40, 0xc2); /* Configure INT1 */
         io_write(sd, 0x41, 0xd7); /* STDI irq for any change, disable INT2 */
@@ -1883,6 +2049,7 @@ static int adv7604_probe(struct i2c_client *client,
                 v4l2_err(sd, "failed to create all i2c clients\n");
                 goto err_i2c;
         }
+        state->restart_stdi_once = true;
 
         /* work queues */
         state->work_queues = create_singlethread_workqueue(client->name);
diff --git a/drivers/media/i2c/soc_camera/mt9v022.c b/drivers/media/i2c/soc_camera/mt9v022.c
index 13057b966ee9..333ef178d6fb 100644
--- a/drivers/media/i2c/soc_camera/mt9v022.c
+++ b/drivers/media/i2c/soc_camera/mt9v022.c
@@ -263,9 +263,14 @@ static int mt9v022_s_crop(struct v4l2_subdev *sd, const struct v4l2_crop *a)
                 if (ret & 1) /* Autoexposure */
                         ret = reg_write(client, mt9v022->reg->max_total_shutter_width,
                                         rect.height + mt9v022->y_skip_top + 43);
-                else
-                        ret = reg_write(client, MT9V022_TOTAL_SHUTTER_WIDTH,
-                                        rect.height + mt9v022->y_skip_top + 43);
+                /*
+                 * If autoexposure is off, there is no need to set
+                 * MT9V022_TOTAL_SHUTTER_WIDTH here. Autoexposure can be off
+                 * only if the user has set exposure manually, using the
+                 * V4L2_CID_EXPOSURE_AUTO with the value V4L2_EXPOSURE_MANUAL.
+                 * In this case the register MT9V022_TOTAL_SHUTTER_WIDTH
+                 * already contains the correct value.
+                 */
         }
         /* Setup frame format: defaults apart from width and height */
         if (!ret)
diff --git a/drivers/media/platform/exynos-gsc/gsc-core.c b/drivers/media/platform/exynos-gsc/gsc-core.c
index bfec9e65aefb..19cbb12a12a2 100644
--- a/drivers/media/platform/exynos-gsc/gsc-core.c
+++ b/drivers/media/platform/exynos-gsc/gsc-core.c
@@ -965,8 +965,10 @@ static struct platform_device_id gsc_driver_ids[] = {
 MODULE_DEVICE_TABLE(platform, gsc_driver_ids);
 
 static const struct of_device_id exynos_gsc_match[] = {
-        { .compatible = "samsung,exynos5250-gsc",
-        .data = &gsc_v_100_drvdata, },
+        {
+                .compatible = "samsung,exynos5-gsc",
+                .data = &gsc_v_100_drvdata,
+        },
         {},
 };
 MODULE_DEVICE_TABLE(of, exynos_gsc_match);
diff --git a/drivers/media/platform/exynos-gsc/gsc-m2m.c b/drivers/media/platform/exynos-gsc/gsc-m2m.c
index 3c7f00577bd9..c065d040ed94 100644
--- a/drivers/media/platform/exynos-gsc/gsc-m2m.c
+++ b/drivers/media/platform/exynos-gsc/gsc-m2m.c
@@ -657,8 +657,7 @@ static int gsc_m2m_release(struct file *file)
         pr_debug("pid: %d, state: 0x%lx, refcnt= %d",
                 task_pid_nr(current), gsc->state, gsc->m2m.refcnt);
 
-        if (mutex_lock_interruptible(&gsc->lock))
-                return -ERESTARTSYS;
+        mutex_lock(&gsc->lock);
 
         v4l2_m2m_ctx_release(ctx->m2m_ctx);
         gsc_ctrls_delete(ctx);
@@ -732,6 +731,7 @@ int gsc_register_m2m_device(struct gsc_dev *gsc)
         gsc->vdev.ioctl_ops     = &gsc_m2m_ioctl_ops;
         gsc->vdev.release       = video_device_release_empty;
         gsc->vdev.lock          = &gsc->lock;
+        gsc->vdev.vfl_dir       = VFL_DIR_M2M;
         snprintf(gsc->vdev.name, sizeof(gsc->vdev.name), "%s.%d:m2m",
                                         GSC_MODULE_NAME, gsc->id);
 
diff --git a/drivers/media/platform/exynos-gsc/gsc-regs.h b/drivers/media/platform/exynos-gsc/gsc-regs.h
index 533e9947a925..4678f9a6a4fd 100644
--- a/drivers/media/platform/exynos-gsc/gsc-regs.h
+++ b/drivers/media/platform/exynos-gsc/gsc-regs.h
@@ -40,10 +40,10 @@
 #define GSC_IN_ROT_YFLIP                (2 << 16)
 #define GSC_IN_ROT_XFLIP                (1 << 16)
 #define GSC_IN_RGB_TYPE_MASK            (3 << 14)
-#define GSC_IN_RGB_HD_WIDE              (3 << 14)
-#define GSC_IN_RGB_HD_NARROW            (2 << 14)
-#define GSC_IN_RGB_SD_WIDE              (1 << 14)
-#define GSC_IN_RGB_SD_NARROW            (0 << 14)
+#define GSC_IN_RGB_HD_NARROW            (3 << 14)
+#define GSC_IN_RGB_HD_WIDE              (2 << 14)
+#define GSC_IN_RGB_SD_NARROW            (1 << 14)
+#define GSC_IN_RGB_SD_WIDE              (0 << 14)
 #define GSC_IN_YUV422_1P_ORDER_MASK     (1 << 13)
 #define GSC_IN_YUV422_1P_ORDER_LSB_Y    (0 << 13)
 #define GSC_IN_YUV422_1P_OEDER_LSB_C    (1 << 13)
@@ -85,10 +85,10 @@
 #define GSC_OUT_GLOBAL_ALPHA_MASK       (0xff << 24)
 #define GSC_OUT_GLOBAL_ALPHA(x)         ((x) << 24)
 #define GSC_OUT_RGB_TYPE_MASK           (3 << 10)
-#define GSC_OUT_RGB_HD_NARROW           (3 << 10)
-#define GSC_OUT_RGB_HD_WIDE             (2 << 10)
-#define GSC_OUT_RGB_SD_NARROW           (1 << 10)
-#define GSC_OUT_RGB_SD_WIDE             (0 << 10)
+#define GSC_OUT_RGB_HD_WIDE             (3 << 10)
+#define GSC_OUT_RGB_HD_NARROW           (2 << 10)
+#define GSC_OUT_RGB_SD_WIDE             (1 << 10)
+#define GSC_OUT_RGB_SD_NARROW           (0 << 10)
 #define GSC_OUT_YUV422_1P_ORDER_MASK    (1 << 9)
 #define GSC_OUT_YUV422_1P_ORDER_LSB_Y   (0 << 9)
 #define GSC_OUT_YUV422_1P_OEDER_LSB_C   (1 << 9)
diff --git a/drivers/media/platform/omap3isp/ispccdc.c b/drivers/media/platform/omap3isp/ispccdc.c
index 60181ab96063..aa9df9d71a7b 100644
--- a/drivers/media/platform/omap3isp/ispccdc.c
+++ b/drivers/media/platform/omap3isp/ispccdc.c
@@ -1706,7 +1706,7 @@ static long ccdc_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
 }
 
 static int ccdc_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
-                                const struct v4l2_event_subscription *sub)
+                                struct v4l2_event_subscription *sub)
 {
         if (sub->type != V4L2_EVENT_FRAME_SYNC)
                 return -EINVAL;
@@ -1719,7 +1719,7 @@ static int ccdc_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
 }
 
 static int ccdc_unsubscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
-                                  const struct v4l2_event_subscription *sub)
+                                  struct v4l2_event_subscription *sub)
 {
         return v4l2_event_unsubscribe(fh, sub);
 }
diff --git a/drivers/media/platform/omap3isp/ispstat.c b/drivers/media/platform/omap3isp/ispstat.c
index d7ac76b5c2ae..b8640be692f1 100644
--- a/drivers/media/platform/omap3isp/ispstat.c
+++ b/drivers/media/platform/omap3isp/ispstat.c
@@ -1025,7 +1025,7 @@ void omap3isp_stat_dma_isr(struct ispstat *stat)
 
 int omap3isp_stat_subscribe_event(struct v4l2_subdev *subdev,
                                   struct v4l2_fh *fh,
-                                  const struct v4l2_event_subscription *sub)
+                                  struct v4l2_event_subscription *sub)
 {
         struct ispstat *stat = v4l2_get_subdevdata(subdev);
 
@@ -1037,7 +1037,7 @@ int omap3isp_stat_subscribe_event(struct v4l2_subdev *subdev,
 
 int omap3isp_stat_unsubscribe_event(struct v4l2_subdev *subdev,
                                     struct v4l2_fh *fh,
-                                    const struct v4l2_event_subscription *sub)
+                                    struct v4l2_event_subscription *sub)
 {
         return v4l2_event_unsubscribe(fh, sub);
 }
diff --git a/drivers/media/platform/omap3isp/ispstat.h b/drivers/media/platform/omap3isp/ispstat.h
index a6fe653eb237..9b7c8654dc8a 100644
--- a/drivers/media/platform/omap3isp/ispstat.h
+++ b/drivers/media/platform/omap3isp/ispstat.h
@@ -147,10 +147,10 @@ int omap3isp_stat_init(struct ispstat *stat, const char *name,
 void omap3isp_stat_cleanup(struct ispstat *stat);
 int omap3isp_stat_subscribe_event(struct v4l2_subdev *subdev,
                                   struct v4l2_fh *fh,
-                                  const struct v4l2_event_subscription *sub);
+                                  struct v4l2_event_subscription *sub);
 int omap3isp_stat_unsubscribe_event(struct v4l2_subdev *subdev,
                                     struct v4l2_fh *fh,
-                                    const struct v4l2_event_subscription *sub);
+                                    struct v4l2_event_subscription *sub);
 int omap3isp_stat_s_stream(struct v4l2_subdev *subdev, int enable);
 
 int omap3isp_stat_busy(struct ispstat *stat);
diff --git a/drivers/media/platform/omap3isp/ispvideo.c b/drivers/media/platform/omap3isp/ispvideo.c
index a0b737fecf13..75cd309035f9 100644
--- a/drivers/media/platform/omap3isp/ispvideo.c
+++ b/drivers/media/platform/omap3isp/ispvideo.c
@@ -792,7 +792,7 @@ isp_video_get_crop(struct file *file, void *fh, struct v4l2_crop *crop)
 }
 
 static int
-isp_video_set_crop(struct file *file, void *fh, struct v4l2_crop *crop)
+isp_video_set_crop(struct file *file, void *fh, const struct v4l2_crop *crop)
 {
         struct isp_video *video = video_drvdata(file);
         struct v4l2_subdev *subdev;
diff --git a/drivers/media/platform/s5p-fimc/Kconfig b/drivers/media/platform/s5p-fimc/Kconfig
index 8f090a8f270e..c16b20d86ed2 100644
--- a/drivers/media/platform/s5p-fimc/Kconfig
+++ b/drivers/media/platform/s5p-fimc/Kconfig
@@ -24,6 +24,7 @@ config VIDEO_S5P_FIMC
 config VIDEO_S5P_MIPI_CSIS
         tristate "S5P/EXYNOS MIPI-CSI2 receiver (MIPI-CSIS) driver"
         depends on REGULATOR
+        select S5P_SETUP_MIPIPHY
         help
           This is a V4L2 driver for Samsung S5P and EXYNOS4 SoC MIPI-CSI2
           receiver (MIPI-CSIS) devices.
diff --git a/drivers/media/platform/s5p-fimc/fimc-capture.c b/drivers/media/platform/s5p-fimc/fimc-capture.c
index 367efd164d0f..891ee873c62b 100644
--- a/drivers/media/platform/s5p-fimc/fimc-capture.c
+++ b/drivers/media/platform/s5p-fimc/fimc-capture.c
@@ -556,8 +556,7 @@ static int fimc_capture_close(struct file *file)
 
         dbg("pid: %d, state: 0x%lx", task_pid_nr(current), fimc->state);
 
-        if (mutex_lock_interruptible(&fimc->lock))
-                return -ERESTARTSYS;
+        mutex_lock(&fimc->lock);
 
         if (--fimc->vid_cap.refcnt == 0) {
                 clear_bit(ST_CAPT_BUSY, &fimc->state);
@@ -1736,7 +1735,9 @@ static int fimc_register_capture_device(struct fimc_dev *fimc,
         q->mem_ops = &vb2_dma_contig_memops;
         q->buf_struct_size = sizeof(struct fimc_vid_buffer);
 
-        vb2_queue_init(q);
+        ret = vb2_queue_init(q);
+        if (ret)
+                goto err_ent;
 
         vid_cap->vd_pad.flags = MEDIA_PAD_FL_SINK;
         ret = media_entity_init(&vfd->entity, 1, &vid_cap->vd_pad, 0);
@@ -1772,9 +1773,13 @@ static int fimc_capture_subdev_registered(struct v4l2_subdev *sd)
         if (ret)
                 return ret;
 
+        fimc->pipeline_ops = v4l2_get_subdev_hostdata(sd);
+
         ret = fimc_register_capture_device(fimc, sd->v4l2_dev);
-        if (ret)
+        if (ret) {
                 fimc_unregister_m2m_device(fimc);
+                fimc->pipeline_ops = NULL;
+        }
 
         return ret;
 }
@@ -1791,6 +1796,7 @@ static void fimc_capture_subdev_unregistered(struct v4l2_subdev *sd)
         if (video_is_registered(&fimc->vid_cap.vfd)) {
                 video_unregister_device(&fimc->vid_cap.vfd);
                 media_entity_cleanup(&fimc->vid_cap.vfd.entity);
+                fimc->pipeline_ops = NULL;
         }
         kfree(fimc->vid_cap.ctx);
         fimc->vid_cap.ctx = NULL;
diff --git a/drivers/media/platform/s5p-fimc/fimc-lite.c b/drivers/media/platform/s5p-fimc/fimc-lite.c
index 70bcf39de879..1b309a72f09f 100644
--- a/drivers/media/platform/s5p-fimc/fimc-lite.c
+++ b/drivers/media/platform/s5p-fimc/fimc-lite.c
@@ -491,8 +491,7 @@ static int fimc_lite_close(struct file *file)
         struct fimc_lite *fimc = video_drvdata(file);
         int ret;
 
-        if (mutex_lock_interruptible(&fimc->lock))
-                return -ERESTARTSYS;
+        mutex_lock(&fimc->lock);
 
         if (--fimc->ref_count == 0 && fimc->out_path == FIMC_IO_DMA) {
                 clear_bit(ST_FLITE_IN_USE, &fimc->state);
@@ -1253,7 +1252,9 @@ static int fimc_lite_subdev_registered(struct v4l2_subdev *sd)
         q->buf_struct_size = sizeof(struct flite_buffer);
         q->drv_priv = fimc;
 
-        vb2_queue_init(q);
+        ret = vb2_queue_init(q);
+        if (ret < 0)
+                return ret;
 
         fimc->vd_pad.flags = MEDIA_PAD_FL_SINK;
         ret = media_entity_init(&vfd->entity, 1, &fimc->vd_pad, 0);
@@ -1261,10 +1262,12 @@ static int fimc_lite_subdev_registered(struct v4l2_subdev *sd)
                 return ret;
 
         video_set_drvdata(vfd, fimc);
+        fimc->pipeline_ops = v4l2_get_subdev_hostdata(sd);
 
         ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1);
         if (ret < 0) {
                 media_entity_cleanup(&vfd->entity);
+                fimc->pipeline_ops = NULL;
                 return ret;
         }
 
@@ -1283,6 +1286,7 @@ static void fimc_lite_subdev_unregistered(struct v4l2_subdev *sd)
         if (video_is_registered(&fimc->vfd)) {
                 video_unregister_device(&fimc->vfd);
                 media_entity_cleanup(&fimc->vfd.entity);
+                fimc->pipeline_ops = NULL;
         }
 }
 
diff --git a/drivers/media/platform/s5p-fimc/fimc-m2m.c b/drivers/media/platform/s5p-fimc/fimc-m2m.c
index 4500e44f6857..62afed3162ea 100644
--- a/drivers/media/platform/s5p-fimc/fimc-m2m.c
+++ b/drivers/media/platform/s5p-fimc/fimc-m2m.c
@@ -718,8 +718,7 @@ static int fimc_m2m_release(struct file *file)
         dbg("pid: %d, state: 0x%lx, refcnt= %d",
                 task_pid_nr(current), fimc->state, fimc->m2m.refcnt);
 
-        if (mutex_lock_interruptible(&fimc->lock))
-                return -ERESTARTSYS;
+        mutex_lock(&fimc->lock);
 
         v4l2_m2m_ctx_release(ctx->m2m_ctx);
         fimc_ctrls_delete(ctx);
diff --git a/drivers/media/platform/s5p-fimc/fimc-mdevice.c b/drivers/media/platform/s5p-fimc/fimc-mdevice.c
index 80ada5882f62..0531ab70a94c 100644
--- a/drivers/media/platform/s5p-fimc/fimc-mdevice.c
+++ b/drivers/media/platform/s5p-fimc/fimc-mdevice.c
@@ -343,53 +343,50 @@ static int fimc_md_register_sensor_entities(struct fimc_md *fmd)
 static int fimc_register_callback(struct device *dev, void *p)
 {
         struct fimc_dev *fimc = dev_get_drvdata(dev);
-        struct v4l2_subdev *sd = &fimc->vid_cap.subdev;
+        struct v4l2_subdev *sd;
         struct fimc_md *fmd = p;
-        int ret = 0;
-
-        if (!fimc || !fimc->pdev)
-                return 0;
+        int ret;
 
-        if (fimc->pdev->id < 0 || fimc->pdev->id >= FIMC_MAX_DEVS)
+        if (fimc == NULL || fimc->id >= FIMC_MAX_DEVS)
                 return 0;
 
-        fimc->pipeline_ops = &fimc_pipeline_ops;
-        fmd->fimc[fimc->pdev->id] = fimc;
+        sd = &fimc->vid_cap.subdev;
         sd->grp_id = FIMC_GROUP_ID;
+        v4l2_set_subdev_hostdata(sd, (void *)&fimc_pipeline_ops);
 
         ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
         if (ret) {
                 v4l2_err(&fmd->v4l2_dev, "Failed to register FIMC.%d (%d)\n",
                          fimc->id, ret);
+                return ret;
         }
 
-        return ret;
+        fmd->fimc[fimc->id] = fimc;
+        return 0;
 }
 
 static int fimc_lite_register_callback(struct device *dev, void *p)
 {
         struct fimc_lite *fimc = dev_get_drvdata(dev);
-        struct v4l2_subdev *sd = &fimc->subdev;
         struct fimc_md *fmd = p;
         int ret;
 
-        if (fimc == NULL)
+        if (fimc == NULL || fimc->index >= FIMC_LITE_MAX_DEVS)
                 return 0;
 
-        if (fimc->index >= FIMC_LITE_MAX_DEVS)
-                return 0;
-
-        fimc->pipeline_ops = &fimc_pipeline_ops;
-        fmd->fimc_lite[fimc->index] = fimc;
-        sd->grp_id = FLITE_GROUP_ID;
+        fimc->subdev.grp_id = FLITE_GROUP_ID;
+        v4l2_set_subdev_hostdata(&fimc->subdev, (void *)&fimc_pipeline_ops);
 
-        ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
+        ret = v4l2_device_register_subdev(&fmd->v4l2_dev, &fimc->subdev);
         if (ret) {
                 v4l2_err(&fmd->v4l2_dev,
                          "Failed to register FIMC-LITE.%d (%d)\n",
                          fimc->index, ret);
+                return ret;
         }
-        return ret;
+
+        fmd->fimc_lite[fimc->index] = fimc;
+        return 0;
 }
 
 static int csis_register_callback(struct device *dev, void *p)
@@ -407,10 +404,12 @@ static int csis_register_callback(struct device *dev, void *p)
         v4l2_info(sd, "csis%d sd: %s\n", pdev->id, sd->name);
 
         id = pdev->id < 0 ? 0 : pdev->id;
-        fmd->csis[id].sd = sd;
         sd->grp_id = CSIS_GROUP_ID;
+
         ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
-        if (ret)
+        if (!ret)
+                fmd->csis[id].sd = sd;
+        else
                 v4l2_err(&fmd->v4l2_dev,
                          "Failed to register CSIS subdevice: %d\n", ret);
         return ret;
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc.c b/drivers/media/platform/s5p-mfc/s5p_mfc.c
index 130f4ac8649e..3afe879d54d7 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc.c
@@ -381,11 +381,8 @@ static void s5p_mfc_handle_frame(struct s5p_mfc_ctx *ctx,
                 ctx->consumed_stream += s5p_mfc_hw_call(dev->mfc_ops,
                                                 get_consumed_stream, dev);
                 if (ctx->codec_mode != S5P_MFC_CODEC_H264_DEC &&
-                        s5p_mfc_hw_call(dev->mfc_ops,
-                                get_dec_frame_type, dev) ==
-                                        S5P_FIMV_DECODE_FRAME_P_FRAME
-                                        && ctx->consumed_stream + STUFF_BYTE <
-                                        src_buf->b->v4l2_planes[0].bytesused) {
+                        ctx->consumed_stream + STUFF_BYTE <
+                        src_buf->b->v4l2_planes[0].bytesused) {
                         /* Run MFC again on the same buffer */
                         mfc_debug(2, "Running again the same buffer\n");
                         ctx->after_packed_pb = 1;
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v6.c b/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v6.c
index 50b5bee3c44e..3a8cfd9fc1bd 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v6.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v6.c
@@ -1762,7 +1762,7 @@ int s5p_mfc_get_dspl_y_adr_v6(struct s5p_mfc_dev *dev)
 
 int s5p_mfc_get_dec_y_adr_v6(struct s5p_mfc_dev *dev)
 {
-        return mfc_read(dev, S5P_FIMV_D_DISPLAY_LUMA_ADDR_V6);
+        return mfc_read(dev, S5P_FIMV_D_DECODED_LUMA_ADDR_V6);
 }
 
 int s5p_mfc_get_dspl_status_v6(struct s5p_mfc_dev *dev)
diff --git a/drivers/media/platform/sh_vou.c b/drivers/media/platform/sh_vou.c
index 85fd312f0a82..a1c87f0ceaab 100644
--- a/drivers/media/platform/sh_vou.c
+++ b/drivers/media/platform/sh_vou.c
@@ -935,9 +935,10 @@ static int sh_vou_g_crop(struct file *file, void *fh, struct v4l2_crop *a)
 /* Assume a dull encoder, do all the work ourselves. */
 static int sh_vou_s_crop(struct file *file, void *fh, const struct v4l2_crop *a)
 {
+        struct v4l2_crop a_writable = *a;
         struct video_device *vdev = video_devdata(file);
         struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
-        struct v4l2_rect *rect = &a->c;
+        struct v4l2_rect *rect = &a_writable.c;
         struct v4l2_crop sd_crop = {.type = V4L2_BUF_TYPE_VIDEO_OUTPUT};
         struct v4l2_pix_format *pix = &vou_dev->pix;
         struct sh_vou_geometry geo;
diff --git a/drivers/media/platform/soc_camera/mx1_camera.c b/drivers/media/platform/soc_camera/mx1_camera.c
index bbe70991d30b..032b8c9097f9 100644
--- a/drivers/media/platform/soc_camera/mx1_camera.c
+++ b/drivers/media/platform/soc_camera/mx1_camera.c
@@ -470,14 +470,6 @@ static void mx1_camera_remove_device(struct soc_camera_device *icd)
         pcdev->icd = NULL;
 }
 
-static int mx1_camera_set_crop(struct soc_camera_device *icd,
-                               struct v4l2_crop *a)
-{
-        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
-
-        return v4l2_subdev_call(sd, video, s_crop, a);
-}
-
 static int mx1_camera_set_bus_param(struct soc_camera_device *icd)
 {
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
@@ -689,7 +681,6 @@ static struct soc_camera_host_ops mx1_soc_camera_host_ops = {
         .add            = mx1_camera_add_device,
         .remove         = mx1_camera_remove_device,
         .set_bus_param  = mx1_camera_set_bus_param,
-        .set_crop       = mx1_camera_set_crop,
         .set_fmt        = mx1_camera_set_fmt,
         .try_fmt        = mx1_camera_try_fmt,
         .init_videobuf  = mx1_camera_init_videobuf,
diff --git a/drivers/media/platform/soc_camera/mx2_camera.c b/drivers/media/platform/soc_camera/mx2_camera.c
index 9fd9d1c5b218..9a55f4c4c7f4 100644
--- a/drivers/media/platform/soc_camera/mx2_camera.c
+++ b/drivers/media/platform/soc_camera/mx2_camera.c
@@ -864,8 +864,10 @@ static int mx2_start_streaming(struct vb2_queue *q, unsigned int count)
 
                 bytesperline = soc_mbus_bytes_per_line(icd->user_width,
                                 icd->current_fmt->host_fmt);
-                if (bytesperline < 0)
+                if (bytesperline < 0) {
+                        spin_unlock_irqrestore(&pcdev->lock, flags);
                         return bytesperline;
+                }
 
                 /*
                  * I didn't manage to properly enable/disable the prp
@@ -878,8 +880,10 @@ static int mx2_start_streaming(struct vb2_queue *q, unsigned int count)
                 pcdev->discard_buffer = dma_alloc_coherent(ici->v4l2_dev.dev,
                                 pcdev->discard_size, &pcdev->discard_buffer_dma,
                                 GFP_KERNEL);
-                if (!pcdev->discard_buffer)
+                if (!pcdev->discard_buffer) {
+                        spin_unlock_irqrestore(&pcdev->lock, flags);
                         return -ENOMEM;
+                }
 
                 pcdev->buf_discard[0].discard = true;
                 list_add_tail(&pcdev->buf_discard[0].queue,
@@ -1099,9 +1103,10 @@ static int mx2_camera_set_bus_param(struct soc_camera_device *icd)
 }
 
 static int mx2_camera_set_crop(struct soc_camera_device *icd,
-                                struct v4l2_crop *a)
+                                const struct v4l2_crop *a)
 {
-        struct v4l2_rect *rect = &a->c;
+        struct v4l2_crop a_writable = *a;
+        struct v4l2_rect *rect = &a_writable.c;
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         struct v4l2_mbus_framefmt mf;
         int ret;
diff --git a/drivers/media/platform/soc_camera/mx3_camera.c b/drivers/media/platform/soc_camera/mx3_camera.c
index 3557ac97e430..261f6e9e1b17 100644
--- a/drivers/media/platform/soc_camera/mx3_camera.c
+++ b/drivers/media/platform/soc_camera/mx3_camera.c
@@ -799,9 +799,10 @@ static inline void stride_align(__u32 *width)
  * default g_crop and cropcap from soc_camera.c
  */
 static int mx3_camera_set_crop(struct soc_camera_device *icd,
-                               struct v4l2_crop *a)
+                               const struct v4l2_crop *a)
 {
-        struct v4l2_rect *rect = &a->c;
+        struct v4l2_crop a_writable = *a;
+        struct v4l2_rect *rect = &a_writable.c;
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
         struct mx3_camera_dev *mx3_cam = ici->priv;
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
diff --git a/drivers/media/platform/soc_camera/omap1_camera.c b/drivers/media/platform/soc_camera/omap1_camera.c
index fa08c7695ccb..13636a585106 100644
--- a/drivers/media/platform/soc_camera/omap1_camera.c
+++ b/drivers/media/platform/soc_camera/omap1_camera.c
@@ -1215,9 +1215,9 @@ static int set_mbus_format(struct omap1_cam_dev *pcdev, struct device *dev,
 }
 
 static int omap1_cam_set_crop(struct soc_camera_device *icd,
-                               struct v4l2_crop *crop)
+                               const struct v4l2_crop *crop)
 {
-        struct v4l2_rect *rect = &crop->c;
+        const struct v4l2_rect *rect = &crop->c;
         const struct soc_camera_format_xlate *xlate = icd->current_fmt;
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         struct device *dev = icd->parent;
diff --git a/drivers/media/platform/soc_camera/pxa_camera.c b/drivers/media/platform/soc_camera/pxa_camera.c
index 1e3776d08dac..3434ffe79c6e 100644
--- a/drivers/media/platform/soc_camera/pxa_camera.c
+++ b/drivers/media/platform/soc_camera/pxa_camera.c
@@ -1337,9 +1337,9 @@ static int pxa_camera_check_frame(u32 width, u32 height)
 }
 
 static int pxa_camera_set_crop(struct soc_camera_device *icd,
-                               struct v4l2_crop *a)
+                               const struct v4l2_crop *a)
 {
-        struct v4l2_rect *rect = &a->c;
+        const struct v4l2_rect *rect = &a->c;
         struct device *dev = icd->parent;
         struct soc_camera_host *ici = to_soc_camera_host(dev);
         struct pxa_camera_dev *pcdev = ici->priv;
diff --git a/drivers/media/platform/soc_camera/sh_mobile_ceu_camera.c b/drivers/media/platform/soc_camera/sh_mobile_ceu_camera.c
index 0a24253dcda2..2d8861c0e8f2 100644
--- a/drivers/media/platform/soc_camera/sh_mobile_ceu_camera.c
+++ b/drivers/media/platform/soc_camera/sh_mobile_ceu_camera.c
@@ -1182,13 +1182,13 @@ static void sh_mobile_ceu_put_formats(struct soc_camera_device *icd)
 }
 
 /* Check if any dimension of r1 is smaller than respective one of r2 */
-static bool is_smaller(struct v4l2_rect *r1, struct v4l2_rect *r2)
+static bool is_smaller(const struct v4l2_rect *r1, const struct v4l2_rect *r2)
 {
         return r1->width < r2->width || r1->height < r2->height;
 }
 
 /* Check if r1 fails to cover r2 */
-static bool is_inside(struct v4l2_rect *r1, struct v4l2_rect *r2)
+static bool is_inside(const struct v4l2_rect *r1, const struct v4l2_rect *r2)
 {
         return r1->left > r2->left || r1->top > r2->top ||
                 r1->left + r1->width < r2->left + r2->width ||
@@ -1263,7 +1263,7 @@ static void update_subrect(struct sh_mobile_ceu_cam *cam)
  * 3. if (2) failed, try to request the maximum image
  */
 static int client_s_crop(struct soc_camera_device *icd, struct v4l2_crop *crop,
-                         const struct v4l2_crop *cam_crop)
+                         struct v4l2_crop *cam_crop)
 {
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         struct v4l2_rect *rect = &crop->c, *cam_rect = &cam_crop->c;
@@ -1519,7 +1519,8 @@ static int client_scale(struct soc_camera_device *icd,
 static int sh_mobile_ceu_set_crop(struct soc_camera_device *icd,
                                   const struct v4l2_crop *a)
 {
-        struct v4l2_rect *rect = &a->c;
+        struct v4l2_crop a_writable = *a;
+        const struct v4l2_rect *rect = &a_writable.c;
         struct device *dev = icd->parent;
         struct soc_camera_host *ici = to_soc_camera_host(dev);
         struct sh_mobile_ceu_dev *pcdev = ici->priv;
@@ -1545,7 +1546,7 @@ static int sh_mobile_ceu_set_crop(struct soc_camera_device *icd,
          * 1. - 2. Apply iterative camera S_CROP for new input window, read back
          * actual camera rectangle.
          */
-        ret = client_s_crop(icd, a, &cam_crop);
+        ret = client_s_crop(icd, &a_writable, &cam_crop);
         if (ret < 0)
                 return ret;
 
@@ -1946,7 +1947,7 @@ static int sh_mobile_ceu_try_fmt(struct soc_camera_device *icd,
 }
 
 static int sh_mobile_ceu_set_livecrop(struct soc_camera_device *icd,
-                                      struct v4l2_crop *a)
+                                      const struct v4l2_crop *a)
 {
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
diff --git a/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c b/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c
index 9859d2a2449b..ba51f65204de 100644
--- a/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c
+++ b/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c
@@ -283,14 +283,13 @@ static inline int dvb_usb_ctrl_feed(struct dvb_demux_feed *dvbdmxfeed,
 
         /* activate the pid on the device pid filter */
         if (adap->props->caps & DVB_USB_ADAP_HAS_PID_FILTER &&
-                        adap->pid_filtering &&
-                        adap->props->pid_filter)
+                        adap->pid_filtering && adap->props->pid_filter) {
                 ret = adap->props->pid_filter(adap, dvbdmxfeed->index,
                                 dvbdmxfeed->pid, (count == 1) ? 1 : 0);
-                        if (ret < 0)
-                                dev_err(&d->udev->dev, "%s: pid_filter() " \
-                                                "failed=%d\n", KBUILD_MODNAME,
-                                                ret);
+                if (ret < 0)
+                        dev_err(&d->udev->dev, "%s: pid_filter() failed=%d\n",
+                                        KBUILD_MODNAME, ret);
+        }
 
         /* start feeding if it is first pid */
         if (adap->feed_count == 1 && count == 1) {
diff --git a/drivers/media/usb/dvb-usb-v2/dvb_usb_urb.c b/drivers/media/usb/dvb-usb-v2/dvb_usb_urb.c
index 0431beed0ef4..5716662b4834 100644
--- a/drivers/media/usb/dvb-usb-v2/dvb_usb_urb.c
+++ b/drivers/media/usb/dvb-usb-v2/dvb_usb_urb.c
@@ -32,9 +32,7 @@ int dvb_usbv2_generic_rw(struct dvb_usb_device *d, u8 *wbuf, u16 wlen, u8 *rbuf,
                 return -EINVAL;
         }
 
-        ret = mutex_lock_interruptible(&d->usb_mutex);
-        if (ret < 0)
-                return ret;
+        mutex_lock(&d->usb_mutex);
 
         dev_dbg(&d->udev->dev, "%s: >>> %*ph\n", __func__, wlen, wbuf);
 
diff --git a/drivers/media/usb/dvb-usb-v2/rtl28xxu.c b/drivers/media/usb/dvb-usb-v2/rtl28xxu.c
index adabba8d28bc..093f1acce403 100644
--- a/drivers/media/usb/dvb-usb-v2/rtl28xxu.c
+++ b/drivers/media/usb/dvb-usb-v2/rtl28xxu.c
@@ -1346,6 +1346,10 @@ static const struct usb_device_id rtl28xxu_id_table[] = {
                 &rtl2832u_props, "DigitalNow Quad DVB-T Receiver", NULL) },
         { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x00d3,
                 &rtl2832u_props, "TerraTec Cinergy T Stick RC (Rev. 3)", NULL) },
+        { DVB_USB_DEVICE(USB_VID_DEXATEK, 0x1102,
+                &rtl2832u_props, "Dexatek DK mini DVB-T Dongle", NULL) },
+        { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x00d7,
+                &rtl2832u_props, "TerraTec Cinergy T Stick+", NULL) },
         { }
 };
 MODULE_DEVICE_TABLE(usb, rtl28xxu_id_table);
diff --git a/drivers/mfd/arizona-core.c b/drivers/mfd/arizona-core.c
index 1b48f2094806..f4f9bf84bc7b 100644
--- a/drivers/mfd/arizona-core.c
+++ b/drivers/mfd/arizona-core.c
@@ -98,9 +98,9 @@ static irqreturn_t arizona_underclocked(int irq, void *data)
 
         if (val & ARIZONA_AIF3_UNDERCLOCKED_STS)
                 dev_err(arizona->dev, "AIF3 underclocked\n");
-        if (val & ARIZONA_AIF3_UNDERCLOCKED_STS)
-                dev_err(arizona->dev, "AIF3 underclocked\n");
         if (val & ARIZONA_AIF2_UNDERCLOCKED_STS)
+                dev_err(arizona->dev, "AIF2 underclocked\n");
+        if (val & ARIZONA_AIF1_UNDERCLOCKED_STS)
                 dev_err(arizona->dev, "AIF1 underclocked\n");
         if (val & ARIZONA_ISRC2_UNDERCLOCKED_STS)
                 dev_err(arizona->dev, "ISRC2 underclocked\n");
@@ -415,11 +415,19 @@ int __devinit arizona_dev_init(struct arizona *arizona)
 
         /* If we have a /RESET GPIO we'll already be reset */
         if (!arizona->pdata.reset) {
+                regcache_mark_dirty(arizona->regmap);
+
                 ret = regmap_write(arizona->regmap, ARIZONA_SOFTWARE_RESET, 0);
                 if (ret != 0) {
                         dev_err(dev, "Failed to reset device: %d\n", ret);
                         goto err_reset;
                 }
+
+                ret = regcache_sync(arizona->regmap);
+                if (ret != 0) {
+                        dev_err(dev, "Failed to sync device: %d\n", ret);
+                        goto err_reset;
+                }
         }
 
         ret = arizona_wait_for_boot(arizona);
@@ -520,7 +528,7 @@ int __devinit arizona_dev_init(struct arizona *arizona)
                 break;
         case WM5110:
                 ret = mfd_add_devices(arizona->dev, -1, wm5110_devs,
-                                      ARRAY_SIZE(wm5102_devs), NULL, 0, NULL);
+                                      ARRAY_SIZE(wm5110_devs), NULL, 0, NULL);
                 break;
         }
 
diff --git a/drivers/mfd/arizona-irq.c b/drivers/mfd/arizona-irq.c
index ef0f2d001df2..b1b009177405 100644
--- a/drivers/mfd/arizona-irq.c
+++ b/drivers/mfd/arizona-irq.c
@@ -178,6 +178,7 @@ int arizona_irq_init(struct arizona *arizona)
 
                 switch (arizona->rev) {
                 case 0:
+                case 1:
                         ctrlif_error = false;
                         break;
                 default:
diff --git a/drivers/mfd/twl-core.c b/drivers/mfd/twl-core.c
index 4ae642320205..a071a8643a47 100644
--- a/drivers/mfd/twl-core.c
+++ b/drivers/mfd/twl-core.c
@@ -671,7 +671,7 @@ add_children(struct twl4030_platform_data *pdata, unsigned irq_base,
         }
 
         if (IS_ENABLED(CONFIG_PWM_TWL6030) && twl_class_is_6030()) {
-                child = add_child(TWL6030_MODULE_ID1, "twl6030-pwm", NULL, 0,
+                child = add_child(SUB_CHIP_ID1, "twl6030-pwm", NULL, 0,
                                   false, 0, 0);
                 if (IS_ERR(child))
                         return PTR_ERR(child);
diff --git a/drivers/mfd/twl4030-irq.c b/drivers/mfd/twl4030-irq.c
index ad733d76207a..cdd1173ed4e9 100644
--- a/drivers/mfd/twl4030-irq.c
+++ b/drivers/mfd/twl4030-irq.c
@@ -672,7 +672,8 @@ int twl4030_sih_setup(struct device *dev, int module, int irq_base)
         irq = sih_mod + twl4030_irq_base;
         irq_set_handler_data(irq, agent);
         agent->irq_name = kasprintf(GFP_KERNEL, "twl4030_%s", sih->name);
-        status = request_threaded_irq(irq, NULL, handle_twl4030_sih, 0,
+        status = request_threaded_irq(irq, NULL, handle_twl4030_sih,
+                                      IRQF_EARLY_RESUME,
                                       agent->irq_name ?: sih->name, NULL);
 
         dev_info(dev, "%s (irq %d) chaining IRQs %d..%d\n", sih->name,
diff --git a/drivers/mfd/wm5102-tables.c b/drivers/mfd/wm5102-tables.c
index 01b9255ed631..14490cc785d2 100644
--- a/drivers/mfd/wm5102-tables.c
+++ b/drivers/mfd/wm5102-tables.c
@@ -43,6 +43,7 @@ static const struct reg_default wm5102_reva_patch[] = {
         { 0x479, 0x0A30 },
         { 0x47B, 0x0810 },
         { 0x47D, 0x0510 },
+        { 0x4D1, 0x017F },
         { 0x500, 0x000D },
         { 0x507, 0x1820 },
         { 0x508, 0x1820 },
@@ -52,524 +53,6 @@ static const struct reg_default wm5102_reva_patch[] = {
         { 0x580, 0x000D },
         { 0x587, 0x1820 },
         { 0x588, 0x1820 },
-        { 0x101, 0x8140 },
-        { 0x3000, 0x2225 },
-        { 0x3001, 0x3a03 },
-        { 0x3002, 0x0225 },
-        { 0x3003, 0x0801 },
-        { 0x3004, 0x6249 },
-        { 0x3005, 0x0c04 },
-        { 0x3006, 0x0225 },
-        { 0x3007, 0x5901 },
-        { 0x3008, 0xe249 },
-        { 0x3009, 0x030d },
-        { 0x300a, 0x0249 },
-        { 0x300b, 0x2c01 },
-        { 0x300c, 0xe249 },
-        { 0x300d, 0x4342 },
-        { 0x300e, 0xe249 },
-        { 0x300f, 0x73c0 },
-        { 0x3010, 0x4249 },
-        { 0x3011, 0x0c00 },
-        { 0x3012, 0x0225 },
-        { 0x3013, 0x1f01 },
-        { 0x3014, 0x0225 },
-        { 0x3015, 0x1e01 },
-        { 0x3016, 0x0225 },
-        { 0x3017, 0xfa00 },
-        { 0x3018, 0x0000 },
-        { 0x3019, 0xf000 },
-        { 0x301a, 0x0000 },
-        { 0x301b, 0xf000 },
-        { 0x301c, 0x0000 },
-        { 0x301d, 0xf000 },
-        { 0x301e, 0x0000 },
-        { 0x301f, 0xf000 },
-        { 0x3020, 0x0000 },
-        { 0x3021, 0xf000 },
-        { 0x3022, 0x0000 },
-        { 0x3023, 0xf000 },
-        { 0x3024, 0x0000 },
-        { 0x3025, 0xf000 },
-        { 0x3026, 0x0000 },
-        { 0x3027, 0xf000 },
-        { 0x3028, 0x0000 },
-        { 0x3029, 0xf000 },
-        { 0x302a, 0x0000 },
-        { 0x302b, 0xf000 },
-        { 0x302c, 0x0000 },
-        { 0x302d, 0xf000 },
-        { 0x302e, 0x0000 },
-        { 0x302f, 0xf000 },
-        { 0x3030, 0x0225 },
-        { 0x3031, 0x1a01 },
-        { 0x3032, 0x0225 },
-        { 0x3033, 0x1e00 },
-        { 0x3034, 0x0225 },
-        { 0x3035, 0x1f00 },
-        { 0x3036, 0x6225 },
-        { 0x3037, 0xf800 },
-        { 0x3038, 0x0000 },
-        { 0x3039, 0xf000 },
-        { 0x303a, 0x0000 },
-        { 0x303b, 0xf000 },
-        { 0x303c, 0x0000 },
-        { 0x303d, 0xf000 },
-        { 0x303e, 0x0000 },
-        { 0x303f, 0xf000 },
-        { 0x3040, 0x2226 },
-        { 0x3041, 0x3a03 },
-        { 0x3042, 0x0226 },
-        { 0x3043, 0x0801 },
-        { 0x3044, 0x6249 },
-        { 0x3045, 0x0c06 },
-        { 0x3046, 0x0226 },
-        { 0x3047, 0x5901 },
-        { 0x3048, 0xe249 },
-        { 0x3049, 0x030d },
-        { 0x304a, 0x0249 },
-        { 0x304b, 0x2c01 },
-        { 0x304c, 0xe249 },
-        { 0x304d, 0x4342 },
-        { 0x304e, 0xe249 },
-        { 0x304f, 0x73c0 },
-        { 0x3050, 0x4249 },
-        { 0x3051, 0x0c00 },
-        { 0x3052, 0x0226 },
-        { 0x3053, 0x1f01 },
-        { 0x3054, 0x0226 },
-        { 0x3055, 0x1e01 },
-        { 0x3056, 0x0226 },
-        { 0x3057, 0xfa00 },
-        { 0x3058, 0x0000 },
-        { 0x3059, 0xf000 },
-        { 0x305a, 0x0000 },
-        { 0x305b, 0xf000 },
-        { 0x305c, 0x0000 },
-        { 0x305d, 0xf000 },
-        { 0x305e, 0x0000 },
-        { 0x305f, 0xf000 },
-        { 0x3060, 0x0000 },
-        { 0x3061, 0xf000 },
-        { 0x3062, 0x0000 },
-        { 0x3063, 0xf000 },
-        { 0x3064, 0x0000 },
-        { 0x3065, 0xf000 },
-        { 0x3066, 0x0000 },
-        { 0x3067, 0xf000 },
-        { 0x3068, 0x0000 },
-        { 0x3069, 0xf000 },
-        { 0x306a, 0x0000 },
-        { 0x306b, 0xf000 },
-        { 0x306c, 0x0000 },
-        { 0x306d, 0xf000 },
-        { 0x306e, 0x0000 },
-        { 0x306f, 0xf000 },
-        { 0x3070, 0x0226 },
-        { 0x3071, 0x1a01 },
-        { 0x3072, 0x0226 },
-        { 0x3073, 0x1e00 },
-        { 0x3074, 0x0226 },
-        { 0x3075, 0x1f00 },
-        { 0x3076, 0x6226 },
-        { 0x3077, 0xf800 },
-        { 0x3078, 0x0000 },
-        { 0x3079, 0xf000 },
-        { 0x307a, 0x0000 },
-        { 0x307b, 0xf000 },
-        { 0x307c, 0x0000 },
-        { 0x307d, 0xf000 },
-        { 0x307e, 0x0000 },
-        { 0x307f, 0xf000 },
-        { 0x3080, 0x2227 },
-        { 0x3081, 0x3a03 },
-        { 0x3082, 0x0227 },
-        { 0x3083, 0x0801 },
-        { 0x3084, 0x6255 },
-        { 0x3085, 0x0c04 },
-        { 0x3086, 0x0227 },
-        { 0x3087, 0x5901 },
-        { 0x3088, 0xe255 },
-        { 0x3089, 0x030d },
-        { 0x308a, 0x0255 },
-        { 0x308b, 0x2c01 },
-        { 0x308c, 0xe255 },
-        { 0x308d, 0x4342 },
-        { 0x308e, 0xe255 },
-        { 0x308f, 0x73c0 },
-        { 0x3090, 0x4255 },
-        { 0x3091, 0x0c00 },
-        { 0x3092, 0x0227 },
-        { 0x3093, 0x1f01 },
-        { 0x3094, 0x0227 },
-        { 0x3095, 0x1e01 },
-        { 0x3096, 0x0227 },
-        { 0x3097, 0xfa00 },
-        { 0x3098, 0x0000 },
-        { 0x3099, 0xf000 },
-        { 0x309a, 0x0000 },
-        { 0x309b, 0xf000 },
-        { 0x309c, 0x0000 },
-        { 0x309d, 0xf000 },
-        { 0x309e, 0x0000 },
-        { 0x309f, 0xf000 },
-        { 0x30a0, 0x0000 },
-        { 0x30a1, 0xf000 },
-        { 0x30a2, 0x0000 },
-        { 0x30a3, 0xf000 },
-        { 0x30a4, 0x0000 },
-        { 0x30a5, 0xf000 },
-        { 0x30a6, 0x0000 },
-        { 0x30a7, 0xf000 },
-        { 0x30a8, 0x0000 },
-        { 0x30a9, 0xf000 },
-        { 0x30aa, 0x0000 },
-        { 0x30ab, 0xf000 },
-        { 0x30ac, 0x0000 },
-        { 0x30ad, 0xf000 },
-        { 0x30ae, 0x0000 },
-        { 0x30af, 0xf000 },
-        { 0x30b0, 0x0227 },
-        { 0x30b1, 0x1a01 },
-        { 0x30b2, 0x0227 },
-        { 0x30b3, 0x1e00 },
-        { 0x30b4, 0x0227 },
-        { 0x30b5, 0x1f00 },
-        { 0x30b6, 0x6227 },
-        { 0x30b7, 0xf800 },
-        { 0x30b8, 0x0000 },
-        { 0x30b9, 0xf000 },
-        { 0x30ba, 0x0000 },
-        { 0x30bb, 0xf000 },
-        { 0x30bc, 0x0000 },
-        { 0x30bd, 0xf000 },
-        { 0x30be, 0x0000 },
-        { 0x30bf, 0xf000 },
-        { 0x30c0, 0x2228 },
-        { 0x30c1, 0x3a03 },
-        { 0x30c2, 0x0228 },
-        { 0x30c3, 0x0801 },
-        { 0x30c4, 0x6255 },
-        { 0x30c5, 0x0c06 },
-        { 0x30c6, 0x0228 },
-        { 0x30c7, 0x5901 },
-        { 0x30c8, 0xe255 },
-        { 0x30c9, 0x030d },
-        { 0x30ca, 0x0255 },
-        { 0x30cb, 0x2c01 },
-        { 0x30cc, 0xe255 },
-        { 0x30cd, 0x4342 },
-        { 0x30ce, 0xe255 },
-        { 0x30cf, 0x73c0 },
-        { 0x30d0, 0x4255 },
-        { 0x30d1, 0x0c00 },
-        { 0x30d2, 0x0228 },
-        { 0x30d3, 0x1f01 },
-        { 0x30d4, 0x0228 },
-        { 0x30d5, 0x1e01 },
-        { 0x30d6, 0x0228 },
-        { 0x30d7, 0xfa00 },
-        { 0x30d8, 0x0000 },
-        { 0x30d9, 0xf000 },
-        { 0x30da, 0x0000 },
-        { 0x30db, 0xf000 },
-        { 0x30dc, 0x0000 },
-        { 0x30dd, 0xf000 },
-        { 0x30de, 0x0000 },
-        { 0x30df, 0xf000 },
-        { 0x30e0, 0x0000 },
-        { 0x30e1, 0xf000 },
-        { 0x30e2, 0x0000 },
-        { 0x30e3, 0xf000 },
-        { 0x30e4, 0x0000 },
-        { 0x30e5, 0xf000 },
-        { 0x30e6, 0x0000 },
-        { 0x30e7, 0xf000 },
-        { 0x30e8, 0x0000 },
-        { 0x30e9, 0xf000 },
-        { 0x30ea, 0x0000 },
-        { 0x30eb, 0xf000 },
-        { 0x30ec, 0x0000 },
-        { 0x30ed, 0xf000 },
-        { 0x30ee, 0x0000 },
-        { 0x30ef, 0xf000 },
-        { 0x30f0, 0x0228 },
-        { 0x30f1, 0x1a01 },
-        { 0x30f2, 0x0228 },
-        { 0x30f3, 0x1e00 },
-        { 0x30f4, 0x0228 },
-        { 0x30f5, 0x1f00 },
-        { 0x30f6, 0x6228 },
-        { 0x30f7, 0xf800 },
-        { 0x30f8, 0x0000 },
-        { 0x30f9, 0xf000 },
-        { 0x30fa, 0x0000 },
-        { 0x30fb, 0xf000 },
-        { 0x30fc, 0x0000 },
-        { 0x30fd, 0xf000 },
-        { 0x30fe, 0x0000 },
-        { 0x30ff, 0xf000 },
-        { 0x3100, 0x222b },
-        { 0x3101, 0x3a03 },
-        { 0x3102, 0x222b },
-        { 0x3103, 0x5803 },
-        { 0x3104, 0xe26f },
-        { 0x3105, 0x030d },
-        { 0x3106, 0x626f },
-        { 0x3107, 0x2c01 },
-        { 0x3108, 0xe26f },
-        { 0x3109, 0x4342 },
-        { 0x310a, 0xe26f },
-        { 0x310b, 0x73c0 },
-        { 0x310c, 0x026f },
-        { 0x310d, 0x0c00 },
-        { 0x310e, 0x022b },
-        { 0x310f, 0x1f01 },
-        { 0x3110, 0x022b },
-        { 0x3111, 0x1e01 },
-        { 0x3112, 0x022b },
-        { 0x3113, 0xfa00 },
-        { 0x3114, 0x0000 },
-        { 0x3115, 0xf000 },
-        { 0x3116, 0x0000 },
-        { 0x3117, 0xf000 },
-        { 0x3118, 0x0000 },
-        { 0x3119, 0xf000 },
-        { 0x311a, 0x0000 },
-        { 0x311b, 0xf000 },
-        { 0x311c, 0x0000 },
-        { 0x311d, 0xf000 },
-        { 0x311e, 0x0000 },
-        { 0x311f, 0xf000 },
-        { 0x3120, 0x022b },
-        { 0x3121, 0x0a01 },
-        { 0x3122, 0x022b },
-        { 0x3123, 0x1e00 },
-        { 0x3124, 0x022b },
-        { 0x3125, 0x1f00 },
-        { 0x3126, 0x622b },
-        { 0x3127, 0xf800 },
-        { 0x3128, 0x0000 },
-        { 0x3129, 0xf000 },
-        { 0x312a, 0x0000 },
-        { 0x312b, 0xf000 },
-        { 0x312c, 0x0000 },
-        { 0x312d, 0xf000 },
-        { 0x312e, 0x0000 },
-        { 0x312f, 0xf000 },
-        { 0x3130, 0x0000 },
-        { 0x3131, 0xf000 },
-        { 0x3132, 0x0000 },
-        { 0x3133, 0xf000 },
-        { 0x3134, 0x0000 },
-        { 0x3135, 0xf000 },
-        { 0x3136, 0x0000 },
-        { 0x3137, 0xf000 },
-        { 0x3138, 0x0000 },
-        { 0x3139, 0xf000 },
-        { 0x313a, 0x0000 },
-        { 0x313b, 0xf000 },
-        { 0x313c, 0x0000 },
-        { 0x313d, 0xf000 },
-        { 0x313e, 0x0000 },
-        { 0x313f, 0xf000 },
-        { 0x3140, 0x0000 },
-        { 0x3141, 0xf000 },
-        { 0x3142, 0x0000 },
-        { 0x3143, 0xf000 },
-        { 0x3144, 0x0000 },
-        { 0x3145, 0xf000 },
-        { 0x3146, 0x0000 },
-        { 0x3147, 0xf000 },
-        { 0x3148, 0x0000 },
-        { 0x3149, 0xf000 },
-        { 0x314a, 0x0000 },
-        { 0x314b, 0xf000 },
-        { 0x314c, 0x0000 },
-        { 0x314d, 0xf000 },
-        { 0x314e, 0x0000 },
-        { 0x314f, 0xf000 },
-        { 0x3150, 0x0000 },
-        { 0x3151, 0xf000 },
-        { 0x3152, 0x0000 },
-        { 0x3153, 0xf000 },
-        { 0x3154, 0x0000 },
-        { 0x3155, 0xf000 },
-        { 0x3156, 0x0000 },
-        { 0x3157, 0xf000 },
-        { 0x3158, 0x0000 },
-        { 0x3159, 0xf000 },
-        { 0x315a, 0x0000 },
-        { 0x315b, 0xf000 },
-        { 0x315c, 0x0000 },
-        { 0x315d, 0xf000 },
-        { 0x315e, 0x0000 },
-        { 0x315f, 0xf000 },
-        { 0x3160, 0x0000 },
-        { 0x3161, 0xf000 },
-        { 0x3162, 0x0000 },
-        { 0x3163, 0xf000 },
-        { 0x3164, 0x0000 },
-        { 0x3165, 0xf000 },
-        { 0x3166, 0x0000 },
-        { 0x3167, 0xf000 },
-        { 0x3168, 0x0000 },
-        { 0x3169, 0xf000 },
-        { 0x316a, 0x0000 },
-        { 0x316b, 0xf000 },
-        { 0x316c, 0x0000 },
-        { 0x316d, 0xf000 },
-        { 0x316e, 0x0000 },
-        { 0x316f, 0xf000 },
-        { 0x3170, 0x0000 },
-        { 0x3171, 0xf000 },
-        { 0x3172, 0x0000 },
-        { 0x3173, 0xf000 },
-        { 0x3174, 0x0000 },
-        { 0x3175, 0xf000 },
-        { 0x3176, 0x0000 },
-        { 0x3177, 0xf000 },
-        { 0x3178, 0x0000 },
-        { 0x3179, 0xf000 },
-        { 0x317a, 0x0000 },
-        { 0x317b, 0xf000 },
-        { 0x317c, 0x0000 },
-        { 0x317d, 0xf000 },
-        { 0x317e, 0x0000 },
-        { 0x317f, 0xf000 },
-        { 0x3180, 0x2001 },
-        { 0x3181, 0xf101 },
-        { 0x3182, 0x0000 },
-        { 0x3183, 0xf000 },
-        { 0x3184, 0x0000 },
-        { 0x3185, 0xf000 },
-        { 0x3186, 0x0000 },
-        { 0x3187, 0xf000 },
-        { 0x3188, 0x0000 },
-        { 0x3189, 0xf000 },
-        { 0x318a, 0x0000 },
-        { 0x318b, 0xf000 },
-        { 0x318c, 0x0000 },
-        { 0x318d, 0xf000 },
-        { 0x318e, 0x0000 },
-        { 0x318f, 0xf000 },
-        { 0x3190, 0x0000 },
-        { 0x3191, 0xf000 },
-        { 0x3192, 0x0000 },
-        { 0x3193, 0xf000 },
-        { 0x3194, 0x0000 },
-        { 0x3195, 0xf000 },
-        { 0x3196, 0x0000 },
-        { 0x3197, 0xf000 },
-        { 0x3198, 0x0000 },
-        { 0x3199, 0xf000 },
-        { 0x319a, 0x0000 },
-        { 0x319b, 0xf000 },
-        { 0x319c, 0x0000 },
-        { 0x319d, 0xf000 },
-        { 0x319e, 0x0000 },
-        { 0x319f, 0xf000 },
-        { 0x31a0, 0x0000 },
-        { 0x31a1, 0xf000 },
-        { 0x31a2, 0x0000 },
-        { 0x31a3, 0xf000 },
-        { 0x31a4, 0x0000 },
-        { 0x31a5, 0xf000 },
-        { 0x31a6, 0x0000 },
-        { 0x31a7, 0xf000 },
-        { 0x31a8, 0x0000 },
-        { 0x31a9, 0xf000 },
-        { 0x31aa, 0x0000 },
-        { 0x31ab, 0xf000 },
-        { 0x31ac, 0x0000 },
-        { 0x31ad, 0xf000 },
-        { 0x31ae, 0x0000 },
-        { 0x31af, 0xf000 },
-        { 0x31b0, 0x0000 },
-        { 0x31b1, 0xf000 },
-        { 0x31b2, 0x0000 },
-        { 0x31b3, 0xf000 },
-        { 0x31b4, 0x0000 },
-        { 0x31b5, 0xf000 },
-        { 0x31b6, 0x0000 },
-        { 0x31b7, 0xf000 },
-        { 0x31b8, 0x0000 },
-        { 0x31b9, 0xf000 },
-        { 0x31ba, 0x0000 },
-        { 0x31bb, 0xf000 },
-        { 0x31bc, 0x0000 },
-        { 0x31bd, 0xf000 },
-        { 0x31be, 0x0000 },
-        { 0x31bf, 0xf000 },
-        { 0x31c0, 0x0000 },
-        { 0x31c1, 0xf000 },
-        { 0x31c2, 0x0000 },
-        { 0x31c3, 0xf000 },
-        { 0x31c4, 0x0000 },
-        { 0x31c5, 0xf000 },
-        { 0x31c6, 0x0000 },
-        { 0x31c7, 0xf000 },
-        { 0x31c8, 0x0000 },
-        { 0x31c9, 0xf000 },
-        { 0x31ca, 0x0000 },
-        { 0x31cb, 0xf000 },
-        { 0x31cc, 0x0000 },
-        { 0x31cd, 0xf000 },
-        { 0x31ce, 0x0000 },
-        { 0x31cf, 0xf000 },
-        { 0x31d0, 0x0000 },
-        { 0x31d1, 0xf000 },
-        { 0x31d2, 0x0000 },
-        { 0x31d3, 0xf000 },
-        { 0x31d4, 0x0000 },
-        { 0x31d5, 0xf000 },
-        { 0x31d6, 0x0000 },
-        { 0x31d7, 0xf000 },
-        { 0x31d8, 0x0000 },
-        { 0x31d9, 0xf000 },
-        { 0x31da, 0x0000 },
-        { 0x31db, 0xf000 },
-        { 0x31dc, 0x0000 },
-        { 0x31dd, 0xf000 },
-        { 0x31de, 0x0000 },
-        { 0x31df, 0xf000 },
-        { 0x31e0, 0x0000 },
-        { 0x31e1, 0xf000 },
-        { 0x31e2, 0x0000 },
-        { 0x31e3, 0xf000 },
-        { 0x31e4, 0x0000 },
-        { 0x31e5, 0xf000 },
-        { 0x31e6, 0x0000 },
-        { 0x31e7, 0xf000 },
-        { 0x31e8, 0x0000 },
-        { 0x31e9, 0xf000 },
-        { 0x31ea, 0x0000 },
-        { 0x31eb, 0xf000 },
-        { 0x31ec, 0x0000 },
-        { 0x31ed, 0xf000 },
-        { 0x31ee, 0x0000 },
-        { 0x31ef, 0xf000 },
-        { 0x31f0, 0x0000 },
-        { 0x31f1, 0xf000 },
-        { 0x31f2, 0x0000 },
-        { 0x31f3, 0xf000 },
-        { 0x31f4, 0x0000 },
-        { 0x31f5, 0xf000 },
-        { 0x31f6, 0x0000 },
-        { 0x31f7, 0xf000 },
-        { 0x31f8, 0x0000 },
-        { 0x31f9, 0xf000 },
-        { 0x31fa, 0x0000 },
-        { 0x31fb, 0xf000 },
-        { 0x31fc, 0x0000 },
-        { 0x31fd, 0xf000 },
-        { 0x31fe, 0x0000 },
-        { 0x31ff, 0xf000 },
-        { 0x024d, 0xff50 },
-        { 0x0252, 0xff50 },
-        { 0x0259, 0x0112 },
-        { 0x025e, 0x0112 },
-        { 0x101, 0x0304 },
         { 0x80, 0x0000 },
 };
 
diff --git a/drivers/mtd/devices/slram.c b/drivers/mtd/devices/slram.c
index 8f52fc858e48..5a5cd2ace4a6 100644
--- a/drivers/mtd/devices/slram.c
+++ b/drivers/mtd/devices/slram.c
@@ -240,7 +240,7 @@ static int parse_cmdline(char *devname, char *szstart, char *szlength)
 
         if (*(szlength) != '+') {
                 devlength = simple_strtoul(szlength, &buffer, 0);
-                devlength = handle_unit(devlength, buffer) - devstart;
+                devlength = handle_unit(devlength, buffer);
                 if (devlength < devstart)
                         goto err_out;
 
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index ec6841d8e956..1a03b7f673ce 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -2983,13 +2983,15 @@ static void nand_decode_ext_id(struct mtd_info *mtd, struct nand_chip *chip,
         /*
          * Field definitions are in the following datasheets:
          * Old style (4,5 byte ID): Samsung K9GAG08U0M (p.32)
-         * New style   (6 byte ID): Samsung K9GAG08U0F (p.44)
+         * New Samsung (6 byte ID): Samsung K9GAG08U0F (p.44)
          * Hynix MLC   (6 byte ID): Hynix H27UBG8T2B (p.22)
          *
-         * Check for ID length, cell type, and Hynix/Samsung ID to decide what
-         * to do.
+         * Check for ID length, non-zero 6th byte, cell type, and Hynix/Samsung
+         * ID to decide what to do.
          */
-        if (id_len == 6 && id_data[0] == NAND_MFR_SAMSUNG) {
+        if (id_len == 6 && id_data[0] == NAND_MFR_SAMSUNG &&
+                        (chip->cellinfo & NAND_CI_CELLTYPE_MSK) &&
+                        id_data[5] != 0x00) {
                 /* Calc pagesize */
                 mtd->writesize = 2048 << (extid & 0x03);
                 extid >>= 2;
diff --git a/drivers/mtd/ofpart.c b/drivers/mtd/ofpart.c
index 64be8f0848b0..d9127e2ed808 100644
--- a/drivers/mtd/ofpart.c
+++ b/drivers/mtd/ofpart.c
@@ -121,7 +121,7 @@ static int parse_ofoldpart_partitions(struct mtd_info *master,
         nr_parts = plen / sizeof(part[0]);
 
         *pparts = kzalloc(nr_parts * sizeof(*(*pparts)), GFP_KERNEL);
-        if (!pparts)
+        if (!*pparts)
                 return -ENOMEM;
 
         names = of_get_property(dp, "partition-names", &plen);
diff --git a/drivers/mtd/onenand/onenand_base.c b/drivers/mtd/onenand/onenand_base.c
index 7153e0d27101..b3f41f200622 100644
--- a/drivers/mtd/onenand/onenand_base.c
+++ b/drivers/mtd/onenand/onenand_base.c
@@ -3694,7 +3694,7 @@ static int flexonenand_check_blocks_erased(struct mtd_info *mtd, int start, int
  * flexonenand_set_boundary     - Writes the SLC boundary
  * @param mtd                   - mtd info structure
  */
-int flexonenand_set_boundary(struct mtd_info *mtd, int die,
+static int flexonenand_set_boundary(struct mtd_info *mtd, int die,
                                     int boundary, int lock)
 {
         struct onenand_chip *this = mtd->priv;
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index b2530b002125..a7d47350ea4b 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -1379,6 +1379,8 @@ static void bond_compute_features(struct bonding *bond)
         struct net_device *bond_dev = bond->dev;
         netdev_features_t vlan_features = BOND_VLAN_FEATURES;
         unsigned short max_hard_header_len = ETH_HLEN;
+        unsigned int gso_max_size = GSO_MAX_SIZE;
+        u16 gso_max_segs = GSO_MAX_SEGS;
         int i;
         unsigned int flags, dst_release_flag = IFF_XMIT_DST_RELEASE;
 
@@ -1394,11 +1396,16 @@ static void bond_compute_features(struct bonding *bond)
                 dst_release_flag &= slave->dev->priv_flags;
                 if (slave->dev->hard_header_len > max_hard_header_len)
                         max_hard_header_len = slave->dev->hard_header_len;
+
+                gso_max_size = min(gso_max_size, slave->dev->gso_max_size);
+                gso_max_segs = min(gso_max_segs, slave->dev->gso_max_segs);
         }
 
 done:
         bond_dev->vlan_features = vlan_features;
         bond_dev->hard_header_len = max_hard_header_len;
+        bond_dev->gso_max_segs = gso_max_segs;
+        netif_set_gso_max_size(bond_dev, gso_max_size);
 
         flags = bond_dev->priv_flags & ~IFF_XMIT_DST_RELEASE;
         bond_dev->priv_flags = flags | dst_release_flag;
@@ -3452,6 +3459,28 @@ static int bond_xmit_hash_policy_l34(struct sk_buff *skb, int count)
 
 /*-------------------------- Device entry points ----------------------------*/
 
+static void bond_work_init_all(struct bonding *bond)
+{
+        INIT_DELAYED_WORK(&bond->mcast_work,
+                          bond_resend_igmp_join_requests_delayed);
+        INIT_DELAYED_WORK(&bond->alb_work, bond_alb_monitor);
+        INIT_DELAYED_WORK(&bond->mii_work, bond_mii_monitor);
+        if (bond->params.mode == BOND_MODE_ACTIVEBACKUP)
+                INIT_DELAYED_WORK(&bond->arp_work, bond_activebackup_arp_mon);
+        else
+                INIT_DELAYED_WORK(&bond->arp_work, bond_loadbalance_arp_mon);
+        INIT_DELAYED_WORK(&bond->ad_work, bond_3ad_state_machine_handler);
+}
+
+static void bond_work_cancel_all(struct bonding *bond)
+{
+        cancel_delayed_work_sync(&bond->mii_work);
+        cancel_delayed_work_sync(&bond->arp_work);
+        cancel_delayed_work_sync(&bond->alb_work);
+        cancel_delayed_work_sync(&bond->ad_work);
+        cancel_delayed_work_sync(&bond->mcast_work);
+}
+
 static int bond_open(struct net_device *bond_dev)
 {
         struct bonding *bond = netdev_priv(bond_dev);
@@ -3474,41 +3503,27 @@ static int bond_open(struct net_device *bond_dev)
         }
         read_unlock(&bond->lock);
 
-        INIT_DELAYED_WORK(&bond->mcast_work, bond_resend_igmp_join_requests_delayed);
+        bond_work_init_all(bond);
 
         if (bond_is_lb(bond)) {
                 /* bond_alb_initialize must be called before the timer
                  * is started.
                  */
-                if (bond_alb_initialize(bond, (bond->params.mode == BOND_MODE_ALB))) {
-                        /* something went wrong - fail the open operation */
+                if (bond_alb_initialize(bond, (bond->params.mode == BOND_MODE_ALB)))
                         return -ENOMEM;
-                }
-
-                INIT_DELAYED_WORK(&bond->alb_work, bond_alb_monitor);
                 queue_delayed_work(bond->wq, &bond->alb_work, 0);
         }
 
-        if (bond->params.miimon) {  /* link check interval, in milliseconds. */
-                INIT_DELAYED_WORK(&bond->mii_work, bond_mii_monitor);
+        if (bond->params.miimon)  /* link check interval, in milliseconds. */
                 queue_delayed_work(bond->wq, &bond->mii_work, 0);
-        }
 
         if (bond->params.arp_interval) {  /* arp interval, in milliseconds. */
-                if (bond->params.mode == BOND_MODE_ACTIVEBACKUP)
-                        INIT_DELAYED_WORK(&bond->arp_work,
-                                          bond_activebackup_arp_mon);
-                else
-                        INIT_DELAYED_WORK(&bond->arp_work,
-                                          bond_loadbalance_arp_mon);
-
                 queue_delayed_work(bond->wq, &bond->arp_work, 0);
                 if (bond->params.arp_validate)
                         bond->recv_probe = bond_arp_rcv;
         }
 
         if (bond->params.mode == BOND_MODE_8023AD) {
-                INIT_DELAYED_WORK(&bond->ad_work, bond_3ad_state_machine_handler);
                 queue_delayed_work(bond->wq, &bond->ad_work, 0);
                 /* register to receive LACPDUs */
                 bond->recv_probe = bond_3ad_lacpdu_recv;
@@ -3523,34 +3538,10 @@ static int bond_close(struct net_device *bond_dev)
         struct bonding *bond = netdev_priv(bond_dev);
 
         write_lock_bh(&bond->lock);
-
         bond->send_peer_notif = 0;
-
         write_unlock_bh(&bond->lock);
 
-        if (bond->params.miimon) {  /* link check interval, in milliseconds. */
-                cancel_delayed_work_sync(&bond->mii_work);
-        }
-
-        if (bond->params.arp_interval) {  /* arp interval, in milliseconds. */
-                cancel_delayed_work_sync(&bond->arp_work);
-        }
-
-        switch (bond->params.mode) {
-        case BOND_MODE_8023AD:
-                cancel_delayed_work_sync(&bond->ad_work);
-                break;
-        case BOND_MODE_TLB:
-        case BOND_MODE_ALB:
-                cancel_delayed_work_sync(&bond->alb_work);
-                break;
-        default:
-                break;
-        }
-
-        if (delayed_work_pending(&bond->mcast_work))
-                cancel_delayed_work_sync(&bond->mcast_work);
-
+        bond_work_cancel_all(bond);
         if (bond_is_lb(bond)) {
                 /* Must be called only after all
                  * slaves have been released
@@ -4429,26 +4420,6 @@ static void bond_setup(struct net_device *bond_dev)
         bond_dev->features |= bond_dev->hw_features;
 }
 
-static void bond_work_cancel_all(struct bonding *bond)
-{
-        if (bond->params.miimon && delayed_work_pending(&bond->mii_work))
-                cancel_delayed_work_sync(&bond->mii_work);
-
-        if (bond->params.arp_interval && delayed_work_pending(&bond->arp_work))
-                cancel_delayed_work_sync(&bond->arp_work);
-
-        if (bond->params.mode == BOND_MODE_ALB &&
-            delayed_work_pending(&bond->alb_work))
-                cancel_delayed_work_sync(&bond->alb_work);
-
-        if (bond->params.mode == BOND_MODE_8023AD &&
-            delayed_work_pending(&bond->ad_work))
-                cancel_delayed_work_sync(&bond->ad_work);
-
-        if (delayed_work_pending(&bond->mcast_work))
-                cancel_delayed_work_sync(&bond->mcast_work);
-}
-
 /*
 * Destroy a bonding device.
 * Must be under rtnl_lock when this function is called.
@@ -4699,12 +4670,13 @@ static int bond_check_params(struct bond_params *params)
              arp_ip_count++) {
                 /* not complete check, but should be good enough to
                    catch mistakes */
-                if (!isdigit(arp_ip_target[arp_ip_count][0])) {
+                __be32 ip = in_aton(arp_ip_target[arp_ip_count]);
+                if (!isdigit(arp_ip_target[arp_ip_count][0]) ||
+                    ip == 0 || ip == htonl(INADDR_BROADCAST)) {
                         pr_warning("Warning: bad arp_ip_target module parameter (%s), ARP monitoring will not be performed\n",
                                    arp_ip_target[arp_ip_count]);
                         arp_interval = 0;
                 } else {
-                        __be32 ip = in_aton(arp_ip_target[arp_ip_count]);
                         arp_target[arp_ip_count] = ip;
                 }
         }
diff --git a/drivers/net/bonding/bond_sysfs.c b/drivers/net/bonding/bond_sysfs.c
index ef8d2a080d17..1877ed7ca086 100644
--- a/drivers/net/bonding/bond_sysfs.c
+++ b/drivers/net/bonding/bond_sysfs.c
@@ -513,6 +513,8 @@ static ssize_t bonding_store_arp_interval(struct device *d,
         int new_value, ret = count;
         struct bonding *bond = to_bond(d);
 
+        if (!rtnl_trylock())
+                return restart_syscall();
         if (sscanf(buf, "%d", &new_value) != 1) {
                 pr_err("%s: no arp_interval value specified.\n",
                        bond->dev->name);
@@ -539,10 +541,6 @@ static ssize_t bonding_store_arp_interval(struct device *d,
                 pr_info("%s: ARP monitoring cannot be used with MII monitoring. %s Disabling MII monitoring.\n",
                         bond->dev->name, bond->dev->name);
                 bond->params.miimon = 0;
-                if (delayed_work_pending(&bond->mii_work)) {
-                        cancel_delayed_work(&bond->mii_work);
-                        flush_workqueue(bond->wq);
-                }
         }
         if (!bond->params.arp_targets[0]) {
                 pr_info("%s: ARP monitoring has been set up, but no ARP targets have been specified.\n",
@@ -554,19 +552,12 @@ static ssize_t bonding_store_arp_interval(struct device *d,
                  * timer will get fired off when the open function
                  * is called.
                  */
-                if (!delayed_work_pending(&bond->arp_work)) {
-                        if (bond->params.mode == BOND_MODE_ACTIVEBACKUP)
-                                INIT_DELAYED_WORK(&bond->arp_work,
-                                                  bond_activebackup_arp_mon);
-                        else
-                                INIT_DELAYED_WORK(&bond->arp_work,
-                                                  bond_loadbalance_arp_mon);
-
-                        queue_delayed_work(bond->wq, &bond->arp_work, 0);
-                }
+                cancel_delayed_work_sync(&bond->mii_work);
+                queue_delayed_work(bond->wq, &bond->arp_work, 0);
         }
 
 out:
+        rtnl_unlock();
         return ret;
 }
 static DEVICE_ATTR(arp_interval, S_IRUGO | S_IWUSR,
@@ -962,6 +953,8 @@ static ssize_t bonding_store_miimon(struct device *d,
         int new_value, ret = count;
         struct bonding *bond = to_bond(d);
 
+        if (!rtnl_trylock())
+                return restart_syscall();
         if (sscanf(buf, "%d", &new_value) != 1) {
                 pr_err("%s: no miimon value specified.\n",
                        bond->dev->name);
@@ -993,10 +986,6 @@ static ssize_t bonding_store_miimon(struct device *d,
                                 bond->params.arp_validate =
                                         BOND_ARP_VALIDATE_NONE;
                         }
-                        if (delayed_work_pending(&bond->arp_work)) {
-                                cancel_delayed_work(&bond->arp_work);
-                                flush_workqueue(bond->wq);
-                        }
                 }
 
                 if (bond->dev->flags & IFF_UP) {
@@ -1005,15 +994,12 @@ static ssize_t bonding_store_miimon(struct device *d,
                          * timer will get fired off when the open function
                          * is called.
                          */
-                        if (!delayed_work_pending(&bond->mii_work)) {
-                                INIT_DELAYED_WORK(&bond->mii_work,
-                                                  bond_mii_monitor);
-                                queue_delayed_work(bond->wq,
-                                                   &bond->mii_work, 0);
-                        }
+                        cancel_delayed_work_sync(&bond->arp_work);
+                        queue_delayed_work(bond->wq, &bond->mii_work, 0);
                 }
         }
 out:
+        rtnl_unlock();
         return ret;
 }
 static DEVICE_ATTR(miimon, S_IRUGO | S_IWUSR,
@@ -1582,6 +1568,7 @@ static ssize_t bonding_store_slaves_active(struct device *d,
                 goto out;
         }
 
+        read_lock(&bond->lock);
         bond_for_each_slave(bond, slave, i) {
                 if (!bond_is_active_slave(slave)) {
                         if (new_value)
@@ -1590,6 +1577,7 @@ static ssize_t bonding_store_slaves_active(struct device *d,
                                 slave->inactive = 1;
                 }
         }
+        read_unlock(&bond->lock);
 out:
         return ret;
 }
diff --git a/drivers/net/can/usb/peak_usb/pcan_usb.c b/drivers/net/can/usb/peak_usb/pcan_usb.c
index 86f26a1ede4c..25723d8ee201 100644
--- a/drivers/net/can/usb/peak_usb/pcan_usb.c
+++ b/drivers/net/can/usb/peak_usb/pcan_usb.c
@@ -519,8 +519,10 @@ static int pcan_usb_decode_error(struct pcan_usb_msg_context *mc, u8 n,
         mc->pdev->dev.can.state = new_state;
 
         if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) {
+                struct skb_shared_hwtstamps *hwts = skb_hwtstamps(skb);
+
                 peak_usb_get_ts_tv(&mc->pdev->time_ref, mc->ts16, &tv);
-                skb->tstamp = timeval_to_ktime(tv);
+                hwts->hwtstamp = timeval_to_ktime(tv);
         }
 
         netif_rx(skb);
@@ -605,6 +607,7 @@ static int pcan_usb_decode_data(struct pcan_usb_msg_context *mc, u8 status_len)
         struct sk_buff *skb;
         struct can_frame *cf;
         struct timeval tv;
+        struct skb_shared_hwtstamps *hwts;
 
         skb = alloc_can_skb(mc->netdev, &cf);
         if (!skb)
@@ -652,7 +655,8 @@ static int pcan_usb_decode_data(struct pcan_usb_msg_context *mc, u8 status_len)
 
         /* convert timestamp into kernel time */
         peak_usb_get_ts_tv(&mc->pdev->time_ref, mc->ts16, &tv);
-        skb->tstamp = timeval_to_ktime(tv);
+        hwts = skb_hwtstamps(skb);
+        hwts->hwtstamp = timeval_to_ktime(tv);
 
         /* push the skb */
         netif_rx(skb);
diff --git a/drivers/net/can/usb/peak_usb/pcan_usb_pro.c b/drivers/net/can/usb/peak_usb/pcan_usb_pro.c
index e1626d92511a..30d79bfa5b10 100644
--- a/drivers/net/can/usb/peak_usb/pcan_usb_pro.c
+++ b/drivers/net/can/usb/peak_usb/pcan_usb_pro.c
@@ -532,6 +532,7 @@ static int pcan_usb_pro_handle_canmsg(struct pcan_usb_pro_interface *usb_if,
         struct can_frame *can_frame;
         struct sk_buff *skb;
         struct timeval tv;
+        struct skb_shared_hwtstamps *hwts;
 
         skb = alloc_can_skb(netdev, &can_frame);
         if (!skb)
@@ -549,7 +550,8 @@ static int pcan_usb_pro_handle_canmsg(struct pcan_usb_pro_interface *usb_if,
                 memcpy(can_frame->data, rx->data, can_frame->can_dlc);
 
         peak_usb_get_ts_tv(&usb_if->time_ref, le32_to_cpu(rx->ts32), &tv);
-        skb->tstamp = timeval_to_ktime(tv);
+        hwts = skb_hwtstamps(skb);
+        hwts->hwtstamp = timeval_to_ktime(tv);
 
         netif_rx(skb);
         netdev->stats.rx_packets++;
@@ -570,6 +572,7 @@ static int pcan_usb_pro_handle_error(struct pcan_usb_pro_interface *usb_if,
         u8 err_mask = 0;
         struct sk_buff *skb;
         struct timeval tv;
+        struct skb_shared_hwtstamps *hwts;
 
         /* nothing should be sent while in BUS_OFF state */
         if (dev->can.state == CAN_STATE_BUS_OFF)
@@ -664,7 +667,8 @@ static int pcan_usb_pro_handle_error(struct pcan_usb_pro_interface *usb_if,
         dev->can.state = new_state;
 
         peak_usb_get_ts_tv(&usb_if->time_ref, le32_to_cpu(er->ts32), &tv);
-        skb->tstamp = timeval_to_ktime(tv);
+        hwts = skb_hwtstamps(skb);
+        hwts->hwtstamp = timeval_to_ktime(tv);
         netif_rx(skb);
         netdev->stats.rx_packets++;
         netdev->stats.rx_bytes += can_frame->can_dlc;
diff --git a/drivers/net/ethernet/8390/ne.c b/drivers/net/ethernet/8390/ne.c
index d04911d33b64..47618e505355 100644
--- a/drivers/net/ethernet/8390/ne.c
+++ b/drivers/net/ethernet/8390/ne.c
@@ -813,6 +813,7 @@ static int __init ne_drv_probe(struct platform_device *pdev)
                 dev->irq = irq[this_dev];
                 dev->mem_end = bad[this_dev];
         }
+        SET_NETDEV_DEV(dev, &pdev->dev);
         err = do_ne_probe(dev);
         if (err) {
                 free_netdev(dev);
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
index bd1fd3d87c24..01611b33a93d 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
@@ -9545,10 +9545,13 @@ static int __devinit bnx2x_prev_unload_common(struct bnx2x *bp)
  */
 static void __devinit bnx2x_prev_interrupted_dmae(struct bnx2x *bp)
 {
-        u32 val = REG_RD(bp, PGLUE_B_REG_PGLUE_B_INT_STS);
-        if (val & PGLUE_B_PGLUE_B_INT_STS_REG_WAS_ERROR_ATTN) {
-                BNX2X_ERR("was error bit was found to be set in pglueb upon startup. Clearing");
-                REG_WR(bp, PGLUE_B_REG_WAS_ERROR_PF_7_0_CLR, 1 << BP_FUNC(bp));
+        if (!CHIP_IS_E1x(bp)) {
+                u32 val = REG_RD(bp, PGLUE_B_REG_PGLUE_B_INT_STS);
+                if (val & PGLUE_B_PGLUE_B_INT_STS_REG_WAS_ERROR_ATTN) {
+                        BNX2X_ERR("was error bit was found to be set in pglueb upon startup. Clearing");
+                        REG_WR(bp, PGLUE_B_REG_WAS_ERROR_PF_7_0_CLR,
+                               1 << BP_FUNC(bp));
+                }
         }
 }
 
diff --git a/drivers/net/ethernet/jme.c b/drivers/net/ethernet/jme.c
index 92317e9c0f73..60ac46f4ac08 100644
--- a/drivers/net/ethernet/jme.c
+++ b/drivers/net/ethernet/jme.c
@@ -1860,10 +1860,14 @@ jme_open(struct net_device *netdev)
         jme_clear_pm(jme);
         JME_NAPI_ENABLE(jme);
 
-        tasklet_enable(&jme->linkch_task);
-        tasklet_enable(&jme->txclean_task);
-        tasklet_hi_enable(&jme->rxclean_task);
-        tasklet_hi_enable(&jme->rxempty_task);
+        tasklet_init(&jme->linkch_task, jme_link_change_tasklet,
+                     (unsigned long) jme);
+        tasklet_init(&jme->txclean_task, jme_tx_clean_tasklet,
+                     (unsigned long) jme);
+        tasklet_init(&jme->rxclean_task, jme_rx_clean_tasklet,
+                     (unsigned long) jme);
+        tasklet_init(&jme->rxempty_task, jme_rx_empty_tasklet,
+                     (unsigned long) jme);
 
         rc = jme_request_irq(jme);
         if (rc)
@@ -3079,22 +3083,6 @@ jme_init_one(struct pci_dev *pdev,
         tasklet_init(&jme->pcc_task,
                      jme_pcc_tasklet,
                      (unsigned long) jme);
-        tasklet_init(&jme->linkch_task,
-                     jme_link_change_tasklet,
-                     (unsigned long) jme);
-        tasklet_init(&jme->txclean_task,
-                     jme_tx_clean_tasklet,
-                     (unsigned long) jme);
-        tasklet_init(&jme->rxclean_task,
-                     jme_rx_clean_tasklet,
-                     (unsigned long) jme);
-        tasklet_init(&jme->rxempty_task,
-                     jme_rx_empty_tasklet,
-                     (unsigned long) jme);
-        tasklet_disable_nosync(&jme->linkch_task);
-        tasklet_disable_nosync(&jme->txclean_task);
-        tasklet_disable_nosync(&jme->rxclean_task);
-        tasklet_disable_nosync(&jme->rxempty_task);
         jme->dpi.cur = PCC_P1;
 
         jme->reg_ghc = 0;
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_dcb_nl.c b/drivers/net/ethernet/mellanox/mlx4/en_dcb_nl.c
index 5d36795877cb..b799ab12a291 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_dcb_nl.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_dcb_nl.c
@@ -237,7 +237,7 @@ static int mlx4_en_dcbnl_ieee_setmaxrate(struct net_device *dev,
         if (err)
                 return err;
 
-        memcpy(priv->maxrate, tmp, sizeof(*priv->maxrate));
+        memcpy(priv->maxrate, tmp, sizeof(priv->maxrate));
 
         return 0;
 }
diff --git a/drivers/net/ethernet/micrel/ksz884x.c b/drivers/net/ethernet/micrel/ksz884x.c
index e558edd1cb6c..69e01977a1dd 100644
--- a/drivers/net/ethernet/micrel/ksz884x.c
+++ b/drivers/net/ethernet/micrel/ksz884x.c
@@ -5459,8 +5459,10 @@ static int prepare_hardware(struct net_device *dev)
         rc = request_irq(dev->irq, netdev_intr, IRQF_SHARED, dev->name, dev);
         if (rc)
                 return rc;
-        tasklet_enable(&hw_priv->rx_tasklet);
-        tasklet_enable(&hw_priv->tx_tasklet);
+        tasklet_init(&hw_priv->rx_tasklet, rx_proc_task,
+                     (unsigned long) hw_priv);
+        tasklet_init(&hw_priv->tx_tasklet, tx_proc_task,
+                     (unsigned long) hw_priv);
 
         hw->promiscuous = 0;
         hw->all_multi = 0;
@@ -7033,16 +7035,6 @@ static int __devinit pcidev_init(struct pci_dev *pdev,
         spin_lock_init(&hw_priv->hwlock);
         mutex_init(&hw_priv->lock);
 
-        /* tasklet is enabled. */
-        tasklet_init(&hw_priv->rx_tasklet, rx_proc_task,
-                (unsigned long) hw_priv);
-        tasklet_init(&hw_priv->tx_tasklet, tx_proc_task,
-                (unsigned long) hw_priv);
-
-        /* tasklet_enable will decrement the atomic counter. */
-        tasklet_disable(&hw_priv->rx_tasklet);
-        tasklet_disable(&hw_priv->tx_tasklet);
-
         for (i = 0; i < TOTAL_PORT_NUM; i++)
                 init_waitqueue_head(&hw_priv->counter[i].counter);
 
diff --git a/drivers/net/ethernet/realtek/8139cp.c b/drivers/net/ethernet/realtek/8139cp.c
index 1c818254b7be..609125a249d9 100644
--- a/drivers/net/ethernet/realtek/8139cp.c
+++ b/drivers/net/ethernet/realtek/8139cp.c
@@ -979,17 +979,6 @@ static void cp_init_hw (struct cp_private *cp)
         cpw32_f (MAC0 + 0, le32_to_cpu (*(__le32 *) (dev->dev_addr + 0)));
         cpw32_f (MAC0 + 4, le32_to_cpu (*(__le32 *) (dev->dev_addr + 4)));
 
-        cpw32_f(HiTxRingAddr, 0);
-        cpw32_f(HiTxRingAddr + 4, 0);
-
-        ring_dma = cp->ring_dma;
-        cpw32_f(RxRingAddr, ring_dma & 0xffffffff);
-        cpw32_f(RxRingAddr + 4, (ring_dma >> 16) >> 16);
-
-        ring_dma += sizeof(struct cp_desc) * CP_RX_RING_SIZE;
-        cpw32_f(TxRingAddr, ring_dma & 0xffffffff);
-        cpw32_f(TxRingAddr + 4, (ring_dma >> 16) >> 16);
-
         cp_start_hw(cp);
         cpw8(TxThresh, 0x06); /* XXX convert magic num to a constant */
 
@@ -1003,6 +992,17 @@ static void cp_init_hw (struct cp_private *cp)
 
         cpw8(Config5, cpr8(Config5) & PMEStatus);
 
+        cpw32_f(HiTxRingAddr, 0);
+        cpw32_f(HiTxRingAddr + 4, 0);
+
+        ring_dma = cp->ring_dma;
+        cpw32_f(RxRingAddr, ring_dma & 0xffffffff);
+        cpw32_f(RxRingAddr + 4, (ring_dma >> 16) >> 16);
+
+        ring_dma += sizeof(struct cp_desc) * CP_RX_RING_SIZE;
+        cpw32_f(TxRingAddr, ring_dma & 0xffffffff);
+        cpw32_f(TxRingAddr + 4, (ring_dma >> 16) >> 16);
+
         cpw16(MultiIntr, 0);
 
         cpw8_f(Cfg9346, Cfg9346_Lock);
@@ -1060,17 +1060,22 @@ static int cp_init_rings (struct cp_private *cp)
 
 static int cp_alloc_rings (struct cp_private *cp)
 {
+        struct device *d = &cp->pdev->dev;
         void *mem;
+        int rc;
 
-        mem = dma_alloc_coherent(&cp->pdev->dev, CP_RING_BYTES,
-                                 &cp->ring_dma, GFP_KERNEL);
+        mem = dma_alloc_coherent(d, CP_RING_BYTES, &cp->ring_dma, GFP_KERNEL);
         if (!mem)
                 return -ENOMEM;
 
         cp->rx_ring = mem;
         cp->tx_ring = &cp->rx_ring[CP_RX_RING_SIZE];
 
-        return cp_init_rings(cp);
+        rc = cp_init_rings(cp);
+        if (rc < 0)
+                dma_free_coherent(d, CP_RING_BYTES, cp->rx_ring, cp->ring_dma);
+
+        return rc;
 }
 
 static void cp_clean_rings (struct cp_private *cp)
diff --git a/drivers/net/ethernet/sis/sis900.c b/drivers/net/ethernet/sis/sis900.c
index fb9f6b38511f..edf5edb13140 100644
--- a/drivers/net/ethernet/sis/sis900.c
+++ b/drivers/net/ethernet/sis/sis900.c
@@ -2479,7 +2479,7 @@ static int sis900_resume(struct pci_dev *pci_dev)
         netif_start_queue(net_dev);
 
         /* Workaround for EDB */
-        sis900_set_mode(ioaddr, HW_SPEED_10_MBPS, FDX_CAPABLE_HALF_SELECTED);
+        sis900_set_mode(sis_priv, HW_SPEED_10_MBPS, FDX_CAPABLE_HALF_SELECTED);
 
         /* Enable all known interrupts by setting the interrupt mask. */
         sw32(imr, RxSOVR | RxORN | RxERR | RxOK | TxURN | TxERR | TxIDLE);
diff --git a/drivers/net/ethernet/smsc/smsc911x.c b/drivers/net/ethernet/smsc/smsc911x.c
index 62d1baf111ea..c53c0f4e2ce3 100644
--- a/drivers/net/ethernet/smsc/smsc911x.c
+++ b/drivers/net/ethernet/smsc/smsc911x.c
@@ -2110,7 +2110,7 @@ static void __devinit smsc911x_read_mac_address(struct net_device *dev)
 static int __devinit smsc911x_init(struct net_device *dev)
 {
         struct smsc911x_data *pdata = netdev_priv(dev);
-        unsigned int byte_test;
+        unsigned int byte_test, mask;
         unsigned int to = 100;
 
         SMSC_TRACE(pdata, probe, "Driver Parameters:");
@@ -2130,9 +2130,22 @@ static int __devinit smsc911x_init(struct net_device *dev)
         /*
          * poll the READY bit in PMT_CTRL. Any other access to the device is
          * forbidden while this bit isn't set. Try for 100ms
+         *
+         * Note that this test is done before the WORD_SWAP register is
+         * programmed. So in some configurations the READY bit is at 16 before
+         * WORD_SWAP is written to. This issue is worked around by waiting
+         * until either bit 0 or bit 16 gets set in PMT_CTRL.
+         *
+         * SMSC has confirmed that checking bit 16 (marked as reserved in
+         * the datasheet) is fine since these bits "will either never be set
+         * or can only go high after READY does (so also indicate the device
+         * is ready)".
          */
-        while (!(smsc911x_reg_read(pdata, PMT_CTRL) & PMT_CTRL_READY_) && --to)
+
+        mask = PMT_CTRL_READY_ | swahw32(PMT_CTRL_READY_);
+        while (!(smsc911x_reg_read(pdata, PMT_CTRL) & mask) && --to)
                 udelay(1000);
+
         if (to == 0) {
                 pr_err("Device not READY in 100ms aborting\n");
                 return -ENODEV;
diff --git a/drivers/net/ethernet/tile/tilegx.c b/drivers/net/ethernet/tile/tilegx.c
index 4e9810013850..66e025ad5df1 100644
--- a/drivers/net/ethernet/tile/tilegx.c
+++ b/drivers/net/ethernet/tile/tilegx.c
@@ -917,7 +917,7 @@ static int tile_net_setup_interrupts(struct net_device *dev)
         ingress_irq = rc;
         tile_irq_activate(ingress_irq, TILE_IRQ_PERCPU);
         rc = request_irq(ingress_irq, tile_net_handle_ingress_irq,
-                         0, NULL, NULL);
+                         0, "tile_net", NULL);
         if (rc != 0) {
                 netdev_err(dev, "request_irq failed: %d\n", rc);
                 destroy_irq(ingress_irq);
diff --git a/drivers/net/ethernet/xilinx/xilinx_axienet_main.c b/drivers/net/ethernet/xilinx/xilinx_axienet_main.c
index 1d04754a6637..a788501e978e 100644
--- a/drivers/net/ethernet/xilinx/xilinx_axienet_main.c
+++ b/drivers/net/ethernet/xilinx/xilinx_axienet_main.c
@@ -894,6 +894,8 @@ out:
         return IRQ_HANDLED;
 }
 
+static void axienet_dma_err_handler(unsigned long data);
+
 /**
  * axienet_open - Driver open routine.
  * @ndev:       Pointer to net_device structure
@@ -942,6 +944,10 @@ static int axienet_open(struct net_device *ndev)
                 phy_start(lp->phy_dev);
         }
 
+        /* Enable tasklets for Axi DMA error handling */
+        tasklet_init(&lp->dma_err_tasklet, axienet_dma_err_handler,
+                     (unsigned long) lp);
+
         /* Enable interrupts for Axi DMA Tx */
         ret = request_irq(lp->tx_irq, axienet_tx_irq, 0, ndev->name, ndev);
         if (ret)
@@ -950,8 +956,7 @@ static int axienet_open(struct net_device *ndev)
         ret = request_irq(lp->rx_irq, axienet_rx_irq, 0, ndev->name, ndev);
         if (ret)
                 goto err_rx_irq;
-        /* Enable tasklets for Axi DMA error handling */
-        tasklet_enable(&lp->dma_err_tasklet);
+
         return 0;
 
 err_rx_irq:
@@ -960,6 +965,7 @@ err_tx_irq:
         if (lp->phy_dev)
                 phy_disconnect(lp->phy_dev);
         lp->phy_dev = NULL;
+        tasklet_kill(&lp->dma_err_tasklet);
         dev_err(lp->dev, "request_irq() failed\n");
         return ret;
 }
@@ -1613,10 +1619,6 @@ static int __devinit axienet_of_probe(struct platform_device *op)
                 goto err_iounmap_2;
         }
 
-        tasklet_init(&lp->dma_err_tasklet, axienet_dma_err_handler,
-                     (unsigned long) lp);
-        tasklet_disable(&lp->dma_err_tasklet);
-
         return 0;
 
 err_iounmap_2:
diff --git a/drivers/net/ethernet/xscale/ixp4xx_eth.c b/drivers/net/ethernet/xscale/ixp4xx_eth.c
index 98934bdf6acf..477d6729b17f 100644
--- a/drivers/net/ethernet/xscale/ixp4xx_eth.c
+++ b/drivers/net/ethernet/xscale/ixp4xx_eth.c
@@ -1102,10 +1102,12 @@ static int init_queues(struct port *port)
 {
         int i;
 
-        if (!ports_open)
-                if (!(dma_pool = dma_pool_create(DRV_NAME, NULL,
-                                                 POOL_ALLOC_SIZE, 32, 0)))
+        if (!ports_open) {
+                dma_pool = dma_pool_create(DRV_NAME, &port->netdev->dev,
+                                           POOL_ALLOC_SIZE, 32, 0);
+                if (!dma_pool)
                         return -ENOMEM;
+        }
 
         if (!(port->desc_tab = dma_pool_alloc(dma_pool, GFP_KERNEL,
                                               &port->desc_tab_phys)))
diff --git a/drivers/net/irda/sir_dev.c b/drivers/net/irda/sir_dev.c
index 5039f08f5a5b..43e9ab4f4d7e 100644
--- a/drivers/net/irda/sir_dev.c
+++ b/drivers/net/irda/sir_dev.c
@@ -222,7 +222,7 @@ static void sirdev_config_fsm(struct work_struct *work)
                         break;
 
                 case SIRDEV_STATE_DONGLE_SPEED:
-                        if (dev->dongle_drv->reset) {
+                        if (dev->dongle_drv->set_speed) {
                                 ret = dev->dongle_drv->set_speed(dev, fsm->param);
                                 if (ret < 0) {
                                         fsm->result = ret;
diff --git a/drivers/net/phy/mdio-bitbang.c b/drivers/net/phy/mdio-bitbang.c
index 6428fcbbdd4b..daec9b05d168 100644
--- a/drivers/net/phy/mdio-bitbang.c
+++ b/drivers/net/phy/mdio-bitbang.c
@@ -234,7 +234,6 @@ void free_mdio_bitbang(struct mii_bus *bus)
         struct mdiobb_ctrl *ctrl = bus->priv;
 
         module_put(ctrl->ops->owner);
-        mdiobus_unregister(bus);
         mdiobus_free(bus);
 }
 EXPORT_SYMBOL(free_mdio_bitbang);
diff --git a/drivers/net/phy/mdio-gpio.c b/drivers/net/phy/mdio-gpio.c
index 899274f2f9b1..2ed1140df3e9 100644
--- a/drivers/net/phy/mdio-gpio.c
+++ b/drivers/net/phy/mdio-gpio.c
@@ -185,17 +185,20 @@ static int __devinit mdio_gpio_probe(struct platform_device *pdev)
 {
         struct mdio_gpio_platform_data *pdata;
         struct mii_bus *new_bus;
-        int ret;
+        int ret, bus_id;
 
-        if (pdev->dev.of_node)
+        if (pdev->dev.of_node) {
                 pdata = mdio_gpio_of_get_data(pdev);
-        else
+                bus_id = of_alias_get_id(pdev->dev.of_node, "mdio-gpio");
+        } else {
                 pdata = pdev->dev.platform_data;
+                bus_id = pdev->id;
+        }
 
         if (!pdata)
                 return -ENODEV;
 
-        new_bus = mdio_gpio_bus_init(&pdev->dev, pdata, pdev->id);
+        new_bus = mdio_gpio_bus_init(&pdev->dev, pdata, bus_id);
         if (!new_bus)
                 return -ENODEV;
 
diff --git a/drivers/net/team/team.c b/drivers/net/team/team.c
index d44cca327588..ad86660fb8f9 100644
--- a/drivers/net/team/team.c
+++ b/drivers/net/team/team.c
@@ -1794,10 +1794,12 @@ static void team_setup(struct net_device *dev)
 
         dev->features |= NETIF_F_LLTX;
         dev->features |= NETIF_F_GRO;
-        dev->hw_features = NETIF_F_HW_VLAN_TX |
+        dev->hw_features = TEAM_VLAN_FEATURES |
+                           NETIF_F_HW_VLAN_TX |
                            NETIF_F_HW_VLAN_RX |
                            NETIF_F_HW_VLAN_FILTER;
 
+        dev->hw_features &= ~(NETIF_F_ALL_CSUM & ~NETIF_F_HW_CSUM);
         dev->features |= dev->hw_features;
 }
 
diff --git a/drivers/net/team/team_mode_broadcast.c b/drivers/net/team/team_mode_broadcast.c
index 9db0171e9366..c5db428e73fa 100644
--- a/drivers/net/team/team_mode_broadcast.c
+++ b/drivers/net/team/team_mode_broadcast.c
@@ -29,8 +29,8 @@ static bool bc_transmit(struct team *team, struct sk_buff *skb)
                         if (last) {
                                 skb2 = skb_clone(skb, GFP_ATOMIC);
                                 if (skb2) {
-                                        ret = team_dev_queue_xmit(team, last,
-                                                                  skb2);
+                                        ret = !team_dev_queue_xmit(team, last,
+                                                                   skb2);
                                         if (!sum_ret)
                                                 sum_ret = ret;
                                 }
@@ -39,7 +39,7 @@ static bool bc_transmit(struct team *team, struct sk_buff *skb)
                 }
         }
         if (last) {
-                ret = team_dev_queue_xmit(team, last, skb);
+                ret = !team_dev_queue_xmit(team, last, skb);
                 if (!sum_ret)
                         sum_ret = ret;
         }
diff --git a/drivers/net/usb/cdc_ncm.c b/drivers/net/usb/cdc_ncm.c
index 4cd582a4f625..74fab1a40156 100644
--- a/drivers/net/usb/cdc_ncm.c
+++ b/drivers/net/usb/cdc_ncm.c
@@ -540,10 +540,12 @@ advance:
             (ctx->ether_desc == NULL) || (ctx->control != intf))
                 goto error;
 
-        /* claim interfaces, if any */
-        temp = usb_driver_claim_interface(driver, ctx->data, dev);
-        if (temp)
-                goto error;
+        /* claim data interface, if different from control */
+        if (ctx->data != ctx->control) {
+                temp = usb_driver_claim_interface(driver, ctx->data, dev);
+                if (temp)
+                        goto error;
+        }
 
         iface_no = ctx->data->cur_altsetting->desc.bInterfaceNumber;
 
@@ -623,6 +625,10 @@ static void cdc_ncm_unbind(struct usbnet *dev, struct usb_interface *intf)
 
         tasklet_kill(&ctx->bh);
 
+        /* handle devices with combined control and data interface */
+        if (ctx->control == ctx->data)
+                ctx->data = NULL;
+
         /* disconnect master --> disconnect slave */
         if (intf == ctx->control && ctx->data) {
                 usb_set_intfdata(ctx->data, NULL);
@@ -1245,6 +1251,14 @@ static const struct usb_device_id cdc_devs[] = {
           .driver_info = (unsigned long) &wwan_info,
         },
 
+        /* Huawei NCM devices disguised as vendor specific */
+        { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x16),
+          .driver_info = (unsigned long)&wwan_info,
+        },
+        { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x46),
+          .driver_info = (unsigned long)&wwan_info,
+        },
+
         /* Generic CDC-NCM devices */
         { USB_INTERFACE_INFO(USB_CLASS_COMM,
                 USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE),
diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c
index 3b566fa0f8e6..1ea91f4237f0 100644
--- a/drivers/net/usb/qmi_wwan.c
+++ b/drivers/net/usb/qmi_wwan.c
@@ -385,6 +385,7 @@ static const struct usb_device_id products[] = {
         },
 
         /* 3. Combined interface devices matching on interface number */
+        {QMI_FIXED_INTF(0x12d1, 0x140c, 1)},    /* Huawei E173 */
         {QMI_FIXED_INTF(0x19d2, 0x0002, 1)},
         {QMI_FIXED_INTF(0x19d2, 0x0012, 1)},
         {QMI_FIXED_INTF(0x19d2, 0x0017, 3)},
diff --git a/drivers/net/usb/smsc95xx.c b/drivers/net/usb/smsc95xx.c
index 3286166415b4..362cb8cfeb92 100644
--- a/drivers/net/usb/smsc95xx.c
+++ b/drivers/net/usb/smsc95xx.c
@@ -184,7 +184,7 @@ static int smsc95xx_mdio_read(struct net_device *netdev, int phy_id, int idx)
         /* set the address, index & direction (read from PHY) */
         phy_id &= dev->mii.phy_id_mask;
         idx &= dev->mii.reg_num_mask;
-        addr = (phy_id << 11) | (idx << 6) | MII_READ_;
+        addr = (phy_id << 11) | (idx << 6) | MII_READ_ | MII_BUSY_;
         ret = smsc95xx_write_reg(dev, MII_ADDR, addr);
         check_warn_goto_done(ret, "Error writing MII_ADDR");
 
@@ -221,7 +221,7 @@ static void smsc95xx_mdio_write(struct net_device *netdev, int phy_id, int idx,
         /* set the address, index & direction (write to PHY) */
         phy_id &= dev->mii.phy_id_mask;
         idx &= dev->mii.reg_num_mask;
-        addr = (phy_id << 11) | (idx << 6) | MII_WRITE_;
+        addr = (phy_id << 11) | (idx << 6) | MII_WRITE_ | MII_BUSY_;
         ret = smsc95xx_write_reg(dev, MII_ADDR, addr);
         check_warn_goto_done(ret, "Error writing MII_ADDR");
 
diff --git a/drivers/net/vxlan.c b/drivers/net/vxlan.c
index 7b4adde93c01..8b5c61917076 100644
--- a/drivers/net/vxlan.c
+++ b/drivers/net/vxlan.c
@@ -1,5 +1,5 @@
 /*
- * VXLAN: Virtual eXtensiable Local Area Network
+ * VXLAN: Virtual eXtensible Local Area Network
  *
  * Copyright (c) 2012 Vyatta Inc.
  *
@@ -50,8 +50,8 @@
 
 #define VXLAN_N_VID     (1u << 24)
 #define VXLAN_VID_MASK  (VXLAN_N_VID - 1)
-/* VLAN + IP header + UDP + VXLAN */
-#define VXLAN_HEADROOM (4 + 20 + 8 + 8)
+/* IP header + UDP + VXLAN + Ethernet header */
+#define VXLAN_HEADROOM (20 + 8 + 8 + 14)
 
 #define VXLAN_FLAGS 0x08000000  /* struct vxlanhdr.vx_flags required value. */
 
@@ -1102,6 +1102,10 @@ static int vxlan_newlink(struct net *net, struct net_device *dev,
 
                 if (!tb[IFLA_MTU])
                         dev->mtu = lowerdev->mtu - VXLAN_HEADROOM;
+
+                /* update header length based on lower device */
+                dev->hard_header_len = lowerdev->hard_header_len +
+                                       VXLAN_HEADROOM;
         }
 
         if (data[IFLA_VXLAN_TOS])
diff --git a/drivers/net/wan/ixp4xx_hss.c b/drivers/net/wan/ixp4xx_hss.c
index 3f575afd8cfc..760776b3d66c 100644
--- a/drivers/net/wan/ixp4xx_hss.c
+++ b/drivers/net/wan/ixp4xx_hss.c
@@ -969,10 +969,12 @@ static int init_hdlc_queues(struct port *port)
 {
         int i;
 
-        if (!ports_open)
-                if (!(dma_pool = dma_pool_create(DRV_NAME, NULL,
-                                                 POOL_ALLOC_SIZE, 32, 0)))
+        if (!ports_open) {
+                dma_pool = dma_pool_create(DRV_NAME, &port->netdev->dev,
+                                           POOL_ALLOC_SIZE, 32, 0);
+                if (!dma_pool)
                         return -ENOMEM;
+        }
 
         if (!(port->desc_tab = dma_pool_alloc(dma_pool, GFP_KERNEL,
                                               &port->desc_tab_phys)))
@@ -1363,7 +1365,7 @@ static int __devinit hss_init_one(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, port);
 
-        netdev_info(dev, "HSS-%i\n", port->id);
+        netdev_info(dev, "initialized\n");
         return 0;
 
 err_free_netdev:
diff --git a/drivers/net/wireless/ath/ath9k/hw.c b/drivers/net/wireless/ath/ath9k/hw.c
index 8e1559aba495..1829b445d0b0 100644
--- a/drivers/net/wireless/ath/ath9k/hw.c
+++ b/drivers/net/wireless/ath/ath9k/hw.c
@@ -1456,7 +1456,7 @@ static bool ath9k_hw_set_reset_reg(struct ath_hw *ah, u32 type)
         switch (type) {
         case ATH9K_RESET_POWER_ON:
                 ret = ath9k_hw_set_reset_power_on(ah);
-                if (!ret)
+                if (ret)
                         ah->reset_power_on = true;
                 break;
         case ATH9K_RESET_WARM:
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/wl_cfg80211.c b/drivers/net/wireless/brcm80211/brcmfmac/wl_cfg80211.c
index a6f1e8166008..481345c23ded 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/wl_cfg80211.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/wl_cfg80211.c
@@ -4401,7 +4401,7 @@ static s32 brcmf_mode_to_nl80211_iftype(s32 mode)
 
 static void brcmf_wiphy_pno_params(struct wiphy *wiphy)
 {
-#ifndef CONFIG_BRCMFISCAN
+#ifndef CONFIG_BRCMISCAN
         /* scheduled scan settings */
         wiphy->max_sched_scan_ssids = BRCMF_PNO_MAX_PFN_COUNT;
         wiphy->max_match_sets = BRCMF_PNO_MAX_PFN_COUNT;
diff --git a/drivers/net/wireless/iwlwifi/dvm/mac80211.c b/drivers/net/wireless/iwlwifi/dvm/mac80211.c
index ff8162d4c454..2d9eee93c743 100644
--- a/drivers/net/wireless/iwlwifi/dvm/mac80211.c
+++ b/drivers/net/wireless/iwlwifi/dvm/mac80211.c
@@ -521,7 +521,7 @@ static void iwlagn_mac_tx(struct ieee80211_hw *hw,
                      ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
 
         if (iwlagn_tx_skb(priv, control->sta, skb))
-                dev_kfree_skb_any(skb);
+                ieee80211_free_txskb(hw, skb);
 }
 
 static void iwlagn_mac_update_tkip_key(struct ieee80211_hw *hw,
@@ -1354,6 +1354,20 @@ static int iwlagn_mac_add_interface(struct ieee80211_hw *hw,
         vif_priv->ctx = ctx;
         ctx->vif = vif;
 
+        /*
+         * In SNIFFER device type, the firmware reports the FCS to
+         * the host, rather than snipping it off. Unfortunately,
+         * mac80211 doesn't (yet) provide a per-packet flag for
+         * this, so that we have to set the hardware flag based
+         * on the interfaces added. As the monitor interface can
+         * only be present by itself, and will be removed before
+         * other interfaces are added, this is safe.
+         */
+        if (vif->type == NL80211_IFTYPE_MONITOR)
+                priv->hw->flags |= IEEE80211_HW_RX_INCLUDES_FCS;
+        else
+                priv->hw->flags &= ~IEEE80211_HW_RX_INCLUDES_FCS;
+
         err = iwl_setup_interface(priv, ctx);
         if (!err || reset)
                 goto out;
diff --git a/drivers/net/wireless/iwlwifi/dvm/main.c b/drivers/net/wireless/iwlwifi/dvm/main.c
index 7ff3f1430678..408132cf83c1 100644
--- a/drivers/net/wireless/iwlwifi/dvm/main.c
+++ b/drivers/net/wireless/iwlwifi/dvm/main.c
@@ -2114,7 +2114,7 @@ static void iwl_free_skb(struct iwl_op_mode *op_mode, struct sk_buff *skb)
 
         info = IEEE80211_SKB_CB(skb);
         iwl_trans_free_tx_cmd(priv->trans, info->driver_data[1]);
-        dev_kfree_skb_any(skb);
+        ieee80211_free_txskb(priv->hw, skb);
 }
 
 static void iwl_set_hw_rfkill_state(struct iwl_op_mode *op_mode, bool state)
diff --git a/drivers/net/wireless/iwlwifi/dvm/rxon.c b/drivers/net/wireless/iwlwifi/dvm/rxon.c
index 10896393e5a0..2830ea290502 100644
--- a/drivers/net/wireless/iwlwifi/dvm/rxon.c
+++ b/drivers/net/wireless/iwlwifi/dvm/rxon.c
@@ -1012,12 +1012,12 @@ static void iwl_calc_basic_rates(struct iwl_priv *priv,
          * As a consequence, it's not as complicated as it sounds, just add
          * any lower rates to the ACK rate bitmap.
          */
-        if (IWL_RATE_11M_INDEX < lowest_present_ofdm)
-                ofdm |= IWL_RATE_11M_MASK >> IWL_FIRST_CCK_RATE;
-        if (IWL_RATE_5M_INDEX < lowest_present_ofdm)
-                ofdm |= IWL_RATE_5M_MASK >> IWL_FIRST_CCK_RATE;
-        if (IWL_RATE_2M_INDEX < lowest_present_ofdm)
-                ofdm |= IWL_RATE_2M_MASK >> IWL_FIRST_CCK_RATE;
+        if (IWL_RATE_11M_INDEX < lowest_present_cck)
+                cck |= IWL_RATE_11M_MASK >> IWL_FIRST_CCK_RATE;
+        if (IWL_RATE_5M_INDEX < lowest_present_cck)
+                cck |= IWL_RATE_5M_MASK >> IWL_FIRST_CCK_RATE;
+        if (IWL_RATE_2M_INDEX < lowest_present_cck)
+                cck |= IWL_RATE_2M_MASK >> IWL_FIRST_CCK_RATE;
         /* 1M already there or needed so always add */
         cck |= IWL_RATE_1M_MASK >> IWL_FIRST_CCK_RATE;
 
diff --git a/drivers/net/wireless/iwlwifi/pcie/rx.c b/drivers/net/wireless/iwlwifi/pcie/rx.c
index 17c8e5d82681..bb69f8f90b3b 100644
--- a/drivers/net/wireless/iwlwifi/pcie/rx.c
+++ b/drivers/net/wireless/iwlwifi/pcie/rx.c
@@ -321,6 +321,14 @@ static void iwl_rx_allocate(struct iwl_trans *trans, gfp_t priority)
                         dma_map_page(trans->dev, page, 0,
                                      PAGE_SIZE << trans_pcie->rx_page_order,
                                      DMA_FROM_DEVICE);
+                if (dma_mapping_error(trans->dev, rxb->page_dma)) {
+                        rxb->page = NULL;
+                        spin_lock_irqsave(&rxq->lock, flags);
+                        list_add(&rxb->list, &rxq->rx_used);
+                        spin_unlock_irqrestore(&rxq->lock, flags);
+                        __free_pages(page, trans_pcie->rx_page_order);
+                        return;
+                }
                 /* dma address must be no more than 36 bits */
                 BUG_ON(rxb->page_dma & ~DMA_BIT_MASK(36));
                 /* and also 256 byte aligned! */
@@ -488,8 +496,19 @@ static void iwl_rx_handle_rxbuf(struct iwl_trans *trans,
                         dma_map_page(trans->dev, rxb->page, 0,
                                      PAGE_SIZE << trans_pcie->rx_page_order,
                                      DMA_FROM_DEVICE);
-                list_add_tail(&rxb->list, &rxq->rx_free);
-                rxq->free_count++;
+                if (dma_mapping_error(trans->dev, rxb->page_dma)) {
+                        /*
+                         * free the page(s) as well to not break
+                         * the invariant that the items on the used
+                         * list have no page(s)
+                         */
+                        __free_pages(rxb->page, trans_pcie->rx_page_order);
+                        rxb->page = NULL;
+                        list_add_tail(&rxb->list, &rxq->rx_used);
+                } else {
+                        list_add_tail(&rxb->list, &rxq->rx_free);
+                        rxq->free_count++;
+                }
         } else
                 list_add_tail(&rxb->list, &rxq->rx_used);
         spin_unlock_irqrestore(&rxq->lock, flags);
diff --git a/drivers/net/wireless/iwlwifi/pcie/tx.c b/drivers/net/wireless/iwlwifi/pcie/tx.c
index 105e3af3c621..79a4ddc002d3 100644
--- a/drivers/net/wireless/iwlwifi/pcie/tx.c
+++ b/drivers/net/wireless/iwlwifi/pcie/tx.c
@@ -480,20 +480,12 @@ void iwl_trans_pcie_txq_enable(struct iwl_trans *trans, int txq_id, int fifo,
 void iwl_trans_pcie_txq_disable(struct iwl_trans *trans, int txq_id)
 {
         struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
-        u16 rd_ptr, wr_ptr;
-        int n_bd = trans_pcie->txq[txq_id].q.n_bd;
 
         if (!test_and_clear_bit(txq_id, trans_pcie->queue_used)) {
                 WARN_ONCE(1, "queue %d not used", txq_id);
                 return;
         }
 
-        rd_ptr = iwl_read_prph(trans, SCD_QUEUE_RDPTR(txq_id)) & (n_bd - 1);
-        wr_ptr = iwl_read_prph(trans, SCD_QUEUE_WRPTR(txq_id));
-
-        WARN_ONCE(rd_ptr != wr_ptr, "queue %d isn't empty: [%d,%d]",
-                  txq_id, rd_ptr, wr_ptr);
-
         iwl_txq_set_inactive(trans, txq_id);
         IWL_DEBUG_TX_QUEUES(trans, "Deactivate queue %d\n", txq_id);
 }
diff --git a/drivers/net/wireless/mwifiex/cmdevt.c b/drivers/net/wireless/mwifiex/cmdevt.c
index 8d465107f52b..ae9010ed58de 100644
--- a/drivers/net/wireless/mwifiex/cmdevt.c
+++ b/drivers/net/wireless/mwifiex/cmdevt.c
@@ -890,9 +890,6 @@ mwifiex_cmd_timeout_func(unsigned long function_context)
                 return;
         }
         cmd_node = adapter->curr_cmd;
-        if (cmd_node->wait_q_enabled)
-                adapter->cmd_wait_q.status = -ETIMEDOUT;
-
         if (cmd_node) {
                 adapter->dbg.timeout_cmd_id =
                         adapter->dbg.last_cmd_id[adapter->dbg.last_cmd_index];
@@ -938,6 +935,14 @@ mwifiex_cmd_timeout_func(unsigned long function_context)
 
                 dev_err(adapter->dev, "ps_mode=%d ps_state=%d\n",
                         adapter->ps_mode, adapter->ps_state);
+
+                if (cmd_node->wait_q_enabled) {
+                        adapter->cmd_wait_q.status = -ETIMEDOUT;
+                        wake_up_interruptible(&adapter->cmd_wait_q.wait);
+                        mwifiex_cancel_pending_ioctl(adapter);
+                        /* reset cmd_sent flag to unblock new commands */
+                        adapter->cmd_sent = false;
+                }
         }
         if (adapter->hw_status == MWIFIEX_HW_STATUS_INITIALIZING)
                 mwifiex_init_fw_complete(adapter);
diff --git a/drivers/net/wireless/mwifiex/sdio.c b/drivers/net/wireless/mwifiex/sdio.c
index fc8a9bfa1248..82cf0fa2d9f6 100644
--- a/drivers/net/wireless/mwifiex/sdio.c
+++ b/drivers/net/wireless/mwifiex/sdio.c
@@ -161,7 +161,6 @@ static int mwifiex_sdio_suspend(struct device *dev)
         struct sdio_mmc_card *card;
         struct mwifiex_adapter *adapter;
         mmc_pm_flag_t pm_flag = 0;
-        int hs_actived = 0;
         int i;
         int ret = 0;
 
@@ -188,12 +187,14 @@ static int mwifiex_sdio_suspend(struct device *dev)
         adapter = card->adapter;
 
         /* Enable the Host Sleep */
-        hs_actived = mwifiex_enable_hs(adapter);
-        if (hs_actived) {
-                pr_debug("cmd: suspend with MMC_PM_KEEP_POWER\n");
-                ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
+        if (!mwifiex_enable_hs(adapter)) {
+                dev_err(adapter->dev, "cmd: failed to suspend\n");
+                return -EFAULT;
         }
 
+        dev_dbg(adapter->dev, "cmd: suspend with MMC_PM_KEEP_POWER\n");
+        ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
+
         /* Indicate device suspended */
         adapter->is_suspended = true;
 
diff --git a/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c b/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c
index 9970c2b1b199..b7e6607e6b6d 100644
--- a/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c
+++ b/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c
@@ -297,6 +297,7 @@ static struct usb_device_id rtl8192c_usb_ids[] = {
         /*=== Customer ID ===*/
         /****** 8188CU ********/
         {RTL_USB_DEVICE(0x050d, 0x1102, rtl92cu_hal_cfg)}, /*Belkin - Edimax*/
+        {RTL_USB_DEVICE(0x050d, 0x11f2, rtl92cu_hal_cfg)}, /*Belkin - ISY*/
         {RTL_USB_DEVICE(0x06f8, 0xe033, rtl92cu_hal_cfg)}, /*Hercules - Edimax*/
         {RTL_USB_DEVICE(0x07b8, 0x8188, rtl92cu_hal_cfg)}, /*Abocom - Abocom*/
         {RTL_USB_DEVICE(0x07b8, 0x8189, rtl92cu_hal_cfg)}, /*Funai - Abocom*/
diff --git a/drivers/net/xen-netfront.c b/drivers/net/xen-netfront.c
index caa011008cd0..fc24eb9b3948 100644
--- a/drivers/net/xen-netfront.c
+++ b/drivers/net/xen-netfront.c
@@ -452,29 +452,85 @@ static void xennet_make_frags(struct sk_buff *skb, struct net_device *dev,
         /* Grant backend access to each skb fragment page. */
         for (i = 0; i < frags; i++) {
                 skb_frag_t *frag = skb_shinfo(skb)->frags + i;
+                struct page *page = skb_frag_page(frag);
 
-                tx->flags |= XEN_NETTXF_more_data;
+                len = skb_frag_size(frag);
+                offset = frag->page_offset;
 
-                id = get_id_from_freelist(&np->tx_skb_freelist, np->tx_skbs);
-                np->tx_skbs[id].skb = skb_get(skb);
-                tx = RING_GET_REQUEST(&np->tx, prod++);
-                tx->id = id;
-                ref = gnttab_claim_grant_reference(&np->gref_tx_head);
-                BUG_ON((signed short)ref < 0);
+                /* Data must not cross a page boundary. */
+                BUG_ON(len + offset > PAGE_SIZE<<compound_order(page));
 
-                mfn = pfn_to_mfn(page_to_pfn(skb_frag_page(frag)));
-                gnttab_grant_foreign_access_ref(ref, np->xbdev->otherend_id,
-                                                mfn, GNTMAP_readonly);
+                /* Skip unused frames from start of page */
+                page += offset >> PAGE_SHIFT;
+                offset &= ~PAGE_MASK;
 
-                tx->gref = np->grant_tx_ref[id] = ref;
-                tx->offset = frag->page_offset;
-                tx->size = skb_frag_size(frag);
-                tx->flags = 0;
+                while (len > 0) {
+                        unsigned long bytes;
+
+                        BUG_ON(offset >= PAGE_SIZE);
+
+                        bytes = PAGE_SIZE - offset;
+                        if (bytes > len)
+                                bytes = len;
+
+                        tx->flags |= XEN_NETTXF_more_data;
+
+                        id = get_id_from_freelist(&np->tx_skb_freelist,
+                                                  np->tx_skbs);
+                        np->tx_skbs[id].skb = skb_get(skb);
+                        tx = RING_GET_REQUEST(&np->tx, prod++);
+                        tx->id = id;
+                        ref = gnttab_claim_grant_reference(&np->gref_tx_head);
+                        BUG_ON((signed short)ref < 0);
+
+                        mfn = pfn_to_mfn(page_to_pfn(page));
+                        gnttab_grant_foreign_access_ref(ref,
+                                                        np->xbdev->otherend_id,
+                                                        mfn, GNTMAP_readonly);
+
+                        tx->gref = np->grant_tx_ref[id] = ref;
+                        tx->offset = offset;
+                        tx->size = bytes;
+                        tx->flags = 0;
+
+                        offset += bytes;
+                        len -= bytes;
+
+                        /* Next frame */
+                        if (offset == PAGE_SIZE && len) {
+                                BUG_ON(!PageCompound(page));
+                                page++;
+                                offset = 0;
+                        }
+                }
         }
 
         np->tx.req_prod_pvt = prod;
 }
 
+/*
+ * Count how many ring slots are required to send the frags of this
+ * skb. Each frag might be a compound page.
+ */
+static int xennet_count_skb_frag_slots(struct sk_buff *skb)
+{
+        int i, frags = skb_shinfo(skb)->nr_frags;
+        int pages = 0;
+
+        for (i = 0; i < frags; i++) {
+                skb_frag_t *frag = skb_shinfo(skb)->frags + i;
+                unsigned long size = skb_frag_size(frag);
+                unsigned long offset = frag->page_offset;
+
+                /* Skip unused frames from start of page */
+                offset &= ~PAGE_MASK;
+
+                pages += PFN_UP(offset + size);
+        }
+
+        return pages;
+}
+
 static int xennet_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         unsigned short id;
@@ -487,23 +543,23 @@ static int xennet_start_xmit(struct sk_buff *skb, struct net_device *dev)
         grant_ref_t ref;
         unsigned long mfn;
         int notify;
-        int frags = skb_shinfo(skb)->nr_frags;
+        int slots;
         unsigned int offset = offset_in_page(data);
         unsigned int len = skb_headlen(skb);
         unsigned long flags;
 
-        frags += DIV_ROUND_UP(offset + len, PAGE_SIZE);
-        if (unlikely(frags > MAX_SKB_FRAGS + 1)) {
-                printk(KERN_ALERT "xennet: skb rides the rocket: %d frags\n",
-                       frags);
-                dump_stack();
+        slots = DIV_ROUND_UP(offset + len, PAGE_SIZE) +
+                xennet_count_skb_frag_slots(skb);
+        if (unlikely(slots > MAX_SKB_FRAGS + 1)) {
+                net_alert_ratelimited(
+                        "xennet: skb rides the rocket: %d slots\n", slots);
                 goto drop;
         }
 
         spin_lock_irqsave(&np->tx_lock, flags);
 
         if (unlikely(!netif_carrier_ok(dev) ||
-                     (frags > 1 && !xennet_can_sg(dev)) ||
+                     (slots > 1 && !xennet_can_sg(dev)) ||
                      netif_needs_gso(skb, netif_skb_features(skb)))) {
                 spin_unlock_irqrestore(&np->tx_lock, flags);
                 goto drop;
diff --git a/drivers/nfc/pn533.c b/drivers/nfc/pn533.c
index 97c440a8cd61..30ae18a03a9c 100644
--- a/drivers/nfc/pn533.c
+++ b/drivers/nfc/pn533.c
@@ -698,13 +698,14 @@ static void pn533_wq_cmd(struct work_struct *work)
 
         cmd = list_first_entry(&dev->cmd_queue, struct pn533_cmd, queue);
 
+        list_del(&cmd->queue);
+
         mutex_unlock(&dev->cmd_lock);
 
         __pn533_send_cmd_frame_async(dev, cmd->out_frame, cmd->in_frame,
                                      cmd->in_frame_len, cmd->cmd_complete,
                                      cmd->arg, cmd->flags);
 
-        list_del(&cmd->queue);
         kfree(cmd);
 }
 
@@ -1678,11 +1679,14 @@ static void pn533_deactivate_target(struct nfc_dev *nfc_dev,
 static int pn533_in_dep_link_up_complete(struct pn533 *dev, void *arg,
                                                 u8 *params, int params_len)
 {
-        struct pn533_cmd_jump_dep *cmd;
         struct pn533_cmd_jump_dep_response *resp;
         struct nfc_target nfc_target;
         u8 target_gt_len;
         int rc;
+        struct pn533_cmd_jump_dep *cmd = (struct pn533_cmd_jump_dep *)arg;
+        u8 active = cmd->active;
+
+        kfree(arg);
 
         if (params_len == -ENOENT) {
                 nfc_dev_dbg(&dev->interface->dev, "");
@@ -1704,7 +1708,6 @@ static int pn533_in_dep_link_up_complete(struct pn533 *dev, void *arg,
         }
 
         resp = (struct pn533_cmd_jump_dep_response *) params;
-        cmd = (struct pn533_cmd_jump_dep *) arg;
         rc = resp->status & PN533_CMD_RET_MASK;
         if (rc != PN533_CMD_RET_SUCCESS) {
                 nfc_dev_err(&dev->interface->dev,
@@ -1734,7 +1737,7 @@ static int pn533_in_dep_link_up_complete(struct pn533 *dev, void *arg,
         if (rc == 0)
                 rc = nfc_dep_link_is_up(dev->nfc_dev,
                                                 dev->nfc_dev->targets[0].idx,
-                                                !cmd->active, NFC_RF_INITIATOR);
+                                                !active, NFC_RF_INITIATOR);
 
         return 0;
 }
@@ -1819,12 +1822,8 @@ static int pn533_dep_link_up(struct nfc_dev *nfc_dev, struct nfc_target *target,
         rc = pn533_send_cmd_frame_async(dev, dev->out_frame, dev->in_frame,
                                 dev->in_maxlen, pn533_in_dep_link_up_complete,
                                 cmd, GFP_KERNEL);
-        if (rc)
-                goto out;
-
-
-out:
-        kfree(cmd);
+        if (rc < 0)
+                kfree(cmd);
 
         return rc;
 }
@@ -2078,8 +2077,12 @@ error:
 static int pn533_tm_send_complete(struct pn533 *dev, void *arg,
                                   u8 *params, int params_len)
 {
+        struct sk_buff *skb_out = arg;
+
         nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
 
+        dev_kfree_skb(skb_out);
+
         if (params_len < 0) {
                 nfc_dev_err(&dev->interface->dev,
                             "Error %d when sending data",
@@ -2117,7 +2120,7 @@ static int pn533_tm_send(struct nfc_dev *nfc_dev, struct sk_buff *skb)
 
         rc = pn533_send_cmd_frame_async(dev, out_frame, dev->in_frame,
                                         dev->in_maxlen, pn533_tm_send_complete,
-                                        NULL, GFP_KERNEL);
+                                        skb, GFP_KERNEL);
         if (rc) {
                 nfc_dev_err(&dev->interface->dev,
                             "Error %d when trying to send data", rc);
diff --git a/drivers/pinctrl/Kconfig b/drivers/pinctrl/Kconfig
index d96caefd914a..aeecf0f72cad 100644
--- a/drivers/pinctrl/Kconfig
+++ b/drivers/pinctrl/Kconfig
@@ -178,7 +178,7 @@ config PINCTRL_COH901
           ports of 8 GPIO pins each.
 
 config PINCTRL_SAMSUNG
-        bool "Samsung pinctrl driver"
+        bool
         depends on OF && GPIOLIB
         select PINMUX
         select PINCONF
diff --git a/drivers/rapidio/rio.c b/drivers/rapidio/rio.c
index c17ae22567e0..0c6fcb461faf 100644
--- a/drivers/rapidio/rio.c
+++ b/drivers/rapidio/rio.c
@@ -401,7 +401,7 @@ EXPORT_SYMBOL_GPL(rio_release_inb_pwrite);
 /**
  * rio_map_inb_region -- Map inbound memory region.
  * @mport: Master port.
- * @lstart: physical address of memory region to be mapped
+ * @local: physical address of memory region to be mapped
  * @rbase: RIO base address assigned to this window
  * @size: Size of the memory region
  * @rflags: Flags for mapping.
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
index 5c4829cba6a6..e872c8be080e 100644
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -1381,22 +1381,14 @@ struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
 }
 EXPORT_SYMBOL_GPL(regulator_get_exclusive);
 
-/**
- * regulator_put - "free" the regulator source
- * @regulator: regulator source
- *
- * Note: drivers must ensure that all regulator_enable calls made on this
- * regulator source are balanced by regulator_disable calls prior to calling
- * this function.
- */
-void regulator_put(struct regulator *regulator)
+/* Locks held by regulator_put() */
+static void _regulator_put(struct regulator *regulator)
 {
         struct regulator_dev *rdev;
 
         if (regulator == NULL || IS_ERR(regulator))
                 return;
 
-        mutex_lock(&regulator_list_mutex);
         rdev = regulator->rdev;
 
         debugfs_remove_recursive(regulator->debugfs);
@@ -1412,6 +1404,20 @@ void regulator_put(struct regulator *regulator)
         rdev->exclusive = 0;
 
         module_put(rdev->owner);
+}
+
+/**
+ * regulator_put - "free" the regulator source
+ * @regulator: regulator source
+ *
+ * Note: drivers must ensure that all regulator_enable calls made on this
+ * regulator source are balanced by regulator_disable calls prior to calling
+ * this function.
+ */
+void regulator_put(struct regulator *regulator)
+{
+        mutex_lock(&regulator_list_mutex);
+        _regulator_put(regulator);
         mutex_unlock(&regulator_list_mutex);
 }
 EXPORT_SYMBOL_GPL(regulator_put);
@@ -1974,7 +1980,7 @@ int regulator_is_supported_voltage(struct regulator *regulator,
         if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
                 ret = regulator_get_voltage(regulator);
                 if (ret >= 0)
-                        return (min_uV >= ret && ret <= max_uV);
+                        return (min_uV <= ret && ret <= max_uV);
                 else
                         return ret;
         }
@@ -3365,7 +3371,7 @@ regulator_register(const struct regulator_desc *regulator_desc,
                 if (ret != 0) {
                         rdev_err(rdev, "Failed to request enable GPIO%d: %d\n",
                                  config->ena_gpio, ret);
-                        goto clean;
+                        goto wash;
                 }
 
                 rdev->ena_gpio = config->ena_gpio;
@@ -3445,10 +3451,11 @@ unset_supplies:
 
 scrub:
         if (rdev->supply)
-                regulator_put(rdev->supply);
+                _regulator_put(rdev->supply);
         if (rdev->ena_gpio)
                 gpio_free(rdev->ena_gpio);
         kfree(rdev->constraints);
+wash:
         device_unregister(&rdev->dev);
         /* device core frees rdev */
         rdev = ERR_PTR(ret);
diff --git a/drivers/remoteproc/remoteproc_virtio.c b/drivers/remoteproc/remoteproc_virtio.c
index e7a4780e93db..9e198e590675 100644
--- a/drivers/remoteproc/remoteproc_virtio.c
+++ b/drivers/remoteproc/remoteproc_virtio.c
@@ -120,15 +120,11 @@ static struct virtqueue *rp_find_vq(struct virtio_device *vdev,
         return vq;
 }
 
-static void rproc_virtio_del_vqs(struct virtio_device *vdev)
+static void __rproc_virtio_del_vqs(struct virtio_device *vdev)
 {
         struct virtqueue *vq, *n;
-        struct rproc *rproc = vdev_to_rproc(vdev);
         struct rproc_vring *rvring;
 
-        /* power down the remote processor before deleting vqs */
-        rproc_shutdown(rproc);
-
         list_for_each_entry_safe(vq, n, &vdev->vqs, list) {
                 rvring = vq->priv;
                 rvring->vq = NULL;
@@ -137,6 +133,16 @@ static void rproc_virtio_del_vqs(struct virtio_device *vdev)
         }
 }
 
+static void rproc_virtio_del_vqs(struct virtio_device *vdev)
+{
+        struct rproc *rproc = vdev_to_rproc(vdev);
+
+        /* power down the remote processor before deleting vqs */
+        rproc_shutdown(rproc);
+
+        __rproc_virtio_del_vqs(vdev);
+}
+
 static int rproc_virtio_find_vqs(struct virtio_device *vdev, unsigned nvqs,
                        struct virtqueue *vqs[],
                        vq_callback_t *callbacks[],
@@ -163,7 +169,7 @@ static int rproc_virtio_find_vqs(struct virtio_device *vdev, unsigned nvqs,
         return 0;
 
 error:
-        rproc_virtio_del_vqs(vdev);
+        __rproc_virtio_del_vqs(vdev);
         return ret;
 }
 
diff --git a/drivers/rtc/rtc-tps65910.c b/drivers/rtc/rtc-tps65910.c
index 7a82337e4dee..073108dcf9e7 100644
--- a/drivers/rtc/rtc-tps65910.c
+++ b/drivers/rtc/rtc-tps65910.c
@@ -288,11 +288,11 @@ static int __devinit tps65910_rtc_probe(struct platform_device *pdev)
 static int __devexit tps65910_rtc_remove(struct platform_device *pdev)
 {
         /* leave rtc running, but disable irqs */
-        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct tps65910_rtc *tps_rtc = platform_get_drvdata(pdev);
 
-        tps65910_rtc_alarm_irq_enable(&rtc->dev, 0);
+        tps65910_rtc_alarm_irq_enable(&pdev->dev, 0);
 
-        rtc_device_unregister(rtc);
+        rtc_device_unregister(tps_rtc->rtc);
         return 0;
 }
 
diff --git a/drivers/s390/char/con3215.c b/drivers/s390/char/con3215.c
index 9ffb6d5f17aa..4ed343e4eb41 100644
--- a/drivers/s390/char/con3215.c
+++ b/drivers/s390/char/con3215.c
@@ -44,7 +44,6 @@
 #define RAW3215_NR_CCWS     3
 #define RAW3215_TIMEOUT     HZ/10     /* time for delayed output */
 
-#define RAW3215_FIXED       1         /* 3215 console device is not be freed */
 #define RAW3215_WORKING     4         /* set if a request is being worked on */
 #define RAW3215_THROTTLED   8         /* set if reading is disabled */
 #define RAW3215_STOPPED     16        /* set if writing is disabled */
@@ -339,8 +338,10 @@ static void raw3215_wakeup(unsigned long data)
         struct tty_struct *tty;
 
         tty = tty_port_tty_get(&raw->port);
-        tty_wakeup(tty);
-        tty_kref_put(tty);
+        if (tty) {
+                tty_wakeup(tty);
+                tty_kref_put(tty);
+        }
 }
 
 /*
@@ -629,8 +630,7 @@ static void raw3215_shutdown(struct raw3215_info *raw)
         DECLARE_WAITQUEUE(wait, current);
         unsigned long flags;
 
-        if (!(raw->port.flags & ASYNC_INITIALIZED) ||
-                        (raw->flags & RAW3215_FIXED))
+        if (!(raw->port.flags & ASYNC_INITIALIZED))
                 return;
         /* Wait for outstanding requests, then free irq */
         spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
@@ -926,8 +926,6 @@ static int __init con3215_init(void)
         dev_set_drvdata(&cdev->dev, raw);
         cdev->handler = raw3215_irq;
 
-        raw->flags |= RAW3215_FIXED;
-
         /* Request the console irq */
         if (raw3215_startup(raw) != 0) {
                 raw3215_free_info(raw);
diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c
index 3e25d3150456..4d6ba00d0047 100644
--- a/drivers/s390/net/qeth_core_main.c
+++ b/drivers/s390/net/qeth_core_main.c
@@ -2942,13 +2942,33 @@ static int qeth_query_ipassists_cb(struct qeth_card *card,
         QETH_DBF_TEXT(SETUP, 2, "qipasscb");
 
         cmd = (struct qeth_ipa_cmd *) data;
+
+        switch (cmd->hdr.return_code) {
+        case IPA_RC_NOTSUPP:
+        case IPA_RC_L2_UNSUPPORTED_CMD:
+                QETH_DBF_TEXT(SETUP, 2, "ipaunsup");
+                card->options.ipa4.supported_funcs |= IPA_SETADAPTERPARMS;
+                card->options.ipa6.supported_funcs |= IPA_SETADAPTERPARMS;
+                return -0;
+        default:
+                if (cmd->hdr.return_code) {
+                        QETH_DBF_MESSAGE(1, "%s IPA_CMD_QIPASSIST: Unhandled "
+                                                "rc=%d\n",
+                                                dev_name(&card->gdev->dev),
+                                                cmd->hdr.return_code);
+                        return 0;
+                }
+        }
+
         if (cmd->hdr.prot_version == QETH_PROT_IPV4) {
                 card->options.ipa4.supported_funcs = cmd->hdr.ipa_supported;
                 card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled;
-        } else {
+        } else if (cmd->hdr.prot_version == QETH_PROT_IPV6) {
                 card->options.ipa6.supported_funcs = cmd->hdr.ipa_supported;
                 card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled;
-        }
+        } else
+                QETH_DBF_MESSAGE(1, "%s IPA_CMD_QIPASSIST: Flawed LIC detected"
+                                        "\n", dev_name(&card->gdev->dev));
         QETH_DBF_TEXT(SETUP, 2, "suppenbl");
         QETH_DBF_TEXT_(SETUP, 2, "%08x", (__u32)cmd->hdr.ipa_supported);
         QETH_DBF_TEXT_(SETUP, 2, "%08x", (__u32)cmd->hdr.ipa_enabled);
diff --git a/drivers/s390/net/qeth_l2_main.c b/drivers/s390/net/qeth_l2_main.c
index e67e0258aec5..fddb62654b6a 100644
--- a/drivers/s390/net/qeth_l2_main.c
+++ b/drivers/s390/net/qeth_l2_main.c
@@ -626,10 +626,13 @@ static int qeth_l2_request_initial_mac(struct qeth_card *card)
         QETH_DBF_TEXT(SETUP, 2, "doL2init");
         QETH_DBF_TEXT_(SETUP, 2, "doL2%s", CARD_BUS_ID(card));
 
-        rc = qeth_query_setadapterparms(card);
-        if (rc) {
-                QETH_DBF_MESSAGE(2, "could not query adapter parameters on "
-                        "device %s: x%x\n", CARD_BUS_ID(card), rc);
+        if (qeth_is_supported(card, IPA_SETADAPTERPARMS)) {
+                rc = qeth_query_setadapterparms(card);
+                if (rc) {
+                        QETH_DBF_MESSAGE(2, "could not query adapter "
+                                "parameters on device %s: x%x\n",
+                                CARD_BUS_ID(card), rc);
+                }
         }
 
         if (card->info.type == QETH_CARD_TYPE_IQD ||
@@ -676,7 +679,7 @@ static int qeth_l2_set_mac_address(struct net_device *dev, void *p)
                 return -ERESTARTSYS;
         }
         rc = qeth_l2_send_delmac(card, &card->dev->dev_addr[0]);
-        if (!rc)
+        if (!rc || (rc == IPA_RC_L2_MAC_NOT_FOUND))
                 rc = qeth_l2_send_setmac(card, addr->sa_data);
         return rc ? -EINVAL : 0;
 }
diff --git a/drivers/scsi/isci/request.c b/drivers/scsi/isci/request.c
index c1bafc3f3fb1..9594ab62702b 100644
--- a/drivers/scsi/isci/request.c
+++ b/drivers/scsi/isci/request.c
@@ -1972,7 +1972,7 @@ sci_io_request_frame_handler(struct isci_request *ireq,
                                                                       frame_index,
                                                                       (void **)&frame_buffer);
 
-                        sci_controller_copy_sata_response(&ireq->stp.req,
+                        sci_controller_copy_sata_response(&ireq->stp.rsp,
                                                                frame_header,
                                                                frame_buffer);
 
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index 2936b447cae9..2c0d0ec8150b 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -55,6 +55,7 @@
 #include <linux/cpu.h>
 #include <linux/mutex.h>
 #include <linux/async.h>
+#include <asm/unaligned.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -1062,6 +1063,50 @@ int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
 EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
 
 /**
+ * scsi_report_opcode - Find out if a given command opcode is supported
+ * @sdev:       scsi device to query
+ * @buffer:     scratch buffer (must be at least 20 bytes long)
+ * @len:        length of buffer
+ * @opcode:     opcode for command to look up
+ *
+ * Uses the REPORT SUPPORTED OPERATION CODES to look up the given
+ * opcode. Returns 0 if RSOC fails or if the command opcode is
+ * unsupported. Returns 1 if the device claims to support the command.
+ */
+int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
+                       unsigned int len, unsigned char opcode)
+{
+        unsigned char cmd[16];
+        struct scsi_sense_hdr sshdr;
+        int result;
+
+        if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3)
+                return 0;
+
+        memset(cmd, 0, 16);
+        cmd[0] = MAINTENANCE_IN;
+        cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES;
+        cmd[2] = 1;             /* One command format */
+        cmd[3] = opcode;
+        put_unaligned_be32(len, &cmd[6]);
+        memset(buffer, 0, len);
+
+        result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
+                                  &sshdr, 30 * HZ, 3, NULL);
+
+        if (result && scsi_sense_valid(&sshdr) &&
+            sshdr.sense_key == ILLEGAL_REQUEST &&
+            (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
+                return 0;
+
+        if ((buffer[1] & 3) == 3) /* Command supported */
+                return 1;
+
+        return 0;
+}
+EXPORT_SYMBOL(scsi_report_opcode);
+
+/**
  * scsi_device_get  -  get an additional reference to a scsi_device
  * @sdev:       device to get a reference to
  *
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index da36a3a81a9e..9032e910bca3 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -900,11 +900,23 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                                 action = ACTION_FAIL;
                                 error = -EILSEQ;
                         /* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */
-                        } else if ((sshdr.asc == 0x20 || sshdr.asc == 0x24) &&
-                                   (cmd->cmnd[0] == UNMAP ||
-                                    cmd->cmnd[0] == WRITE_SAME_16 ||
-                                    cmd->cmnd[0] == WRITE_SAME)) {
-                                description = "Discard failure";
+                        } else if (sshdr.asc == 0x20 || sshdr.asc == 0x24) {
+                                switch (cmd->cmnd[0]) {
+                                case UNMAP:
+                                        description = "Discard failure";
+                                        break;
+                                case WRITE_SAME:
+                                case WRITE_SAME_16:
+                                        if (cmd->cmnd[1] & 0x8)
+                                                description = "Discard failure";
+                                        else
+                                                description =
+                                                        "Write same failure";
+                                        break;
+                                default:
+                                        description = "Invalid command failure";
+                                        break;
+                                }
                                 action = ACTION_FAIL;
                                 error = -EREMOTEIO;
                         } else
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 12f6fdfc1147..352bc77b7c88 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -99,6 +99,7 @@ MODULE_ALIAS_SCSI_DEVICE(TYPE_RBC);
 #endif
 
 static void sd_config_discard(struct scsi_disk *, unsigned int);
+static void sd_config_write_same(struct scsi_disk *);
 static int  sd_revalidate_disk(struct gendisk *);
 static void sd_unlock_native_capacity(struct gendisk *disk);
 static int  sd_probe(struct device *);
@@ -395,6 +396,45 @@ sd_store_max_medium_access_timeouts(struct device *dev,
         return err ? err : count;
 }
 
+static ssize_t
+sd_show_write_same_blocks(struct device *dev, struct device_attribute *attr,
+                          char *buf)
+{
+        struct scsi_disk *sdkp = to_scsi_disk(dev);
+
+        return snprintf(buf, 20, "%u\n", sdkp->max_ws_blocks);
+}
+
+static ssize_t
+sd_store_write_same_blocks(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
+{
+        struct scsi_disk *sdkp = to_scsi_disk(dev);
+        struct scsi_device *sdp = sdkp->device;
+        unsigned long max;
+        int err;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+
+        if (sdp->type != TYPE_DISK)
+                return -EINVAL;
+
+        err = kstrtoul(buf, 10, &max);
+
+        if (err)
+                return err;
+
+        if (max == 0)
+                sdp->no_write_same = 1;
+        else if (max <= SD_MAX_WS16_BLOCKS)
+                sdkp->max_ws_blocks = max;
+
+        sd_config_write_same(sdkp);
+
+        return count;
+}
+
 static struct device_attribute sd_disk_attrs[] = {
         __ATTR(cache_type, S_IRUGO|S_IWUSR, sd_show_cache_type,
                sd_store_cache_type),
@@ -410,6 +450,8 @@ static struct device_attribute sd_disk_attrs[] = {
         __ATTR(thin_provisioning, S_IRUGO, sd_show_thin_provisioning, NULL),
         __ATTR(provisioning_mode, S_IRUGO|S_IWUSR, sd_show_provisioning_mode,
                sd_store_provisioning_mode),
+        __ATTR(max_write_same_blocks, S_IRUGO|S_IWUSR,
+               sd_show_write_same_blocks, sd_store_write_same_blocks),
         __ATTR(max_medium_access_timeouts, S_IRUGO|S_IWUSR,
                sd_show_max_medium_access_timeouts,
                sd_store_max_medium_access_timeouts),
@@ -561,19 +603,23 @@ static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode)
                 return;
 
         case SD_LBP_UNMAP:
-                max_blocks = min_not_zero(sdkp->max_unmap_blocks, 0xffffffff);
+                max_blocks = min_not_zero(sdkp->max_unmap_blocks,
+                                          (u32)SD_MAX_WS16_BLOCKS);
                 break;
 
         case SD_LBP_WS16:
-                max_blocks = min_not_zero(sdkp->max_ws_blocks, 0xffffffff);
+                max_blocks = min_not_zero(sdkp->max_ws_blocks,
+                                          (u32)SD_MAX_WS16_BLOCKS);
                 break;
 
         case SD_LBP_WS10:
-                max_blocks = min_not_zero(sdkp->max_ws_blocks, (u32)0xffff);
+                max_blocks = min_not_zero(sdkp->max_ws_blocks,
+                                          (u32)SD_MAX_WS10_BLOCKS);
                 break;
 
         case SD_LBP_ZERO:
-                max_blocks = min_not_zero(sdkp->max_ws_blocks, (u32)0xffff);
+                max_blocks = min_not_zero(sdkp->max_ws_blocks,
+                                          (u32)SD_MAX_WS10_BLOCKS);
                 q->limits.discard_zeroes_data = 1;
                 break;
         }
@@ -583,29 +629,26 @@ static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode)
 }
 
 /**
- * scsi_setup_discard_cmnd - unmap blocks on thinly provisioned device
+ * sd_setup_discard_cmnd - unmap blocks on thinly provisioned device
  * @sdp: scsi device to operate one
  * @rq: Request to prepare
  *
  * Will issue either UNMAP or WRITE SAME(16) depending on preference
  * indicated by target device.
  **/
-static int scsi_setup_discard_cmnd(struct scsi_device *sdp, struct request *rq)
+static int sd_setup_discard_cmnd(struct scsi_device *sdp, struct request *rq)
 {
         struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
-        struct bio *bio = rq->bio;
-        sector_t sector = bio->bi_sector;
-        unsigned int nr_sectors = bio_sectors(bio);
+        sector_t sector = blk_rq_pos(rq);
+        unsigned int nr_sectors = blk_rq_sectors(rq);
+        unsigned int nr_bytes = blk_rq_bytes(rq);
         unsigned int len;
         int ret;
         char *buf;
         struct page *page;
 
-        if (sdkp->device->sector_size == 4096) {
-                sector >>= 3;
-                nr_sectors >>= 3;
-        }
-
+        sector >>= ilog2(sdp->sector_size) - 9;
+        nr_sectors >>= ilog2(sdp->sector_size) - 9;
         rq->timeout = SD_TIMEOUT;
 
         memset(rq->cmd, 0, rq->cmd_len);
@@ -660,6 +703,7 @@ static int scsi_setup_discard_cmnd(struct scsi_device *sdp, struct request *rq)
         blk_add_request_payload(rq, page, len);
         ret = scsi_setup_blk_pc_cmnd(sdp, rq);
         rq->buffer = page_address(page);
+        rq->__data_len = nr_bytes;
 
 out:
         if (ret != BLKPREP_OK) {
@@ -669,6 +713,83 @@ out:
         return ret;
 }
 
+static void sd_config_write_same(struct scsi_disk *sdkp)
+{
+        struct request_queue *q = sdkp->disk->queue;
+        unsigned int logical_block_size = sdkp->device->sector_size;
+        unsigned int blocks = 0;
+
+        if (sdkp->device->no_write_same) {
+                sdkp->max_ws_blocks = 0;
+                goto out;
+        }
+
+        /* Some devices can not handle block counts above 0xffff despite
+         * supporting WRITE SAME(16). Consequently we default to 64k
+         * blocks per I/O unless the device explicitly advertises a
+         * bigger limit.
+         */
+        if (sdkp->max_ws_blocks == 0)
+                sdkp->max_ws_blocks = SD_MAX_WS10_BLOCKS;
+
+        if (sdkp->ws16 || sdkp->max_ws_blocks > SD_MAX_WS10_BLOCKS)
+                blocks = min_not_zero(sdkp->max_ws_blocks,
+                                      (u32)SD_MAX_WS16_BLOCKS);
+        else
+                blocks = min_not_zero(sdkp->max_ws_blocks,
+                                      (u32)SD_MAX_WS10_BLOCKS);
+
+out:
+        blk_queue_max_write_same_sectors(q, blocks * (logical_block_size >> 9));
+}
+
+/**
+ * sd_setup_write_same_cmnd - write the same data to multiple blocks
+ * @sdp: scsi device to operate one
+ * @rq: Request to prepare
+ *
+ * Will issue either WRITE SAME(10) or WRITE SAME(16) depending on
+ * preference indicated by target device.
+ **/
+static int sd_setup_write_same_cmnd(struct scsi_device *sdp, struct request *rq)
+{
+        struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
+        struct bio *bio = rq->bio;
+        sector_t sector = blk_rq_pos(rq);
+        unsigned int nr_sectors = blk_rq_sectors(rq);
+        unsigned int nr_bytes = blk_rq_bytes(rq);
+        int ret;
+
+        if (sdkp->device->no_write_same)
+                return BLKPREP_KILL;
+
+        BUG_ON(bio_offset(bio) || bio_iovec(bio)->bv_len != sdp->sector_size);
+
+        sector >>= ilog2(sdp->sector_size) - 9;
+        nr_sectors >>= ilog2(sdp->sector_size) - 9;
+
+        rq->__data_len = sdp->sector_size;
+        rq->timeout = SD_WRITE_SAME_TIMEOUT;
+        memset(rq->cmd, 0, rq->cmd_len);
+
+        if (sdkp->ws16 || sector > 0xffffffff || nr_sectors > 0xffff) {
+                rq->cmd_len = 16;
+                rq->cmd[0] = WRITE_SAME_16;
+                put_unaligned_be64(sector, &rq->cmd[2]);
+                put_unaligned_be32(nr_sectors, &rq->cmd[10]);
+        } else {
+                rq->cmd_len = 10;
+                rq->cmd[0] = WRITE_SAME;
+                put_unaligned_be32(sector, &rq->cmd[2]);
+                put_unaligned_be16(nr_sectors, &rq->cmd[7]);
+        }
+
+        ret = scsi_setup_blk_pc_cmnd(sdp, rq);
+        rq->__data_len = nr_bytes;
+
+        return ret;
+}
+
 static int scsi_setup_flush_cmnd(struct scsi_device *sdp, struct request *rq)
 {
         rq->timeout = SD_FLUSH_TIMEOUT;
@@ -712,7 +833,10 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
          * block PC requests to make life easier.
          */
         if (rq->cmd_flags & REQ_DISCARD) {
-                ret = scsi_setup_discard_cmnd(sdp, rq);
+                ret = sd_setup_discard_cmnd(sdp, rq);
+                goto out;
+        } else if (rq->cmd_flags & REQ_WRITE_SAME) {
+                ret = sd_setup_write_same_cmnd(sdp, rq);
                 goto out;
         } else if (rq->cmd_flags & REQ_FLUSH) {
                 ret = scsi_setup_flush_cmnd(sdp, rq);
@@ -1482,12 +1606,21 @@ static int sd_done(struct scsi_cmnd *SCpnt)
         unsigned int good_bytes = result ? 0 : scsi_bufflen(SCpnt);
         struct scsi_sense_hdr sshdr;
         struct scsi_disk *sdkp = scsi_disk(SCpnt->request->rq_disk);
+        struct request *req = SCpnt->request;
         int sense_valid = 0;
         int sense_deferred = 0;
         unsigned char op = SCpnt->cmnd[0];
+        unsigned char unmap = SCpnt->cmnd[1] & 8;
 
-        if ((SCpnt->request->cmd_flags & REQ_DISCARD) && !result)
-                scsi_set_resid(SCpnt, 0);
+        if (req->cmd_flags & REQ_DISCARD || req->cmd_flags & REQ_WRITE_SAME) {
+                if (!result) {
+                        good_bytes = blk_rq_bytes(req);
+                        scsi_set_resid(SCpnt, 0);
+                } else {
+                        good_bytes = 0;
+                        scsi_set_resid(SCpnt, blk_rq_bytes(req));
+                }
+        }
 
         if (result) {
                 sense_valid = scsi_command_normalize_sense(SCpnt, &sshdr);
@@ -1536,9 +1669,25 @@ static int sd_done(struct scsi_cmnd *SCpnt)
                 if (sshdr.asc == 0x10)  /* DIX: Host detected corruption */
                         good_bytes = sd_completed_bytes(SCpnt);
                 /* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */
-                if ((sshdr.asc == 0x20 || sshdr.asc == 0x24) &&
-                    (op == UNMAP || op == WRITE_SAME_16 || op == WRITE_SAME))
-                        sd_config_discard(sdkp, SD_LBP_DISABLE);
+                if (sshdr.asc == 0x20 || sshdr.asc == 0x24) {
+                        switch (op) {
+                        case UNMAP:
+                                sd_config_discard(sdkp, SD_LBP_DISABLE);
+                                break;
+                        case WRITE_SAME_16:
+                        case WRITE_SAME:
+                                if (unmap)
+                                        sd_config_discard(sdkp, SD_LBP_DISABLE);
+                                else {
+                                        sdkp->device->no_write_same = 1;
+                                        sd_config_write_same(sdkp);
+
+                                        good_bytes = 0;
+                                        req->__data_len = blk_rq_bytes(req);
+                                        req->cmd_flags |= REQ_QUIET;
+                                }
+                        }
+                }
                 break;
         default:
                 break;
@@ -2374,9 +2523,7 @@ static void sd_read_block_limits(struct scsi_disk *sdkp)
         if (buffer[3] == 0x3c) {
                 unsigned int lba_count, desc_count;
 
-                sdkp->max_ws_blocks =
-                        (u32) min_not_zero(get_unaligned_be64(&buffer[36]),
-                                           (u64)0xffffffff);
+                sdkp->max_ws_blocks = (u32)get_unaligned_be64(&buffer[36]);
 
                 if (!sdkp->lbpme)
                         goto out;
@@ -2469,6 +2616,13 @@ static void sd_read_block_provisioning(struct scsi_disk *sdkp)
         kfree(buffer);
 }
 
+static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer)
+{
+        if (scsi_report_opcode(sdkp->device, buffer, SD_BUF_SIZE,
+                               WRITE_SAME_16))
+                sdkp->ws16 = 1;
+}
+
 static int sd_try_extended_inquiry(struct scsi_device *sdp)
 {
         /*
@@ -2528,6 +2682,7 @@ static int sd_revalidate_disk(struct gendisk *disk)
                 sd_read_write_protect_flag(sdkp, buffer);
                 sd_read_cache_type(sdkp, buffer);
                 sd_read_app_tag_own(sdkp, buffer);
+                sd_read_write_same(sdkp, buffer);
         }
 
         sdkp->first_scan = 0;
@@ -2545,6 +2700,7 @@ static int sd_revalidate_disk(struct gendisk *disk)
         blk_queue_flush(sdkp->disk->queue, flush);
 
         set_capacity(disk, sdkp->capacity);
+        sd_config_write_same(sdkp);
         kfree(buffer);
 
  out:
diff --git a/drivers/scsi/sd.h b/drivers/scsi/sd.h
index 47c52a6d733c..74a1e4ca5401 100644
--- a/drivers/scsi/sd.h
+++ b/drivers/scsi/sd.h
@@ -14,6 +14,7 @@
 #define SD_TIMEOUT              (30 * HZ)
 #define SD_MOD_TIMEOUT          (75 * HZ)
 #define SD_FLUSH_TIMEOUT        (60 * HZ)
+#define SD_WRITE_SAME_TIMEOUT   (120 * HZ)
 
 /*
  * Number of allowed retries
@@ -39,6 +40,11 @@ enum {
 };
 
 enum {
+        SD_MAX_WS10_BLOCKS = 0xffff,
+        SD_MAX_WS16_BLOCKS = 0x7fffff,
+};
+
+enum {
         SD_LBP_FULL = 0,        /* Full logical block provisioning */
         SD_LBP_UNMAP,           /* Use UNMAP command */
         SD_LBP_WS16,            /* Use WRITE SAME(16) with UNMAP bit */
@@ -77,6 +83,7 @@ struct scsi_disk {
         unsigned        lbpws : 1;
         unsigned        lbpws10 : 1;
         unsigned        lbpvpd : 1;
+        unsigned        ws16 : 1;
 };
 #define to_scsi_disk(obj) container_of(obj,struct scsi_disk,dev)
 
diff --git a/drivers/staging/android/android_alarm.h b/drivers/staging/android/android_alarm.h
index f2ffd963f1c3..d0cafd637199 100644
--- a/drivers/staging/android/android_alarm.h
+++ b/drivers/staging/android/android_alarm.h
@@ -51,12 +51,10 @@ enum android_alarm_return_flags {
 #define ANDROID_ALARM_WAIT                  _IO('a', 1)
 
 #define ALARM_IOW(c, type, size)            _IOW('a', (c) | ((type) << 4), size)
-#define ALARM_IOR(c, type, size)            _IOR('a', (c) | ((type) << 4), size)
-
 /* Set alarm */
 #define ANDROID_ALARM_SET(type)             ALARM_IOW(2, type, struct timespec)
 #define ANDROID_ALARM_SET_AND_WAIT(type)    ALARM_IOW(3, type, struct timespec)
-#define ANDROID_ALARM_GET_TIME(type)        ALARM_IOR(4, type, struct timespec)
+#define ANDROID_ALARM_GET_TIME(type)        ALARM_IOW(4, type, struct timespec)
 #define ANDROID_ALARM_SET_RTC               _IOW('a', 5, struct timespec)
 #define ANDROID_ALARM_BASE_CMD(cmd)         (cmd & ~(_IOC(0, 0, 0xf0, 0)))
 #define ANDROID_ALARM_IOCTL_TO_TYPE(cmd)    (_IOC_NR(cmd) >> 4)
diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index 9097155e9ebe..dcecbfb17243 100644
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -1819,8 +1819,10 @@ void target_execute_cmd(struct se_cmd *cmd)
         /*
          * If the received CDB has aleady been aborted stop processing it here.
          */
-        if (transport_check_aborted_status(cmd, 1))
+        if (transport_check_aborted_status(cmd, 1)) {
+                complete(&cmd->t_transport_stop_comp);
                 return;
+        }
 
         /*
          * Determine if IOCTL context caller in requesting the stopping of this
@@ -3067,7 +3069,7 @@ void transport_send_task_abort(struct se_cmd *cmd)
         unsigned long flags;
 
         spin_lock_irqsave(&cmd->t_state_lock, flags);
-        if (cmd->se_cmd_flags & SCF_SENT_CHECK_CONDITION) {
+        if (cmd->se_cmd_flags & (SCF_SENT_CHECK_CONDITION | SCF_SENT_DELAYED_TAS)) {
                 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
                 return;
         }
diff --git a/drivers/tty/hvc/hvc_console.c b/drivers/tty/hvc/hvc_console.c
index a5dec1ca1b82..13ee53bd0bf6 100644
--- a/drivers/tty/hvc/hvc_console.c
+++ b/drivers/tty/hvc/hvc_console.c
@@ -424,7 +424,6 @@ static void hvc_hangup(struct tty_struct *tty)
 {
         struct hvc_struct *hp = tty->driver_data;
         unsigned long flags;
-        int temp_open_count;
 
         if (!hp)
                 return;
@@ -444,7 +443,6 @@ static void hvc_hangup(struct tty_struct *tty)
                 return;
         }
 
-        temp_open_count = hp->port.count;
         hp->port.count = 0;
         spin_unlock_irqrestore(&hp->port.lock, flags);
         tty_port_tty_set(&hp->port, NULL);
@@ -453,11 +451,6 @@ static void hvc_hangup(struct tty_struct *tty)
 
         if (hp->ops->notifier_hangup)
                 hp->ops->notifier_hangup(hp, hp->data);
-
-        while(temp_open_count) {
-                --temp_open_count;
-                tty_port_put(&hp->port);
-        }
 }
 
 /*
diff --git a/drivers/tty/serial/max310x.c b/drivers/tty/serial/max310x.c
index 2bc28a59d385..1ab1d2c66de4 100644
--- a/drivers/tty/serial/max310x.c
+++ b/drivers/tty/serial/max310x.c
@@ -1239,6 +1239,7 @@ static int __devexit max310x_remove(struct spi_device *spi)
 static const struct spi_device_id max310x_id_table[] = {
         { "max3107",    MAX310X_TYPE_MAX3107 },
         { "max3108",    MAX310X_TYPE_MAX3108 },
+        { }
 };
 MODULE_DEVICE_TABLE(spi, max310x_id_table);
 
diff --git a/drivers/tty/vt/vt.c b/drivers/tty/vt/vt.c
index f87d7e8964bf..4e0d0c3734b3 100644
--- a/drivers/tty/vt/vt.c
+++ b/drivers/tty/vt/vt.c
@@ -539,25 +539,25 @@ static void insert_char(struct vc_data *vc, unsigned int nr)
 {
         unsigned short *p = (unsigned short *) vc->vc_pos;
 
-        scr_memmovew(p + nr, p, vc->vc_cols - vc->vc_x);
+        scr_memmovew(p + nr, p, (vc->vc_cols - vc->vc_x) * 2);
         scr_memsetw(p, vc->vc_video_erase_char, nr * 2);
         vc->vc_need_wrap = 0;
         if (DO_UPDATE(vc))
                 do_update_region(vc, (unsigned long) p,
-                        (vc->vc_cols - vc->vc_x) / 2 + 1);
+                        vc->vc_cols - vc->vc_x);
 }
 
 static void delete_char(struct vc_data *vc, unsigned int nr)
 {
         unsigned short *p = (unsigned short *) vc->vc_pos;
 
-        scr_memcpyw(p, p + nr, vc->vc_cols - vc->vc_x - nr);
+        scr_memcpyw(p, p + nr, (vc->vc_cols - vc->vc_x - nr) * 2);
         scr_memsetw(p + vc->vc_cols - vc->vc_x - nr, vc->vc_video_erase_char,
                         nr * 2);
         vc->vc_need_wrap = 0;
         if (DO_UPDATE(vc))
                 do_update_region(vc, (unsigned long) p,
-                        (vc->vc_cols - vc->vc_x) / 2);
+                        vc->vc_cols - vc->vc_x);
 }
 
 static int softcursor_original;
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 1e741bca0265..f034716190ff 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -2151,8 +2151,15 @@ EXPORT_SYMBOL_GPL(usb_bus_start_enum);
 irqreturn_t usb_hcd_irq (int irq, void *__hcd)
 {
         struct usb_hcd          *hcd = __hcd;
+        unsigned long           flags;
         irqreturn_t             rc;
 
+        /* IRQF_DISABLED doesn't work correctly with shared IRQs
+         * when the first handler doesn't use it.  So let's just
+         * assume it's never used.
+         */
+        local_irq_save(flags);
+
         if (unlikely(HCD_DEAD(hcd) || !HCD_HW_ACCESSIBLE(hcd)))
                 rc = IRQ_NONE;
         else if (hcd->driver->irq(hcd) == IRQ_NONE)
@@ -2160,6 +2167,7 @@ irqreturn_t usb_hcd_irq (int irq, void *__hcd)
         else
                 rc = IRQ_HANDLED;
 
+        local_irq_restore(flags);
         return rc;
 }
 EXPORT_SYMBOL_GPL(usb_hcd_irq);
@@ -2347,6 +2355,14 @@ static int usb_hcd_request_irqs(struct usb_hcd *hcd,
         int retval;
 
         if (hcd->driver->irq) {
+
+                /* IRQF_DISABLED doesn't work as advertised when used together
+                 * with IRQF_SHARED. As usb_hcd_irq() will always disable
+                 * interrupts we can remove it here.
+                 */
+                if (irqflags & IRQF_SHARED)
+                        irqflags &= ~IRQF_DISABLED;
+
                 snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
                                 hcd->driver->description, hcd->self.busnum);
                 retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
diff --git a/drivers/usb/early/ehci-dbgp.c b/drivers/usb/early/ehci-dbgp.c
index e426ad626d74..4bfa78af379c 100644
--- a/drivers/usb/early/ehci-dbgp.c
+++ b/drivers/usb/early/ehci-dbgp.c
@@ -20,6 +20,7 @@
 #include <linux/usb/ehci_def.h>
 #include <linux/delay.h>
 #include <linux/serial_core.h>
+#include <linux/kconfig.h>
 #include <linux/kgdb.h>
 #include <linux/kthread.h>
 #include <asm/io.h>
@@ -614,12 +615,6 @@ err:
         return -ENODEV;
 }
 
-int dbgp_external_startup(struct usb_hcd *hcd)
-{
-        return xen_dbgp_external_startup(hcd) ?: _dbgp_external_startup();
-}
-EXPORT_SYMBOL_GPL(dbgp_external_startup);
-
 static int ehci_reset_port(int port)
 {
         u32 portsc;
@@ -979,6 +974,7 @@ struct console early_dbgp_console = {
         .index =        -1,
 };
 
+#if IS_ENABLED(CONFIG_USB_EHCI_HCD)
 int dbgp_reset_prep(struct usb_hcd *hcd)
 {
         int ret = xen_dbgp_reset_prep(hcd);
@@ -1007,6 +1003,13 @@ int dbgp_reset_prep(struct usb_hcd *hcd)
 }
 EXPORT_SYMBOL_GPL(dbgp_reset_prep);
 
+int dbgp_external_startup(struct usb_hcd *hcd)
+{
+        return xen_dbgp_external_startup(hcd) ?: _dbgp_external_startup();
+}
+EXPORT_SYMBOL_GPL(dbgp_external_startup);
+#endif /* USB_EHCI_HCD */
+
 #ifdef CONFIG_KGDB
 
 static char kgdbdbgp_buf[DBGP_MAX_PACKET];
diff --git a/drivers/usb/host/ehci-ls1x.c b/drivers/usb/host/ehci-ls1x.c
index ca759652626b..aa0f328922df 100644
--- a/drivers/usb/host/ehci-ls1x.c
+++ b/drivers/usb/host/ehci-ls1x.c
@@ -113,7 +113,7 @@ static int ehci_hcd_ls1x_probe(struct platform_device *pdev)
                 goto err_put_hcd;
         }
 
-        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
         if (ret)
                 goto err_put_hcd;
 
diff --git a/drivers/usb/host/ohci-xls.c b/drivers/usb/host/ohci-xls.c
index 84201cd1a472..41e378f17c66 100644
--- a/drivers/usb/host/ohci-xls.c
+++ b/drivers/usb/host/ohci-xls.c
@@ -56,7 +56,7 @@ static int ohci_xls_probe_internal(const struct hc_driver *driver,
                 goto err3;
         }
 
-        retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
+        retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
         if (retval != 0)
                 goto err4;
         return retval;
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index d0b87e7b4abf..b6b84dacc791 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -707,11 +707,12 @@ static void rxstate(struct musb *musb, struct musb_request *req)
                 fifo_count = musb_readw(epio, MUSB_RXCOUNT);
 
                 /*
-                 *  use mode 1 only if we expect data of at least ep packet_sz
-                 *  and have not yet received a short packet
+                 * Enable Mode 1 on RX transfers only when short_not_ok flag
+                 * is set. Currently short_not_ok flag is set only from
+                 * file_storage and f_mass_storage drivers
                  */
-                if ((request->length - request->actual >= musb_ep->packet_sz) &&
-                        (fifo_count >= musb_ep->packet_sz))
+
+                if (request->short_not_ok && fifo_count == musb_ep->packet_sz)
                         use_mode_1 = 1;
                 else
                         use_mode_1 = 0;
@@ -727,6 +728,27 @@ static void rxstate(struct musb *musb, struct musb_request *req)
                                 c = musb->dma_controller;
                                 channel = musb_ep->dma;
 
+        /* We use DMA Req mode 0 in rx_csr, and DMA controller operates in
+         * mode 0 only. So we do not get endpoint interrupts due to DMA
+         * completion. We only get interrupts from DMA controller.
+         *
+         * We could operate in DMA mode 1 if we knew the size of the tranfer
+         * in advance. For mass storage class, request->length = what the host
+         * sends, so that'd work.  But for pretty much everything else,
+         * request->length is routinely more than what the host sends. For
+         * most these gadgets, end of is signified either by a short packet,
+         * or filling the last byte of the buffer.  (Sending extra data in
+         * that last pckate should trigger an overflow fault.)  But in mode 1,
+         * we don't get DMA completion interrupt for short packets.
+         *
+         * Theoretically, we could enable DMAReq irq (MUSB_RXCSR_DMAMODE = 1),
+         * to get endpoint interrupt on every DMA req, but that didn't seem
+         * to work reliably.
+         *
+         * REVISIT an updated g_file_storage can set req->short_not_ok, which
+         * then becomes usable as a runtime "use mode 1" hint...
+         */
+
                                 /* Experimental: Mode1 works with mass storage use cases */
                                 if (use_mode_1) {
                                         csr |= MUSB_RXCSR_AUTOCLEAR;
diff --git a/drivers/usb/musb/ux500.c b/drivers/usb/musb/ux500.c
index d62a91fedc22..0e62f504410e 100644
--- a/drivers/usb/musb/ux500.c
+++ b/drivers/usb/musb/ux500.c
@@ -65,7 +65,7 @@ static int __devinit ux500_probe(struct platform_device *pdev)
         struct platform_device          *musb;
         struct ux500_glue               *glue;
         struct clk                      *clk;
-
+        int                             musbid;
         int                             ret = -ENOMEM;
 
         glue = kzalloc(sizeof(*glue), GFP_KERNEL);
diff --git a/drivers/usb/otg/Kconfig b/drivers/usb/otg/Kconfig
index d8c8a42bff3e..6223062d5d1b 100644
--- a/drivers/usb/otg/Kconfig
+++ b/drivers/usb/otg/Kconfig
@@ -58,7 +58,7 @@ config USB_ULPI_VIEWPORT
 
 config TWL4030_USB
         tristate "TWL4030 USB Transceiver Driver"
-        depends on TWL4030_CORE && REGULATOR_TWL4030
+        depends on TWL4030_CORE && REGULATOR_TWL4030 && USB_MUSB_OMAP2PLUS
         select USB_OTG_UTILS
         help
           Enable this to support the USB OTG transceiver on TWL4030
@@ -68,7 +68,7 @@ config TWL4030_USB
 
 config TWL6030_USB
         tristate "TWL6030 USB Transceiver Driver"
-        depends on TWL4030_CORE && OMAP_USB2
+        depends on TWL4030_CORE && OMAP_USB2 && USB_MUSB_OMAP2PLUS
         select USB_OTG_UTILS
         help
           Enable this to support the USB OTG transceiver on TWL6030
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index 7179b0c5f814..cff8dd5b462d 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -2430,7 +2430,7 @@ static void keyspan_release(struct usb_serial *serial)
 static int keyspan_port_probe(struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
-        struct keyspan_port_private *s_priv;
+        struct keyspan_serial_private *s_priv;
         struct keyspan_port_private *p_priv;
         const struct keyspan_device_details *d_details;
         struct callbacks *cback;
@@ -2445,7 +2445,6 @@ static int keyspan_port_probe(struct usb_serial_port *port)
         if (!p_priv)
                 return -ENOMEM;
 
-        s_priv = usb_get_serial_data(port->serial);
         p_priv->device_details = d_details;
 
         /* Setup values for the various callback routines */
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 5dee7d61241e..edc64bb6f457 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -158,6 +158,7 @@ static void option_instat_callback(struct urb *urb);
 #define NOVATELWIRELESS_PRODUCT_EVDO_EMBEDDED_HIGHSPEED 0x8001
 #define NOVATELWIRELESS_PRODUCT_HSPA_EMBEDDED_FULLSPEED 0x9000
 #define NOVATELWIRELESS_PRODUCT_HSPA_EMBEDDED_HIGHSPEED 0x9001
+#define NOVATELWIRELESS_PRODUCT_E362            0x9010
 #define NOVATELWIRELESS_PRODUCT_G1              0xA001
 #define NOVATELWIRELESS_PRODUCT_G1_M            0xA002
 #define NOVATELWIRELESS_PRODUCT_G2              0xA010
@@ -193,6 +194,9 @@ static void option_instat_callback(struct urb *urb);
 #define DELL_PRODUCT_5730_MINICARD_TELUS        0x8181
 #define DELL_PRODUCT_5730_MINICARD_VZW          0x8182
 
+#define DELL_PRODUCT_5800_MINICARD_VZW          0x8195  /* Novatel E362 */
+#define DELL_PRODUCT_5800_V2_MINICARD_VZW       0x8196  /* Novatel E362 */
+
 #define KYOCERA_VENDOR_ID                       0x0c88
 #define KYOCERA_PRODUCT_KPC650                  0x17da
 #define KYOCERA_PRODUCT_KPC680                  0x180a
@@ -283,6 +287,7 @@ static void option_instat_callback(struct urb *urb);
 /* ALCATEL PRODUCTS */
 #define ALCATEL_VENDOR_ID                       0x1bbb
 #define ALCATEL_PRODUCT_X060S_X200              0x0000
+#define ALCATEL_PRODUCT_X220_X500D              0x0017
 
 #define PIRELLI_VENDOR_ID                       0x1266
 #define PIRELLI_PRODUCT_C100_1                  0x1002
@@ -706,6 +711,7 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_G2) },
         /* Novatel Ovation MC551 a.k.a. Verizon USB551L */
         { USB_DEVICE_AND_INTERFACE_INFO(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC551, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_E362, 0xff, 0xff, 0xff) },
 
         { USB_DEVICE(AMOI_VENDOR_ID, AMOI_PRODUCT_H01) },
         { USB_DEVICE(AMOI_VENDOR_ID, AMOI_PRODUCT_H01A) },
@@ -728,6 +734,8 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5730_MINICARD_SPRINT) },      /* Dell Wireless 5730 Mobile Broadband EVDO/HSPA Mini-Card */
         { USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5730_MINICARD_TELUS) },       /* Dell Wireless 5730 Mobile Broadband EVDO/HSPA Mini-Card */
         { USB_DEVICE(DELL_VENDOR_ID, DELL_PRODUCT_5730_MINICARD_VZW) },         /* Dell Wireless 5730 Mobile Broadband EVDO/HSPA Mini-Card */
+        { USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, DELL_PRODUCT_5800_MINICARD_VZW, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(DELL_VENDOR_ID, DELL_PRODUCT_5800_V2_MINICARD_VZW, 0xff, 0xff, 0xff) },
         { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_E100A) },   /* ADU-E100, ADU-310 */
         { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_500A) },
         { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_620UW) },
@@ -1157,6 +1165,7 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_X060S_X200),
           .driver_info = (kernel_ulong_t)&alcatel_x200_blacklist
         },
+        { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_X220_X500D) },
         { USB_DEVICE(AIRPLUS_VENDOR_ID, AIRPLUS_PRODUCT_MCD650) },
         { USB_DEVICE(TLAYTECH_VENDOR_ID, TLAYTECH_PRODUCT_TEU800) },
         { USB_DEVICE(LONGCHEER_VENDOR_ID, FOUR_G_SYSTEMS_PRODUCT_W14),
diff --git a/drivers/usb/serial/usb_wwan.c b/drivers/usb/serial/usb_wwan.c
index 61a73ad1a187..a3e9c095f0d8 100644
--- a/drivers/usb/serial/usb_wwan.c
+++ b/drivers/usb/serial/usb_wwan.c
@@ -455,9 +455,6 @@ static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port,
         struct usb_serial *serial = port->serial;
         struct urb *urb;
 
-        if (endpoint == -1)
-                return NULL;    /* endpoint not needed */
-
         urb = usb_alloc_urb(0, GFP_KERNEL);     /* No ISO */
         if (urb == NULL) {
                 dev_dbg(&serial->interface->dev,
@@ -489,6 +486,9 @@ int usb_wwan_port_probe(struct usb_serial_port *port)
         init_usb_anchor(&portdata->delayed);
 
         for (i = 0; i < N_IN_URB; i++) {
+                if (!port->bulk_in_size)
+                        break;
+
                 buffer = (u8 *)__get_free_page(GFP_KERNEL);
                 if (!buffer)
                         goto bail_out_error;
@@ -502,8 +502,8 @@ int usb_wwan_port_probe(struct usb_serial_port *port)
         }
 
         for (i = 0; i < N_OUT_URB; i++) {
-                if (port->bulk_out_endpointAddress == -1)
-                        continue;
+                if (!port->bulk_out_size)
+                        break;
 
                 buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL);
                 if (!buffer)
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index a3d54366afcc..92f35abee92d 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -186,6 +186,12 @@ static int slave_configure(struct scsi_device *sdev)
                 /* Some devices don't handle VPD pages correctly */
                 sdev->skip_vpd_pages = 1;
 
+                /* Do not attempt to use REPORT SUPPORTED OPERATION CODES */
+                sdev->no_report_opcodes = 1;
+
+                /* Do not attempt to use WRITE SAME */
+                sdev->no_write_same = 1;
+
                 /* Some disks return the total number of blocks in response
                  * to READ CAPACITY rather than the highest block number.
                  * If this device makes that mistake, tell the sd driver. */
diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c
index 99ac2cb08b43..dedaf81d8f36 100644
--- a/drivers/vhost/vhost.c
+++ b/drivers/vhost/vhost.c
@@ -1076,7 +1076,7 @@ static int translate_desc(struct vhost_dev *dev, u64 addr, u32 len,
                 }
                 _iov = iov + ret;
                 size = reg->memory_size - addr + reg->guest_phys_addr;
-                _iov->iov_len = min((u64)len, size);
+                _iov->iov_len = min((u64)len - s, size);
                 _iov->iov_base = (void __user *)(unsigned long)
                         (reg->userspace_addr + addr - reg->guest_phys_addr);
                 s += size;
diff --git a/drivers/video/omap2/dss/dsi.c b/drivers/video/omap2/dss/dsi.c
index d64ac3842884..bee92846cfab 100644
--- a/drivers/video/omap2/dss/dsi.c
+++ b/drivers/video/omap2/dss/dsi.c
@@ -365,11 +365,20 @@ struct platform_device *dsi_get_dsidev_from_id(int module)
         struct omap_dss_output *out;
         enum omap_dss_output_id id;
 
-        id = module == 0 ? OMAP_DSS_OUTPUT_DSI1 : OMAP_DSS_OUTPUT_DSI2;
+        switch (module) {
+        case 0:
+                id = OMAP_DSS_OUTPUT_DSI1;
+                break;
+        case 1:
+                id = OMAP_DSS_OUTPUT_DSI2;
+                break;
+        default:
+                return NULL;
+        }
 
         out = omap_dss_get_output(id);
 
-        return out->pdev;
+        return out ? out->pdev : NULL;
 }
 
 static inline void dsi_write_reg(struct platform_device *dsidev,
diff --git a/drivers/video/omap2/dss/dss.c b/drivers/video/omap2/dss/dss.c
index 2ab1c3e96553..5f6eea801b06 100644
--- a/drivers/video/omap2/dss/dss.c
+++ b/drivers/video/omap2/dss/dss.c
@@ -697,11 +697,15 @@ static int dss_get_clocks(void)
 
         dss.dss_clk = clk;
 
-        clk = clk_get(NULL, dss.feat->clk_name);
-        if (IS_ERR(clk)) {
-                DSSERR("Failed to get %s\n", dss.feat->clk_name);
-                r = PTR_ERR(clk);
-                goto err;
+        if (dss.feat->clk_name) {
+                clk = clk_get(NULL, dss.feat->clk_name);
+                if (IS_ERR(clk)) {
+                        DSSERR("Failed to get %s\n", dss.feat->clk_name);
+                        r = PTR_ERR(clk);
+                        goto err;
+                }
+        } else {
+                clk = NULL;
         }
 
         dss.dpll4_m4_ck = clk;
@@ -805,10 +809,10 @@ static int __init dss_init_features(struct device *dev)
 
         if (cpu_is_omap24xx())
                 src = &omap24xx_dss_feats;
-        else if (cpu_is_omap34xx())
-                src = &omap34xx_dss_feats;
         else if (cpu_is_omap3630())
                 src = &omap3630_dss_feats;
+        else if (cpu_is_omap34xx())
+                src = &omap34xx_dss_feats;
         else if (cpu_is_omap44xx())
                 src = &omap44xx_dss_feats;
         else if (soc_is_omap54xx())
diff --git a/drivers/video/omap2/dss/hdmi.c b/drivers/video/omap2/dss/hdmi.c
index a48a7dd75b33..8c9b8b3b7f77 100644
--- a/drivers/video/omap2/dss/hdmi.c
+++ b/drivers/video/omap2/dss/hdmi.c
@@ -644,8 +644,10 @@ static void hdmi_dump_regs(struct seq_file *s)
 {
         mutex_lock(&hdmi.lock);
 
-        if (hdmi_runtime_get())
+        if (hdmi_runtime_get()) {
+                mutex_unlock(&hdmi.lock);
                 return;
+        }
 
         hdmi.ip_data.ops->dump_wrapper(&hdmi.ip_data, s);
         hdmi.ip_data.ops->dump_pll(&hdmi.ip_data, s);
diff --git a/drivers/video/omap2/omapfb/omapfb-ioctl.c b/drivers/video/omap2/omapfb/omapfb-ioctl.c
index 606b89f12351..d630b26a005c 100644
--- a/drivers/video/omap2/omapfb/omapfb-ioctl.c
+++ b/drivers/video/omap2/omapfb/omapfb-ioctl.c
@@ -787,7 +787,7 @@ int omapfb_ioctl(struct fb_info *fbi, unsigned int cmd, unsigned long arg)
 
         case OMAPFB_WAITFORVSYNC:
                 DBG("ioctl WAITFORVSYNC\n");
-                if (!display && !display->output && !display->output->manager) {
+                if (!display || !display->output || !display->output->manager) {
                         r = -EINVAL;
                         break;
                 }
diff --git a/drivers/xen/privcmd.c b/drivers/xen/privcmd.c
index 8adb9cc267f9..71f5c459b088 100644
--- a/drivers/xen/privcmd.c
+++ b/drivers/xen/privcmd.c
@@ -361,13 +361,13 @@ static long privcmd_ioctl_mmap_batch(void __user *udata, int version)
         down_write(&mm->mmap_sem);
 
         vma = find_vma(mm, m.addr);
-        ret = -EINVAL;
         if (!vma ||
             vma->vm_ops != &privcmd_vm_ops ||
             (m.addr != vma->vm_start) ||
             ((m.addr + (nr_pages << PAGE_SHIFT)) != vma->vm_end) ||
             !privcmd_enforce_singleshot_mapping(vma)) {
                 up_write(&mm->mmap_sem);
+                ret = -EINVAL;
                 goto out;
         }
 
@@ -383,12 +383,16 @@ static long privcmd_ioctl_mmap_batch(void __user *udata, int version)
 
         up_write(&mm->mmap_sem);
 
-        if (state.global_error && (version == 1)) {
-                /* Write back errors in second pass. */
-                state.user_mfn = (xen_pfn_t *)m.arr;
-                state.err      = err_array;
-                ret = traverse_pages(m.num, sizeof(xen_pfn_t),
-                                     &pagelist, mmap_return_errors_v1, &state);
+        if (version == 1) {
+                if (state.global_error) {
+                        /* Write back errors in second pass. */
+                        state.user_mfn = (xen_pfn_t *)m.arr;
+                        state.err      = err_array;
+                        ret = traverse_pages(m.num, sizeof(xen_pfn_t),
+                                             &pagelist, mmap_return_errors_v1, &state);
+                } else
+                        ret = 0;
+
         } else if (version == 2) {
                 ret = __copy_to_user(m.err, err_array, m.num * sizeof(int));
                 if (ret)