73 files changed, 983 insertions, 439 deletions

diff --git a/MAINTAINERS b/MAINTAINERS
index 3523ab000f1f..bd07f6c1890f 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -5667,7 +5667,6 @@ F:	drivers/media/video/*7146*
 F:      include/media/*7146*
 
 SAMSUNG AUDIO (ASoC) DRIVERS
-M:      Jassi Brar <jassisinghbrar@gmail.com>
 M:      Sangbeom Kim <sbkim73@samsung.com>
 L:      alsa-devel@alsa-project.org (moderated for non-subscribers)
 S:      Supported
diff --git a/arch/powerpc/boot/dts/p1023rds.dts b/arch/powerpc/boot/dts/p1023rds.dts
index d9b776740a67..d3b478242ea9 100644
--- a/arch/powerpc/boot/dts/p1023rds.dts
+++ b/arch/powerpc/boot/dts/p1023rds.dts
@@ -449,6 +449,7 @@
                         interrupt-parent = <&mpic>;
                         interrupts = <16 2>;
                         interrupt-map-mask = <0xf800 0 0 7>;
+                        /* IRQ[0:3] are pulled up on board, set to active-low */
                         interrupt-map = <
                                 /* IDSEL 0x0 */
                                 0000 0 0 1 &mpic 0 1
@@ -488,11 +489,15 @@
                         interrupt-parent = <&mpic>;
                         interrupts = <16 2>;
                         interrupt-map-mask = <0xf800 0 0 7>;
+                        /*
+                         * IRQ[4:6] only for PCIe, set to active-high,
+                         * IRQ[7] is pulled up on board, set to active-low
+                         */
                         interrupt-map = <
                                 /* IDSEL 0x0 */
-                                0000 0 0 1 &mpic 4 1
-                                0000 0 0 2 &mpic 5 1
-                                0000 0 0 3 &mpic 6 1
+                                0000 0 0 1 &mpic 4 2
+                                0000 0 0 2 &mpic 5 2
+                                0000 0 0 3 &mpic 6 2
                                 0000 0 0 4 &mpic 7 1
                                 >;
                         ranges = <0x2000000 0x0 0xa0000000
@@ -527,12 +532,16 @@
                         interrupt-parent = <&mpic>;
                         interrupts = <16 2>;
                         interrupt-map-mask = <0xf800 0 0 7>;
+                        /*
+                         * IRQ[8:10] are pulled up on board, set to active-low
+                         * IRQ[11] only for PCIe, set to active-high,
+                         */
                         interrupt-map = <
                                 /* IDSEL 0x0 */
                                 0000 0 0 1 &mpic 8 1
                                 0000 0 0 2 &mpic 9 1
                                 0000 0 0 3 &mpic 10 1
-                                0000 0 0 4 &mpic 11 1
+                                0000 0 0 4 &mpic 11 2
                                 >;
                         ranges = <0x2000000 0x0 0x80000000
                                   0x2000000 0x0 0x80000000
diff --git a/arch/powerpc/configs/ppc44x_defconfig b/arch/powerpc/configs/ppc44x_defconfig
index 6cdf1c0d2c8a..3b98d7354341 100644
--- a/arch/powerpc/configs/ppc44x_defconfig
+++ b/arch/powerpc/configs/ppc44x_defconfig
@@ -52,6 +52,8 @@ CONFIG_MTD_CFI=y
 CONFIG_MTD_JEDECPROBE=y
 CONFIG_MTD_CFI_AMDSTD=y
 CONFIG_MTD_PHYSMAP_OF=y
+CONFIG_MTD_NAND=m
+CONFIG_MTD_NAND_NDFC=m
 CONFIG_MTD_UBI=m
 CONFIG_MTD_UBI_GLUEBI=m
 CONFIG_PROC_DEVICETREE=y
diff --git a/arch/powerpc/mm/hugetlbpage.c b/arch/powerpc/mm/hugetlbpage.c
index 5964371303ac..8558b572e55d 100644
--- a/arch/powerpc/mm/hugetlbpage.c
+++ b/arch/powerpc/mm/hugetlbpage.c
@@ -15,6 +15,7 @@
 #include <linux/of_fdt.h>
 #include <linux/memblock.h>
 #include <linux/bootmem.h>
+#include <linux/moduleparam.h>
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
 #include <asm/tlb.h>
diff --git a/arch/powerpc/platforms/85xx/Kconfig b/arch/powerpc/platforms/85xx/Kconfig
index 45023e26aea3..d7946be298b6 100644
--- a/arch/powerpc/platforms/85xx/Kconfig
+++ b/arch/powerpc/platforms/85xx/Kconfig
@@ -203,7 +203,7 @@ config P3060_QDS
         select PPC_E500MC
         select PHYS_64BIT
         select SWIOTLB
-        select MPC8xxx_GPIO
+        select GPIO_MPC8XXX
         select HAS_RAPIDIO
         select PPC_EPAPR_HV_PIC
         help
diff --git a/arch/powerpc/platforms/85xx/p3060_qds.c b/arch/powerpc/platforms/85xx/p3060_qds.c
index 01dcf44871e9..081cf4ac1881 100644
--- a/arch/powerpc/platforms/85xx/p3060_qds.c
+++ b/arch/powerpc/platforms/85xx/p3060_qds.c
@@ -70,7 +70,7 @@ define_machine(p3060_qds) {
         .power_save             = e500_idle,
 };
 
-machine_device_initcall(p3060_qds, declare_of_platform_devices);
+machine_device_initcall(p3060_qds, corenet_ds_publish_devices);
 
 #ifdef CONFIG_SWIOTLB
 machine_arch_initcall(p3060_qds, swiotlb_setup_bus_notifier);
diff --git a/arch/powerpc/sysdev/ehv_pic.c b/arch/powerpc/sysdev/ehv_pic.c
index af1a5df46b3e..b6731e4a6646 100644
--- a/arch/powerpc/sysdev/ehv_pic.c
+++ b/arch/powerpc/sysdev/ehv_pic.c
@@ -280,6 +280,7 @@ void __init ehv_pic_init(void)
 
         if (!ehv_pic->irqhost) {
                 of_node_put(np);
+                kfree(ehv_pic);
                 return;
         }
 
diff --git a/arch/powerpc/sysdev/fsl_lbc.c b/arch/powerpc/sysdev/fsl_lbc.c
index c4d96fa32ba5..d5c3c90ee698 100644
--- a/arch/powerpc/sysdev/fsl_lbc.c
+++ b/arch/powerpc/sysdev/fsl_lbc.c
@@ -328,6 +328,7 @@ static int __devinit fsl_lbc_ctrl_probe(struct platform_device *dev)
 err:
         iounmap(fsl_lbc_ctrl_dev->regs);
         kfree(fsl_lbc_ctrl_dev);
+        fsl_lbc_ctrl_dev = NULL;
         return ret;
 }
 
diff --git a/arch/powerpc/sysdev/qe_lib/qe.c b/arch/powerpc/sysdev/qe_lib/qe.c
index 3363fbc964f8..ceb09cbd2329 100644
--- a/arch/powerpc/sysdev/qe_lib/qe.c
+++ b/arch/powerpc/sysdev/qe_lib/qe.c
@@ -216,7 +216,7 @@ int qe_setbrg(enum qe_clock brg, unsigned int rate, unsigned int multiplier)
         /* Errata QE_General4, which affects some MPC832x and MPC836x SOCs, says
            that the BRG divisor must be even if you're not using divide-by-16
            mode. */
-        if (!div16 && (divisor & 1))
+        if (!div16 && (divisor & 1) && (divisor > 3))
                 divisor++;
 
         tempval = ((divisor - 1) << QE_BRGC_DIVISOR_SHIFT) |
diff --git a/drivers/acpi/apei/erst.c b/drivers/acpi/apei/erst.c
index 127408069ca7..631b9477b99c 100644
--- a/drivers/acpi/apei/erst.c
+++ b/drivers/acpi/apei/erst.c
@@ -932,7 +932,8 @@ static int erst_check_table(struct acpi_table_erst *erst_tab)
 static int erst_open_pstore(struct pstore_info *psi);
 static int erst_close_pstore(struct pstore_info *psi);
 static ssize_t erst_reader(u64 *id, enum pstore_type_id *type,
-                           struct timespec *time, struct pstore_info *psi);
+                           struct timespec *time, char **buf,
+                           struct pstore_info *psi);
 static int erst_writer(enum pstore_type_id type, u64 *id, unsigned int part,
                        size_t size, struct pstore_info *psi);
 static int erst_clearer(enum pstore_type_id type, u64 id,
@@ -986,17 +987,23 @@ static int erst_close_pstore(struct pstore_info *psi)
 }
 
 static ssize_t erst_reader(u64 *id, enum pstore_type_id *type,
-                           struct timespec *time, struct pstore_info *psi)
+                           struct timespec *time, char **buf,
+                           struct pstore_info *psi)
 {
         int rc;
         ssize_t len = 0;
         u64 record_id;
-        struct cper_pstore_record *rcd = (struct cper_pstore_record *)
-                                        (erst_info.buf - sizeof(*rcd));
+        struct cper_pstore_record *rcd;
+        size_t rcd_len = sizeof(*rcd) + erst_info.bufsize;
 
         if (erst_disable)
                 return -ENODEV;
 
+        rcd = kmalloc(rcd_len, GFP_KERNEL);
+        if (!rcd) {
+                rc = -ENOMEM;
+                goto out;
+        }
 skip:
         rc = erst_get_record_id_next(&reader_pos, &record_id);
         if (rc)
@@ -1004,22 +1011,27 @@ skip:
 
         /* no more record */
         if (record_id == APEI_ERST_INVALID_RECORD_ID) {
-                rc = -1;
+                rc = -EINVAL;
                 goto out;
         }
 
-        len = erst_read(record_id, &rcd->hdr, sizeof(*rcd) +
-                        erst_info.bufsize);
+        len = erst_read(record_id, &rcd->hdr, rcd_len);
         /* The record may be cleared by others, try read next record */
         if (len == -ENOENT)
                 goto skip;
-        else if (len < 0) {
-                rc = -1;
+        else if (len < sizeof(*rcd)) {
+                rc = -EIO;
                 goto out;
         }
         if (uuid_le_cmp(rcd->hdr.creator_id, CPER_CREATOR_PSTORE) != 0)
                 goto skip;
 
+        *buf = kmalloc(len, GFP_KERNEL);
+        if (*buf == NULL) {
+                rc = -ENOMEM;
+                goto out;
+        }
+        memcpy(*buf, rcd->data, len - sizeof(*rcd));
         *id = record_id;
         if (uuid_le_cmp(rcd->sec_hdr.section_type,
                         CPER_SECTION_TYPE_DMESG) == 0)
@@ -1037,6 +1049,7 @@ skip:
         time->tv_nsec = 0;
 
 out:
+        kfree(rcd);
         return (rc < 0) ? rc : (len - sizeof(*rcd));
 }
 
diff --git a/drivers/crypto/mv_cesa.c b/drivers/crypto/mv_cesa.c
index 5c6f56f21443..dcd8babae9eb 100644
--- a/drivers/crypto/mv_cesa.c
+++ b/drivers/crypto/mv_cesa.c
@@ -343,11 +343,13 @@ static void mv_process_hash_current(int first_block)
                 else
                         op.config |= CFG_MID_FRAG;
 
-                writel(req_ctx->state[0], cpg->reg + DIGEST_INITIAL_VAL_A);
-                writel(req_ctx->state[1], cpg->reg + DIGEST_INITIAL_VAL_B);
-                writel(req_ctx->state[2], cpg->reg + DIGEST_INITIAL_VAL_C);
-                writel(req_ctx->state[3], cpg->reg + DIGEST_INITIAL_VAL_D);
-                writel(req_ctx->state[4], cpg->reg + DIGEST_INITIAL_VAL_E);
+                if (first_block) {
+                        writel(req_ctx->state[0], cpg->reg + DIGEST_INITIAL_VAL_A);
+                        writel(req_ctx->state[1], cpg->reg + DIGEST_INITIAL_VAL_B);
+                        writel(req_ctx->state[2], cpg->reg + DIGEST_INITIAL_VAL_C);
+                        writel(req_ctx->state[3], cpg->reg + DIGEST_INITIAL_VAL_D);
+                        writel(req_ctx->state[4], cpg->reg + DIGEST_INITIAL_VAL_E);
+                }
         }
 
         memcpy(cpg->sram + SRAM_CONFIG, &op, sizeof(struct sec_accel_config));
diff --git a/drivers/edac/mpc85xx_edac.c b/drivers/edac/mpc85xx_edac.c
index 8af8e864a9cf..73464a62adf7 100644
--- a/drivers/edac/mpc85xx_edac.c
+++ b/drivers/edac/mpc85xx_edac.c
@@ -1128,7 +1128,7 @@ static struct of_device_id mpc85xx_mc_err_of_match[] = {
         { .compatible = "fsl,p1020-memory-controller", },
         { .compatible = "fsl,p1021-memory-controller", },
         { .compatible = "fsl,p2020-memory-controller", },
-        { .compatible = "fsl,p4080-memory-controller", },
+        { .compatible = "fsl,qoriq-memory-controller", },
         {},
 };
 MODULE_DEVICE_TABLE(of, mpc85xx_mc_err_of_match);
diff --git a/drivers/firmware/efivars.c b/drivers/firmware/efivars.c
index 8370f72d87ff..b0a81173a268 100644
--- a/drivers/firmware/efivars.c
+++ b/drivers/firmware/efivars.c
@@ -457,7 +457,8 @@ static int efi_pstore_close(struct pstore_info *psi)
 }
 
 static ssize_t efi_pstore_read(u64 *id, enum pstore_type_id *type,
-                               struct timespec *timespec, struct pstore_info *psi)
+                               struct timespec *timespec,
+                               char **buf, struct pstore_info *psi)
 {
         efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
         struct efivars *efivars = psi->data;
@@ -478,7 +479,11 @@ static ssize_t efi_pstore_read(u64 *id, enum pstore_type_id *type,
                                 timespec->tv_nsec = 0;
                                 get_var_data_locked(efivars, &efivars->walk_entry->var);
                                 size = efivars->walk_entry->var.DataSize;
-                                memcpy(psi->buf, efivars->walk_entry->var.Data, size);
+                                *buf = kmalloc(size, GFP_KERNEL);
+                                if (*buf == NULL)
+                                        return -ENOMEM;
+                                memcpy(*buf, efivars->walk_entry->var.Data,
+                                       size);
                                 efivars->walk_entry = list_entry(efivars->walk_entry->list.next,
                                                    struct efivar_entry, list);
                                 return size;
@@ -576,7 +581,8 @@ static int efi_pstore_close(struct pstore_info *psi)
 }
 
 static ssize_t efi_pstore_read(u64 *id, enum pstore_type_id *type,
-                               struct timespec *time, struct pstore_info *psi)
+                               struct timespec *timespec,
+                               char **buf, struct pstore_info *psi)
 {
         return -1;
 }
diff --git a/drivers/gpio/gpio-pca953x.c b/drivers/gpio/gpio-pca953x.c
index 147df8ae79db..d3f3e8f54561 100644
--- a/drivers/gpio/gpio-pca953x.c
+++ b/drivers/gpio/gpio-pca953x.c
@@ -546,7 +546,7 @@ static void pca953x_irq_teardown(struct pca953x_chip *chip)
  * Translate OpenFirmware node properties into platform_data
  * WARNING: This is DEPRECATED and will be removed eventually!
  */
-void
+static void
 pca953x_get_alt_pdata(struct i2c_client *client, int *gpio_base, int *invert)
 {
         struct device_node *node;
@@ -574,7 +574,7 @@ pca953x_get_alt_pdata(struct i2c_client *client, int *gpio_base, int *invert)
                 *invert = *val;
 }
 #else
-void
+static void
 pca953x_get_alt_pdata(struct i2c_client *client, int *gpio_base, int *invert)
 {
         *gpio_base = -1;
diff --git a/drivers/gpu/drm/exynos/exynos_drm_buf.c b/drivers/gpu/drm/exynos/exynos_drm_buf.c
index 6f8afea94fc9..2bb07bca511a 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_buf.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_buf.c
@@ -27,82 +27,84 @@
 #include "drm.h"
 
 #include "exynos_drm_drv.h"
+#include "exynos_drm_gem.h"
 #include "exynos_drm_buf.h"
 
-static DEFINE_MUTEX(exynos_drm_buf_lock);
-
 static int lowlevel_buffer_allocate(struct drm_device *dev,
-                struct exynos_drm_buf_entry *entry)
+                struct exynos_drm_gem_buf *buffer)
 {
         DRM_DEBUG_KMS("%s\n", __FILE__);
 
-        entry->vaddr = dma_alloc_writecombine(dev->dev, entry->size,
-                        (dma_addr_t *)&entry->paddr, GFP_KERNEL);
-        if (!entry->paddr) {
+        buffer->kvaddr = dma_alloc_writecombine(dev->dev, buffer->size,
+                        &buffer->dma_addr, GFP_KERNEL);
+        if (!buffer->kvaddr) {
                 DRM_ERROR("failed to allocate buffer.\n");
                 return -ENOMEM;
         }
 
-        DRM_DEBUG_KMS("allocated : vaddr(0x%x), paddr(0x%x), size(0x%x)\n",
-                        (unsigned int)entry->vaddr, entry->paddr, entry->size);
+        DRM_DEBUG_KMS("vaddr(0x%lx), dma_addr(0x%lx), size(0x%lx)\n",
+                        (unsigned long)buffer->kvaddr,
+                        (unsigned long)buffer->dma_addr,
+                        buffer->size);
 
         return 0;
 }
 
 static void lowlevel_buffer_deallocate(struct drm_device *dev,
-                struct exynos_drm_buf_entry *entry)
+                struct exynos_drm_gem_buf *buffer)
 {
         DRM_DEBUG_KMS("%s.\n", __FILE__);
 
-        if (entry->paddr && entry->vaddr && entry->size)
-                dma_free_writecombine(dev->dev, entry->size, entry->vaddr,
-                                entry->paddr);
+        if (buffer->dma_addr && buffer->size)
+                dma_free_writecombine(dev->dev, buffer->size, buffer->kvaddr,
+                                (dma_addr_t)buffer->dma_addr);
         else
-                DRM_DEBUG_KMS("entry data is null.\n");
+                DRM_DEBUG_KMS("buffer data are invalid.\n");
 }
 
-struct exynos_drm_buf_entry *exynos_drm_buf_create(struct drm_device *dev,
+struct exynos_drm_gem_buf *exynos_drm_buf_create(struct drm_device *dev,
                 unsigned int size)
 {
-        struct exynos_drm_buf_entry *entry;
+        struct exynos_drm_gem_buf *buffer;
 
         DRM_DEBUG_KMS("%s.\n", __FILE__);
+        DRM_DEBUG_KMS("desired size = 0x%x\n", size);
 
-        entry = kzalloc(sizeof(*entry), GFP_KERNEL);
-        if (!entry) {
-                DRM_ERROR("failed to allocate exynos_drm_buf_entry.\n");
+        buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
+        if (!buffer) {
+                DRM_ERROR("failed to allocate exynos_drm_gem_buf.\n");
                 return ERR_PTR(-ENOMEM);
         }
 
-        entry->size = size;
+        buffer->size = size;
 
         /*
          * allocate memory region with size and set the memory information
-         * to vaddr and paddr of a entry object.
+         * to vaddr and dma_addr of a buffer object.
          */
-        if (lowlevel_buffer_allocate(dev, entry) < 0) {
-                kfree(entry);
-                entry = NULL;
+        if (lowlevel_buffer_allocate(dev, buffer) < 0) {
+                kfree(buffer);
+                buffer = NULL;
                 return ERR_PTR(-ENOMEM);
         }
 
-        return entry;
+        return buffer;
 }
 
 void exynos_drm_buf_destroy(struct drm_device *dev,
-                struct exynos_drm_buf_entry *entry)
+                struct exynos_drm_gem_buf *buffer)
 {
         DRM_DEBUG_KMS("%s.\n", __FILE__);
 
-        if (!entry) {
-                DRM_DEBUG_KMS("entry is null.\n");
+        if (!buffer) {
+                DRM_DEBUG_KMS("buffer is null.\n");
                 return;
         }
 
-        lowlevel_buffer_deallocate(dev, entry);
+        lowlevel_buffer_deallocate(dev, buffer);
 
-        kfree(entry);
-        entry = NULL;
+        kfree(buffer);
+        buffer = NULL;
 }
 
 MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
diff --git a/drivers/gpu/drm/exynos/exynos_drm_buf.h b/drivers/gpu/drm/exynos/exynos_drm_buf.h
index 045d59eab01a..6e91f9caa5db 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_buf.h
+++ b/drivers/gpu/drm/exynos/exynos_drm_buf.h
@@ -26,28 +26,15 @@
 #ifndef _EXYNOS_DRM_BUF_H_
 #define _EXYNOS_DRM_BUF_H_
 
-/*
- * exynos drm buffer entry structure.
- *
- * @paddr: physical address of allocated memory.
- * @vaddr: kernel virtual address of allocated memory.
- * @size: size of allocated memory.
- */
-struct exynos_drm_buf_entry {
-        dma_addr_t paddr;
-        void __iomem *vaddr;
-        unsigned int size;
-};
-
 /* allocate physical memory. */
-struct exynos_drm_buf_entry *exynos_drm_buf_create(struct drm_device *dev,
+struct exynos_drm_gem_buf *exynos_drm_buf_create(struct drm_device *dev,
                 unsigned int size);
 
-/* get physical memory information of a drm framebuffer. */
-struct exynos_drm_buf_entry *exynos_drm_fb_get_buf(struct drm_framebuffer *fb);
+/* get memory information of a drm framebuffer. */
+struct exynos_drm_gem_buf *exynos_drm_fb_get_buf(struct drm_framebuffer *fb);
 
 /* remove allocated physical memory. */
 void exynos_drm_buf_destroy(struct drm_device *dev,
-                struct exynos_drm_buf_entry *entry);
+                struct exynos_drm_gem_buf *buffer);
 
 #endif
diff --git a/drivers/gpu/drm/exynos/exynos_drm_connector.c b/drivers/gpu/drm/exynos/exynos_drm_connector.c
index 985d9e768728..d620b0784257 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_connector.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_connector.c
@@ -37,6 +37,8 @@
 
 struct exynos_drm_connector {
         struct drm_connector    drm_connector;
+        uint32_t                encoder_id;
+        struct exynos_drm_manager *manager;
 };
 
 /* convert exynos_video_timings to drm_display_mode */
@@ -47,6 +49,7 @@ convert_to_display_mode(struct drm_display_mode *mode,
         DRM_DEBUG_KMS("%s\n", __FILE__);
 
         mode->clock = timing->pixclock / 1000;
+        mode->vrefresh = timing->refresh;
 
         mode->hdisplay = timing->xres;
         mode->hsync_start = mode->hdisplay + timing->left_margin;
@@ -57,6 +60,12 @@ convert_to_display_mode(struct drm_display_mode *mode,
         mode->vsync_start = mode->vdisplay + timing->upper_margin;
         mode->vsync_end = mode->vsync_start + timing->vsync_len;
         mode->vtotal = mode->vsync_end + timing->lower_margin;
+
+        if (timing->vmode & FB_VMODE_INTERLACED)
+                mode->flags |= DRM_MODE_FLAG_INTERLACE;
+
+        if (timing->vmode & FB_VMODE_DOUBLE)
+                mode->flags |= DRM_MODE_FLAG_DBLSCAN;
 }
 
 /* convert drm_display_mode to exynos_video_timings */
@@ -69,7 +78,7 @@ convert_to_video_timing(struct fb_videomode *timing,
         memset(timing, 0, sizeof(*timing));
 
         timing->pixclock = mode->clock * 1000;
-        timing->refresh = mode->vrefresh;
+        timing->refresh = drm_mode_vrefresh(mode);
 
         timing->xres = mode->hdisplay;
         timing->left_margin = mode->hsync_start - mode->hdisplay;
@@ -92,15 +101,16 @@ convert_to_video_timing(struct fb_videomode *timing,
 
 static int exynos_drm_connector_get_modes(struct drm_connector *connector)
 {
-        struct exynos_drm_manager *manager =
-                                exynos_drm_get_manager(connector->encoder);
-        struct exynos_drm_display *display = manager->display;
+        struct exynos_drm_connector *exynos_connector =
+                                        to_exynos_connector(connector);
+        struct exynos_drm_manager *manager = exynos_connector->manager;
+        struct exynos_drm_display_ops *display_ops = manager->display_ops;
         unsigned int count;
 
         DRM_DEBUG_KMS("%s\n", __FILE__);
 
-        if (!display) {
-                DRM_DEBUG_KMS("display is null.\n");
+        if (!display_ops) {
+                DRM_DEBUG_KMS("display_ops is null.\n");
                 return 0;
         }
 
@@ -112,7 +122,7 @@ static int exynos_drm_connector_get_modes(struct drm_connector *connector)
          * P.S. in case of lcd panel, count is always 1 if success
          * because lcd panel has only one mode.
          */
-        if (display->get_edid) {
+        if (display_ops->get_edid) {
                 int ret;
                 void *edid;
 
@@ -122,7 +132,7 @@ static int exynos_drm_connector_get_modes(struct drm_connector *connector)
                         return 0;
                 }
 
-                ret = display->get_edid(manager->dev, connector,
+                ret = display_ops->get_edid(manager->dev, connector,
                                                 edid, MAX_EDID);
                 if (ret < 0) {
                         DRM_ERROR("failed to get edid data.\n");
@@ -140,8 +150,8 @@ static int exynos_drm_connector_get_modes(struct drm_connector *connector)
                 struct drm_display_mode *mode = drm_mode_create(connector->dev);
                 struct fb_videomode *timing;
 
-                if (display->get_timing)
-                        timing = display->get_timing(manager->dev);
+                if (display_ops->get_timing)
+                        timing = display_ops->get_timing(manager->dev);
                 else {
                         drm_mode_destroy(connector->dev, mode);
                         return 0;
@@ -162,9 +172,10 @@ static int exynos_drm_connector_get_modes(struct drm_connector *connector)
 static int exynos_drm_connector_mode_valid(struct drm_connector *connector,
                                             struct drm_display_mode *mode)
 {
-        struct exynos_drm_manager *manager =
-                                exynos_drm_get_manager(connector->encoder);
-        struct exynos_drm_display *display = manager->display;
+        struct exynos_drm_connector *exynos_connector =
+                                        to_exynos_connector(connector);
+        struct exynos_drm_manager *manager = exynos_connector->manager;
+        struct exynos_drm_display_ops *display_ops = manager->display_ops;
         struct fb_videomode timing;
         int ret = MODE_BAD;
 
@@ -172,8 +183,8 @@ static int exynos_drm_connector_mode_valid(struct drm_connector *connector,
 
         convert_to_video_timing(&timing, mode);
 
-        if (display && display->check_timing)
-                if (!display->check_timing(manager->dev, (void *)&timing))
+        if (display_ops && display_ops->check_timing)
+                if (!display_ops->check_timing(manager->dev, (void *)&timing))
                         ret = MODE_OK;
 
         return ret;
@@ -181,9 +192,25 @@ static int exynos_drm_connector_mode_valid(struct drm_connector *connector,
 
 struct drm_encoder *exynos_drm_best_encoder(struct drm_connector *connector)
 {
+        struct drm_device *dev = connector->dev;
+        struct exynos_drm_connector *exynos_connector =
+                                        to_exynos_connector(connector);
+        struct drm_mode_object *obj;
+        struct drm_encoder *encoder;
+
         DRM_DEBUG_KMS("%s\n", __FILE__);
 
-        return connector->encoder;
+        obj = drm_mode_object_find(dev, exynos_connector->encoder_id,
+                                   DRM_MODE_OBJECT_ENCODER);
+        if (!obj) {
+                DRM_DEBUG_KMS("Unknown ENCODER ID %d\n",
+                                exynos_connector->encoder_id);
+                return NULL;
+        }
+
+        encoder = obj_to_encoder(obj);
+
+        return encoder;
 }
 
 static struct drm_connector_helper_funcs exynos_connector_helper_funcs = {
@@ -196,15 +223,17 @@ static struct drm_connector_helper_funcs exynos_connector_helper_funcs = {
 static enum drm_connector_status
 exynos_drm_connector_detect(struct drm_connector *connector, bool force)
 {
-        struct exynos_drm_manager *manager =
-                                exynos_drm_get_manager(connector->encoder);
-        struct exynos_drm_display *display = manager->display;
+        struct exynos_drm_connector *exynos_connector =
+                                        to_exynos_connector(connector);
+        struct exynos_drm_manager *manager = exynos_connector->manager;
+        struct exynos_drm_display_ops *display_ops =
+                                        manager->display_ops;
         enum drm_connector_status status = connector_status_disconnected;
 
         DRM_DEBUG_KMS("%s\n", __FILE__);
 
-        if (display && display->is_connected) {
-                if (display->is_connected(manager->dev))
+        if (display_ops && display_ops->is_connected) {
+                if (display_ops->is_connected(manager->dev))
                         status = connector_status_connected;
                 else
                         status = connector_status_disconnected;
@@ -251,9 +280,11 @@ struct drm_connector *exynos_drm_connector_create(struct drm_device *dev,
 
         connector = &exynos_connector->drm_connector;
 
-        switch (manager->display->type) {
+        switch (manager->display_ops->type) {
         case EXYNOS_DISPLAY_TYPE_HDMI:
                 type = DRM_MODE_CONNECTOR_HDMIA;
+                connector->interlace_allowed = true;
+                connector->polled = DRM_CONNECTOR_POLL_HPD;
                 break;
         default:
                 type = DRM_MODE_CONNECTOR_Unknown;
@@ -267,7 +298,10 @@ struct drm_connector *exynos_drm_connector_create(struct drm_device *dev,
         if (err)
                 goto err_connector;
 
+        exynos_connector->encoder_id = encoder->base.id;
+        exynos_connector->manager = manager;
         connector->encoder = encoder;
+
         err = drm_mode_connector_attach_encoder(connector, encoder);
         if (err) {
                 DRM_ERROR("failed to attach a connector to a encoder\n");
diff --git a/drivers/gpu/drm/exynos/exynos_drm_crtc.c b/drivers/gpu/drm/exynos/exynos_drm_crtc.c
index 9337e5e2dbb6..ee43cc220853 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_crtc.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_crtc.c
@@ -29,36 +29,17 @@
 #include "drmP.h"
 #include "drm_crtc_helper.h"
 
+#include "exynos_drm_crtc.h"
 #include "exynos_drm_drv.h"
 #include "exynos_drm_fb.h"
 #include "exynos_drm_encoder.h"
+#include "exynos_drm_gem.h"
 #include "exynos_drm_buf.h"
 
 #define to_exynos_crtc(x)       container_of(x, struct exynos_drm_crtc,\
                                 drm_crtc)
 
 /*
- * Exynos specific crtc postion structure.
- *
- * @fb_x: offset x on a framebuffer to be displyed
- *      - the unit is screen coordinates.
- * @fb_y: offset y on a framebuffer to be displayed
- *      - the unit is screen coordinates.
- * @crtc_x: offset x on hardware screen.
- * @crtc_y: offset y on hardware screen.
- * @crtc_w: width of hardware screen.
- * @crtc_h: height of hardware screen.
- */
-struct exynos_drm_crtc_pos {
-        unsigned int fb_x;
-        unsigned int fb_y;
-        unsigned int crtc_x;
-        unsigned int crtc_y;
-        unsigned int crtc_w;
-        unsigned int crtc_h;
-};
-
-/*
  * Exynos specific crtc structure.
  *
  * @drm_crtc: crtc object.
@@ -85,30 +66,31 @@ static void exynos_drm_crtc_apply(struct drm_crtc *crtc)
 
         exynos_drm_fn_encoder(crtc, overlay,
                         exynos_drm_encoder_crtc_mode_set);
-        exynos_drm_fn_encoder(crtc, NULL, exynos_drm_encoder_crtc_commit);
+        exynos_drm_fn_encoder(crtc, &exynos_crtc->pipe,
+                        exynos_drm_encoder_crtc_commit);
 }
 
-static int exynos_drm_overlay_update(struct exynos_drm_overlay *overlay,
-                                       struct drm_framebuffer *fb,
-                                       struct drm_display_mode *mode,
-                                       struct exynos_drm_crtc_pos *pos)
+int exynos_drm_overlay_update(struct exynos_drm_overlay *overlay,
+                              struct drm_framebuffer *fb,
+                              struct drm_display_mode *mode,
+                              struct exynos_drm_crtc_pos *pos)
 {
-        struct exynos_drm_buf_entry *entry;
+        struct exynos_drm_gem_buf *buffer;
         unsigned int actual_w;
         unsigned int actual_h;
 
-        entry = exynos_drm_fb_get_buf(fb);
-        if (!entry) {
-                DRM_LOG_KMS("entry is null.\n");
+        buffer = exynos_drm_fb_get_buf(fb);
+        if (!buffer) {
+                DRM_LOG_KMS("buffer is null.\n");
                 return -EFAULT;
         }
 
-        overlay->paddr = entry->paddr;
-        overlay->vaddr = entry->vaddr;
+        overlay->dma_addr = buffer->dma_addr;
+        overlay->vaddr = buffer->kvaddr;
 
-        DRM_DEBUG_KMS("vaddr = 0x%lx, paddr = 0x%lx\n",
+        DRM_DEBUG_KMS("vaddr = 0x%lx, dma_addr = 0x%lx\n",
                         (unsigned long)overlay->vaddr,
-                        (unsigned long)overlay->paddr);
+                        (unsigned long)overlay->dma_addr);
 
         actual_w = min((mode->hdisplay - pos->crtc_x), pos->crtc_w);
         actual_h = min((mode->vdisplay - pos->crtc_y), pos->crtc_h);
@@ -171,9 +153,26 @@ static int exynos_drm_crtc_update(struct drm_crtc *crtc)
 
 static void exynos_drm_crtc_dpms(struct drm_crtc *crtc, int mode)
 {
-        DRM_DEBUG_KMS("%s\n", __FILE__);
+        struct exynos_drm_crtc *exynos_crtc = to_exynos_crtc(crtc);
 
-        /* TODO */
+        DRM_DEBUG_KMS("crtc[%d] mode[%d]\n", crtc->base.id, mode);
+
+        switch (mode) {
+        case DRM_MODE_DPMS_ON:
+                exynos_drm_fn_encoder(crtc, &exynos_crtc->pipe,
+                                exynos_drm_encoder_crtc_commit);
+                break;
+        case DRM_MODE_DPMS_STANDBY:
+        case DRM_MODE_DPMS_SUSPEND:
+        case DRM_MODE_DPMS_OFF:
+                /* TODO */
+                exynos_drm_fn_encoder(crtc, NULL,
+                                exynos_drm_encoder_crtc_disable);
+                break;
+        default:
+                DRM_DEBUG_KMS("unspecified mode %d\n", mode);
+                break;
+        }
 }
 
 static void exynos_drm_crtc_prepare(struct drm_crtc *crtc)
@@ -185,9 +184,12 @@ static void exynos_drm_crtc_prepare(struct drm_crtc *crtc)
 
 static void exynos_drm_crtc_commit(struct drm_crtc *crtc)
 {
+        struct exynos_drm_crtc *exynos_crtc = to_exynos_crtc(crtc);
+
         DRM_DEBUG_KMS("%s\n", __FILE__);
 
-        /* drm framework doesn't check NULL. */
+        exynos_drm_fn_encoder(crtc, &exynos_crtc->pipe,
+                        exynos_drm_encoder_crtc_commit);
 }
 
 static bool
diff --git a/drivers/gpu/drm/exynos/exynos_drm_crtc.h b/drivers/gpu/drm/exynos/exynos_drm_crtc.h
index c584042d6d2c..25f72a62cb88 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_crtc.h
+++ b/drivers/gpu/drm/exynos/exynos_drm_crtc.h
@@ -35,4 +35,29 @@ int exynos_drm_crtc_create(struct drm_device *dev, unsigned int nr);
 int exynos_drm_crtc_enable_vblank(struct drm_device *dev, int crtc);
 void exynos_drm_crtc_disable_vblank(struct drm_device *dev, int crtc);
 
+/*
+ * Exynos specific crtc postion structure.
+ *
+ * @fb_x: offset x on a framebuffer to be displyed
+ *      - the unit is screen coordinates.
+ * @fb_y: offset y on a framebuffer to be displayed
+ *      - the unit is screen coordinates.
+ * @crtc_x: offset x on hardware screen.
+ * @crtc_y: offset y on hardware screen.
+ * @crtc_w: width of hardware screen.
+ * @crtc_h: height of hardware screen.
+ */
+struct exynos_drm_crtc_pos {
+        unsigned int fb_x;
+        unsigned int fb_y;
+        unsigned int crtc_x;
+        unsigned int crtc_y;
+        unsigned int crtc_w;
+        unsigned int crtc_h;
+};
+
+int exynos_drm_overlay_update(struct exynos_drm_overlay *overlay,
+                              struct drm_framebuffer *fb,
+                              struct drm_display_mode *mode,
+                              struct exynos_drm_crtc_pos *pos);
 #endif
diff --git a/drivers/gpu/drm/exynos/exynos_drm_drv.c b/drivers/gpu/drm/exynos/exynos_drm_drv.c
index 83810cbe3c17..53e2216de61d 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_drv.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_drv.c
@@ -27,6 +27,7 @@
 
 #include "drmP.h"
 #include "drm.h"
+#include "drm_crtc_helper.h"
 
 #include <drm/exynos_drm.h>
 
@@ -61,6 +62,9 @@ static int exynos_drm_load(struct drm_device *dev, unsigned long flags)
 
         drm_mode_config_init(dev);
 
+        /* init kms poll for handling hpd */
+        drm_kms_helper_poll_init(dev);
+
         exynos_drm_mode_config_init(dev);
 
         /*
@@ -116,6 +120,7 @@ static int exynos_drm_unload(struct drm_device *dev)
         exynos_drm_fbdev_fini(dev);
         exynos_drm_device_unregister(dev);
         drm_vblank_cleanup(dev);
+        drm_kms_helper_poll_fini(dev);
         drm_mode_config_cleanup(dev);
         kfree(dev->dev_private);
 
diff --git a/drivers/gpu/drm/exynos/exynos_drm_drv.h b/drivers/gpu/drm/exynos/exynos_drm_drv.h
index c03683f2ae72..5e02e6ecc2e0 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_drv.h
+++ b/drivers/gpu/drm/exynos/exynos_drm_drv.h
@@ -29,6 +29,7 @@
 #ifndef _EXYNOS_DRM_DRV_H_
 #define _EXYNOS_DRM_DRV_H_
 
+#include <linux/module.h>
 #include "drm.h"
 
 #define MAX_CRTC        2
@@ -79,8 +80,8 @@ struct exynos_drm_overlay_ops {
  * @scan_flag: interlace or progressive way.
  *      (it could be DRM_MODE_FLAG_*)
  * @bpp: pixel size.(in bit)
- * @paddr: bus(accessed by dma) physical memory address to this overlay
- *              and this is physically continuous.
+ * @dma_addr: bus(accessed by dma) address to the memory region allocated
+ *      for a overlay.
  * @vaddr: virtual memory addresss to this overlay.
  * @default_win: a window to be enabled.
  * @color_key: color key on or off.
@@ -108,7 +109,7 @@ struct exynos_drm_overlay {
         unsigned int scan_flag;
         unsigned int bpp;
         unsigned int pitch;
-        dma_addr_t paddr;
+        dma_addr_t dma_addr;
         void __iomem *vaddr;
 
         bool default_win;
@@ -130,7 +131,7 @@ struct exynos_drm_overlay {
  * @check_timing: check if timing is valid or not.
  * @power_on: display device on or off.
  */
-struct exynos_drm_display {
+struct exynos_drm_display_ops {
         enum exynos_drm_output_type type;
         bool (*is_connected)(struct device *dev);
         int (*get_edid)(struct device *dev, struct drm_connector *connector,
@@ -146,12 +147,14 @@ struct exynos_drm_display {
  * @mode_set: convert drm_display_mode to hw specific display mode and
  *            would be called by encoder->mode_set().
  * @commit: set current hw specific display mode to hw.
+ * @disable: disable hardware specific display mode.
  * @enable_vblank: specific driver callback for enabling vblank interrupt.
  * @disable_vblank: specific driver callback for disabling vblank interrupt.
  */
 struct exynos_drm_manager_ops {
         void (*mode_set)(struct device *subdrv_dev, void *mode);
         void (*commit)(struct device *subdrv_dev);
+        void (*disable)(struct device *subdrv_dev);
         int (*enable_vblank)(struct device *subdrv_dev);
         void (*disable_vblank)(struct device *subdrv_dev);
 };
@@ -178,7 +181,7 @@ struct exynos_drm_manager {
         int pipe;
         struct exynos_drm_manager_ops *ops;
         struct exynos_drm_overlay_ops *overlay_ops;
-        struct exynos_drm_display *display;
+        struct exynos_drm_display_ops *display_ops;
 };
 
 /*
diff --git a/drivers/gpu/drm/exynos/exynos_drm_encoder.c b/drivers/gpu/drm/exynos/exynos_drm_encoder.c
index 7cf6fa86a67e..153061415baf 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_encoder.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_encoder.c
@@ -53,15 +53,36 @@ static void exynos_drm_encoder_dpms(struct drm_encoder *encoder, int mode)
         struct drm_device *dev = encoder->dev;
         struct drm_connector *connector;
         struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
+        struct exynos_drm_manager_ops *manager_ops = manager->ops;
 
         DRM_DEBUG_KMS("%s, encoder dpms: %d\n", __FILE__, mode);
 
+        switch (mode) {
+        case DRM_MODE_DPMS_ON:
+                if (manager_ops && manager_ops->commit)
+                        manager_ops->commit(manager->dev);
+                break;
+        case DRM_MODE_DPMS_STANDBY:
+        case DRM_MODE_DPMS_SUSPEND:
+        case DRM_MODE_DPMS_OFF:
+                /* TODO */
+                if (manager_ops && manager_ops->disable)
+                        manager_ops->disable(manager->dev);
+                break;
+        default:
+                DRM_ERROR("unspecified mode %d\n", mode);
+                break;
+        }
+
         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
                 if (connector->encoder == encoder) {
-                        struct exynos_drm_display *display = manager->display;
+                        struct exynos_drm_display_ops *display_ops =
+                                                        manager->display_ops;
 
-                        if (display && display->power_on)
-                                display->power_on(manager->dev, mode);
+                        DRM_DEBUG_KMS("connector[%d] dpms[%d]\n",
+                                        connector->base.id, mode);
+                        if (display_ops && display_ops->power_on)
+                                display_ops->power_on(manager->dev, mode);
                 }
         }
 }
@@ -116,15 +137,11 @@ static void exynos_drm_encoder_commit(struct drm_encoder *encoder)
 {
         struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
         struct exynos_drm_manager_ops *manager_ops = manager->ops;
-        struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
 
         DRM_DEBUG_KMS("%s\n", __FILE__);
 
         if (manager_ops && manager_ops->commit)
                 manager_ops->commit(manager->dev);
-
-        if (overlay_ops && overlay_ops->commit)
-                overlay_ops->commit(manager->dev);
 }
 
 static struct drm_crtc *
@@ -208,10 +225,23 @@ void exynos_drm_fn_encoder(struct drm_crtc *crtc, void *data,
 {
         struct drm_device *dev = crtc->dev;
         struct drm_encoder *encoder;
+        struct exynos_drm_private *private = dev->dev_private;
+        struct exynos_drm_manager *manager;
 
         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
-                if (encoder->crtc != crtc)
-                        continue;
+                /*
+                 * if crtc is detached from encoder, check pipe,
+                 * otherwise check crtc attached to encoder
+                 */
+                if (!encoder->crtc) {
+                        manager = to_exynos_encoder(encoder)->manager;
+                        if (manager->pipe < 0 ||
+                                        private->crtc[manager->pipe] != crtc)
+                                continue;
+                } else {
+                        if (encoder->crtc != crtc)
+                                continue;
+                }
 
                 fn(encoder, data);
         }
@@ -250,8 +280,18 @@ void exynos_drm_encoder_crtc_commit(struct drm_encoder *encoder, void *data)
         struct exynos_drm_manager *manager =
                 to_exynos_encoder(encoder)->manager;
         struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
+        int crtc = *(int *)data;
+
+        DRM_DEBUG_KMS("%s\n", __FILE__);
+
+        /*
+         * when crtc is detached from encoder, this pipe is used
+         * to select manager operation
+         */
+        manager->pipe = crtc;
 
-        overlay_ops->commit(manager->dev);
+        if (overlay_ops && overlay_ops->commit)
+                overlay_ops->commit(manager->dev);
 }
 
 void exynos_drm_encoder_crtc_mode_set(struct drm_encoder *encoder, void *data)
@@ -261,7 +301,28 @@ void exynos_drm_encoder_crtc_mode_set(struct drm_encoder *encoder, void *data)
         struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
         struct exynos_drm_overlay *overlay = data;
 
-        overlay_ops->mode_set(manager->dev, overlay);
+        if (overlay_ops && overlay_ops->mode_set)
+                overlay_ops->mode_set(manager->dev, overlay);
+}
+
+void exynos_drm_encoder_crtc_disable(struct drm_encoder *encoder, void *data)
+{
+        struct exynos_drm_manager *manager =
+                to_exynos_encoder(encoder)->manager;
+        struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
+
+        DRM_DEBUG_KMS("\n");
+
+        if (overlay_ops && overlay_ops->disable)
+                overlay_ops->disable(manager->dev);
+
+        /*
+         * crtc is already detached from encoder and last
+         * function for detaching is properly done, so
+         * clear pipe from manager to prevent repeated call
+         */
+        if (!encoder->crtc)
+                manager->pipe = -1;
 }
 
 MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
diff --git a/drivers/gpu/drm/exynos/exynos_drm_encoder.h b/drivers/gpu/drm/exynos/exynos_drm_encoder.h
index 5ecd645d06a9..a22acfbf0e4e 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_encoder.h
+++ b/drivers/gpu/drm/exynos/exynos_drm_encoder.h
@@ -41,5 +41,6 @@ void exynos_drm_enable_vblank(struct drm_encoder *encoder, void *data);
 void exynos_drm_disable_vblank(struct drm_encoder *encoder, void *data);
 void exynos_drm_encoder_crtc_commit(struct drm_encoder *encoder, void *data);
 void exynos_drm_encoder_crtc_mode_set(struct drm_encoder *encoder, void *data);
+void exynos_drm_encoder_crtc_disable(struct drm_encoder *encoder, void *data);
 
 #endif
diff --git a/drivers/gpu/drm/exynos/exynos_drm_fb.c b/drivers/gpu/drm/exynos/exynos_drm_fb.c
index 48d29cfd5240..5bf4a1ac7f82 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_fb.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_fb.c
@@ -29,7 +29,9 @@
 #include "drmP.h"
 #include "drm_crtc.h"
 #include "drm_crtc_helper.h"
+#include "drm_fb_helper.h"
 
+#include "exynos_drm_drv.h"
 #include "exynos_drm_fb.h"
 #include "exynos_drm_buf.h"
 #include "exynos_drm_gem.h"
@@ -41,14 +43,14 @@
  *
  * @fb: drm framebuffer obejct.
  * @exynos_gem_obj: exynos specific gem object containing a gem object.
- * @entry: pointer to exynos drm buffer entry object.
- *      - containing only the information to physically continuous memory
- *      region allocated at default framebuffer creation.
+ * @buffer: pointer to exynos_drm_gem_buffer object.
+ *      - contain the memory information to memory region allocated
+ *      at default framebuffer creation.
  */
 struct exynos_drm_fb {
         struct drm_framebuffer          fb;
         struct exynos_drm_gem_obj       *exynos_gem_obj;
-        struct exynos_drm_buf_entry     *entry;
+        struct exynos_drm_gem_buf       *buffer;
 };
 
 static void exynos_drm_fb_destroy(struct drm_framebuffer *fb)
@@ -63,8 +65,8 @@ static void exynos_drm_fb_destroy(struct drm_framebuffer *fb)
          * default framebuffer has no gem object so
          * a buffer of the default framebuffer should be released at here.
          */
-        if (!exynos_fb->exynos_gem_obj && exynos_fb->entry)
-                exynos_drm_buf_destroy(fb->dev, exynos_fb->entry);
+        if (!exynos_fb->exynos_gem_obj && exynos_fb->buffer)
+                exynos_drm_buf_destroy(fb->dev, exynos_fb->buffer);
 
         kfree(exynos_fb);
         exynos_fb = NULL;
@@ -143,29 +145,29 @@ exynos_drm_fb_init(struct drm_file *file_priv, struct drm_device *dev,
          */
         if (!mode_cmd->handle) {
                 if (!file_priv) {
-                        struct exynos_drm_buf_entry *entry;
+                        struct exynos_drm_gem_buf *buffer;
 
                         /*
                          * in case that file_priv is NULL, it allocates
                          * only buffer and this buffer would be used
                          * for default framebuffer.
                          */
-                        entry = exynos_drm_buf_create(dev, size);
-                        if (IS_ERR(entry)) {
-                                ret = PTR_ERR(entry);
+                        buffer = exynos_drm_buf_create(dev, size);
+                        if (IS_ERR(buffer)) {
+                                ret = PTR_ERR(buffer);
                                 goto err_buffer;
                         }
 
-                        exynos_fb->entry = entry;
+                        exynos_fb->buffer = buffer;
 
-                        DRM_LOG_KMS("default fb: paddr = 0x%lx, size = 0x%x\n",
-                                        (unsigned long)entry->paddr, size);
+                        DRM_LOG_KMS("default: dma_addr = 0x%lx, size = 0x%x\n",
+                                        (unsigned long)buffer->dma_addr, size);
 
                         goto out;
                 } else {
-                        exynos_gem_obj = exynos_drm_gem_create(file_priv, dev,
-                                                        size,
-                                                        &mode_cmd->handle);
+                        exynos_gem_obj = exynos_drm_gem_create(dev, file_priv,
+                                                        &mode_cmd->handle,
+                                                        size);
                         if (IS_ERR(exynos_gem_obj)) {
                                 ret = PTR_ERR(exynos_gem_obj);
                                 goto err_buffer;
@@ -189,10 +191,10 @@ exynos_drm_fb_init(struct drm_file *file_priv, struct drm_device *dev,
          * so that default framebuffer has no its own gem object,
          * only its own buffer object.
          */
-        exynos_fb->entry = exynos_gem_obj->entry;
+        exynos_fb->buffer = exynos_gem_obj->buffer;
 
-        DRM_LOG_KMS("paddr = 0x%lx, size = 0x%x, gem object = 0x%x\n",
-                        (unsigned long)exynos_fb->entry->paddr, size,
+        DRM_LOG_KMS("dma_addr = 0x%lx, size = 0x%x, gem object = 0x%x\n",
+                        (unsigned long)exynos_fb->buffer->dma_addr, size,
                         (unsigned int)&exynos_gem_obj->base);
 
 out:
@@ -220,26 +222,36 @@ struct drm_framebuffer *exynos_drm_fb_create(struct drm_device *dev,
         return exynos_drm_fb_init(file_priv, dev, mode_cmd);
 }
 
-struct exynos_drm_buf_entry *exynos_drm_fb_get_buf(struct drm_framebuffer *fb)
+struct exynos_drm_gem_buf *exynos_drm_fb_get_buf(struct drm_framebuffer *fb)
 {
         struct exynos_drm_fb *exynos_fb = to_exynos_fb(fb);
-        struct exynos_drm_buf_entry *entry;
+        struct exynos_drm_gem_buf *buffer;
 
         DRM_DEBUG_KMS("%s\n", __FILE__);
 
-        entry = exynos_fb->entry;
-        if (!entry)
+        buffer = exynos_fb->buffer;
+        if (!buffer)
                 return NULL;
 
-        DRM_DEBUG_KMS("vaddr = 0x%lx, paddr = 0x%lx\n",
-                        (unsigned long)entry->vaddr,
-                        (unsigned long)entry->paddr);
+        DRM_DEBUG_KMS("vaddr = 0x%lx, dma_addr = 0x%lx\n",
+                        (unsigned long)buffer->kvaddr,
+                        (unsigned long)buffer->dma_addr);
 
-        return entry;
+        return buffer;
+}
+
+static void exynos_drm_output_poll_changed(struct drm_device *dev)
+{
+        struct exynos_drm_private *private = dev->dev_private;
+        struct drm_fb_helper *fb_helper = private->fb_helper;
+
+        if (fb_helper)
+                drm_fb_helper_hotplug_event(fb_helper);
 }
 
 static struct drm_mode_config_funcs exynos_drm_mode_config_funcs = {
         .fb_create = exynos_drm_fb_create,
+        .output_poll_changed = exynos_drm_output_poll_changed,
 };
 
 void exynos_drm_mode_config_init(struct drm_device *dev)
diff --git a/drivers/gpu/drm/exynos/exynos_drm_fbdev.c b/drivers/gpu/drm/exynos/exynos_drm_fbdev.c
index 1f4b3d1a7713..836f41008187 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_fbdev.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_fbdev.c
@@ -33,6 +33,7 @@
 
 #include "exynos_drm_drv.h"
 #include "exynos_drm_fb.h"
+#include "exynos_drm_gem.h"
 #include "exynos_drm_buf.h"
 
 #define MAX_CONNECTOR           4
@@ -85,15 +86,13 @@ static struct fb_ops exynos_drm_fb_ops = {
 };
 
 static int exynos_drm_fbdev_update(struct drm_fb_helper *helper,
-                                     struct drm_framebuffer *fb,
-                                     unsigned int fb_width,
-                                     unsigned int fb_height)
+                                     struct drm_framebuffer *fb)
 {
         struct fb_info *fbi = helper->fbdev;
         struct drm_device *dev = helper->dev;
         struct exynos_drm_fbdev *exynos_fb = to_exynos_fbdev(helper);
-        struct exynos_drm_buf_entry *entry;
-        unsigned int size = fb_width * fb_height * (fb->bits_per_pixel >> 3);
+        struct exynos_drm_gem_buf *buffer;
+        unsigned int size = fb->width * fb->height * (fb->bits_per_pixel >> 3);
         unsigned long offset;
 
         DRM_DEBUG_KMS("%s\n", __FILE__);
@@ -101,20 +100,20 @@ static int exynos_drm_fbdev_update(struct drm_fb_helper *helper,
         exynos_fb->fb = fb;
 
         drm_fb_helper_fill_fix(fbi, fb->pitch, fb->depth);
-        drm_fb_helper_fill_var(fbi, helper, fb_width, fb_height);
+        drm_fb_helper_fill_var(fbi, helper, fb->width, fb->height);
 
-        entry = exynos_drm_fb_get_buf(fb);
-        if (!entry) {
-                DRM_LOG_KMS("entry is null.\n");
+        buffer = exynos_drm_fb_get_buf(fb);
+        if (!buffer) {
+                DRM_LOG_KMS("buffer is null.\n");
                 return -EFAULT;
         }
 
         offset = fbi->var.xoffset * (fb->bits_per_pixel >> 3);
         offset += fbi->var.yoffset * fb->pitch;
 
-        dev->mode_config.fb_base = entry->paddr;
-        fbi->screen_base = entry->vaddr + offset;
-        fbi->fix.smem_start = entry->paddr + offset;
+        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->screen_size = size;
         fbi->fix.smem_len = size;
 
@@ -171,8 +170,7 @@ static int exynos_drm_fbdev_create(struct drm_fb_helper *helper,
                 goto out;
         }
 
-        ret = exynos_drm_fbdev_update(helper, helper->fb, sizes->fb_width,
-                        sizes->fb_height);
+        ret = exynos_drm_fbdev_update(helper, helper->fb);
         if (ret < 0)
                 fb_dealloc_cmap(&fbi->cmap);
 
@@ -235,8 +233,7 @@ static int exynos_drm_fbdev_recreate(struct drm_fb_helper *helper,
         }
 
         helper->fb = exynos_fbdev->fb;
-        return exynos_drm_fbdev_update(helper, helper->fb, sizes->fb_width,
-                        sizes->fb_height);
+        return exynos_drm_fbdev_update(helper, helper->fb);
 }
 
 static int exynos_drm_fbdev_probe(struct drm_fb_helper *helper,
@@ -405,6 +402,18 @@ int exynos_drm_fbdev_reinit(struct drm_device *dev)
         fb_helper = private->fb_helper;
 
         if (fb_helper) {
+                struct list_head temp_list;
+
+                INIT_LIST_HEAD(&temp_list);
+
+                /*
+                 * fb_helper is reintialized but kernel fb is reused
+                 * so kernel_fb_list need to be backuped and restored
+                 */
+                if (!list_empty(&fb_helper->kernel_fb_list))
+                        list_replace_init(&fb_helper->kernel_fb_list,
+                                        &temp_list);
+
                 drm_fb_helper_fini(fb_helper);
 
                 ret = drm_fb_helper_init(dev, fb_helper,
@@ -414,6 +423,9 @@ int exynos_drm_fbdev_reinit(struct drm_device *dev)
                         return ret;
                 }
 
+                if (!list_empty(&temp_list))
+                        list_replace(&temp_list, &fb_helper->kernel_fb_list);
+
                 ret = drm_fb_helper_single_add_all_connectors(fb_helper);
                 if (ret < 0) {
                         DRM_ERROR("failed to add fb helper to connectors\n");
diff --git a/drivers/gpu/drm/exynos/exynos_drm_fimd.c b/drivers/gpu/drm/exynos/exynos_drm_fimd.c
index 4659c88cdd9b..db3b3d9e731d 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_fimd.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_fimd.c
@@ -64,7 +64,7 @@ struct fimd_win_data {
         unsigned int            fb_width;
         unsigned int            fb_height;
         unsigned int            bpp;
-        dma_addr_t              paddr;
+        dma_addr_t              dma_addr;
         void __iomem            *vaddr;
         unsigned int            buf_offsize;
         unsigned int            line_size;      /* bytes */
@@ -124,7 +124,7 @@ static int fimd_display_power_on(struct device *dev, int mode)
         return 0;
 }
 
-static struct exynos_drm_display fimd_display = {
+static struct exynos_drm_display_ops fimd_display_ops = {
         .type = EXYNOS_DISPLAY_TYPE_LCD,
         .is_connected = fimd_display_is_connected,
         .get_timing = fimd_get_timing,
@@ -177,6 +177,40 @@ static void fimd_commit(struct device *dev)
         writel(val, ctx->regs + VIDCON0);
 }
 
+static void fimd_disable(struct device *dev)
+{
+        struct fimd_context *ctx = get_fimd_context(dev);
+        struct exynos_drm_subdrv *subdrv = &ctx->subdrv;
+        struct drm_device *drm_dev = subdrv->drm_dev;
+        struct exynos_drm_manager *manager = &subdrv->manager;
+        u32 val;
+
+        DRM_DEBUG_KMS("%s\n", __FILE__);
+
+        /* fimd dma off */
+        val = readl(ctx->regs + VIDCON0);
+        val &= ~(VIDCON0_ENVID | VIDCON0_ENVID_F);
+        writel(val, ctx->regs + VIDCON0);
+
+        /*
+         * if vblank is enabled status with dma off then
+         * it disables vsync interrupt.
+         */
+        if (drm_dev->vblank_enabled[manager->pipe] &&
+                atomic_read(&drm_dev->vblank_refcount[manager->pipe])) {
+                drm_vblank_put(drm_dev, manager->pipe);
+
+                /*
+                 * if vblank_disable_allowed is 0 then disable
+                 * vsync interrupt right now else the vsync interrupt
+                 * would be disabled by drm timer once a current process
+                 * gives up ownershop of vblank event.
+                 */
+                if (!drm_dev->vblank_disable_allowed)
+                        drm_vblank_off(drm_dev, manager->pipe);
+        }
+}
+
 static int fimd_enable_vblank(struct device *dev)
 {
         struct fimd_context *ctx = get_fimd_context(dev);
@@ -220,6 +254,7 @@ static void fimd_disable_vblank(struct device *dev)
 
 static struct exynos_drm_manager_ops fimd_manager_ops = {
         .commit = fimd_commit,
+        .disable = fimd_disable,
         .enable_vblank = fimd_enable_vblank,
         .disable_vblank = fimd_disable_vblank,
 };
@@ -251,7 +286,7 @@ static void fimd_win_mode_set(struct device *dev,
         win_data->ovl_height = overlay->crtc_height;
         win_data->fb_width = overlay->fb_width;
         win_data->fb_height = overlay->fb_height;
-        win_data->paddr = overlay->paddr + offset;
+        win_data->dma_addr = overlay->dma_addr + offset;
         win_data->vaddr = overlay->vaddr + offset;
         win_data->bpp = overlay->bpp;
         win_data->buf_offsize = (overlay->fb_width - overlay->crtc_width) *
@@ -263,7 +298,7 @@ static void fimd_win_mode_set(struct device *dev,
         DRM_DEBUG_KMS("ovl_width = %d, ovl_height = %d\n",
                         win_data->ovl_width, win_data->ovl_height);
         DRM_DEBUG_KMS("paddr = 0x%lx, vaddr = 0x%lx\n",
-                        (unsigned long)win_data->paddr,
+                        (unsigned long)win_data->dma_addr,
                         (unsigned long)win_data->vaddr);
         DRM_DEBUG_KMS("fb_width = %d, crtc_width = %d\n",
                         overlay->fb_width, overlay->crtc_width);
@@ -376,16 +411,16 @@ static void fimd_win_commit(struct device *dev)
         writel(val, ctx->regs + SHADOWCON);
 
         /* buffer start address */
-        val = win_data->paddr;
+        val = (unsigned long)win_data->dma_addr;
         writel(val, ctx->regs + VIDWx_BUF_START(win, 0));
 
         /* buffer end address */
         size = win_data->fb_width * win_data->ovl_height * (win_data->bpp >> 3);
-        val = win_data->paddr + size;
+        val = (unsigned long)(win_data->dma_addr + size);
         writel(val, ctx->regs + VIDWx_BUF_END(win, 0));
 
         DRM_DEBUG_KMS("start addr = 0x%lx, end addr = 0x%lx, size = 0x%lx\n",
-                        (unsigned long)win_data->paddr, val, size);
+                        (unsigned long)win_data->dma_addr, val, size);
         DRM_DEBUG_KMS("ovl_width = %d, ovl_height = %d\n",
                         win_data->ovl_width, win_data->ovl_height);
 
@@ -447,7 +482,6 @@ static void fimd_win_commit(struct device *dev)
 static void fimd_win_disable(struct device *dev)
 {
         struct fimd_context *ctx = get_fimd_context(dev);
-        struct fimd_win_data *win_data;
         int win = ctx->default_win;
         u32 val;
 
@@ -456,8 +490,6 @@ static void fimd_win_disable(struct device *dev)
         if (win < 0 || win > WINDOWS_NR)
                 return;
 
-        win_data = &ctx->win_data[win];
-
         /* protect windows */
         val = readl(ctx->regs + SHADOWCON);
         val |= SHADOWCON_WINx_PROTECT(win);
@@ -528,6 +560,16 @@ static irqreturn_t fimd_irq_handler(int irq, void *dev_id)
                 /* VSYNC interrupt */
                 writel(VIDINTCON1_INT_FRAME, ctx->regs + VIDINTCON1);
 
+        /*
+         * in case that vblank_disable_allowed is 1, it could induce
+         * the problem that manager->pipe could be -1 because with
+         * disable callback, vsync interrupt isn't disabled and at this moment,
+         * vsync interrupt could occur. the vsync interrupt would be disabled
+         * by timer handler later.
+         */
+        if (manager->pipe == -1)
+                return IRQ_HANDLED;
+
         drm_handle_vblank(drm_dev, manager->pipe);
         fimd_finish_pageflip(drm_dev, manager->pipe);
 
@@ -548,13 +590,6 @@ static int fimd_subdrv_probe(struct drm_device *drm_dev, struct device *dev)
          */
         drm_dev->irq_enabled = 1;
 
-        /*
-         * with vblank_disable_allowed = 1, vblank interrupt will be disabled
-         * by drm timer once a current process gives up ownership of
-         * vblank event.(drm_vblank_put function was called)
-         */
-        drm_dev->vblank_disable_allowed = 1;
-
         return 0;
 }
 
@@ -731,7 +766,7 @@ static int __devinit fimd_probe(struct platform_device *pdev)
         subdrv->manager.pipe = -1;
         subdrv->manager.ops = &fimd_manager_ops;
         subdrv->manager.overlay_ops = &fimd_overlay_ops;
-        subdrv->manager.display = &fimd_display;
+        subdrv->manager.display_ops = &fimd_display_ops;
         subdrv->manager.dev = dev;
 
         platform_set_drvdata(pdev, ctx);
diff --git a/drivers/gpu/drm/exynos/exynos_drm_gem.c b/drivers/gpu/drm/exynos/exynos_drm_gem.c
index a8e7a88906ed..aba0fe47f7ea 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_gem.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_gem.c
@@ -62,40 +62,28 @@ static unsigned int get_gem_mmap_offset(struct drm_gem_object *obj)
         return (unsigned int)obj->map_list.hash.key << PAGE_SHIFT;
 }
 
-struct exynos_drm_gem_obj *exynos_drm_gem_create(struct drm_file *file_priv,
-                struct drm_device *dev, unsigned int size,
-                unsigned int *handle)
+static struct exynos_drm_gem_obj
+                *exynos_drm_gem_init(struct drm_device *drm_dev,
+                        struct drm_file *file_priv, unsigned int *handle,
+                        unsigned int size)
 {
         struct exynos_drm_gem_obj *exynos_gem_obj;
-        struct exynos_drm_buf_entry *entry;
         struct drm_gem_object *obj;
         int ret;
 
-        DRM_DEBUG_KMS("%s\n", __FILE__);
-
-        size = roundup(size, PAGE_SIZE);
-
         exynos_gem_obj = kzalloc(sizeof(*exynos_gem_obj), GFP_KERNEL);
         if (!exynos_gem_obj) {
                 DRM_ERROR("failed to allocate exynos gem object.\n");
                 return ERR_PTR(-ENOMEM);
         }
 
-        /* allocate the new buffer object and memory region. */
-        entry = exynos_drm_buf_create(dev, size);
-        if (!entry) {
-                kfree(exynos_gem_obj);
-                return ERR_PTR(-ENOMEM);
-        }
-
-        exynos_gem_obj->entry = entry;
-
         obj = &exynos_gem_obj->base;
 
-        ret = drm_gem_object_init(dev, obj, size);
+        ret = drm_gem_object_init(drm_dev, obj, size);
         if (ret < 0) {
-                DRM_ERROR("failed to initailize gem object.\n");
-                goto err_obj_init;
+                DRM_ERROR("failed to initialize gem object.\n");
+                ret = -EINVAL;
+                goto err_object_init;
         }
 
         DRM_DEBUG_KMS("created file object = 0x%x\n", (unsigned int)obj->filp);
@@ -127,24 +115,50 @@ err_handle_create:
 err_create_mmap_offset:
         drm_gem_object_release(obj);
 
-err_obj_init:
-        exynos_drm_buf_destroy(dev, exynos_gem_obj->entry);
-
+err_object_init:
         kfree(exynos_gem_obj);
 
         return ERR_PTR(ret);
 }
 
+struct exynos_drm_gem_obj *exynos_drm_gem_create(struct drm_device *dev,
+                                struct drm_file *file_priv,
+                                unsigned int *handle, unsigned long size)
+{
+
+        struct exynos_drm_gem_obj *exynos_gem_obj = NULL;
+        struct exynos_drm_gem_buf *buffer;
+
+        size = roundup(size, PAGE_SIZE);
+
+        DRM_DEBUG_KMS("%s: size = 0x%lx\n", __FILE__, size);
+
+        buffer = exynos_drm_buf_create(dev, size);
+        if (IS_ERR(buffer)) {
+                return ERR_CAST(buffer);
+        }
+
+        exynos_gem_obj = exynos_drm_gem_init(dev, file_priv, handle, size);
+        if (IS_ERR(exynos_gem_obj)) {
+                exynos_drm_buf_destroy(dev, buffer);
+                return exynos_gem_obj;
+        }
+
+        exynos_gem_obj->buffer = buffer;
+
+        return exynos_gem_obj;
+}
+
 int exynos_drm_gem_create_ioctl(struct drm_device *dev, void *data,
-                struct drm_file *file_priv)
+                                        struct drm_file *file_priv)
 {
         struct drm_exynos_gem_create *args = data;
-        struct exynos_drm_gem_obj *exynos_gem_obj;
+        struct exynos_drm_gem_obj *exynos_gem_obj = NULL;
 
-        DRM_DEBUG_KMS("%s : size = 0x%x\n", __FILE__, args->size);
+        DRM_DEBUG_KMS("%s\n", __FILE__);
 
-        exynos_gem_obj = exynos_drm_gem_create(file_priv, dev, args->size,
-                        &args->handle);
+        exynos_gem_obj = exynos_drm_gem_create(dev, file_priv,
+                                                &args->handle, args->size);
         if (IS_ERR(exynos_gem_obj))
                 return PTR_ERR(exynos_gem_obj);
 
@@ -175,7 +189,7 @@ static int exynos_drm_gem_mmap_buffer(struct file *filp,
 {
         struct drm_gem_object *obj = filp->private_data;
         struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
-        struct exynos_drm_buf_entry *entry;
+        struct exynos_drm_gem_buf *buffer;
         unsigned long pfn, vm_size;
 
         DRM_DEBUG_KMS("%s\n", __FILE__);
@@ -187,20 +201,20 @@ static int exynos_drm_gem_mmap_buffer(struct file *filp,
 
         vm_size = vma->vm_end - vma->vm_start;
         /*
-         * a entry contains information to physically continuous memory
+         * a buffer contains information to physically continuous memory
          * allocated by user request or at framebuffer creation.
          */
-        entry = exynos_gem_obj->entry;
+        buffer = exynos_gem_obj->buffer;
 
         /* check if user-requested size is valid. */
-        if (vm_size > entry->size)
+        if (vm_size > buffer->size)
                 return -EINVAL;
 
         /*
          * get page frame number to physical memory to be mapped
          * to user space.
          */
-        pfn = exynos_gem_obj->entry->paddr >> PAGE_SHIFT;
+        pfn = ((unsigned long)exynos_gem_obj->buffer->dma_addr) >> PAGE_SHIFT;
 
         DRM_DEBUG_KMS("pfn = 0x%lx\n", pfn);
 
@@ -281,7 +295,7 @@ void exynos_drm_gem_free_object(struct drm_gem_object *gem_obj)
 
         exynos_gem_obj = to_exynos_gem_obj(gem_obj);
 
-        exynos_drm_buf_destroy(gem_obj->dev, exynos_gem_obj->entry);
+        exynos_drm_buf_destroy(gem_obj->dev, exynos_gem_obj->buffer);
 
         kfree(exynos_gem_obj);
 }
@@ -302,8 +316,8 @@ int exynos_drm_gem_dumb_create(struct drm_file *file_priv,
         args->pitch = args->width * args->bpp >> 3;
         args->size = args->pitch * args->height;
 
-        exynos_gem_obj = exynos_drm_gem_create(file_priv, dev, args->size,
-                                                        &args->handle);
+        exynos_gem_obj = exynos_drm_gem_create(dev, file_priv, &args->handle,
+                                                        args->size);
         if (IS_ERR(exynos_gem_obj))
                 return PTR_ERR(exynos_gem_obj);
 
@@ -360,7 +374,8 @@ int exynos_drm_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 
         mutex_lock(&dev->struct_mutex);
 
-        pfn = (exynos_gem_obj->entry->paddr >> PAGE_SHIFT) + page_offset;
+        pfn = (((unsigned long)exynos_gem_obj->buffer->dma_addr) >>
+                        PAGE_SHIFT) + page_offset;
 
         ret = vm_insert_mixed(vma, (unsigned long)vmf->virtual_address, pfn);
 
diff --git a/drivers/gpu/drm/exynos/exynos_drm_gem.h b/drivers/gpu/drm/exynos/exynos_drm_gem.h
index e5fc0148277b..ef8797334e6d 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_gem.h
+++ b/drivers/gpu/drm/exynos/exynos_drm_gem.h
@@ -30,13 +30,29 @@
                         struct exynos_drm_gem_obj, base)
 
 /*
+ * exynos drm gem buffer structure.
+ *
+ * @kvaddr: kernel virtual address to allocated memory region.
+ * @dma_addr: bus address(accessed by dma) to allocated memory region.
+ *      - this address could be physical address without IOMMU and
+ *      device address with IOMMU.
+ * @size: size of allocated memory region.
+ */
+struct exynos_drm_gem_buf {
+        void __iomem            *kvaddr;
+        dma_addr_t              dma_addr;
+        unsigned long           size;
+};
+
+/*
  * exynos drm buffer structure.
  *
  * @base: a gem object.
  *      - a new handle to this gem object would be created
  *      by drm_gem_handle_create().
- * @entry: pointer to exynos drm buffer entry object.
- *      - containing the information to physically
+ * @buffer: a pointer to exynos_drm_gem_buffer object.
+ *      - contain the information to memory region allocated
+ *      by user request or at framebuffer creation.
  *      continuous memory region allocated by user request
  *      or at framebuffer creation.
  *
@@ -45,13 +61,13 @@
  */
 struct exynos_drm_gem_obj {
         struct drm_gem_object base;
-        struct exynos_drm_buf_entry *entry;
+        struct exynos_drm_gem_buf *buffer;
 };
 
 /* create a new buffer and get a new gem handle. */
-struct exynos_drm_gem_obj *exynos_drm_gem_create(struct drm_file *file_priv,
-                struct drm_device *dev, unsigned int size,
-                unsigned int *handle);
+struct exynos_drm_gem_obj *exynos_drm_gem_create(struct drm_device *dev,
+                struct drm_file *file_priv,
+                unsigned int *handle, unsigned long size);
 
 /*
  * request gem object creation and buffer allocation as the size
diff --git a/drivers/net/wireless/ath/ath9k/hw.c b/drivers/net/wireless/ath/ath9k/hw.c
index 2f91acccb7db..8873c6e6fb96 100644
--- a/drivers/net/wireless/ath/ath9k/hw.c
+++ b/drivers/net/wireless/ath/ath9k/hw.c
@@ -1827,7 +1827,8 @@ static void ath9k_set_power_sleep(struct ath_hw *ah, int setChip)
         }
 
         /* Clear Bit 14 of AR_WA after putting chip into Full Sleep mode. */
-        REG_WRITE(ah, AR_WA, ah->WARegVal & ~AR_WA_D3_L1_DISABLE);
+        if (AR_SREV_9300_20_OR_LATER(ah))
+                REG_WRITE(ah, AR_WA, ah->WARegVal & ~AR_WA_D3_L1_DISABLE);
 }
 
 /*
diff --git a/drivers/staging/iio/industrialio-core.c b/drivers/staging/iio/industrialio-core.c
index 26564094e33b..aec9311b108c 100644
--- a/drivers/staging/iio/industrialio-core.c
+++ b/drivers/staging/iio/industrialio-core.c
@@ -242,25 +242,24 @@ static const struct file_operations iio_event_chrdev_fileops = {
 
 static int iio_event_getfd(struct iio_dev *indio_dev)
 {
+        struct iio_event_interface *ev_int = indio_dev->event_interface;
         int fd;
 
-        if (indio_dev->event_interface == NULL)
+        if (ev_int == NULL)
                 return -ENODEV;
 
-        mutex_lock(&indio_dev->event_interface->event_list_lock);
-        if (test_and_set_bit(IIO_BUSY_BIT_POS,
-                             &indio_dev->event_interface->flags)) {
-                mutex_unlock(&indio_dev->event_interface->event_list_lock);
+        mutex_lock(&ev_int->event_list_lock);
+        if (test_and_set_bit(IIO_BUSY_BIT_POS, &ev_int->flags)) {
+                mutex_unlock(&ev_int->event_list_lock);
                 return -EBUSY;
         }
-        mutex_unlock(&indio_dev->event_interface->event_list_lock);
+        mutex_unlock(&ev_int->event_list_lock);
         fd = anon_inode_getfd("iio:event",
-                                &iio_event_chrdev_fileops,
-                                indio_dev->event_interface, O_RDONLY);
+                                &iio_event_chrdev_fileops, ev_int, O_RDONLY);
         if (fd < 0) {
-                mutex_lock(&indio_dev->event_interface->event_list_lock);
+                mutex_lock(&ev_int->event_list_lock);
                 clear_bit(IIO_BUSY_BIT_POS, &ev_int->flags);
-                mutex_unlock(&indio_dev->event_interface->event_list_lock);
+                mutex_unlock(&ev_int->event_list_lock);
         }
         return fd;
 }
diff --git a/drivers/video/da8xx-fb.c b/drivers/video/da8xx-fb.c
index 55f91d9ab00b..29577bf1f559 100644
--- a/drivers/video/da8xx-fb.c
+++ b/drivers/video/da8xx-fb.c
@@ -116,6 +116,7 @@
 /* Clock registers available only on Version 2 */
 #define  LCD_CLK_ENABLE_REG                     0x6c
 #define  LCD_CLK_RESET_REG                      0x70
+#define  LCD_CLK_MAIN_RESET                     BIT(3)
 
 #define LCD_NUM_BUFFERS 2
 
@@ -244,6 +245,10 @@ static inline void lcd_enable_raster(void)
 {
         u32 reg;
 
+        /* Bring LCDC out of reset */
+        if (lcd_revision == LCD_VERSION_2)
+                lcdc_write(0, LCD_CLK_RESET_REG);
+
         reg = lcdc_read(LCD_RASTER_CTRL_REG);
         if (!(reg & LCD_RASTER_ENABLE))
                 lcdc_write(reg | LCD_RASTER_ENABLE, LCD_RASTER_CTRL_REG);
@@ -257,6 +262,10 @@ static inline void lcd_disable_raster(void)
         reg = lcdc_read(LCD_RASTER_CTRL_REG);
         if (reg & LCD_RASTER_ENABLE)
                 lcdc_write(reg & ~LCD_RASTER_ENABLE, LCD_RASTER_CTRL_REG);
+
+        if (lcd_revision == LCD_VERSION_2)
+                /* Write 1 to reset LCDC */
+                lcdc_write(LCD_CLK_MAIN_RESET, LCD_CLK_RESET_REG);
 }
 
 static void lcd_blit(int load_mode, struct da8xx_fb_par *par)
@@ -584,8 +593,12 @@ static void lcd_reset(struct da8xx_fb_par *par)
         lcdc_write(0, LCD_DMA_CTRL_REG);
         lcdc_write(0, LCD_RASTER_CTRL_REG);
 
-        if (lcd_revision == LCD_VERSION_2)
+        if (lcd_revision == LCD_VERSION_2) {
                 lcdc_write(0, LCD_INT_ENABLE_SET_REG);
+                /* Write 1 to reset */
+                lcdc_write(LCD_CLK_MAIN_RESET, LCD_CLK_RESET_REG);
+                lcdc_write(0, LCD_CLK_RESET_REG);
+        }
 }
 
 static void lcd_calc_clk_divider(struct da8xx_fb_par *par)
diff --git a/drivers/video/omap/dispc.c b/drivers/video/omap/dispc.c
index 0ccd7adf47bb..6f61e781f15a 100644
--- a/drivers/video/omap/dispc.c
+++ b/drivers/video/omap/dispc.c
@@ -19,6 +19,7 @@
  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  */
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/dma-mapping.h>
 #include <linux/mm.h>
 #include <linux/vmalloc.h>
diff --git a/drivers/video/omap2/dss/dispc.c b/drivers/video/omap2/dss/dispc.c
index 3532782551cb..5c81533eacaa 100644
--- a/drivers/video/omap2/dss/dispc.c
+++ b/drivers/video/omap2/dss/dispc.c
@@ -1720,12 +1720,11 @@ static int dispc_ovl_calc_scaling(enum omap_plane plane,
         const int maxdownscale = dss_feat_get_param_max(FEAT_PARAM_DOWNSCALE);
         unsigned long fclk = 0;
 
-        if ((ovl->caps & OMAP_DSS_OVL_CAP_SCALE) == 0) {
-                if (width != out_width || height != out_height)
-                        return -EINVAL;
-                else
-                        return 0;
-        }
+        if (width == out_width && height == out_height)
+                return 0;
+
+        if ((ovl->caps & OMAP_DSS_OVL_CAP_SCALE) == 0)
+                return -EINVAL;
 
         if (out_width < width / maxdownscale ||
                         out_width > width * 8)
diff --git a/drivers/video/omap2/dss/hdmi.c b/drivers/video/omap2/dss/hdmi.c
index 3262f0f1fa35..c56378c555b0 100644
--- a/drivers/video/omap2/dss/hdmi.c
+++ b/drivers/video/omap2/dss/hdmi.c
@@ -269,7 +269,7 @@ static void update_hdmi_timings(struct hdmi_config *cfg,
 unsigned long hdmi_get_pixel_clock(void)
 {
         /* HDMI Pixel Clock in Mhz */
-        return hdmi.ip_data.cfg.timings.timings.pixel_clock * 10000;
+        return hdmi.ip_data.cfg.timings.timings.pixel_clock * 1000;
 }
 
 static void hdmi_compute_pll(struct omap_dss_device *dssdev, int phy,
diff --git a/drivers/video/via/share.h b/drivers/video/via/share.h
index 69d882cbe709..c01c1c162726 100644
--- a/drivers/video/via/share.h
+++ b/drivers/video/via/share.h
@@ -559,8 +559,8 @@
 #define M1200X720_R60_VSP       POSITIVE
 
 /* 1200x900@60 Sync Polarity (DCON) */
-#define M1200X900_R60_HSP       NEGATIVE
-#define M1200X900_R60_VSP       NEGATIVE
+#define M1200X900_R60_HSP       POSITIVE
+#define M1200X900_R60_VSP       POSITIVE
 
 /* 1280x600@60 Sync Polarity (GTF Mode) */
 #define M1280x600_R60_HSP       NEGATIVE
diff --git a/fs/pstore/platform.c b/fs/pstore/platform.c
index 2bd620f0d796..57bbf9078ac8 100644
--- a/fs/pstore/platform.c
+++ b/fs/pstore/platform.c
@@ -167,6 +167,7 @@ int pstore_register(struct pstore_info *psi)
         }
 
         psinfo = psi;
+        mutex_init(&psinfo->read_mutex);
         spin_unlock(&pstore_lock);
 
         if (owner && !try_module_get(owner)) {
@@ -195,30 +196,32 @@ EXPORT_SYMBOL_GPL(pstore_register);
 void pstore_get_records(int quiet)
 {
         struct pstore_info *psi = psinfo;
+        char                    *buf = NULL;
         ssize_t                 size;
         u64                     id;
         enum pstore_type_id     type;
         struct timespec         time;
         int                     failed = 0, rc;
-        unsigned long           flags;
 
         if (!psi)
                 return;
 
-        spin_lock_irqsave(&psinfo->buf_lock, flags);
+        mutex_lock(&psi->read_mutex);
         rc = psi->open(psi);
         if (rc)
                 goto out;
 
-        while ((size = psi->read(&id, &type, &time, psi)) > 0) {
-                rc = pstore_mkfile(type, psi->name, id, psi->buf, (size_t)size,
+        while ((size = psi->read(&id, &type, &time, &buf, psi)) > 0) {
+                rc = pstore_mkfile(type, psi->name, id, buf, (size_t)size,
                                   time, psi);
+                kfree(buf);
+                buf = NULL;
                 if (rc && (rc != -EEXIST || !quiet))
                         failed++;
         }
         psi->close(psi);
 out:
-        spin_unlock_irqrestore(&psinfo->buf_lock, flags);
+        mutex_unlock(&psi->read_mutex);
 
         if (failed)
                 printk(KERN_WARNING "pstore: failed to load %d record(s) from '%s'\n",
diff --git a/include/drm/exynos_drm.h b/include/drm/exynos_drm.h
index 1d161cb3aca5..12050434d57a 100644
--- a/include/drm/exynos_drm.h
+++ b/include/drm/exynos_drm.h
@@ -32,17 +32,16 @@
 /**
  * User-desired buffer creation information structure.
  *
- * @size: requested size for the object.
+ * @size: user-desired memory allocation size.
  *      - this size value would be page-aligned internally.
  * @flags: user request for setting memory type or cache attributes.
- * @handle: returned handle for the object.
- * @pad: just padding to be 64-bit aligned.
+ * @handle: returned a handle to created gem object.
+ *      - this handle will be set by gem module of kernel side.
  */
 struct drm_exynos_gem_create {
-        unsigned int size;
+        uint64_t size;
         unsigned int flags;
         unsigned int handle;
-        unsigned int pad;
 };
 
 /**
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index 139c4db55f17..c86c940d1de3 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -156,6 +156,7 @@ extern u64 timecounter_cyc2time(struct timecounter *tc,
  * @mult:               cycle to nanosecond multiplier
  * @shift:              cycle to nanosecond divisor (power of two)
  * @max_idle_ns:        max idle time permitted by the clocksource (nsecs)
+ * @maxadj              maximum adjustment value to mult (~11%)
  * @flags:              flags describing special properties
  * @archdata:           arch-specific data
  * @suspend:            suspend function for the clocksource, if necessary
@@ -172,7 +173,7 @@ struct clocksource {
         u32 mult;
         u32 shift;
         u64 max_idle_ns;
-
+        u32 maxadj;
 #ifdef CONFIG_ARCH_CLOCKSOURCE_DATA
         struct arch_clocksource_data archdata;
 #endif
diff --git a/include/linux/pstore.h b/include/linux/pstore.h
index ea567321ae3c..2ca8cde5459d 100644
--- a/include/linux/pstore.h
+++ b/include/linux/pstore.h
@@ -35,10 +35,12 @@ struct pstore_info {
         spinlock_t      buf_lock;       /* serialize access to 'buf' */
         char            *buf;
         size_t          bufsize;
+        struct mutex    read_mutex;     /* serialize open/read/close */
         int             (*open)(struct pstore_info *psi);
         int             (*close)(struct pstore_info *psi);
         ssize_t         (*read)(u64 *id, enum pstore_type_id *type,
-                        struct timespec *time, struct pstore_info *psi);
+                        struct timespec *time, char **buf,
+                        struct pstore_info *psi);
         int             (*write)(enum pstore_type_id type, u64 *id,
                         unsigned int part, size_t size, struct pstore_info *psi);
         int             (*erase)(enum pstore_type_id type, u64 id,
diff --git a/kernel/cgroup_freezer.c b/kernel/cgroup_freezer.c
index 5e828a2ca8e6..213c0351dad8 100644
--- a/kernel/cgroup_freezer.c
+++ b/kernel/cgroup_freezer.c
@@ -153,6 +153,13 @@ static void freezer_destroy(struct cgroup_subsys *ss,
         kfree(cgroup_freezer(cgroup));
 }
 
+/* task is frozen or will freeze immediately when next it gets woken */
+static bool is_task_frozen_enough(struct task_struct *task)
+{
+        return frozen(task) ||
+                (task_is_stopped_or_traced(task) && freezing(task));
+}
+
 /*
  * The call to cgroup_lock() in the freezer.state write method prevents
  * a write to that file racing against an attach, and hence the
@@ -231,7 +238,7 @@ static void update_if_frozen(struct cgroup *cgroup,
         cgroup_iter_start(cgroup, &it);
         while ((task = cgroup_iter_next(cgroup, &it))) {
                 ntotal++;
-                if (frozen(task))
+                if (is_task_frozen_enough(task))
                         nfrozen++;
         }
 
@@ -284,7 +291,7 @@ static int try_to_freeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
         while ((task = cgroup_iter_next(cgroup, &it))) {
                 if (!freeze_task(task, true))
                         continue;
-                if (frozen(task))
+                if (is_task_frozen_enough(task))
                         continue;
                 if (!freezing(task) && !freezer_should_skip(task))
                         num_cant_freeze_now++;
diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index 422e567eecf6..ae34bf51682b 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -885,10 +885,13 @@ static void __remove_hrtimer(struct hrtimer *timer,
                              struct hrtimer_clock_base *base,
                              unsigned long newstate, int reprogram)
 {
+        struct timerqueue_node *next_timer;
         if (!(timer->state & HRTIMER_STATE_ENQUEUED))
                 goto out;
 
-        if (&timer->node == timerqueue_getnext(&base->active)) {
+        next_timer = timerqueue_getnext(&base->active);
+        timerqueue_del(&base->active, &timer->node);
+        if (&timer->node == next_timer) {
 #ifdef CONFIG_HIGH_RES_TIMERS
                 /* Reprogram the clock event device. if enabled */
                 if (reprogram && hrtimer_hres_active()) {
@@ -901,7 +904,6 @@ static void __remove_hrtimer(struct hrtimer *timer,
                 }
 #endif
         }
-        timerqueue_del(&base->active, &timer->node);
         if (!timerqueue_getnext(&base->active))
                 base->cpu_base->active_bases &= ~(1 << base->index);
 out:
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 67ce837ae52c..0e2b179bc7b3 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -1596,7 +1596,7 @@ int request_percpu_irq(unsigned int irq, irq_handler_t handler,
                 return -ENOMEM;
 
         action->handler = handler;
-        action->flags = IRQF_PERCPU;
+        action->flags = IRQF_PERCPU | IRQF_NO_SUSPEND;
         action->name = devname;
         action->percpu_dev_id = dev_id;
 
diff --git a/kernel/irq/spurious.c b/kernel/irq/spurious.c
index b5f4742693c0..dc813a948be2 100644
--- a/kernel/irq/spurious.c
+++ b/kernel/irq/spurious.c
@@ -84,7 +84,9 @@ static int try_one_irq(int irq, struct irq_desc *desc, bool force)
          */
         action = desc->action;
         if (!action || !(action->flags & IRQF_SHARED) ||
-            (action->flags & __IRQF_TIMER) || !action->next)
+            (action->flags & __IRQF_TIMER) ||
+            (action->handler(irq, action->dev_id) == IRQ_HANDLED) ||
+            !action->next)
                 goto out;
 
         /* Already running on another processor */
diff --git a/kernel/time/clocksource.c b/kernel/time/clocksource.c
index cf52fda2e096..cfc65e1eb9fb 100644
--- a/kernel/time/clocksource.c
+++ b/kernel/time/clocksource.c
@@ -492,6 +492,22 @@ void clocksource_touch_watchdog(void)
 }
 
 /**
+ * clocksource_max_adjustment- Returns max adjustment amount
+ * @cs:         Pointer to clocksource
+ *
+ */
+static u32 clocksource_max_adjustment(struct clocksource *cs)
+{
+        u64 ret;
+        /*
+         * We won't try to correct for more then 11% adjustments (110,000 ppm),
+         */
+        ret = (u64)cs->mult * 11;
+        do_div(ret,100);
+        return (u32)ret;
+}
+
+/**
  * clocksource_max_deferment - Returns max time the clocksource can be deferred
  * @cs:         Pointer to clocksource
  *
@@ -503,25 +519,28 @@ static u64 clocksource_max_deferment(struct clocksource *cs)
         /*
          * Calculate the maximum number of cycles that we can pass to the
          * cyc2ns function without overflowing a 64-bit signed result. The
-         * maximum number of cycles is equal to ULLONG_MAX/cs->mult which
-         * is equivalent to the below.
-         * max_cycles < (2^63)/cs->mult
-         * max_cycles < 2^(log2((2^63)/cs->mult))
-         * max_cycles < 2^(log2(2^63) - log2(cs->mult))
-         * max_cycles < 2^(63 - log2(cs->mult))
-         * max_cycles < 1 << (63 - log2(cs->mult))
+         * maximum number of cycles is equal to ULLONG_MAX/(cs->mult+cs->maxadj)
+         * which is equivalent to the below.
+         * max_cycles < (2^63)/(cs->mult + cs->maxadj)
+         * max_cycles < 2^(log2((2^63)/(cs->mult + cs->maxadj)))
+         * max_cycles < 2^(log2(2^63) - log2(cs->mult + cs->maxadj))
+         * max_cycles < 2^(63 - log2(cs->mult + cs->maxadj))
+         * max_cycles < 1 << (63 - log2(cs->mult + cs->maxadj))
          * Please note that we add 1 to the result of the log2 to account for
          * any rounding errors, ensure the above inequality is satisfied and
          * no overflow will occur.
          */
-        max_cycles = 1ULL << (63 - (ilog2(cs->mult) + 1));
+        max_cycles = 1ULL << (63 - (ilog2(cs->mult + cs->maxadj) + 1));
 
         /*
          * The actual maximum number of cycles we can defer the clocksource is
          * determined by the minimum of max_cycles and cs->mask.
+         * Note: Here we subtract the maxadj to make sure we don't sleep for
+         * too long if there's a large negative adjustment.
          */
         max_cycles = min_t(u64, max_cycles, (u64) cs->mask);
-        max_nsecs = clocksource_cyc2ns(max_cycles, cs->mult, cs->shift);
+        max_nsecs = clocksource_cyc2ns(max_cycles, cs->mult - cs->maxadj,
+                                        cs->shift);
 
         /*
          * To ensure that the clocksource does not wrap whilst we are idle,
@@ -640,7 +659,6 @@ static void clocksource_enqueue(struct clocksource *cs)
 void __clocksource_updatefreq_scale(struct clocksource *cs, u32 scale, u32 freq)
 {
         u64 sec;
-
         /*
          * Calc the maximum number of seconds which we can run before
          * wrapping around. For clocksources which have a mask > 32bit
@@ -661,6 +679,20 @@ void __clocksource_updatefreq_scale(struct clocksource *cs, u32 scale, u32 freq)
 
         clocks_calc_mult_shift(&cs->mult, &cs->shift, freq,
                                NSEC_PER_SEC / scale, sec * scale);
+
+        /*
+         * for clocksources that have large mults, to avoid overflow.
+         * Since mult may be adjusted by ntp, add an safety extra margin
+         *
+         */
+        cs->maxadj = clocksource_max_adjustment(cs);
+        while ((cs->mult + cs->maxadj < cs->mult)
+                || (cs->mult - cs->maxadj > cs->mult)) {
+                cs->mult >>= 1;
+                cs->shift--;
+                cs->maxadj = clocksource_max_adjustment(cs);
+        }
+
         cs->max_idle_ns = clocksource_max_deferment(cs);
 }
 EXPORT_SYMBOL_GPL(__clocksource_updatefreq_scale);
@@ -701,6 +733,12 @@ EXPORT_SYMBOL_GPL(__clocksource_register_scale);
  */
 int clocksource_register(struct clocksource *cs)
 {
+        /* calculate max adjustment for given mult/shift */
+        cs->maxadj = clocksource_max_adjustment(cs);
+        WARN_ONCE(cs->mult + cs->maxadj < cs->mult,
+                "Clocksource %s might overflow on 11%% adjustment\n",
+                cs->name);
+
         /* calculate max idle time permitted for this clocksource */
         cs->max_idle_ns = clocksource_max_deferment(cs);
 
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index 2b021b0e8507..237841378c03 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -249,6 +249,8 @@ ktime_t ktime_get(void)
                 secs = xtime.tv_sec + wall_to_monotonic.tv_sec;
                 nsecs = xtime.tv_nsec + wall_to_monotonic.tv_nsec;
                 nsecs += timekeeping_get_ns();
+                /* If arch requires, add in gettimeoffset() */
+                nsecs += arch_gettimeoffset();
 
         } while (read_seqretry(&xtime_lock, seq));
         /*
@@ -280,6 +282,8 @@ void ktime_get_ts(struct timespec *ts)
                 *ts = xtime;
                 tomono = wall_to_monotonic;
                 nsecs = timekeeping_get_ns();
+                /* If arch requires, add in gettimeoffset() */
+                nsecs += arch_gettimeoffset();
 
         } while (read_seqretry(&xtime_lock, seq));
 
@@ -802,14 +806,44 @@ static void timekeeping_adjust(s64 offset)
         s64 error, interval = timekeeper.cycle_interval;
         int adj;
 
+        /*
+         * The point of this is to check if the error is greater then half
+         * an interval.
+         *
+         * First we shift it down from NTP_SHIFT to clocksource->shifted nsecs.
+         *
+         * Note we subtract one in the shift, so that error is really error*2.
+         * This "saves" dividing(shifting) intererval twice, but keeps the
+         * (error > interval) comparision as still measuring if error is
+         * larger then half an interval.
+         *
+         * Note: It does not "save" on aggrivation when reading the code.
+         */
         error = timekeeper.ntp_error >> (timekeeper.ntp_error_shift - 1);
         if (error > interval) {
+                /*
+                 * We now divide error by 4(via shift), which checks if
+                 * the error is greater then twice the interval.
+                 * If it is greater, we need a bigadjust, if its smaller,
+                 * we can adjust by 1.
+                 */
                 error >>= 2;
+                /*
+                 * XXX - In update_wall_time, we round up to the next
+                 * nanosecond, and store the amount rounded up into
+                 * the error. This causes the likely below to be unlikely.
+                 *
+                 * The properfix is to avoid rounding up by using
+                 * the high precision timekeeper.xtime_nsec instead of
+                 * xtime.tv_nsec everywhere. Fixing this will take some
+                 * time.
+                 */
                 if (likely(error <= interval))
                         adj = 1;
                 else
                         adj = timekeeping_bigadjust(error, &interval, &offset);
         } else if (error < -interval) {
+                /* See comment above, this is just switched for the negative */
                 error >>= 2;
                 if (likely(error >= -interval)) {
                         adj = -1;
@@ -817,9 +851,65 @@ static void timekeeping_adjust(s64 offset)
                         offset = -offset;
                 } else
                         adj = timekeeping_bigadjust(error, &interval, &offset);
-        } else
+        } else /* No adjustment needed */
                 return;
 
+        WARN_ONCE(timekeeper.clock->maxadj &&
+                        (timekeeper.mult + adj > timekeeper.clock->mult +
+                                                timekeeper.clock->maxadj),
+                        "Adjusting %s more then 11%% (%ld vs %ld)\n",
+                        timekeeper.clock->name, (long)timekeeper.mult + adj,
+                        (long)timekeeper.clock->mult +
+                                timekeeper.clock->maxadj);
+        /*
+         * So the following can be confusing.
+         *
+         * To keep things simple, lets assume adj == 1 for now.
+         *
+         * When adj != 1, remember that the interval and offset values
+         * have been appropriately scaled so the math is the same.
+         *
+         * The basic idea here is that we're increasing the multiplier
+         * by one, this causes the xtime_interval to be incremented by
+         * one cycle_interval. This is because:
+         *      xtime_interval = cycle_interval * mult
+         * So if mult is being incremented by one:
+         *      xtime_interval = cycle_interval * (mult + 1)
+         * Its the same as:
+         *      xtime_interval = (cycle_interval * mult) + cycle_interval
+         * Which can be shortened to:
+         *      xtime_interval += cycle_interval
+         *
+         * So offset stores the non-accumulated cycles. Thus the current
+         * time (in shifted nanoseconds) is:
+         *      now = (offset * adj) + xtime_nsec
+         * Now, even though we're adjusting the clock frequency, we have
+         * to keep time consistent. In other words, we can't jump back
+         * in time, and we also want to avoid jumping forward in time.
+         *
+         * So given the same offset value, we need the time to be the same
+         * both before and after the freq adjustment.
+         *      now = (offset * adj_1) + xtime_nsec_1
+         *      now = (offset * adj_2) + xtime_nsec_2
+         * So:
+         *      (offset * adj_1) + xtime_nsec_1 =
+         *              (offset * adj_2) + xtime_nsec_2
+         * And we know:
+         *      adj_2 = adj_1 + 1
+         * So:
+         *      (offset * adj_1) + xtime_nsec_1 =
+         *              (offset * (adj_1+1)) + xtime_nsec_2
+         *      (offset * adj_1) + xtime_nsec_1 =
+         *              (offset * adj_1) + offset + xtime_nsec_2
+         * Canceling the sides:
+         *      xtime_nsec_1 = offset + xtime_nsec_2
+         * Which gives us:
+         *      xtime_nsec_2 = xtime_nsec_1 - offset
+         * Which simplfies to:
+         *      xtime_nsec -= offset
+         *
+         * XXX - TODO: Doc ntp_error calculation.
+         */
         timekeeper.mult += adj;
         timekeeper.xtime_interval += interval;
         timekeeper.xtime_nsec -= offset;
diff --git a/mm/percpu-vm.c b/mm/percpu-vm.c
index ea534960a04b..12a48a88c0d8 100644
--- a/mm/percpu-vm.c
+++ b/mm/percpu-vm.c
@@ -50,14 +50,13 @@ static struct page **pcpu_get_pages_and_bitmap(struct pcpu_chunk *chunk,
 
         if (!pages || !bitmap) {
                 if (may_alloc && !pages)
-                        pages = pcpu_mem_alloc(pages_size);
+                        pages = pcpu_mem_zalloc(pages_size);
                 if (may_alloc && !bitmap)
-                        bitmap = pcpu_mem_alloc(bitmap_size);
+                        bitmap = pcpu_mem_zalloc(bitmap_size);
                 if (!pages || !bitmap)
                         return NULL;
         }
 
-        memset(pages, 0, pages_size);
         bitmap_copy(bitmap, chunk->populated, pcpu_unit_pages);
 
         *bitmapp = bitmap;
@@ -143,8 +142,8 @@ static void pcpu_pre_unmap_flush(struct pcpu_chunk *chunk,
                                  int page_start, int page_end)
 {
         flush_cache_vunmap(
-                pcpu_chunk_addr(chunk, pcpu_first_unit_cpu, page_start),
-                pcpu_chunk_addr(chunk, pcpu_last_unit_cpu, page_end));
+                pcpu_chunk_addr(chunk, pcpu_low_unit_cpu, page_start),
+                pcpu_chunk_addr(chunk, pcpu_high_unit_cpu, page_end));
 }
 
 static void __pcpu_unmap_pages(unsigned long addr, int nr_pages)
@@ -206,8 +205,8 @@ static void pcpu_post_unmap_tlb_flush(struct pcpu_chunk *chunk,
                                       int page_start, int page_end)
 {
         flush_tlb_kernel_range(
-                pcpu_chunk_addr(chunk, pcpu_first_unit_cpu, page_start),
-                pcpu_chunk_addr(chunk, pcpu_last_unit_cpu, page_end));
+                pcpu_chunk_addr(chunk, pcpu_low_unit_cpu, page_start),
+                pcpu_chunk_addr(chunk, pcpu_high_unit_cpu, page_end));
 }
 
 static int __pcpu_map_pages(unsigned long addr, struct page **pages,
@@ -284,8 +283,8 @@ static void pcpu_post_map_flush(struct pcpu_chunk *chunk,
                                 int page_start, int page_end)
 {
         flush_cache_vmap(
-                pcpu_chunk_addr(chunk, pcpu_first_unit_cpu, page_start),
-                pcpu_chunk_addr(chunk, pcpu_last_unit_cpu, page_end));
+                pcpu_chunk_addr(chunk, pcpu_low_unit_cpu, page_start),
+                pcpu_chunk_addr(chunk, pcpu_high_unit_cpu, page_end));
 }
 
 /**
diff --git a/mm/percpu.c b/mm/percpu.c
index bf80e55dbed7..3bb810a72006 100644
--- a/mm/percpu.c
+++ b/mm/percpu.c
@@ -116,9 +116,9 @@ static int pcpu_atom_size __read_mostly;
 static int pcpu_nr_slots __read_mostly;
 static size_t pcpu_chunk_struct_size __read_mostly;
 
-/* cpus with the lowest and highest unit numbers */
-static unsigned int pcpu_first_unit_cpu __read_mostly;
-static unsigned int pcpu_last_unit_cpu __read_mostly;
+/* cpus with the lowest and highest unit addresses */
+static unsigned int pcpu_low_unit_cpu __read_mostly;
+static unsigned int pcpu_high_unit_cpu __read_mostly;
 
 /* the address of the first chunk which starts with the kernel static area */
 void *pcpu_base_addr __read_mostly;
@@ -273,11 +273,11 @@ static void __maybe_unused pcpu_next_pop(struct pcpu_chunk *chunk,
              (rs) = (re) + 1, pcpu_next_pop((chunk), &(rs), &(re), (end)))
 
 /**
- * pcpu_mem_alloc - allocate memory
+ * pcpu_mem_zalloc - allocate memory
  * @size: bytes to allocate
  *
  * Allocate @size bytes.  If @size is smaller than PAGE_SIZE,
- * kzalloc() is used; otherwise, vmalloc() is used.  The returned
+ * kzalloc() is used; otherwise, vzalloc() is used.  The returned
  * memory is always zeroed.
  *
  * CONTEXT:
@@ -286,7 +286,7 @@ static void __maybe_unused pcpu_next_pop(struct pcpu_chunk *chunk,
  * RETURNS:
  * Pointer to the allocated area on success, NULL on failure.
  */
-static void *pcpu_mem_alloc(size_t size)
+static void *pcpu_mem_zalloc(size_t size)
 {
         if (WARN_ON_ONCE(!slab_is_available()))
                 return NULL;
@@ -302,7 +302,7 @@ static void *pcpu_mem_alloc(size_t size)
  * @ptr: memory to free
  * @size: size of the area
  *
- * Free @ptr.  @ptr should have been allocated using pcpu_mem_alloc().
+ * Free @ptr.  @ptr should have been allocated using pcpu_mem_zalloc().
  */
 static void pcpu_mem_free(void *ptr, size_t size)
 {
@@ -384,7 +384,7 @@ static int pcpu_extend_area_map(struct pcpu_chunk *chunk, int new_alloc)
         size_t old_size = 0, new_size = new_alloc * sizeof(new[0]);
         unsigned long flags;
 
-        new = pcpu_mem_alloc(new_size);
+        new = pcpu_mem_zalloc(new_size);
         if (!new)
                 return -ENOMEM;
 
@@ -604,11 +604,12 @@ static struct pcpu_chunk *pcpu_alloc_chunk(void)
 {
         struct pcpu_chunk *chunk;
 
-        chunk = pcpu_mem_alloc(pcpu_chunk_struct_size);
+        chunk = pcpu_mem_zalloc(pcpu_chunk_struct_size);
         if (!chunk)
                 return NULL;
 
-        chunk->map = pcpu_mem_alloc(PCPU_DFL_MAP_ALLOC * sizeof(chunk->map[0]));
+        chunk->map = pcpu_mem_zalloc(PCPU_DFL_MAP_ALLOC *
+                                                sizeof(chunk->map[0]));
         if (!chunk->map) {
                 kfree(chunk);
                 return NULL;
@@ -977,6 +978,17 @@ bool is_kernel_percpu_address(unsigned long addr)
  * address.  The caller is responsible for ensuring @addr stays valid
  * until this function finishes.
  *
+ * percpu allocator has special setup for the first chunk, which currently
+ * supports either embedding in linear address space or vmalloc mapping,
+ * and, from the second one, the backing allocator (currently either vm or
+ * km) provides translation.
+ *
+ * The addr can be tranlated simply without checking if it falls into the
+ * first chunk. But the current code reflects better how percpu allocator
+ * actually works, and the verification can discover both bugs in percpu
+ * allocator itself and per_cpu_ptr_to_phys() callers. So we keep current
+ * code.
+ *
  * RETURNS:
  * The physical address for @addr.
  */
@@ -984,19 +996,19 @@ phys_addr_t per_cpu_ptr_to_phys(void *addr)
 {
         void __percpu *base = __addr_to_pcpu_ptr(pcpu_base_addr);
         bool in_first_chunk = false;
-        unsigned long first_start, first_end;
+        unsigned long first_low, first_high;
         unsigned int cpu;
 
         /*
-         * The following test on first_start/end isn't strictly
+         * The following test on unit_low/high isn't strictly
          * necessary but will speed up lookups of addresses which
          * aren't in the first chunk.
          */
-        first_start = pcpu_chunk_addr(pcpu_first_chunk, pcpu_first_unit_cpu, 0);
-        first_end = pcpu_chunk_addr(pcpu_first_chunk, pcpu_last_unit_cpu,
-                                    pcpu_unit_pages);
-        if ((unsigned long)addr >= first_start &&
-            (unsigned long)addr < first_end) {
+        first_low = pcpu_chunk_addr(pcpu_first_chunk, pcpu_low_unit_cpu, 0);
+        first_high = pcpu_chunk_addr(pcpu_first_chunk, pcpu_high_unit_cpu,
+                                     pcpu_unit_pages);
+        if ((unsigned long)addr >= first_low &&
+            (unsigned long)addr < first_high) {
                 for_each_possible_cpu(cpu) {
                         void *start = per_cpu_ptr(base, cpu);
 
@@ -1233,7 +1245,9 @@ int __init pcpu_setup_first_chunk(const struct pcpu_alloc_info *ai,
 
         for (cpu = 0; cpu < nr_cpu_ids; cpu++)
                 unit_map[cpu] = UINT_MAX;
-        pcpu_first_unit_cpu = NR_CPUS;
+
+        pcpu_low_unit_cpu = NR_CPUS;
+        pcpu_high_unit_cpu = NR_CPUS;
 
         for (group = 0, unit = 0; group < ai->nr_groups; group++, unit += i) {
                 const struct pcpu_group_info *gi = &ai->groups[group];
@@ -1253,9 +1267,13 @@ int __init pcpu_setup_first_chunk(const struct pcpu_alloc_info *ai,
                         unit_map[cpu] = unit + i;
                         unit_off[cpu] = gi->base_offset + i * ai->unit_size;
 
-                        if (pcpu_first_unit_cpu == NR_CPUS)
-                                pcpu_first_unit_cpu = cpu;
-                        pcpu_last_unit_cpu = cpu;
+                        /* determine low/high unit_cpu */
+                        if (pcpu_low_unit_cpu == NR_CPUS ||
+                            unit_off[cpu] < unit_off[pcpu_low_unit_cpu])
+                                pcpu_low_unit_cpu = cpu;
+                        if (pcpu_high_unit_cpu == NR_CPUS ||
+                            unit_off[cpu] > unit_off[pcpu_high_unit_cpu])
+                                pcpu_high_unit_cpu = cpu;
                 }
         }
         pcpu_nr_units = unit;
@@ -1889,7 +1907,7 @@ void __init percpu_init_late(void)
 
                 BUILD_BUG_ON(size > PAGE_SIZE);
 
-                map = pcpu_mem_alloc(size);
+                map = pcpu_mem_zalloc(size);
                 BUG_ON(!map);
 
                 spin_lock_irqsave(&pcpu_lock, flags);
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 2d78d95955ab..55472c48825e 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -496,7 +496,7 @@ static int xs_nospace(struct rpc_task *task)
         struct rpc_rqst *req = task->tk_rqstp;
         struct rpc_xprt *xprt = req->rq_xprt;
         struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
-        int ret = 0;
+        int ret = -EAGAIN;
 
         dprintk("RPC: %5u xmit incomplete (%u left of %u)\n",
                         task->tk_pid, req->rq_slen - req->rq_bytes_sent,
@@ -508,7 +508,6 @@ static int xs_nospace(struct rpc_task *task)
         /* Don't race with disconnect */
         if (xprt_connected(xprt)) {
                 if (test_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags)) {
-                        ret = -EAGAIN;
                         /*
                          * Notify TCP that we're limited by the application
                          * window size
diff --git a/sound/pci/cs5535audio/cs5535audio_pcm.c b/sound/pci/cs5535audio/cs5535audio_pcm.c
index e083122ca55a..dbf94b189e75 100644
--- a/sound/pci/cs5535audio/cs5535audio_pcm.c
+++ b/sound/pci/cs5535audio/cs5535audio_pcm.c
@@ -148,7 +148,7 @@ static int cs5535audio_build_dma_packets(struct cs5535audio *cs5535au,
                 struct cs5535audio_dma_desc *desc =
                         &((struct cs5535audio_dma_desc *) dma->desc_buf.area)[i];
                 desc->addr = cpu_to_le32(addr);
-                desc->size = cpu_to_le32(period_bytes);
+                desc->size = cpu_to_le16(period_bytes);
                 desc->ctlreserved = cpu_to_le16(PRD_EOP);
                 desc_addr += sizeof(struct cs5535audio_dma_desc);
                 addr += period_bytes;
diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index e44b107fdc75..4562e9de6a1a 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -4046,9 +4046,9 @@ int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
 
         /* Search for codec ID */
         for (q = tbl; q->subvendor; q++) {
-                unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
-
-                if (vendorid == codec->subsystem_id)
+                unsigned int mask = 0xffff0000 | q->subdevice_mask;
+                unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
+                if ((codec->subsystem_id & mask) == id)
                         break;
         }
 
diff --git a/sound/pci/hda/hda_eld.c b/sound/pci/hda/hda_eld.c
index 7ae7578bdcc0..c1da422e085a 100644
--- a/sound/pci/hda/hda_eld.c
+++ b/sound/pci/hda/hda_eld.c
@@ -347,18 +347,28 @@ int snd_hdmi_get_eld(struct hdmi_eld *eld,
 
         for (i = 0; i < size; i++) {
                 unsigned int val = hdmi_get_eld_data(codec, nid, i);
+                /*
+                 * Graphics driver might be writing to ELD buffer right now.
+                 * Just abort. The caller will repoll after a while.
+                 */
                 if (!(val & AC_ELDD_ELD_VALID)) {
-                        if (!i) {
-                                snd_printd(KERN_INFO
-                                           "HDMI: invalid ELD data\n");
-                                ret = -EINVAL;
-                                goto error;
-                        }
                         snd_printd(KERN_INFO
                                   "HDMI: invalid ELD data byte %d\n", i);
-                        val = 0;
-                } else
-                        val &= AC_ELDD_ELD_DATA;
+                        ret = -EINVAL;
+                        goto error;
+                }
+                val &= AC_ELDD_ELD_DATA;
+                /*
+                 * The first byte cannot be zero. This can happen on some DVI
+                 * connections. Some Intel chips may also need some 250ms delay
+                 * to return non-zero ELD data, even when the graphics driver
+                 * correctly writes ELD content before setting ELD_valid bit.
+                 */
+                if (!val && !i) {
+                        snd_printdd(KERN_INFO "HDMI: 0 ELD data\n");
+                        ret = -EINVAL;
+                        goto error;
+                }
                 buf[i] = val;
         }
 
diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c
index 2fbab8e29576..70a7abda7e22 100644
--- a/sound/pci/hda/patch_cirrus.c
+++ b/sound/pci/hda/patch_cirrus.c
@@ -58,6 +58,8 @@ struct cs_spec {
         unsigned int gpio_mask;
         unsigned int gpio_dir;
         unsigned int gpio_data;
+        unsigned int gpio_eapd_hp; /* EAPD GPIO bit for headphones */
+        unsigned int gpio_eapd_speaker; /* EAPD GPIO bit for speakers */
 
         struct hda_pcm pcm_rec[2];      /* PCM information */
 
@@ -76,6 +78,7 @@ enum {
         CS420X_MBP53,
         CS420X_MBP55,
         CS420X_IMAC27,
+        CS420X_APPLE,
         CS420X_AUTO,
         CS420X_MODELS
 };
@@ -928,10 +931,9 @@ static void cs_automute(struct hda_codec *codec)
                                         spdif_present ? 0 : PIN_OUT);
                 }
         }
-        if (spec->board_config == CS420X_MBP53 ||
-            spec->board_config == CS420X_MBP55 ||
-            spec->board_config == CS420X_IMAC27) {
-                unsigned int gpio = hp_present ? 0x02 : 0x08;
+        if (spec->gpio_eapd_hp) {
+                unsigned int gpio = hp_present ?
+                        spec->gpio_eapd_hp : spec->gpio_eapd_speaker;
                 snd_hda_codec_write(codec, 0x01, 0,
                                     AC_VERB_SET_GPIO_DATA, gpio);
         }
@@ -1276,6 +1278,7 @@ static const char * const cs420x_models[CS420X_MODELS] = {
         [CS420X_MBP53] = "mbp53",
         [CS420X_MBP55] = "mbp55",
         [CS420X_IMAC27] = "imac27",
+        [CS420X_APPLE] = "apple",
         [CS420X_AUTO] = "auto",
 };
 
@@ -1285,7 +1288,13 @@ static const struct snd_pci_quirk cs420x_cfg_tbl[] = {
         SND_PCI_QUIRK(0x10de, 0x0d94, "MacBookAir 3,1(2)", CS420X_MBP55),
         SND_PCI_QUIRK(0x10de, 0xcb79, "MacBookPro 5,5", CS420X_MBP55),
         SND_PCI_QUIRK(0x10de, 0xcb89, "MacBookPro 7,1", CS420X_MBP55),
-        SND_PCI_QUIRK(0x8086, 0x7270, "IMac 27 Inch", CS420X_IMAC27),
+        /* this conflicts with too many other models */
+        /*SND_PCI_QUIRK(0x8086, 0x7270, "IMac 27 Inch", CS420X_IMAC27),*/
+        {} /* terminator */
+};
+
+static const struct snd_pci_quirk cs420x_codec_cfg_tbl[] = {
+        SND_PCI_QUIRK_VENDOR(0x106b, "Apple", CS420X_APPLE),
         {} /* terminator */
 };
 
@@ -1367,6 +1376,10 @@ static int patch_cs420x(struct hda_codec *codec)
         spec->board_config =
                 snd_hda_check_board_config(codec, CS420X_MODELS,
                                            cs420x_models, cs420x_cfg_tbl);
+        if (spec->board_config < 0)
+                spec->board_config =
+                        snd_hda_check_board_codec_sid_config(codec,
+                                CS420X_MODELS, NULL, cs420x_codec_cfg_tbl);
         if (spec->board_config >= 0)
                 fix_pincfg(codec, spec->board_config, cs_pincfgs);
 
@@ -1374,10 +1387,11 @@ static int patch_cs420x(struct hda_codec *codec)
         case CS420X_IMAC27:
         case CS420X_MBP53:
         case CS420X_MBP55:
-                /* GPIO1 = headphones */
-                /* GPIO3 = speakers */
-                spec->gpio_mask = 0x0a;
-                spec->gpio_dir = 0x0a;
+        case CS420X_APPLE:
+                spec->gpio_eapd_hp = 2; /* GPIO1 = headphones */
+                spec->gpio_eapd_speaker = 8; /* GPIO3 = speakers */
+                spec->gpio_mask = spec->gpio_dir =
+                        spec->gpio_eapd_hp | spec->gpio_eapd_speaker;
                 break;
         }
 
diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
index 9850c5b481ea..c505fd5d338c 100644
--- a/sound/pci/hda/patch_hdmi.c
+++ b/sound/pci/hda/patch_hdmi.c
@@ -69,6 +69,7 @@ struct hdmi_spec_per_pin {
         struct hda_codec *codec;
         struct hdmi_eld sink_eld;
         struct delayed_work work;
+        int repoll_count;
 };
 
 struct hdmi_spec {
@@ -748,7 +749,7 @@ static void hdmi_setup_audio_infoframe(struct hda_codec *codec, int pin_idx,
  * Unsolicited events
  */
 
-static void hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, bool retry);
+static void hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, int repoll);
 
 static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
 {
@@ -766,7 +767,7 @@ static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
         if (pin_idx < 0)
                 return;
 
-        hdmi_present_sense(&spec->pins[pin_idx], true);
+        hdmi_present_sense(&spec->pins[pin_idx], 1);
 }
 
 static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res)
@@ -960,7 +961,7 @@ static int hdmi_read_pin_conn(struct hda_codec *codec, int pin_idx)
         return 0;
 }
 
-static void hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, bool retry)
+static void hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, int repoll)
 {
         struct hda_codec *codec = per_pin->codec;
         struct hdmi_eld *eld = &per_pin->sink_eld;
@@ -989,7 +990,7 @@ static void hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, bool retry)
         if (eld_valid) {
                 if (!snd_hdmi_get_eld(eld, codec, pin_nid))
                         snd_hdmi_show_eld(eld);
-                else if (retry) {
+                else if (repoll) {
                         queue_delayed_work(codec->bus->workq,
                                            &per_pin->work,
                                            msecs_to_jiffies(300));
@@ -1004,7 +1005,10 @@ static void hdmi_repoll_eld(struct work_struct *work)
         struct hdmi_spec_per_pin *per_pin =
         container_of(to_delayed_work(work), struct hdmi_spec_per_pin, work);
 
-        hdmi_present_sense(per_pin, false);
+        if (per_pin->repoll_count++ > 6)
+                per_pin->repoll_count = 0;
+
+        hdmi_present_sense(per_pin, per_pin->repoll_count);
 }
 
 static int hdmi_add_pin(struct hda_codec *codec, hda_nid_t pin_nid)
@@ -1235,7 +1239,7 @@ static int generic_hdmi_build_jack(struct hda_codec *codec, int pin_idx)
         if (err < 0)
                 return err;
 
-        hdmi_present_sense(per_pin, false);
+        hdmi_present_sense(per_pin, 0);
         return 0;
 }
 
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index 336d14eb72af..cbde019d3d52 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -277,6 +277,12 @@ static bool alc_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
         return false;
 }
 
+static inline hda_nid_t get_capsrc(struct alc_spec *spec, int idx)
+{
+        return spec->capsrc_nids ?
+                spec->capsrc_nids[idx] : spec->adc_nids[idx];
+}
+
 /* select the given imux item; either unmute exclusively or select the route */
 static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx,
                           unsigned int idx, bool force)
@@ -303,8 +309,7 @@ static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx,
                 adc_idx = spec->dyn_adc_idx[idx];
         }
 
-        nid = spec->capsrc_nids ?
-                spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
+        nid = get_capsrc(spec, adc_idx);
 
         /* no selection? */
         num_conns = snd_hda_get_conn_list(codec, nid, NULL);
@@ -1054,8 +1059,19 @@ static bool alc_rebuild_imux_for_auto_mic(struct hda_codec *codec)
         spec->imux_pins[2] = spec->dock_mic_pin;
         for (i = 0; i < 3; i++) {
                 strcpy(imux->items[i].label, texts[i]);
-                if (spec->imux_pins[i])
+                if (spec->imux_pins[i]) {
+                        hda_nid_t pin = spec->imux_pins[i];
+                        int c;
+                        for (c = 0; c < spec->num_adc_nids; c++) {
+                                hda_nid_t cap = get_capsrc(spec, c);
+                                int idx = get_connection_index(codec, cap, pin);
+                                if (idx >= 0) {
+                                        imux->items[i].index = idx;
+                                        break;
+                                }
+                        }
                         imux->num_items = i + 1;
+                }
         }
         spec->num_mux_defs = 1;
         spec->input_mux = imux;
@@ -1957,10 +1973,8 @@ static int alc_build_controls(struct hda_codec *codec)
                 if (!kctl)
                         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
                 for (i = 0; kctl && i < kctl->count; i++) {
-                        const hda_nid_t *nids = spec->capsrc_nids;
-                        if (!nids)
-                                nids = spec->adc_nids;
-                        err = snd_hda_add_nid(codec, kctl, i, nids[i]);
+                        err = snd_hda_add_nid(codec, kctl, i,
+                                              get_capsrc(spec, i));
                         if (err < 0)
                                 return err;
                 }
@@ -2747,8 +2761,7 @@ static int alc_auto_create_input_ctls(struct hda_codec *codec)
                 }
 
                 for (c = 0; c < num_adcs; c++) {
-                        hda_nid_t cap = spec->capsrc_nids ?
-                                spec->capsrc_nids[c] : spec->adc_nids[c];
+                        hda_nid_t cap = get_capsrc(spec, c);
                         idx = get_connection_index(codec, cap, pin);
                         if (idx >= 0) {
                                 spec->imux_pins[imux->num_items] = pin;
@@ -3694,8 +3707,7 @@ static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
         if (!pin)
                 return 0;
         for (i = 0; i < spec->num_adc_nids; i++) {
-                hda_nid_t cap = spec->capsrc_nids ?
-                        spec->capsrc_nids[i] : spec->adc_nids[i];
+                hda_nid_t cap = get_capsrc(spec, i);
                 int idx;
 
                 idx = get_connection_index(codec, cap, pin);
diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
index 470f6f286e81..f3658658548e 100644
--- a/sound/pci/hda/patch_sigmatel.c
+++ b/sound/pci/hda/patch_sigmatel.c
@@ -1641,6 +1641,8 @@ static const struct snd_pci_quirk stac92hd73xx_codec_id_cfg_tbl[] = {
                       "Alienware M17x", STAC_ALIENWARE_M17X),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x043a,
                       "Alienware M17x", STAC_ALIENWARE_M17X),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0490,
+                      "Alienware M17x", STAC_ALIENWARE_M17X),
         {} /* terminator */
 };
 
diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c
index 431c0d417eeb..b5137629f8e9 100644
--- a/sound/pci/hda/patch_via.c
+++ b/sound/pci/hda/patch_via.c
@@ -208,6 +208,7 @@ struct via_spec {
         /* work to check hp jack state */
         struct hda_codec *codec;
         struct delayed_work vt1708_hp_work;
+        int hp_work_active;
         int vt1708_jack_detect;
         int vt1708_hp_present;
 
@@ -305,27 +306,35 @@ enum {
 static void analog_low_current_mode(struct hda_codec *codec);
 static bool is_aa_path_mute(struct hda_codec *codec);
 
-static void vt1708_start_hp_work(struct via_spec *spec)
+#define hp_detect_with_aa(codec) \
+        (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1 && \
+         !is_aa_path_mute(codec))
+
+static void vt1708_stop_hp_work(struct via_spec *spec)
 {
         if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
                 return;
-        snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81,
-                            !spec->vt1708_jack_detect);
-        if (!delayed_work_pending(&spec->vt1708_hp_work))
-                schedule_delayed_work(&spec->vt1708_hp_work,
-                                      msecs_to_jiffies(100));
+        if (spec->hp_work_active) {
+                snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, 1);
+                cancel_delayed_work_sync(&spec->vt1708_hp_work);
+                spec->hp_work_active = 0;
+        }
 }
 
-static void vt1708_stop_hp_work(struct via_spec *spec)
+static void vt1708_update_hp_work(struct via_spec *spec)
 {
         if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
                 return;
-        if (snd_hda_get_bool_hint(spec->codec, "analog_loopback_hp_detect") == 1
-            && !is_aa_path_mute(spec->codec))
-                return;
-        snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81,
-                            !spec->vt1708_jack_detect);
-        cancel_delayed_work_sync(&spec->vt1708_hp_work);
+        if (spec->vt1708_jack_detect &&
+            (spec->active_streams || hp_detect_with_aa(spec->codec))) {
+                if (!spec->hp_work_active) {
+                        snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, 0);
+                        schedule_delayed_work(&spec->vt1708_hp_work,
+                                              msecs_to_jiffies(100));
+                        spec->hp_work_active = 1;
+                }
+        } else if (!hp_detect_with_aa(spec->codec))
+                vt1708_stop_hp_work(spec);
 }
 
 static void set_widgets_power_state(struct hda_codec *codec)
@@ -343,12 +352,7 @@ static int analog_input_switch_put(struct snd_kcontrol *kcontrol,
 
         set_widgets_power_state(codec);
         analog_low_current_mode(snd_kcontrol_chip(kcontrol));
-        if (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1) {
-                if (is_aa_path_mute(codec))
-                        vt1708_start_hp_work(codec->spec);
-                else
-                        vt1708_stop_hp_work(codec->spec);
-        }
+        vt1708_update_hp_work(codec->spec);
         return change;
 }
 
@@ -1154,7 +1158,7 @@ static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo,
         spec->cur_dac_stream_tag = stream_tag;
         spec->cur_dac_format = format;
         mutex_unlock(&spec->config_mutex);
-        vt1708_start_hp_work(spec);
+        vt1708_update_hp_work(spec);
         return 0;
 }
 
@@ -1174,7 +1178,7 @@ static int via_playback_hp_pcm_prepare(struct hda_pcm_stream *hinfo,
         spec->cur_hp_stream_tag = stream_tag;
         spec->cur_hp_format = format;
         mutex_unlock(&spec->config_mutex);
-        vt1708_start_hp_work(spec);
+        vt1708_update_hp_work(spec);
         return 0;
 }
 
@@ -1188,7 +1192,7 @@ static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo,
         snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
         spec->active_streams &= ~STREAM_MULTI_OUT;
         mutex_unlock(&spec->config_mutex);
-        vt1708_stop_hp_work(spec);
+        vt1708_update_hp_work(spec);
         return 0;
 }
 
@@ -1203,7 +1207,7 @@ static int via_playback_hp_pcm_cleanup(struct hda_pcm_stream *hinfo,
                 snd_hda_codec_setup_stream(codec, spec->hp_dac_nid, 0, 0, 0);
         spec->active_streams &= ~STREAM_INDEP_HP;
         mutex_unlock(&spec->config_mutex);
-        vt1708_stop_hp_work(spec);
+        vt1708_update_hp_work(spec);
         return 0;
 }
 
@@ -1645,7 +1649,8 @@ static void via_hp_automute(struct hda_codec *codec)
         int nums;
         struct via_spec *spec = codec->spec;
 
-        if (!spec->hp_independent_mode && spec->autocfg.hp_pins[0])
+        if (!spec->hp_independent_mode && spec->autocfg.hp_pins[0] &&
+            (spec->codec_type != VT1708 || spec->vt1708_jack_detect))
                 present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
 
         if (spec->smart51_enabled)
@@ -2612,8 +2617,6 @@ static int vt1708_jack_detect_get(struct snd_kcontrol *kcontrol,
 
         if (spec->codec_type != VT1708)
                 return 0;
-        spec->vt1708_jack_detect =
-                !((snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8) & 0x1);
         ucontrol->value.integer.value[0] = spec->vt1708_jack_detect;
         return 0;
 }
@@ -2623,18 +2626,22 @@ static int vt1708_jack_detect_put(struct snd_kcontrol *kcontrol,
 {
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
         struct via_spec *spec = codec->spec;
-        int change;
+        int val;
 
         if (spec->codec_type != VT1708)
                 return 0;
-        spec->vt1708_jack_detect = ucontrol->value.integer.value[0];
-        change = (0x1 & (snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8))
-                == !spec->vt1708_jack_detect;
-        if (spec->vt1708_jack_detect) {
+        val = !!ucontrol->value.integer.value[0];
+        if (spec->vt1708_jack_detect == val)
+                return 0;
+        spec->vt1708_jack_detect = val;
+        if (spec->vt1708_jack_detect &&
+            snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") != 1) {
                 mute_aa_path(codec, 1);
                 notify_aa_path_ctls(codec);
         }
-        return change;
+        via_hp_automute(codec);
+        vt1708_update_hp_work(spec);
+        return 1;
 }
 
 static const struct snd_kcontrol_new vt1708_jack_detect_ctl = {
@@ -2771,6 +2778,7 @@ static int via_init(struct hda_codec *codec)
         via_auto_init_unsol_event(codec);
 
         via_hp_automute(codec);
+        vt1708_update_hp_work(spec);
 
         return 0;
 }
@@ -2787,7 +2795,9 @@ static void vt1708_update_hp_jack_state(struct work_struct *work)
                 spec->vt1708_hp_present ^= 1;
                 via_hp_automute(spec->codec);
         }
-        vt1708_start_hp_work(spec);
+        if (spec->vt1708_jack_detect)
+                schedule_delayed_work(&spec->vt1708_hp_work,
+                                      msecs_to_jiffies(100));
 }
 
 static int get_mux_nids(struct hda_codec *codec)
diff --git a/sound/pci/lx6464es/lx_core.c b/sound/pci/lx6464es/lx_core.c
index 5c8717e29eeb..8c3e7fcefd99 100644
--- a/sound/pci/lx6464es/lx_core.c
+++ b/sound/pci/lx6464es/lx_core.c
@@ -78,10 +78,15 @@ unsigned long lx_dsp_reg_read(struct lx6464es *chip, int port)
         return ioread32(address);
 }
 
-void lx_dsp_reg_readbuf(struct lx6464es *chip, int port, u32 *data, u32 len)
+static void lx_dsp_reg_readbuf(struct lx6464es *chip, int port, u32 *data,
+                               u32 len)
 {
-        void __iomem *address = lx_dsp_register(chip, port);
-        memcpy_fromio(data, address, len*sizeof(u32));
+        u32 __iomem *address = lx_dsp_register(chip, port);
+        int i;
+
+        /* we cannot use memcpy_fromio */
+        for (i = 0; i != len; ++i)
+                data[i] = ioread32(address + i);
 }
 
 
@@ -91,11 +96,15 @@ void lx_dsp_reg_write(struct lx6464es *chip, int port, unsigned data)
         iowrite32(data, address);
 }
 
-void lx_dsp_reg_writebuf(struct lx6464es *chip, int port, const u32 *data,
-                         u32 len)
+static void lx_dsp_reg_writebuf(struct lx6464es *chip, int port,
+                                const u32 *data, u32 len)
 {
-        void __iomem *address = lx_dsp_register(chip, port);
-        memcpy_toio(address, data, len*sizeof(u32));
+        u32 __iomem *address = lx_dsp_register(chip, port);
+        int i;
+
+        /* we cannot use memcpy_to */
+        for (i = 0; i != len; ++i)
+                iowrite32(data[i], address + i);
 }
 
 
diff --git a/sound/pci/lx6464es/lx_core.h b/sound/pci/lx6464es/lx_core.h
index 1dd562980b6c..4d7ff797a646 100644
--- a/sound/pci/lx6464es/lx_core.h
+++ b/sound/pci/lx6464es/lx_core.h
@@ -72,10 +72,7 @@ enum {
 };
 
 unsigned long lx_dsp_reg_read(struct lx6464es *chip, int port);
-void lx_dsp_reg_readbuf(struct lx6464es *chip, int port, u32 *data, u32 len);
 void lx_dsp_reg_write(struct lx6464es *chip, int port, unsigned data);
-void lx_dsp_reg_writebuf(struct lx6464es *chip, int port, const u32 *data,
-                         u32 len);
 
 /* plx register access */
 enum {
diff --git a/sound/pci/rme9652/hdspm.c b/sound/pci/rme9652/hdspm.c
index e760adad9523..19ee2203cbb5 100644
--- a/sound/pci/rme9652/hdspm.c
+++ b/sound/pci/rme9652/hdspm.c
@@ -6518,7 +6518,7 @@ static int __devinit snd_hdspm_create(struct snd_card *card,
                         hdspm->io_type = AES32;
                         hdspm->card_name = "RME AES32";
                         hdspm->midiPorts = 2;
-                } else if ((hdspm->firmware_rev == 0xd5) ||
+                } else if ((hdspm->firmware_rev == 0xd2) ||
                         ((hdspm->firmware_rev >= 0xc8)  &&
                                 (hdspm->firmware_rev <= 0xcf))) {
                         hdspm->io_type = MADI;
diff --git a/sound/soc/codecs/adau1373.c b/sound/soc/codecs/adau1373.c
index 1ccf8dd47576..45c63028b40d 100644
--- a/sound/soc/codecs/adau1373.c
+++ b/sound/soc/codecs/adau1373.c
@@ -245,7 +245,7 @@ static const char *adau1373_bass_hpf_cutoff_text[] = {
 };
 
 static const unsigned int adau1373_bass_tlv[] = {
-        TLV_DB_RANGE_HEAD(4),
+        TLV_DB_RANGE_HEAD(3),
         0, 2, TLV_DB_SCALE_ITEM(-600, 600, 1),
         3, 4, TLV_DB_SCALE_ITEM(950, 250, 0),
         5, 7, TLV_DB_SCALE_ITEM(1400, 150, 0),
diff --git a/sound/soc/codecs/cs4271.c b/sound/soc/codecs/cs4271.c
index 23d1bd5dadda..69fde1506fe1 100644
--- a/sound/soc/codecs/cs4271.c
+++ b/sound/soc/codecs/cs4271.c
@@ -434,7 +434,8 @@ static int cs4271_soc_suspend(struct snd_soc_codec *codec, pm_message_t mesg)
 {
         int ret;
         /* Set power-down bit */
-        ret = snd_soc_update_bits(codec, CS4271_MODE2, 0, CS4271_MODE2_PDN);
+        ret = snd_soc_update_bits(codec, CS4271_MODE2, CS4271_MODE2_PDN,
+                                  CS4271_MODE2_PDN);
         if (ret < 0)
                 return ret;
         return 0;
@@ -501,8 +502,9 @@ static int cs4271_probe(struct snd_soc_codec *codec)
                 return ret;
         }
 
-        ret = snd_soc_update_bits(codec, CS4271_MODE2, 0,
-                CS4271_MODE2_PDN | CS4271_MODE2_CPEN);
+        ret = snd_soc_update_bits(codec, CS4271_MODE2,
+                                  CS4271_MODE2_PDN | CS4271_MODE2_CPEN,
+                                  CS4271_MODE2_PDN | CS4271_MODE2_CPEN);
         if (ret < 0)
                 return ret;
         ret = snd_soc_update_bits(codec, CS4271_MODE2, CS4271_MODE2_PDN, 0);
diff --git a/sound/soc/codecs/rt5631.c b/sound/soc/codecs/rt5631.c
index 27a078cbb6eb..4646e808b90a 100644
--- a/sound/soc/codecs/rt5631.c
+++ b/sound/soc/codecs/rt5631.c
@@ -177,7 +177,7 @@ static const DECLARE_TLV_DB_SCALE(dac_vol_tlv, -95625, 375, 0);
 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -3450, 150, 0);
 /* {0, +20, +24, +30, +35, +40, +44, +50, +52}dB */
 static unsigned int mic_bst_tlv[] = {
-        TLV_DB_RANGE_HEAD(6),
+        TLV_DB_RANGE_HEAD(7),
         0, 0, TLV_DB_SCALE_ITEM(0, 0, 0),
         1, 1, TLV_DB_SCALE_ITEM(2000, 0, 0),
         2, 2, TLV_DB_SCALE_ITEM(2400, 0, 0),
diff --git a/sound/soc/codecs/sgtl5000.c b/sound/soc/codecs/sgtl5000.c
index d15695d1c273..bbcf921166f7 100644
--- a/sound/soc/codecs/sgtl5000.c
+++ b/sound/soc/codecs/sgtl5000.c
@@ -365,7 +365,7 @@ static const DECLARE_TLV_DB_SCALE(capture_6db_attenuate, -600, 600, 0);
 
 /* tlv for mic gain, 0db 20db 30db 40db */
 static const unsigned int mic_gain_tlv[] = {
-        TLV_DB_RANGE_HEAD(4),
+        TLV_DB_RANGE_HEAD(2),
         0, 0, TLV_DB_SCALE_ITEM(0, 0, 0),
         1, 3, TLV_DB_SCALE_ITEM(2000, 1000, 0),
 };
diff --git a/sound/soc/codecs/sta32x.c b/sound/soc/codecs/sta32x.c
index bb82408ab8e1..d2f37152f940 100644
--- a/sound/soc/codecs/sta32x.c
+++ b/sound/soc/codecs/sta32x.c
@@ -76,6 +76,8 @@ struct sta32x_priv {
 
         unsigned int mclk;
         unsigned int format;
+
+        u32 coef_shadow[STA32X_COEF_COUNT];
 };
 
 static const DECLARE_TLV_DB_SCALE(mvol_tlv, -12700, 50, 1);
@@ -227,6 +229,7 @@ static int sta32x_coefficient_put(struct snd_kcontrol *kcontrol,
                                   struct snd_ctl_elem_value *ucontrol)
 {
         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
         int numcoef = kcontrol->private_value >> 16;
         int index = kcontrol->private_value & 0xffff;
         unsigned int cfud;
@@ -239,6 +242,11 @@ static int sta32x_coefficient_put(struct snd_kcontrol *kcontrol,
         snd_soc_write(codec, STA32X_CFUD, cfud);
 
         snd_soc_write(codec, STA32X_CFADDR2, index);
+        for (i = 0; i < numcoef && (index + i < STA32X_COEF_COUNT); i++)
+                sta32x->coef_shadow[index + i] =
+                          (ucontrol->value.bytes.data[3 * i] << 16)
+                        | (ucontrol->value.bytes.data[3 * i + 1] << 8)
+                        | (ucontrol->value.bytes.data[3 * i + 2]);
         for (i = 0; i < 3 * numcoef; i++)
                 snd_soc_write(codec, STA32X_B1CF1 + i,
                               ucontrol->value.bytes.data[i]);
@@ -252,6 +260,48 @@ static int sta32x_coefficient_put(struct snd_kcontrol *kcontrol,
         return 0;
 }
 
+int sta32x_sync_coef_shadow(struct snd_soc_codec *codec)
+{
+        struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
+        unsigned int cfud;
+        int i;
+
+        /* preserve reserved bits in STA32X_CFUD */
+        cfud = snd_soc_read(codec, STA32X_CFUD) & 0xf0;
+
+        for (i = 0; i < STA32X_COEF_COUNT; i++) {
+                snd_soc_write(codec, STA32X_CFADDR2, i);
+                snd_soc_write(codec, STA32X_B1CF1,
+                              (sta32x->coef_shadow[i] >> 16) & 0xff);
+                snd_soc_write(codec, STA32X_B1CF2,
+                              (sta32x->coef_shadow[i] >> 8) & 0xff);
+                snd_soc_write(codec, STA32X_B1CF3,
+                              (sta32x->coef_shadow[i]) & 0xff);
+                /* chip documentation does not say if the bits are
+                 * self-clearing, so do it explicitly */
+                snd_soc_write(codec, STA32X_CFUD, cfud);
+                snd_soc_write(codec, STA32X_CFUD, cfud | 0x01);
+        }
+        return 0;
+}
+
+int sta32x_cache_sync(struct snd_soc_codec *codec)
+{
+        unsigned int mute;
+        int rc;
+
+        if (!codec->cache_sync)
+                return 0;
+
+        /* mute during register sync */
+        mute = snd_soc_read(codec, STA32X_MMUTE);
+        snd_soc_write(codec, STA32X_MMUTE, mute | STA32X_MMUTE_MMUTE);
+        sta32x_sync_coef_shadow(codec);
+        rc = snd_soc_cache_sync(codec);
+        snd_soc_write(codec, STA32X_MMUTE, mute);
+        return rc;
+}
+
 #define SINGLE_COEF(xname, index) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
         .info = sta32x_coefficient_info, \
@@ -661,7 +711,7 @@ static int sta32x_set_bias_level(struct snd_soc_codec *codec,
                                 return ret;
                         }
 
-                        snd_soc_cache_sync(codec);
+                        sta32x_cache_sync(codec);
                 }
 
                 /* Power up to mute */
@@ -790,6 +840,17 @@ static int sta32x_probe(struct snd_soc_codec *codec)
                             STA32X_CxCFG_OM_MASK,
                             2 << STA32X_CxCFG_OM_SHIFT);
 
+        /* initialize coefficient shadow RAM with reset values */
+        for (i = 4; i <= 49; i += 5)
+                sta32x->coef_shadow[i] = 0x400000;
+        for (i = 50; i <= 54; i++)
+                sta32x->coef_shadow[i] = 0x7fffff;
+        sta32x->coef_shadow[55] = 0x5a9df7;
+        sta32x->coef_shadow[56] = 0x7fffff;
+        sta32x->coef_shadow[59] = 0x7fffff;
+        sta32x->coef_shadow[60] = 0x400000;
+        sta32x->coef_shadow[61] = 0x400000;
+
         sta32x_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
         /* Bias level configuration will have done an extra enable */
         regulator_bulk_disable(ARRAY_SIZE(sta32x->supplies), sta32x->supplies);
diff --git a/sound/soc/codecs/sta32x.h b/sound/soc/codecs/sta32x.h
index b97ee5a75667..d8e32a6262ee 100644
--- a/sound/soc/codecs/sta32x.h
+++ b/sound/soc/codecs/sta32x.h
@@ -19,6 +19,7 @@
 /* STA326 register addresses */
 
 #define STA32X_REGISTER_COUNT   0x2d
+#define STA32X_COEF_COUNT 62
 
 #define STA32X_CONFA    0x00
 #define STA32X_CONFB    0x01
diff --git a/sound/soc/codecs/wm8731.c b/sound/soc/codecs/wm8731.c
index 7e5ec03f6f8d..a7c9ae17fc7e 100644
--- a/sound/soc/codecs/wm8731.c
+++ b/sound/soc/codecs/wm8731.c
@@ -453,6 +453,7 @@ static int wm8731_set_bias_level(struct snd_soc_codec *codec,
                 snd_soc_write(codec, WM8731_PWR, 0xffff);
                 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies),
                                        wm8731->supplies);
+                codec->cache_sync = 1;
                 break;
         }
         codec->dapm.bias_level = level;
diff --git a/sound/soc/codecs/wm8753.c b/sound/soc/codecs/wm8753.c
index a9504710bb69..3a629d0d690e 100644
--- a/sound/soc/codecs/wm8753.c
+++ b/sound/soc/codecs/wm8753.c
@@ -190,6 +190,9 @@ static int wm8753_set_dai(struct snd_kcontrol *kcontrol,
         struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec);
         u16 ioctl;
 
+        if (wm8753->dai_func == ucontrol->value.integer.value[0])
+                return 0;
+
         if (codec->active)
                 return -EBUSY;
 
diff --git a/sound/soc/codecs/wm8962.c b/sound/soc/codecs/wm8962.c
index 91d3c6dbeba3..53edd9a8c758 100644
--- a/sound/soc/codecs/wm8962.c
+++ b/sound/soc/codecs/wm8962.c
@@ -1973,7 +1973,7 @@ static int wm8962_reset(struct snd_soc_codec *codec)
 static const DECLARE_TLV_DB_SCALE(inpga_tlv, -2325, 75, 0);
 static const DECLARE_TLV_DB_SCALE(mixin_tlv, -1500, 300, 0);
 static const unsigned int mixinpga_tlv[] = {
-        TLV_DB_RANGE_HEAD(7),
+        TLV_DB_RANGE_HEAD(5),
         0, 1, TLV_DB_SCALE_ITEM(0, 600, 0),
         2, 2, TLV_DB_SCALE_ITEM(1300, 1300, 0),
         3, 4, TLV_DB_SCALE_ITEM(1800, 200, 0),
@@ -1988,7 +1988,7 @@ static const DECLARE_TLV_DB_SCALE(bypass_tlv, -1500, 300, 0);
 static const DECLARE_TLV_DB_SCALE(out_tlv, -12100, 100, 1);
 static const DECLARE_TLV_DB_SCALE(hp_tlv, -700, 100, 0);
 static const unsigned int classd_tlv[] = {
-        TLV_DB_RANGE_HEAD(7),
+        TLV_DB_RANGE_HEAD(2),
         0, 6, TLV_DB_SCALE_ITEM(0, 150, 0),
         7, 7, TLV_DB_SCALE_ITEM(1200, 0, 0),
 };
diff --git a/sound/soc/codecs/wm8993.c b/sound/soc/codecs/wm8993.c
index eec8e1435116..d1a142f48b09 100644
--- a/sound/soc/codecs/wm8993.c
+++ b/sound/soc/codecs/wm8993.c
@@ -512,7 +512,7 @@ static const DECLARE_TLV_DB_SCALE(drc_comp_threash, -4500, 75, 0);
 static const DECLARE_TLV_DB_SCALE(drc_comp_amp, -2250, 75, 0);
 static const DECLARE_TLV_DB_SCALE(drc_min_tlv, -1800, 600, 0);
 static const unsigned int drc_max_tlv[] = {
-        TLV_DB_RANGE_HEAD(4),
+        TLV_DB_RANGE_HEAD(2),
         0, 2, TLV_DB_SCALE_ITEM(1200, 600, 0),
         3, 3, TLV_DB_SCALE_ITEM(3600, 0, 0),
 };
diff --git a/sound/soc/codecs/wm9081.c b/sound/soc/codecs/wm9081.c
index 3cd35a02c28c..4a398c3bfe84 100644
--- a/sound/soc/codecs/wm9081.c
+++ b/sound/soc/codecs/wm9081.c
@@ -807,7 +807,6 @@ static int wm9081_set_bias_level(struct snd_soc_codec *codec,
                         mdelay(100);
 
                         /* Normal bias enable & soft start off */
-                        reg |= WM9081_BIAS_ENA;
                         reg &= ~WM9081_VMID_RAMP;
                         snd_soc_write(codec, WM9081_VMID_CONTROL, reg);
 
@@ -818,7 +817,7 @@ static int wm9081_set_bias_level(struct snd_soc_codec *codec,
                 }
 
                 /* VMID 2*240k */
-                reg = snd_soc_read(codec, WM9081_BIAS_CONTROL_1);
+                reg = snd_soc_read(codec, WM9081_VMID_CONTROL);
                 reg &= ~WM9081_VMID_SEL_MASK;
                 reg |= 0x04;
                 snd_soc_write(codec, WM9081_VMID_CONTROL, reg);
@@ -830,14 +829,15 @@ static int wm9081_set_bias_level(struct snd_soc_codec *codec,
                 break;
 
         case SND_SOC_BIAS_OFF:
-                /* Startup bias source */
+                /* Startup bias source and disable bias */
                 reg = snd_soc_read(codec, WM9081_BIAS_CONTROL_1);
                 reg |= WM9081_BIAS_SRC;
+                reg &= ~WM9081_BIAS_ENA;
                 snd_soc_write(codec, WM9081_BIAS_CONTROL_1, reg);
 
-                /* Disable VMID and biases with soft ramping */
+                /* Disable VMID with soft ramping */
                 reg = snd_soc_read(codec, WM9081_VMID_CONTROL);
-                reg &= ~(WM9081_VMID_SEL_MASK | WM9081_BIAS_ENA);
+                reg &= ~WM9081_VMID_SEL_MASK;
                 reg |= WM9081_VMID_RAMP;
                 snd_soc_write(codec, WM9081_VMID_CONTROL, reg);
 
diff --git a/sound/soc/codecs/wm9090.c b/sound/soc/codecs/wm9090.c
index 2b5252c9e377..f94c06057c64 100644
--- a/sound/soc/codecs/wm9090.c
+++ b/sound/soc/codecs/wm9090.c
@@ -177,19 +177,19 @@ static void wait_for_dc_servo(struct snd_soc_codec *codec)
 }
 
 static const unsigned int in_tlv[] = {
-        TLV_DB_RANGE_HEAD(6),
+        TLV_DB_RANGE_HEAD(3),
         0, 0, TLV_DB_SCALE_ITEM(-600, 0, 0),
         1, 3, TLV_DB_SCALE_ITEM(-350, 350, 0),
         4, 6, TLV_DB_SCALE_ITEM(600, 600, 0),
 };
 static const unsigned int mix_tlv[] = {
-        TLV_DB_RANGE_HEAD(4),
+        TLV_DB_RANGE_HEAD(2),
         0, 2, TLV_DB_SCALE_ITEM(-1200, 300, 0),
         3, 3, TLV_DB_SCALE_ITEM(0, 0, 0),
 };
 static const DECLARE_TLV_DB_SCALE(out_tlv, -5700, 100, 0);
 static const unsigned int spkboost_tlv[] = {
-        TLV_DB_RANGE_HEAD(7),
+        TLV_DB_RANGE_HEAD(2),
         0, 6, TLV_DB_SCALE_ITEM(0, 150, 0),
         7, 7, TLV_DB_SCALE_ITEM(1200, 0, 0),
 };
diff --git a/sound/soc/codecs/wm_hubs.c b/sound/soc/codecs/wm_hubs.c
index 84f33d4ea2cd..48e61e912400 100644
--- a/sound/soc/codecs/wm_hubs.c
+++ b/sound/soc/codecs/wm_hubs.c
@@ -40,7 +40,7 @@ static const DECLARE_TLV_DB_SCALE(outmix_tlv, -2100, 300, 0);
 static const DECLARE_TLV_DB_SCALE(spkmixout_tlv, -1800, 600, 1);
 static const DECLARE_TLV_DB_SCALE(outpga_tlv, -5700, 100, 0);
 static const unsigned int spkboost_tlv[] = {
-        TLV_DB_RANGE_HEAD(7),
+        TLV_DB_RANGE_HEAD(2),
         0, 6, TLV_DB_SCALE_ITEM(0, 150, 0),
         7, 7, TLV_DB_SCALE_ITEM(1200, 0, 0),
 };
diff --git a/sound/soc/fsl/fsl_ssi.c b/sound/soc/fsl/fsl_ssi.c
index 0268cf989736..83c4bd5b2dd7 100644
--- a/sound/soc/fsl/fsl_ssi.c
+++ b/sound/soc/fsl/fsl_ssi.c
@@ -694,6 +694,7 @@ static int __devinit fsl_ssi_probe(struct platform_device *pdev)
 
         /* Initialize the the device_attribute structure */
         dev_attr = &ssi_private->dev_attr;
+        sysfs_attr_init(&dev_attr->attr);
         dev_attr->attr.name = "statistics";
         dev_attr->attr.mode = S_IRUGO;
         dev_attr->show = fsl_sysfs_ssi_show;